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