rewrote memory system entirely (hunk, cache, and zone are gone, memory pools replaced...
[xonotic/darkplaces.git] / cl_parse.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // cl_parse.c  -- parse a message received from the server
21
22 #include "quakedef.h"
23
24 char *svc_strings[128] =
25 {
26         "svc_bad",
27         "svc_nop",
28         "svc_disconnect",
29         "svc_updatestat",
30         "svc_version",          // [long] server version
31         "svc_setview",          // [short] entity number
32         "svc_sound",                    // <see code>
33         "svc_time",                     // [float] server time
34         "svc_print",                    // [string] null terminated string
35         "svc_stufftext",                // [string] stuffed into client's console buffer
36                                                 // the string should be \n terminated
37         "svc_setangle",         // [vec3] set the view angle to this absolute value
38
39         "svc_serverinfo",               // [long] version
40                                                 // [string] signon string
41                                                 // [string]..[0]model cache [string]...[0]sounds cache
42                                                 // [string]..[0]item cache
43         "svc_lightstyle",               // [byte] [string]
44         "svc_updatename",               // [byte] [string]
45         "svc_updatefrags",      // [byte] [short]
46         "svc_clientdata",               // <shortbits + data>
47         "svc_stopsound",                // <see code>
48         "svc_updatecolors",     // [byte] [byte]
49         "svc_particle",         // [vec3] <variable>
50         "svc_damage",                   // [byte] impact [byte] blood [vec3] from
51         
52         "svc_spawnstatic",
53         "OBSOLETE svc_spawnbinary",
54         "svc_spawnbaseline",
55         
56         "svc_temp_entity",              // <variable>
57         "svc_setpause",
58         "svc_signonnum",
59         "svc_centerprint",
60         "svc_killedmonster",
61         "svc_foundsecret",
62         "svc_spawnstaticsound",
63         "svc_intermission",
64         "svc_finale",                   // [string] music [string] text
65         "svc_cdtrack",                  // [byte] track [byte] looptrack
66         "svc_sellscreen",
67         "svc_cutscene",
68         "svc_showlmp",  // [string] iconlabel [string] lmpfile [short] x [short] y
69         "svc_hidelmp",  // [string] iconlabel
70         "svc_skybox", // [string] skyname
71         "", // 38
72         "", // 39
73         "", // 40
74         "", // 41
75         "", // 42
76         "", // 43
77         "", // 44
78         "", // 45
79         "", // 46
80         "", // 47
81         "", // 48
82         "", // 49
83         "", // 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 = {0, "demo_nehahra", "0"};
92
93 void CL_Parse_Init(void)
94 {
95         // LordHavoc: added demo_nehahra cvar
96         Cvar_RegisterVariable (&demo_nehahra);
97         if (gamemode == GAME_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 //FIXME finish this code!
243 #define MAX_STATICLIGHTS 2048
244 // tyrlite types
245 #define LIGHTFADE_LMINUSX 0 // light, arghlite, others?
246 #define LIGHTFADE_LDIVX 1
247 #define LIGHTFADE_LDIVX2 2 // hlight
248 #define LIGHTFADE_L 3
249 #define LIGHTFADE_DEFAULT 999999 // light util not yet identified, switched later
250
251 typedef struct
252 {
253         int fadetype; // one of the LIGHTFADE_ values
254         int style;
255         vec3_t origin;
256         vec_t radius; // the point at which lighting stops
257         vec3_t direction;
258         vec_t cone; // if non-zero, it is a spot light
259         vec3_t color;
260         vec_t distancescale; // attenuation
261         vec_t lightsubtract; // biasing lighting toward black (hlight feature)
262 }
263 staticlight_t;
264
265 staticlight_t staticlight[MAX_STATICLIGHTS];
266 int staticlights;
267
268 int r_sunlightenabled;
269 vec3_t r_sunlightdirection, r_sunlightcolor;
270 vec3_t r_light_ambientcolor;
271
272 void CL_ParseEntityLump(char *entdata)
273 {
274         char *data;
275         char key[128], value[4096];
276         char targetnamebuffer[65536];
277         char *targetname[8192], *target[MAX_STATICLIGHTS], light_target[256];
278         vec3_t targetnameorigin[8192], targetnametemporigin, v;
279         int targets, targetnames, targetnamebufferpos, targetnameorigintofillin;
280         int i, j, n;
281         float f1, f2, f3, f4;
282         float ambientlight, ambientcolor[3], sunlight, sunlightdirection[3], sunlightcolor[3];
283         int light_fadetype, light_style, hlight, tyrlite, light_enable;
284         float light_origin[3], light_light, light_distancescale, light_lightcolor[3], light_color[3], light_direction[3], light_cone, light_lightradius;
285         FOG_clear(); // LordHavoc: no fog until set
286         R_SetSkyBox(""); // LordHavoc: no environment mapped sky until set
287         r_sunlightenabled = false;
288         staticlights = 0;
289         data = entdata;
290         if (!data)
291                 return;
292         data = COM_Parse(data);
293         if (!data)
294                 return; // error
295         if (com_token[0] != '{')
296                 return; // error
297         hlight = false;
298         tyrlite = false;
299         ambientlight = 0;
300         ambientcolor[0] = ambientcolor[1] = ambientcolor[2] = 1;
301         sunlight = 0;
302         sunlightcolor[0] = sunlightcolor[1] = sunlightcolor[2] = 1;
303         sunlightdirection[0] = 0;
304         sunlightdirection[1] = 0;
305         sunlightdirection[2] = -1;
306         targets = 0;
307         targetnames = 0;
308         targetnamebufferpos = 0;
309         targetnameorigintofillin = -1;
310         targetnametemporigin[0] = 0;
311         targetnametemporigin[1] = 0;
312         targetnametemporigin[2] = 0;
313         while (1)
314         {
315                 data = COM_Parse(data);
316                 if (!data)
317                         return; // error
318                 if (com_token[0] == '}')
319                         break; // end of worldspawn
320                 if (com_token[0] == '_')
321                         strcpy(key, com_token + 1);
322                 else
323                         strcpy(key, com_token);
324                 while (key[strlen(key)-1] == ' ') // remove trailing spaces
325                         key[strlen(key)-1] = 0;
326                 data = COM_Parse(data);
327                 if (!data)
328                         return; // error
329                 strcpy(value, com_token);
330                 if (!strcmp("sky", key))
331                         R_SetSkyBox(value);
332                 else if (!strcmp("skyname", key)) // non-standard, introduced by QuakeForge... sigh.
333                         R_SetSkyBox(value);
334                 else if (!strcmp("qlsky", key)) // non-standard, introduced by QuakeLives (EEK)
335                         R_SetSkyBox(value);
336                 else if (!strcmp("fog", key))
337                         scanf(value, "%f %f %f %f", &fog_density, &fog_red, &fog_green, &fog_blue);
338                 else if (!strcmp("fog_density", key))
339                         fog_density = atof(value);
340                 else if (!strcmp("fog_red", key))
341                         fog_red = atof(value);
342                 else if (!strcmp("fog_green", key))
343                         fog_green = atof(value);
344                 else if (!strcmp("fog_blue", key))
345                         fog_blue = atof(value);
346                 else if (!strcmp("light", key))
347                         ambientlight = atof(value);
348                 else if (!strcmp("sunlight", key))
349                 {
350                         sunlight = atof(value);
351                         tyrlite = true;
352                 }
353                 else if (!strcmp("sun_color", key))
354                 {
355                         if (scanf(value, "%f %f %f", &v[0], &v[1], &v[2]) == 3)
356                                 VectorCopy(v, sunlightcolor);
357                         tyrlite = true;
358                 }
359                 else if (!strcmp("sun_mangle", key))
360                 {
361                         if (scanf(value, "%f %f %f", &v[0], &v[1], &v[2]) == 3)
362                                 AngleVectors(v, sunlightdirection, NULL, NULL);
363                         tyrlite = true;
364                 }
365                 else if (!strcmp("origin", key))
366                 {
367                         if (scanf(value, "%f %f %f", &v[0], &v[1], &v[2]) == 3)
368                         {
369                                 VectorCopy(v, targetnametemporigin);
370                                 VectorCopy(v, light_origin);
371                         }
372                 }
373                 else if (!strcmp("targetname", key))
374                 {
375                         if ((targetnames < 8192) && (strlen(value) + 1 + targetnamebufferpos <= 65536))
376                         {
377                                 targetname[targetnames] = targetnamebuffer + targetnamebufferpos;
378                                 strcpy(targetnamebuffer + targetnamebufferpos, value);
379                                 targetnamebufferpos += strlen(value) + 1;
380                                 targetnameorigintofillin = targetnames++;
381                         }
382                 }
383         }
384         if (targetnameorigintofillin >= 0)
385                 VectorCopy(targetnametemporigin, targetnameorigin[targetnameorigintofillin]);
386
387         if (sunlight)
388         {
389                 r_sunlightenabled = true;
390                 VectorScale(sunlightcolor, sunlight, r_sunlightcolor);
391                 VectorCopy(sunlightdirection, r_sunlightdirection);
392         }
393         VectorScale(ambientcolor, ambientlight, r_light_ambientcolor);
394
395         while(1)
396         {
397                 data = COM_Parse(data);
398                 if (!data)
399                         break; // done
400                 if (com_token[0] != '{')
401                         break; // error
402                 light_light = 0;
403                 light_lightcolor[0] = light_lightcolor[1] = light_lightcolor[2] = 1.0f;
404                 light_color[0] = light_color[1] = light_color[2] = 1.0f;
405                 light_direction[0] = light_direction[1] = light_direction[2] = 0.0f;
406                 light_cone = -cos(20*M_PI/180);
407                 light_distancescale = 1.0f;
408                 light_fadetype = LIGHTFADE_DEFAULT; // replaced later when light util is identified
409                 light_style = 0;
410                 light_lightradius = 0;
411                 light_enable = false;
412                 targetnameorigintofillin = -1;
413                 targetnametemporigin[0] = 0;
414                 targetnametemporigin[1] = 0;
415                 targetnametemporigin[2] = 0;
416                 while (1)
417                 {
418                         data = COM_Parse(data);
419                         if (!data)
420                                 return; // error
421                         if (com_token[0] == '}')
422                                 break;
423                         if (com_token[0] == '_')
424                                 strcpy(key, com_token + 1);
425                         else
426                                 strcpy(key, com_token);
427                         while (key[strlen(key)-1] == ' ') // remove trailing spaces
428                                 key[strlen(key)-1] = 0;
429                         data = COM_Parse(data);
430                         if (!data)
431                                 return; // error
432                         strcpy(value, com_token);
433                         if (!strcmp("light", key))
434                         {
435                                 n = scanf(value, "%f %f %f %f", &f1, &f2, &f3, &f4);
436                                 switch(n)
437                                 {
438                                 case 1:
439                                         // id light, arghlite, tyrlite, others
440                                         light_light = f1;
441                                         light_lightcolor[0] = light_lightcolor[1] = light_lightcolor[2] = 1.0f;
442                                         break;
443                                 case 3:
444                                         // hlight specific (supports all 3 light formats, but this one is unique to it)
445                                         hlight = true;
446                                         light_light = max(f1, max(f2, f3));
447                                         light_lightcolor[0] = f1 / light_light;
448                                         light_lightcolor[1] = f2 / light_light;
449                                         light_lightcolor[2] = f3 / light_light;
450                                         break;
451                                 case 4:
452                                         // halflife
453                                         hlight = true; // unless this is a halflife map, probably hlight
454                                         light_light = f4;
455                                         light_lightcolor[0] = f1 * (1.0f / 255.0f);
456                                         light_lightcolor[1] = f1 * (1.0f / 255.0f);
457                                         light_lightcolor[2] = f1 * (1.0f / 255.0f);
458                                         break;
459                                 default:
460                                         // error
461                                         break;
462                                 }
463                         }
464                         else if (!strcmp("color", key))
465                         {
466                                 n = scanf(value, "%f %f %f", &f1, &f2, &f3);
467                                 if (n == 3)
468                                 {
469                                         light_color[0] = f1;
470                                         light_color[1] = f2;
471                                         light_color[2] = f3;
472                                 }
473                                 // n != 3 is an error
474                         }
475                         else if (!strcmp("wait", key))
476                                 light_distancescale = atof(value);
477                         else if (!strcmp("delay", key))
478                         {
479                                 light_fadetype = atoi(value);
480                                 tyrlite = true;
481                         }
482                         else if (!strcmp("angle", key))
483                                 light_cone = -cos(atof(value) * M_PI / 360);
484                         else if (!strcmp("mangle", key))
485                         {
486                                 n = scanf(value, "%f %f %f", &v[0], &v[1], &v[2]);
487                                 if (n == 3)
488                                         AngleVectors(v, light_direction, NULL, NULL);
489                                 // n != 3 is an error
490                                 tyrlite = true;
491                         }
492                         else if (!strcmp("style", key))
493                         {
494                                 n = atoi(value);
495                                 if (n >= 0 && n < MAX_LIGHTSTYLES)
496                                         light_style = n;
497                         }
498                         else if (!strcmp("lightradius", key))
499                         {
500                                 hlight = true;
501                                 light_lightradius = atof(value);
502                         }
503                         else if (!strcmp("classname", key))
504                                 if (!strncmp(value, "light", 5))
505                                         light_enable = true;
506                         else if (!strcmp("origin", key))
507                         {
508                                 if (scanf(value, "%f %f %f", &v[0], &v[1], &v[2]) == 3)
509                                         VectorCopy(v, targetnametemporigin);
510                         }
511                         else if (!strcmp("targetname", key))
512                         {
513                                 if ((targetnames < 8192) && (strlen(value) + 1 + targetnamebufferpos <= 65536))
514                                 {
515                                         targetname[targetnames] = targetnamebuffer + targetnamebufferpos;
516                                         strcpy(targetnamebuffer + targetnamebufferpos, value);
517                                         targetnamebufferpos += strlen(value) + 1;
518                                         targetnameorigintofillin = targetnames++;
519                                 }
520                         }
521                         else if (!strcmp("target", key))
522                                 if (strlen(value) < sizeof(light_target))
523                                         strcpy(light_target, value);
524                 }
525                 if (targetnameorigintofillin >= 0)
526                         VectorCopy(targetnametemporigin, targetnameorigin[targetnameorigintofillin]);
527                 if (light_enable && staticlights < MAX_STATICLIGHTS && light_light != 0)
528                 {
529                         VectorCopy(light_origin, staticlight[staticlights].origin);
530                         staticlight[staticlights].color[0] = light_light * light_lightcolor[0] * light_color[0];
531                         staticlight[staticlights].color[1] = light_light * light_lightcolor[1] * light_color[1];
532                         staticlight[staticlights].color[2] = light_light * light_lightcolor[2] * light_color[2];
533                         VectorCopy(light_direction, staticlight[staticlights].direction);
534                         staticlight[staticlights].cone = light_cone;
535                         staticlight[staticlights].distancescale = light_distancescale;
536                         staticlight[staticlights].fadetype = light_fadetype;
537                         staticlight[staticlights].style = light_style;
538                         if (light_target && (targets < 8192) && (strlen(value) + 1 + targetnamebufferpos <= 65536))
539                         {
540                                 target[staticlights] = targetnamebuffer + targetnamebufferpos;
541                                 strcpy(targetnamebuffer + targetnamebufferpos, value);
542                                 targetnamebufferpos += strlen(value) + 1;
543                         }
544                         else
545                                 target[staticlights] = NULL;
546                         staticlight[staticlights].lightsubtract = 0;
547                         if (light_lightradius)
548                         {
549                                 staticlight[staticlights].fadetype = LIGHTFADE_LDIVX2;
550                                 staticlight[staticlights].lightsubtract = max(staticlight[staticlights].color[0], max(staticlight[staticlights].color[1], staticlight[staticlights].color[2])) * 0.5f / (light_lightradius * light_distancescale * light_lightradius * light_distancescale * (1.0f / 65536.0f) + 1.0f);
551                         }
552                         staticlights++;
553                 }
554         }
555         if (cl.worldmodel->ishlbsp)
556                 n = LIGHTFADE_LDIVX2;
557         else if (tyrlite)
558                 n = LIGHTFADE_LMINUSX;
559         else if (hlight)
560                 n = LIGHTFADE_LDIVX2;
561         else
562                 n = LIGHTFADE_LMINUSX;
563         for (i = 0;i < staticlights;i++)
564         {
565                 if (staticlight[i].fadetype == LIGHTFADE_DEFAULT)
566                         staticlight[i].fadetype = n;
567                 if (target[i])
568                 {
569                         for (j = 0;j < targetnames;j++)
570                         {
571                                 if (!strcmp(target[i], targetname[j]))
572                                 {
573                                         VectorSubtract(targetnameorigin[j], staticlight[i].origin, v);
574                                         VectorNormalize(v);
575                                         VectorCopy(v, staticlight[i].direction);
576                                         break;
577                                 }
578                         }
579                 }
580                 if (staticlight[i].direction[0] == 0 && staticlight[i].direction[1] == 0 && staticlight[i].direction[2] == 0)
581                         staticlight[i].cone = 0;
582         }
583 }
584
585 /*
586 =====================
587 CL_SignonReply
588
589 An svc_signonnum has been received, perform a client side setup
590 =====================
591 */
592 static void CL_SignonReply (void)
593 {
594         char    str[8192];
595
596 Con_DPrintf ("CL_SignonReply: %i\n", cls.signon);
597
598         switch (cls.signon)
599         {
600         case 1:
601                 MSG_WriteByte (&cls.message, clc_stringcmd);
602                 MSG_WriteString (&cls.message, "prespawn");
603                 break;
604
605         case 2:
606                 MSG_WriteByte (&cls.message, clc_stringcmd);
607                 MSG_WriteString (&cls.message, va("name \"%s\"\n", cl_name.string));
608
609                 MSG_WriteByte (&cls.message, clc_stringcmd);
610                 MSG_WriteString (&cls.message, va("color %i %i\n", cl_color.integer >> 4, cl_color.integer & 15));
611
612                 if (cl_pmodel.integer)
613                 {
614                         MSG_WriteByte (&cls.message, clc_stringcmd);
615                         MSG_WriteString (&cls.message, va("pmodel %i\n", cl_pmodel.integer));
616                 }
617
618                 MSG_WriteByte (&cls.message, clc_stringcmd);
619                 sprintf (str, "spawn %s", cls.spawnparms);
620                 MSG_WriteString (&cls.message, str);
621                 break;
622
623         case 3:
624                 MSG_WriteByte (&cls.message, clc_stringcmd);
625                 MSG_WriteString (&cls.message, "begin");
626                 break;
627
628         case 4:
629 //              SCR_EndLoadingPlaque ();                // allow normal screen updates
630                 Con_ClearNotify();
631                 break;
632         }
633 }
634
635 /*
636 ==================
637 CL_ParseServerInfo
638 ==================
639 */
640 void CL_ParseServerInfo (void)
641 {
642         char    *str;
643         int             i;
644         int             nummodels, numsounds;
645         char    model_precache[MAX_MODELS][MAX_QPATH];
646         char    sound_precache[MAX_SOUNDS][MAX_QPATH];
647
648         Con_DPrintf ("Serverinfo packet received.\n");
649 //
650 // wipe the client_state_t struct
651 //
652         CL_ClearState ();
653
654 // parse protocol version number
655         i = MSG_ReadLong ();
656         if (i != PROTOCOL_VERSION && i != DPPROTOCOL_VERSION && i != 250)
657         {
658                 Con_Printf ("Server returned version %i, not %i or %i", i, DPPROTOCOL_VERSION, PROTOCOL_VERSION);
659                 return;
660         }
661         Nehahrademcompatibility = false;
662         if (i == 250)
663                 Nehahrademcompatibility = true;
664         if (cls.demoplayback && demo_nehahra.integer)
665                 Nehahrademcompatibility = true;
666         dpprotocol = i == DPPROTOCOL_VERSION;
667
668 // parse maxclients
669         cl.maxclients = MSG_ReadByte ();
670         if (cl.maxclients < 1 || cl.maxclients > MAX_SCOREBOARD)
671         {
672                 Con_Printf("Bad maxclients (%u) from server\n", cl.maxclients);
673                 return;
674         }
675         cl.scores = Mem_Alloc(cl_scores_mempool, cl.maxclients*sizeof(*cl.scores));
676
677 // parse gametype
678         cl.gametype = MSG_ReadByte ();
679
680 // parse signon message
681         str = MSG_ReadString ();
682         strncpy (cl.levelname, str, sizeof(cl.levelname)-1);
683
684 // seperate the printfs so the server message can have a color
685         if (!Nehahrademcompatibility) // no messages when playing the Nehahra movie
686         {
687                 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");
688                 Con_Printf ("%c%s\n", 2, str);
689         }
690
691 //
692 // first we go through and touch all of the precache data that still
693 // happens to be in the cache, so precaching something else doesn't
694 // needlessly purge it
695 //
696
697         Mem_CheckSentinelsGlobal();
698
699         Mod_ClearUsed();
700
701         Mem_CheckSentinelsGlobal();
702
703 // precache models
704         memset (cl.model_precache, 0, sizeof(cl.model_precache));
705         for (nummodels=1 ; ; nummodels++)
706         {
707                 str = MSG_ReadString ();
708                 if (!str[0])
709                         break;
710                 if (nummodels==MAX_MODELS)
711                 {
712                         Con_Printf ("Server sent too many model precaches\n");
713                         return;
714                 }
715                 if (strlen(str) >= MAX_QPATH)
716                         Host_Error ("Server sent a precache name of %i characters (max %i)", strlen(str), MAX_QPATH - 1);
717                 strcpy (model_precache[nummodels], str);
718                 Mod_TouchModel (str);
719         }
720
721 // precache sounds
722         memset (cl.sound_precache, 0, sizeof(cl.sound_precache));
723         for (numsounds=1 ; ; numsounds++)
724         {
725                 str = MSG_ReadString ();
726                 if (!str[0])
727                         break;
728                 if (numsounds==MAX_SOUNDS)
729                 {
730                         Con_Printf ("Server sent too many sound precaches\n");
731                         return;
732                 }
733                 if (strlen(str) >= MAX_QPATH)
734                         Host_Error ("Server sent a precache name of %i characters (max %i)", strlen(str), MAX_QPATH - 1);
735                 strcpy (sound_precache[numsounds], str);
736                 S_TouchSound (str);
737         }
738
739         Mem_CheckSentinelsGlobal();
740
741         Mod_PurgeUnused();
742
743 //
744 // now we try to load everything else until a cache allocation fails
745 //
746
747         Mem_CheckSentinelsGlobal();
748
749         for (i=1 ; i<nummodels ; i++)
750         {
751                 // LordHavoc: i == 1 means the first model is the world model
752                 cl.model_precache[i] = Mod_ForName (model_precache[i], false, true, i == 1);
753
754                 if (cl.model_precache[i] == NULL)
755                 {
756                         Con_Printf("Model %s not found\n", model_precache[i]);
757                         return;
758                 }
759                 CL_KeepaliveMessage ();
760         }
761
762         Mem_CheckSentinelsGlobal();
763
764         S_BeginPrecaching ();
765         for (i=1 ; i<numsounds ; i++)
766         {
767                 cl.sound_precache[i] = S_PrecacheSound (sound_precache[i]);
768                 CL_KeepaliveMessage ();
769         }
770         S_EndPrecaching ();
771
772 // local state
773         cl_entities[0].render.model = cl.worldmodel = cl.model_precache[1];
774         cl_entities[0].render.scale = 1;
775         cl_entities[0].render.alpha = 1;
776
777         R_NewMap ();
778
779         Mem_CheckSentinelsGlobal();
780
781         noclip_anglehack = false;               // noclip is turned off at start
782 }
783
784 void CL_ValidateState(entity_state_t *s)
785 {
786         model_t *model;
787
788         if (!s->active)
789                 return;
790
791         if (s->modelindex >= MAX_MODELS)
792                 Host_Error("CL_ValidateState: modelindex (%i) >= MAX_MODELS (%i)\n", s->modelindex, MAX_MODELS);
793
794         // colormap is client index + 1
795         if (s->colormap > cl.maxclients)
796                 Host_Error ("CL_ValidateState: colormap (%i) > cl.maxclients (%i)", s->colormap, cl.maxclients);
797
798         model = cl.model_precache[s->modelindex];
799         Mod_CheckLoaded(model);
800         if (model && s->frame >= model->numframes)
801         {
802                 Con_Printf("CL_ValidateState: no such frame %i in \"%s\"\n", s->frame, model->name);
803                 s->frame = 0;
804         }
805         if (model && s->skin > 0 && s->skin >= model->numskins)
806         {
807                 Con_Printf("CL_ValidateState: no such skin %i in \"%s\"\n", s->skin, model->name);
808                 s->skin = 0;
809         }
810 }
811
812 /*
813 ==================
814 CL_ParseUpdate
815
816 Parse an entity update message from the server
817 If an entities model or origin changes from frame to frame, it must be
818 relinked.  Other attributes can change without relinking.
819 ==================
820 */
821 byte entkill[MAX_EDICTS];
822 int bitprofile[32], bitprofilecount = 0;
823 void CL_ParseUpdate (int bits)
824 {
825         int i, num, deltadie;
826         entity_t *ent;
827         entity_state_t new;
828
829         if (cls.signon == SIGNONS - 1)
830         {       // first update is the final signon stage
831                 cls.signon = SIGNONS;
832                 CL_SignonReply ();
833         }
834
835         if (bits & U_MOREBITS)
836                 bits |= (MSG_ReadByte()<<8);
837         if ((bits & U_EXTEND1) && (!Nehahrademcompatibility))
838         {
839                 bits |= MSG_ReadByte() << 16;
840                 if (bits & U_EXTEND2)
841                         bits |= MSG_ReadByte() << 24;
842         }
843
844         if (bits & U_LONGENTITY)
845                 num = (unsigned) MSG_ReadShort ();
846         else
847                 num = (unsigned) MSG_ReadByte ();
848
849         if (num >= MAX_EDICTS)
850                 Host_Error("CL_ParseUpdate: entity number (%i) >= MAX_EDICTS (%i)\n", num, MAX_EDICTS);
851         if (num < 1)
852                 Host_Error("CL_ParseUpdate: invalid entity number (%i)\n", num);
853
854         // mark as visible (no kill)
855         entkill[num] = 0;
856
857         ent = CL_EntityNum (num);
858
859         for (i = 0;i < 32;i++)
860                 if (bits & (1 << i))
861                         bitprofile[i]++;
862         bitprofilecount++;
863
864         deltadie = false;
865         if (bits & U_DELTA)
866         {
867                 new = ent->state_current;
868                 if (!new.active)
869                         deltadie = true; // was not present in previous frame, leave hidden until next full update
870         }
871         else
872                 new = ent->state_baseline;
873
874         new.time = cl.mtime[0];
875
876         new.flags = 0;
877         new.active = true;
878         if (bits & U_MODEL)             new.modelindex = (new.modelindex & 0xFF00) | MSG_ReadByte();
879         if (bits & U_FRAME)             new.frame = (new.frame & 0xFF00) | MSG_ReadByte();
880         if (bits & U_COLORMAP)  new.colormap = MSG_ReadByte();
881         if (bits & U_SKIN)              new.skin = MSG_ReadByte();
882         if (bits & U_EFFECTS)   new.effects = (new.effects & 0xFF00) | MSG_ReadByte();
883         if (bits & U_ORIGIN1)   new.origin[0] = MSG_ReadCoord();
884         if (bits & U_ANGLE1)    new.angles[0] = MSG_ReadAngle();
885         if (bits & U_ORIGIN2)   new.origin[1] = MSG_ReadCoord();
886         if (bits & U_ANGLE2)    new.angles[1] = MSG_ReadAngle();
887         if (bits & U_ORIGIN3)   new.origin[2] = MSG_ReadCoord();
888         if (bits & U_ANGLE3)    new.angles[2] = MSG_ReadAngle();
889         if (bits & U_STEP)              new.flags |= RENDER_STEP;
890         if (bits & U_ALPHA)             new.alpha = MSG_ReadByte();
891         if (bits & U_SCALE)             new.scale = MSG_ReadByte();
892         if (bits & U_EFFECTS2)  new.effects = (new.effects & 0x00FF) | (MSG_ReadByte() << 8);
893         if (bits & U_GLOWSIZE)  new.glowsize = MSG_ReadByte();
894         if (bits & U_GLOWCOLOR) new.glowcolor = MSG_ReadByte();
895 #if 0
896         if (bits & U_COLORMOD)  {int i = MSG_ReadByte();float r = (((int) i >> 5) & 7) * 1.0 / 7, g = (((int) i >> 2) & 7) * 1.0 / 7, b = ((int) i & 3) * 1.0 / 3;Con_Printf("warning: U_COLORMOD %i (%1.2f %1.2f %1.2f) ignored\n", i, r, g, b);}
897 #else
898         // apparently the dpcrush demo uses this (unintended, and it uses white anyway)
899         if (bits & U_COLORMOD)  MSG_ReadByte();
900 #endif
901         if (bits & U_GLOWTRAIL) new.flags |= RENDER_GLOWTRAIL;
902         if (bits & U_FRAME2)    new.frame = (new.frame & 0x00FF) | (MSG_ReadByte() << 8);
903         if (bits & U_MODEL2)    new.modelindex = (new.modelindex & 0x00FF) | (MSG_ReadByte() << 8);
904         if (bits & U_VIEWMODEL) new.flags |= RENDER_VIEWMODEL;
905         if (bits & U_EXTERIORMODEL)     new.flags |= RENDER_EXTERIORMODEL;
906
907         // LordHavoc: to allow playback of the Nehahra movie
908         if (Nehahrademcompatibility && (bits & U_EXTEND1))
909         {
910                 // LordHavoc: evil format
911                 int i = MSG_ReadFloat();
912                 int j = MSG_ReadFloat() * 255.0f;
913                 if (i == 2)
914                 {
915                         if (MSG_ReadFloat())
916                                 new.effects |= EF_FULLBRIGHT;
917                 }
918                 if (j < 0)
919                         new.alpha = 0;
920                 else if (j == 0 || j >= 255)
921                         new.alpha = 255;
922                 else
923                         new.alpha = j;
924         }
925
926         if (deltadie)
927         {
928                 // hide the entity
929                 new.active = false;
930         }
931         else
932                 CL_ValidateState(&new);
933
934         if (new.flags & RENDER_STEP) // FIXME: rename this flag?
935         {
936                 // make time identical for memcmp
937                 new.time = ent->state_current.time;
938                 if (memcmp(&new, &ent->state_current, sizeof(entity_state_t)))
939                 {
940                         // state has changed
941                         ent->state_previous = ent->state_current;
942                         ent->state_current = new;
943                         // assume 10fps animation
944                         ent->state_previous.time = cl.mtime[0];
945                         ent->state_current.time = cl.mtime[0] + 0.1; //ent->state_previous.time + 0.1;
946                 }
947         }
948         else
949         {
950                 ent->state_previous = ent->state_current;
951                 ent->state_current = new;
952         }
953 }
954
955 char *bitprofilenames[32] =
956 {
957         "U_MOREBITS",
958         "U_ORIGIN1",
959         "U_ORIGIN2",
960         "U_ORIGIN3",
961         "U_ANGLE2",
962         "U_STEP",
963         "U_FRAME",
964         "U_SIGNAL",
965         "U_ANGLE1",
966         "U_ANGLE3",
967         "U_MODEL",
968         "U_COLORMAP",
969         "U_SKIN",
970         "U_EFFECTS",
971         "U_LONGENTITY",
972         "U_EXTEND1",
973         "U_DELTA",
974         "U_ALPHA",
975         "U_SCALE",
976         "U_EFFECTS2",
977         "U_GLOWSIZE",
978         "U_GLOWCOLOR",
979         "obsolete U_COLORMOD",
980         "U_EXTEND2",
981         "U_GLOWTRAIL",
982         "U_VIEWMODEL",
983         "U_FRAME2",
984         "U_MODEL2",
985         "U_EXTERIORMODEL",
986         "U_UNUSED29",
987         "U_UNUSED30",
988         "U_EXTEND3",
989 };
990
991 void CL_BitProfile_f(void)
992 {
993         int i;
994         Con_Printf("bitprofile: %i updates\n");
995         if (bitprofilecount)
996                 for (i = 0;i < 32;i++)
997 //                      if (bitprofile[i])
998                                 Con_Printf("%s: %i %3.2f%%\n", bitprofilenames[i], bitprofile[i], bitprofile[i] * 100.0 / bitprofilecount);
999         Con_Printf("\n");
1000         for (i = 0;i < 32;i++)
1001                 bitprofile[i] = 0;
1002         bitprofilecount = 0;
1003 }
1004
1005 void CL_EntityUpdateSetup(void)
1006 {
1007         memset(entkill, 1, MAX_EDICTS);
1008 }
1009
1010 void CL_EntityUpdateEnd(void)
1011 {
1012         int i;
1013         for (i = 1;i < MAX_EDICTS;i++)
1014                 if (entkill[i])
1015                         cl_entities[i].state_previous.active = cl_entities[i].state_current.active = 0;
1016 }
1017
1018 /*
1019 ==================
1020 CL_ParseBaseline
1021 ==================
1022 */
1023 void CL_ParseBaseline (entity_t *ent, int large)
1024 {
1025         int i;
1026
1027         memset(&ent->state_baseline, 0, sizeof(entity_state_t));
1028         ent->state_baseline.active = true;
1029         if (large)
1030         {
1031                 ent->state_baseline.modelindex = (unsigned short) MSG_ReadShort ();
1032                 ent->state_baseline.frame = (unsigned short) MSG_ReadShort ();
1033         }
1034         else
1035         {
1036                 ent->state_baseline.modelindex = MSG_ReadByte ();
1037                 ent->state_baseline.frame = MSG_ReadByte ();
1038         }
1039         ent->state_baseline.colormap = MSG_ReadByte();
1040         ent->state_baseline.skin = MSG_ReadByte();
1041         for (i = 0;i < 3;i++)
1042         {
1043                 ent->state_baseline.origin[i] = MSG_ReadCoord ();
1044                 ent->state_baseline.angles[i] = MSG_ReadAngle ();
1045         }
1046         ent->state_baseline.alpha = 255;
1047         ent->state_baseline.scale = 16;
1048         ent->state_baseline.glowsize = 0;
1049         ent->state_baseline.glowcolor = 254;
1050         ent->state_previous = ent->state_current = ent->state_baseline;
1051
1052         CL_ValidateState(&ent->state_baseline);
1053 }
1054
1055
1056 /*
1057 ==================
1058 CL_ParseClientdata
1059
1060 Server information pertaining to this client only
1061 ==================
1062 */
1063 void CL_ParseClientdata (int bits)
1064 {
1065         int i, j;
1066
1067         bits &= 0xFFFF;
1068         if (bits & SU_EXTEND1)
1069                 bits |= (MSG_ReadByte() << 16);
1070         if (bits & SU_EXTEND2)
1071                 bits |= (MSG_ReadByte() << 24);
1072
1073         if (bits & SU_VIEWHEIGHT)
1074                 cl.viewheight = MSG_ReadChar ();
1075         else
1076                 cl.viewheight = DEFAULT_VIEWHEIGHT;
1077
1078         if (bits & SU_IDEALPITCH)
1079                 cl.idealpitch = MSG_ReadChar ();
1080         else
1081                 cl.idealpitch = 0;
1082         
1083         VectorCopy (cl.mvelocity[0], cl.mvelocity[1]);
1084         for (i=0 ; i<3 ; i++)
1085         {
1086                 if (bits & (SU_PUNCH1<<i) )
1087                 {
1088                         if (dpprotocol)
1089                                 cl.punchangle[i] = MSG_ReadPreciseAngle();
1090                         else
1091                                 cl.punchangle[i] = MSG_ReadChar();
1092                 }
1093                 else
1094                         cl.punchangle[i] = 0;
1095                 if (bits & (SU_PUNCHVEC1<<i))
1096                         cl.punchvector[i] = MSG_ReadFloatCoord();
1097                 else
1098                         cl.punchvector[i] = 0;
1099                 if (bits & (SU_VELOCITY1<<i) )
1100                         cl.mvelocity[0][i] = MSG_ReadChar()*16;
1101                 else
1102                         cl.mvelocity[0][i] = 0;
1103         }
1104
1105         i = MSG_ReadLong ();
1106         if (cl.items != i)
1107         {       // set flash times
1108                 for (j=0 ; j<32 ; j++)
1109                         if ( (i & (1<<j)) && !(cl.items & (1<<j)))
1110                                 cl.item_gettime[j] = cl.time;
1111                 cl.items = i;
1112         }
1113                 
1114         cl.onground = (bits & SU_ONGROUND) != 0;
1115         cl.inwater = (bits & SU_INWATER) != 0;
1116
1117         cl.stats[STAT_WEAPONFRAME] = (bits & SU_WEAPONFRAME) ? MSG_ReadByte() : 0;
1118         cl.stats[STAT_ARMOR] = (bits & SU_ARMOR) ? MSG_ReadByte() : 0;
1119         cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? MSG_ReadByte() : 0;
1120         cl.stats[STAT_HEALTH] = MSG_ReadShort();
1121         cl.stats[STAT_AMMO] = MSG_ReadByte();
1122
1123         cl.stats[STAT_SHELLS] = MSG_ReadByte();
1124         cl.stats[STAT_NAILS] = MSG_ReadByte();
1125         cl.stats[STAT_ROCKETS] = MSG_ReadByte();
1126         cl.stats[STAT_CELLS] = MSG_ReadByte();
1127
1128         i = MSG_ReadByte ();
1129
1130         if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1131                 cl.stats[STAT_ACTIVEWEAPON] = (1<<i);
1132         else
1133                 cl.stats[STAT_ACTIVEWEAPON] = i;
1134 }
1135
1136 /*
1137 =====================
1138 CL_ParseStatic
1139 =====================
1140 */
1141 void CL_ParseStatic (int large)
1142 {
1143         entity_t *ent;
1144
1145         if (cl.num_statics >= MAX_STATIC_ENTITIES)
1146                 Host_Error ("Too many static entities");
1147         ent = &cl_static_entities[cl.num_statics++];
1148         CL_ParseBaseline (ent, large);
1149
1150 // copy it to the current state
1151         ent->render.model = cl.model_precache[ent->state_baseline.modelindex];
1152         ent->render.frame = ent->render.frame1 = ent->render.frame2 = ent->state_baseline.frame;
1153         ent->render.framelerp = 0;
1154         // make torchs play out of sync
1155         ent->render.frame1time = ent->render.frame2time = lhrandom(-10, -1);
1156         ent->render.colormap = -1; // no special coloring
1157         ent->render.skinnum = ent->state_baseline.skin;
1158         ent->render.effects = ent->state_baseline.effects;
1159         ent->render.alpha = 1;
1160         ent->render.scale = 1;
1161         ent->render.alpha = 1;
1162
1163         VectorCopy (ent->state_baseline.origin, ent->render.origin);
1164         VectorCopy (ent->state_baseline.angles, ent->render.angles);    
1165 }
1166
1167 /*
1168 ===================
1169 CL_ParseStaticSound
1170 ===================
1171 */
1172 void CL_ParseStaticSound (int large)
1173 {
1174         vec3_t          org;
1175         int                     sound_num, vol, atten;
1176
1177         MSG_ReadVector(org);
1178         if (large)
1179                 sound_num = (unsigned short) MSG_ReadShort ();
1180         else
1181                 sound_num = MSG_ReadByte ();
1182         vol = MSG_ReadByte ();
1183         atten = MSG_ReadByte ();
1184         
1185         S_StaticSound (cl.sound_precache[sound_num], org, vol, atten);
1186 }
1187
1188 void CL_ParseEffect (void)
1189 {
1190         vec3_t          org;
1191         int                     modelindex, startframe, framecount, framerate;
1192
1193         MSG_ReadVector(org);
1194         modelindex = MSG_ReadByte ();
1195         startframe = MSG_ReadByte ();
1196         framecount = MSG_ReadByte ();
1197         framerate = MSG_ReadByte ();
1198
1199         CL_Effect(org, modelindex, startframe, framecount, framerate);
1200 }
1201
1202 void CL_ParseEffect2 (void)
1203 {
1204         vec3_t          org;
1205         int                     modelindex, startframe, framecount, framerate;
1206
1207         MSG_ReadVector(org);
1208         modelindex = MSG_ReadShort ();
1209         startframe = MSG_ReadShort ();
1210         framecount = MSG_ReadByte ();
1211         framerate = MSG_ReadByte ();
1212
1213         CL_Effect(org, modelindex, startframe, framecount, framerate);
1214 }
1215
1216
1217 #define SHOWNET(x) if(cl_shownet.integer==2)Con_Printf ("%3i:%s\n", msg_readcount-1, x);
1218
1219 /*
1220 =====================
1221 CL_ParseServerMessage
1222 =====================
1223 */
1224 void CL_ParseServerMessage (void)
1225 {
1226         int                     cmd;
1227         int                     i, entitiesupdated;
1228         byte            cmdlog[32];
1229         char            *cmdlogname[32], *temp;
1230         int                     cmdindex, cmdcount = 0;
1231         
1232 //
1233 // if recording demos, copy the message out
1234 //
1235         if (cl_shownet.integer == 1)
1236                 Con_Printf ("%i ",net_message.cursize);
1237         else if (cl_shownet.integer == 2)
1238                 Con_Printf ("------------------\n");
1239         
1240         cl.onground = false;    // unless the server says otherwise     
1241 //
1242 // parse the message
1243 //
1244         MSG_BeginReading ();
1245
1246         entitiesupdated = false;
1247         CL_EntityUpdateSetup();
1248         
1249         while (1)
1250         {
1251                 if (msg_badread)
1252                         Host_Error ("CL_ParseServerMessage: Bad server message");
1253
1254                 cmd = MSG_ReadByte ();
1255
1256                 if (cmd == -1)
1257                 {
1258                         SHOWNET("END OF MESSAGE");
1259                         break;          // end of message
1260                 }
1261
1262                 cmdindex = cmdcount & 31;
1263                 cmdcount++;
1264                 cmdlog[cmdindex] = cmd;
1265
1266                 // if the high bit of the command byte is set, it is a fast update
1267                 if (cmd & 128)
1268                 {
1269                         // 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)
1270                         temp = "entity";
1271                         cmdlogname[cmdindex] = temp;
1272                         SHOWNET("fast update");
1273                         CL_ParseUpdate (cmd&127);
1274                         continue;
1275                 }
1276
1277                 SHOWNET(svc_strings[cmd]);
1278                 cmdlogname[cmdindex] = svc_strings[cmd];
1279                 if (!cmdlogname[cmdindex])
1280                 {
1281                         // 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)
1282                         temp = "<unknown>";
1283                         cmdlogname[cmdindex] = temp;
1284                 }
1285         
1286                 // other commands
1287                 switch (cmd)
1288                 {
1289                 default:
1290                         {
1291                                 char description[32*64], temp[64];
1292                                 int count;
1293                                 strcpy(description, "packet dump: ");
1294                                 i = cmdcount - 32;
1295                                 if (i < 0)
1296                                         i = 0;
1297                                 count = cmdcount - i;
1298                                 i &= 31;
1299                                 while(count > 0)
1300                                 {
1301                                         sprintf(temp, "%3i:%s ", cmdlog[i], cmdlogname[i]);
1302                                         strcat(description, temp);
1303                                         count--;
1304                                         i++;
1305                                         i &= 31;
1306                                 }
1307                                 description[strlen(description)-1] = '\n'; // replace the last space with a newline
1308                                 Con_Printf("%s", description);
1309                                 Host_Error ("CL_ParseServerMessage: Illegible server message\n");
1310                         }
1311                         break;
1312                         
1313                 case svc_nop:
1314 //                      Con_Printf ("svc_nop\n");
1315                         break;
1316                         
1317                 case svc_time:
1318                         // handle old protocols which do not have entity update ranges
1319                         entitiesupdated = true;
1320                         cl.mtime[1] = cl.mtime[0];
1321                         cl.mtime[0] = MSG_ReadFloat ();                 
1322                         break;
1323
1324                 case svc_clientdata:
1325                         i = MSG_ReadShort ();
1326                         CL_ParseClientdata (i);
1327                         break;
1328                 
1329                 case svc_version:
1330                         i = MSG_ReadLong ();
1331                         if (i != PROTOCOL_VERSION && i != DPPROTOCOL_VERSION && i != 250)
1332                                 Host_Error ("CL_ParseServerMessage: Server is protocol %i, not %i or %i", i, DPPROTOCOL_VERSION, PROTOCOL_VERSION);
1333                         Nehahrademcompatibility = false;
1334                         if (i == 250)
1335                                 Nehahrademcompatibility = true;
1336                         if (cls.demoplayback && demo_nehahra.integer)
1337                                 Nehahrademcompatibility = true;
1338                         dpprotocol = i == DPPROTOCOL_VERSION;
1339                         break;
1340                         
1341                 case svc_disconnect:
1342                         Host_EndGame ("Server disconnected\n");
1343
1344                 case svc_print:
1345                         Con_Printf ("%s", MSG_ReadString ());
1346                         break;
1347                         
1348                 case svc_centerprint:
1349                         SCR_CenterPrint (MSG_ReadString ());
1350                         break;
1351                         
1352                 case svc_stufftext:
1353                         Cbuf_AddText (MSG_ReadString ());
1354                         break;
1355
1356                 case svc_damage:
1357                         V_ParseDamage ();
1358                         break;
1359
1360                 case svc_serverinfo:
1361                         CL_ParseServerInfo ();
1362 //                      vid.recalc_refdef = true;       // leave intermission full screen
1363                         break;
1364                         
1365                 case svc_setangle:
1366                         for (i=0 ; i<3 ; i++)
1367                                 cl.viewangles[i] = MSG_ReadAngle ();
1368                         break;
1369                         
1370                 case svc_setview:
1371                         cl.viewentity = MSG_ReadShort ();
1372                         break;
1373                                         
1374                 case svc_lightstyle:
1375                         i = MSG_ReadByte ();
1376                         if (i >= MAX_LIGHTSTYLES)
1377                                 Host_Error ("svc_lightstyle >= MAX_LIGHTSTYLES");
1378                         strncpy (cl_lightstyle[i].map,  MSG_ReadString(), MAX_STYLESTRING - 1);
1379                         cl_lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
1380                         cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
1381                         break;
1382                         
1383                 case svc_sound:
1384                         CL_ParseStartSoundPacket(false);
1385                         break;
1386
1387                 case svc_sound2:
1388                         CL_ParseStartSoundPacket(true);
1389                         break;
1390
1391                 case svc_stopsound:
1392                         i = MSG_ReadShort();
1393                         S_StopSound(i>>3, i&7);
1394                         break;
1395
1396                 case svc_updatename:
1397                         i = MSG_ReadByte ();
1398                         if (i >= cl.maxclients)
1399                                 Host_Error ("CL_ParseServerMessage: svc_updatename >= MAX_SCOREBOARD");
1400                         strcpy (cl.scores[i].name, MSG_ReadString ());
1401                         break;
1402                         
1403                 case svc_updatefrags:
1404                         i = MSG_ReadByte ();
1405                         if (i >= cl.maxclients)
1406                                 Host_Error ("CL_ParseServerMessage: svc_updatefrags >= MAX_SCOREBOARD");
1407                         cl.scores[i].frags = MSG_ReadShort ();
1408                         break;                  
1409
1410                 case svc_updatecolors:
1411                         i = MSG_ReadByte ();
1412                         if (i >= cl.maxclients)
1413                                 Host_Error ("CL_ParseServerMessage: svc_updatecolors >= MAX_SCOREBOARD");
1414                         cl.scores[i].colors = MSG_ReadByte ();
1415                         break;
1416                         
1417                 case svc_particle:
1418                         CL_ParseParticleEffect ();
1419                         break;
1420
1421                 case svc_effect:
1422                         CL_ParseEffect ();
1423                         break;
1424
1425                 case svc_effect2:
1426                         CL_ParseEffect2 ();
1427                         break;
1428
1429                 case svc_spawnbaseline:
1430                         i = MSG_ReadShort ();
1431                         // must use CL_EntityNum() to force cl.num_entities up
1432                         CL_ParseBaseline (CL_EntityNum(i), false);
1433                         break;
1434                 case svc_spawnbaseline2:
1435                         i = MSG_ReadShort ();
1436                         // must use CL_EntityNum() to force cl.num_entities up
1437                         CL_ParseBaseline (CL_EntityNum(i), true);
1438                         break;
1439                 case svc_spawnstatic:
1440                         CL_ParseStatic (false);
1441                         break;
1442                 case svc_spawnstatic2:
1443                         CL_ParseStatic (true);
1444                         break;
1445                 case svc_temp_entity:
1446                         CL_ParseTEnt ();
1447                         break;
1448
1449                 case svc_setpause:
1450                         cl.paused = MSG_ReadByte ();
1451                         if (cl.paused)
1452                                 CDAudio_Pause ();
1453                         else
1454                                 CDAudio_Resume ();
1455                         break;
1456                         
1457                 case svc_signonnum:
1458                         i = MSG_ReadByte ();
1459                         if (i <= cls.signon)
1460                                 Host_Error ("Received signon %i when at %i", i, cls.signon);
1461                         cls.signon = i;
1462                         CL_SignonReply ();
1463                         break;
1464
1465                 case svc_killedmonster:
1466                         cl.stats[STAT_MONSTERS]++;
1467                         break;
1468
1469                 case svc_foundsecret:
1470                         cl.stats[STAT_SECRETS]++;
1471                         break;
1472
1473                 case svc_updatestat:
1474                         i = MSG_ReadByte ();
1475                         if (i < 0 || i >= MAX_CL_STATS)
1476                                 Host_Error ("svc_updatestat: %i is invalid", i);
1477                         cl.stats[i] = MSG_ReadLong ();
1478                         break;
1479                         
1480                 case svc_spawnstaticsound:
1481                         CL_ParseStaticSound (false);
1482                         break;
1483
1484                 case svc_spawnstaticsound2:
1485                         CL_ParseStaticSound (true);
1486                         break;
1487
1488                 case svc_cdtrack:
1489                         cl.cdtrack = MSG_ReadByte ();
1490                         cl.looptrack = MSG_ReadByte ();
1491                         if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
1492                                 CDAudio_Play ((byte)cls.forcetrack, true);
1493                         else
1494                                 CDAudio_Play ((byte)cl.cdtrack, true);
1495                         break;
1496
1497                 case svc_intermission:
1498                         cl.intermission = 1;
1499                         cl.completed_time = cl.time;
1500 //                      vid.recalc_refdef = true;       // go to full screen
1501                         break;
1502
1503                 case svc_finale:
1504                         cl.intermission = 2;
1505                         cl.completed_time = cl.time;
1506 //                      vid.recalc_refdef = true;       // go to full screen
1507                         SCR_CenterPrint (MSG_ReadString ());
1508                         break;
1509
1510                 case svc_cutscene:
1511                         cl.intermission = 3;
1512                         cl.completed_time = cl.time;
1513 //                      vid.recalc_refdef = true;       // go to full screen
1514                         SCR_CenterPrint (MSG_ReadString ());                    
1515                         break;
1516
1517                 case svc_sellscreen:
1518                         Cmd_ExecuteString ("help", src_command);
1519                         break;
1520                 case svc_hidelmp:
1521                         SHOWLMP_decodehide();
1522                         break;
1523                 case svc_showlmp:
1524                         SHOWLMP_decodeshow();
1525                         break;
1526                 case svc_skybox:
1527                         R_SetSkyBox(MSG_ReadString());
1528                         break;
1529                 }
1530         }
1531
1532         if (entitiesupdated)
1533                 CL_EntityUpdateEnd();
1534 }