cl_parse.c

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