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 void CL_ParseServerInfo (void)
 343 {
 344         char *str;
 345         int i;
 346         int nummodels, numsounds;
 347         char model_precache[MAX_MODELS][MAX_QPATH];
 348         char sound_precache[MAX_SOUNDS][MAX_QPATH];
 349         entity_t *ent;
 350
 351         Con_DPrintf ("Serverinfo packet received.\n");
 352 //
 353 // wipe the client_state_t struct
 354 //
 355         CL_ClearState ();
 356
 357 // parse protocol version number
 358         i = MSG_ReadLong ();
 359         if (i != PROTOCOL_VERSION && i != DPPROTOCOL_VERSION1 && i != DPPROTOCOL_VERSION2 && i != DPPROTOCOL_VERSION3 && i != 250)
 360         {
 361                 Con_Printf ("Server is protocol %i, not %i, %i, %i or %i", i, DPPROTOCOL_VERSION1, DPPROTOCOL_VERSION2, DPPROTOCOL_VERSION3, PROTOCOL_VERSION);
 362                 return;
 363         }
 364         Nehahrademcompatibility = false;
 365         if (i == 250)
 366                 Nehahrademcompatibility = true;
 367         if (cls.demoplayback && demo_nehahra.integer)
 368                 Nehahrademcompatibility = true;
 369         dpprotocol = i;
 370         if (dpprotocol != DPPROTOCOL_VERSION1 && dpprotocol != DPPROTOCOL_VERSION2 && dpprotocol != DPPROTOCOL_VERSION3)
 371                 dpprotocol = 0;
 372
 373 // parse maxclients
 374         cl.maxclients = MSG_ReadByte ();
 375         if (cl.maxclients < 1 || cl.maxclients > MAX_SCOREBOARD)
 376         {
 377                 Con_Printf("Bad maxclients (%u) from server\n", cl.maxclients);
 378                 return;
 379         }
 380         cl.scores = Mem_Alloc(cl_scores_mempool, cl.maxclients*sizeof(*cl.scores));
 381
 382 // parse gametype
 383         cl.gametype = MSG_ReadByte ();
 384
 385 // parse signon message
 386         str = MSG_ReadString ();
 387         strncpy (cl.levelname, str, sizeof(cl.levelname)-1);
 388
 389 // seperate the printfs so the server message can have a color
 390         if (!Nehahrademcompatibility) // no messages when playing the Nehahra movie
 391         {
 392                 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");
 393                 Con_Printf ("%c%s\n", 2, str);
 394         }
 395
 396 //
 397 // first we go through and touch all of the precache data that still
 398 // happens to be in the cache, so precaching something else doesn't
 399 // needlessly purge it
 400 //
 401
 402         Mem_CheckSentinelsGlobal();
 403
 404         Mod_ClearUsed();
 405
 406 // precache models
 407         memset (cl.model_precache, 0, sizeof(cl.model_precache));
 408         for (nummodels=1 ; ; nummodels++)
 409         {
 410                 str = MSG_ReadString ();
 411                 if (!str[0])
 412                         break;
 413                 if (nummodels==MAX_MODELS)
 414                 {
 415                         Host_Error ("Server sent too many model precaches\n");
 416                         return;
 417                 }
 418                 if (strlen(str) >= MAX_QPATH)
 419                         Host_Error ("Server sent a precache name of %i characters (max %i)", strlen(str), MAX_QPATH - 1);
 420                 strcpy (model_precache[nummodels], str);
 421                 Mod_TouchModel (str);
 422         }
 423
 424 // precache sounds
 425         memset (cl.sound_precache, 0, sizeof(cl.sound_precache));
 426         for (numsounds=1 ; ; numsounds++)
 427         {
 428                 str = MSG_ReadString ();
 429                 if (!str[0])
 430                         break;
 431                 if (numsounds==MAX_SOUNDS)
 432                 {
 433                         Host_Error ("Server sent too many sound precaches\n");
 434                         return;
 435                 }
 436                 if (strlen(str) >= MAX_QPATH)
 437                         Host_Error ("Server sent a precache name of %i characters (max %i)", strlen(str), MAX_QPATH - 1);
 438                 strcpy (sound_precache[numsounds], str);
 439                 S_TouchSound (str);
 440         }
 441
 442         Mod_PurgeUnused();
 443
 444 //
 445 // now we try to load everything else until a cache allocation fails
 446 //
 447
 448         for (i=1 ; i<nummodels ; i++)
 449         {
 450                 // LordHavoc: i == 1 means the first model is the world model
 451                 cl.model_precache[i] = Mod_ForName (model_precache[i], false, false, i == 1);
 452
 453                 if (cl.model_precache[i] == NULL)
 454                 {
 455                         Host_Error("Model %s not found\n", model_precache[i]);
 456                         return;
 457                 }
 458                 CL_KeepaliveMessage ();
 459         }
 460
 461         S_BeginPrecaching ();
 462         for (i=1 ; i<numsounds ; i++)
 463         {
 464                 cl.sound_precache[i] = S_PrecacheSound (sound_precache[i], true);
 465                 CL_KeepaliveMessage ();
 466         }
 467         S_EndPrecaching ();
 468
 469 // local state
 470         ent = &cl_entities[0];
 471         memset(ent, 0, sizeof(entity_t));
 472         ent->render.model = cl.worldmodel = cl.model_precache[1];
 473         ent->render.scale = 1;
 474         ent->render.alpha = 1;
 475
 476         if (ent->render.angles[0] || ent->render.angles[2])
 477         {
 478                 // pitch or roll
 479                 VectorAdd(ent->render.origin, ent->render.model->rotatedmins, ent->render.mins);
 480                 VectorAdd(ent->render.origin, ent->render.model->rotatedmaxs, ent->render.maxs);
 481         }
 482         else if (ent->render.angles[1])
 483         {
 484                 // yaw
 485                 VectorAdd(ent->render.origin, ent->render.model->yawmins, ent->render.mins);
 486                 VectorAdd(ent->render.origin, ent->render.model->yawmaxs, ent->render.maxs);
 487         }
 488         else
 489         {
 490                 VectorAdd(ent->render.origin, ent->render.model->normalmins, ent->render.mins);
 491                 VectorAdd(ent->render.origin, ent->render.model->normalmaxs, ent->render.maxs);
 492         }
 493
 494         cl_num_entities = 1;
 495
 496         R_NewMap ();
 497
 498         CL_CGVM_Start();
 499
 500         Mem_CheckSentinelsGlobal();
 501
 502         noclip_anglehack = false;               // noclip is turned off at start
 503 }
 504
 505 void CL_ValidateState(entity_state_t *s)
 506 {
 507         model_t *model;
 508
 509         if (!s->active)
 510                 return;
 511
 512         if (s->modelindex >= MAX_MODELS)
 513                 Host_Error("CL_ValidateState: modelindex (%i) >= MAX_MODELS (%i)\n", s->modelindex, MAX_MODELS);
 514
 515         // colormap is client index + 1
 516         if (s->colormap > cl.maxclients)
 517                 Host_Error ("CL_ValidateState: colormap (%i) > cl.maxclients (%i)", s->colormap, cl.maxclients);
 518
 519         model = cl.model_precache[s->modelindex];
 520         Mod_CheckLoaded(model);
 521         if (model && s->frame >= model->numframes)
 522         {
 523                 Con_DPrintf("CL_ValidateState: no such frame %i in \"%s\"\n", s->frame, model->name);
 524                 s->frame = 0;
 525         }
 526         if (model && s->skin > 0 && s->skin >= model->numskins)
 527         {
 528                 Con_DPrintf("CL_ValidateState: no such skin %i in \"%s\"\n", s->skin, model->name);
 529                 s->skin = 0;
 530         }
 531 }
 532
 533 /*
 534 ==================
 535 CL_ParseUpdate
 536
 537 Parse an entity update message from the server
 538 If an entities model or origin changes from frame to frame, it must be
 539 relinked.  Other attributes can change without relinking.
 540 ==================
 541 */
 542 qbyte entkill[MAX_EDICTS];
 543 int bitprofile[32], bitprofilecount = 0;
 544 void CL_ParseUpdate (int bits)
 545 {
 546         int i, num, deltadie;
 547         entity_t *ent;
 548         entity_state_t new;
 549
 550         if (bits & U_MOREBITS)
 551                 bits |= (MSG_ReadByte()<<8);
 552         if ((bits & U_EXTEND1) && (!Nehahrademcompatibility))
 553         {
 554                 bits |= MSG_ReadByte() << 16;
 555                 if (bits & U_EXTEND2)
 556                         bits |= MSG_ReadByte() << 24;
 557         }
 558
 559         if (bits & U_LONGENTITY)
 560                 num = (unsigned) MSG_ReadShort ();
 561         else
 562                 num = (unsigned) MSG_ReadByte ();
 563
 564         if (num >= MAX_EDICTS)
 565                 Host_Error("CL_ParseUpdate: entity number (%i) >= MAX_EDICTS (%i)\n", num, MAX_EDICTS);
 566         if (num < 1)
 567                 Host_Error("CL_ParseUpdate: invalid entity number (%i)\n", num);
 568
 569         // mark as visible (no kill)
 570         entkill[num] = 0;
 571
 572         ent = CL_EntityNum (num);
 573
 574         for (i = 0;i < 32;i++)
 575                 if (bits & (1 << i))
 576                         bitprofile[i]++;
 577         bitprofilecount++;
 578
 579         deltadie = false;
 580         if (bits & U_DELTA)
 581         {
 582                 new = ent->state_current;
 583                 if (!new.active)
 584                         deltadie = true; // was not present in previous frame, leave hidden until next full update
 585         }
 586         else
 587                 new = ent->state_baseline;
 588
 589         new.time = cl.mtime[0];
 590
 591         new.flags = 0;
 592         new.active = true;
 593         if (bits & U_MODEL)             new.modelindex = (new.modelindex & 0xFF00) | MSG_ReadByte();
 594         if (bits & U_FRAME)             new.frame = (new.frame & 0xFF00) | MSG_ReadByte();
 595         if (bits & U_COLORMAP)  new.colormap = MSG_ReadByte();
 596         if (bits & U_SKIN)              new.skin = MSG_ReadByte();
 597         if (bits & U_EFFECTS)   new.effects = (new.effects & 0xFF00) | MSG_ReadByte();
 598         if (bits & U_ORIGIN1)   new.origin[0] = MSG_ReadCoord();
 599         if (bits & U_ANGLE1)    new.angles[0] = MSG_ReadAngle();
 600         if (bits & U_ORIGIN2)   new.origin[1] = MSG_ReadCoord();
 601         if (bits & U_ANGLE2)    new.angles[1] = MSG_ReadAngle();
 602         if (bits & U_ORIGIN3)   new.origin[2] = MSG_ReadCoord();
 603         if (bits & U_ANGLE3)    new.angles[2] = MSG_ReadAngle();
 604         if (bits & U_STEP)              new.flags |= RENDER_STEP;
 605         if (bits & U_ALPHA)             new.alpha = MSG_ReadByte();
 606         if (bits & U_SCALE)             new.scale = MSG_ReadByte();
 607         if (bits & U_EFFECTS2)  new.effects = (new.effects & 0x00FF) | (MSG_ReadByte() << 8);
 608         if (bits & U_GLOWSIZE)  new.glowsize = MSG_ReadByte();
 609         if (bits & U_GLOWCOLOR) new.glowcolor = MSG_ReadByte();
 610         // apparently the dpcrush demo uses this (unintended, and it uses white anyway)
 611         if (bits & U_COLORMOD)  MSG_ReadByte();
 612         if (bits & U_GLOWTRAIL) new.flags |= RENDER_GLOWTRAIL;
 613         if (bits & U_FRAME2)    new.frame = (new.frame & 0x00FF) | (MSG_ReadByte() << 8);
 614         if (bits & U_MODEL2)    new.modelindex = (new.modelindex & 0x00FF) | (MSG_ReadByte() << 8);
 615         if (bits & U_VIEWMODEL) new.flags |= RENDER_VIEWMODEL;
 616         if (bits & U_EXTERIORMODEL)     new.flags |= RENDER_EXTERIORMODEL;
 617
 618         // LordHavoc: to allow playback of the Nehahra movie
 619         if (Nehahrademcompatibility && (bits & U_EXTEND1))
 620         {
 621                 // LordHavoc: evil format
 622                 int i = MSG_ReadFloat();
 623                 int j = MSG_ReadFloat() * 255.0f;
 624                 if (i == 2)
 625                 {
 626                         i = MSG_ReadFloat();
 627                         if (i)
 628                                 new.effects |= EF_FULLBRIGHT;
 629                 }
 630                 if (j < 0)
 631                         new.alpha = 0;
 632                 else if (j == 0 || j >= 255)
 633                         new.alpha = 255;
 634                 else
 635                         new.alpha = j;
 636         }
 637
 638         if (deltadie)
 639         {
 640                 // hide the entity
 641                 new.active = false;
 642         }
 643         else
 644                 CL_ValidateState(&new);
 645
 646         if (new.flags & RENDER_STEP) // FIXME: rename this flag?
 647         {
 648                 // make time identical for memcmp
 649                 new.time = ent->state_current.time;
 650                 if (memcmp(&new, &ent->state_current, sizeof(entity_state_t)))
 651                 {
 652                         // set it back to what it should be
 653                         new.time = cl.mtime[0] + 0.1;
 654                         // state has changed
 655                         ent->state_previous = ent->state_current;
 656                         ent->state_current = new;
 657                         // assume 10fps animation
 658                         //ent->state_previous.time = cl.mtime[0] - 0.1;
 659                 }
 660         }
 661         else
 662         {
 663                 ent->state_previous = ent->state_current;
 664                 ent->state_current = new;
 665         }
 666 }
 667
 668 void CL_ReadEntityFrame(void)
 669 {
 670         entity_t *ent;
 671         entity_state_t *s;
 672         entity_frame_t entityframe;
 673         int i;
 674         EntityFrame_Read(&cl.entitydatabase);
 675         EntityFrame_FetchFrame(&cl.entitydatabase, EntityFrame_MostRecentlyRecievedFrameNum(&cl.entitydatabase), &entityframe);
 676         for (i = 0;i < entityframe.numentities;i++)
 677         {
 678                 s = &entityframe.entitydata[i];
 679                 entkill[s->number] = 0;
 680                 ent = &cl_entities[s->number];
 681                 memcpy(&ent->state_previous, &ent->state_current, sizeof(*s));
 682                 memcpy(&ent->state_current, s, sizeof(*s));
 683                 ent->state_current.time = cl.mtime[0];
 684         }
 685         VectorCopy(cl.viewentoriginnew, cl.viewentoriginold);
 686         VectorCopy(entityframe.eye, cl.viewentoriginnew);
 687 }
 688
 689 char *bitprofilenames[32] =
 690 {
 691         "U_MOREBITS",
 692         "U_ORIGIN1",
 693         "U_ORIGIN2",
 694         "U_ORIGIN3",
 695         "U_ANGLE2",
 696         "U_STEP",
 697         "U_FRAME",
 698         "U_SIGNAL",
 699         "U_ANGLE1",
 700         "U_ANGLE3",
 701         "U_MODEL",
 702         "U_COLORMAP",
 703         "U_SKIN",
 704         "U_EFFECTS",
 705         "U_LONGENTITY",
 706         "U_EXTEND1",
 707         "U_DELTA",
 708         "U_ALPHA",
 709         "U_SCALE",
 710         "U_EFFECTS2",
 711         "U_GLOWSIZE",
 712         "U_GLOWCOLOR",
 713         "obsolete U_COLORMOD",
 714         "U_EXTEND2",
 715         "U_GLOWTRAIL",
 716         "U_VIEWMODEL",
 717         "U_FRAME2",
 718         "U_MODEL2",
 719         "U_EXTERIORMODEL",
 720         "U_UNUSED29",
 721         "U_UNUSED30",
 722         "U_EXTEND3",
 723 };
 724
 725 void CL_BitProfile_f(void)
 726 {
 727         int i;
 728         Con_Printf("bitprofile: %i updates\n");
 729         if (bitprofilecount)
 730                 for (i = 0;i < 32;i++)
 731                         Con_Printf("%s: %i %3.2f%%\n", bitprofilenames[i], bitprofile[i], bitprofile[i] * 100.0 / bitprofilecount);
 732         Con_Printf("\n");
 733         for (i = 0;i < 32;i++)
 734                 bitprofile[i] = 0;
 735         bitprofilecount = 0;
 736 }
 737
 738 void CL_EntityUpdateSetup(void)
 739 {
 740         memset(entkill, 1, MAX_EDICTS);
 741 }
 742
 743 void CL_EntityUpdateEnd(void)
 744 {
 745         int i;
 746         for (i = 1;i < MAX_EDICTS;i++)
 747                 if (entkill[i])
 748                         cl_entities[i].state_previous.active = cl_entities[i].state_current.active = 0;
 749 }
 750
 751 /*
 752 ==================
 753 CL_ParseBaseline
 754 ==================
 755 */
 756 void CL_ParseBaseline (entity_t *ent, int large)
 757 {
 758         int i;
 759
 760         memset(&ent->state_baseline, 0, sizeof(entity_state_t));
 761         ent->state_baseline.active = true;
 762         if (large)
 763         {
 764                 ent->state_baseline.modelindex = (unsigned short) MSG_ReadShort ();
 765                 ent->state_baseline.frame = (unsigned short) MSG_ReadShort ();
 766         }
 767         else
 768         {
 769                 ent->state_baseline.modelindex = MSG_ReadByte ();
 770                 ent->state_baseline.frame = MSG_ReadByte ();
 771         }
 772         ent->state_baseline.colormap = MSG_ReadByte();
 773         ent->state_baseline.skin = MSG_ReadByte();
 774         for (i = 0;i < 3;i++)
 775         {
 776                 ent->state_baseline.origin[i] = MSG_ReadCoord ();
 777                 ent->state_baseline.angles[i] = MSG_ReadAngle ();
 778         }
 779         ent->state_baseline.alpha = 255;
 780         ent->state_baseline.scale = 16;
 781         ent->state_baseline.glowsize = 0;
 782         ent->state_baseline.glowcolor = 254;
 783         ent->state_previous = ent->state_current = ent->state_baseline;
 784
 785         CL_ValidateState(&ent->state_baseline);
 786 }
 787
 788
 789 /*
 790 ==================
 791 CL_ParseClientdata
 792
 793 Server information pertaining to this client only
 794 ==================
 795 */
 796 void CL_ParseClientdata (int bits)
 797 {
 798         int i, j;
 799
 800         bits &= 0xFFFF;
 801         if (bits & SU_EXTEND1)
 802                 bits |= (MSG_ReadByte() << 16);
 803         if (bits & SU_EXTEND2)
 804                 bits |= (MSG_ReadByte() << 24);
 805
 806         if (bits & SU_VIEWHEIGHT)
 807                 cl.viewheight = MSG_ReadChar ();
 808         else
 809                 cl.viewheight = DEFAULT_VIEWHEIGHT;
 810
 811         if (bits & SU_IDEALPITCH)
 812                 cl.idealpitch = MSG_ReadChar ();
 813         else
 814                 cl.idealpitch = 0;
 815
 816         VectorCopy (cl.mvelocity[0], cl.mvelocity[1]);
 817         for (i=0 ; i<3 ; i++)
 818         {
 819                 if (bits & (SU_PUNCH1<<i) )
 820                 {
 821                         if (dpprotocol)
 822                                 cl.punchangle[i] = MSG_ReadPreciseAngle();
 823                         else
 824                                 cl.punchangle[i] = MSG_ReadChar();
 825                 }
 826                 else
 827                         cl.punchangle[i] = 0;
 828                 if (bits & (SU_PUNCHVEC1<<i))
 829                         cl.punchvector[i] = MSG_ReadCoord();
 830                 else
 831                         cl.punchvector[i] = 0;
 832                 if (bits & (SU_VELOCITY1<<i) )
 833                         cl.mvelocity[0][i] = MSG_ReadChar()*16;
 834                 else
 835                         cl.mvelocity[0][i] = 0;
 836         }
 837
 838         i = MSG_ReadLong ();
 839         if (cl.items != i)
 840         {       // set flash times
 841                 for (j=0 ; j<32 ; j++)
 842                         if ( (i & (1<<j)) && !(cl.items & (1<<j)))
 843                                 cl.item_gettime[j] = cl.time;
 844                 cl.items = i;
 845         }
 846
 847         cl.onground = (bits & SU_ONGROUND) != 0;
 848         cl.inwater = (bits & SU_INWATER) != 0;
 849
 850         cl.stats[STAT_WEAPONFRAME] = (bits & SU_WEAPONFRAME) ? MSG_ReadByte() : 0;
 851         cl.stats[STAT_ARMOR] = (bits & SU_ARMOR) ? MSG_ReadByte() : 0;
 852         cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? MSG_ReadByte() : 0;
 853         cl.stats[STAT_HEALTH] = MSG_ReadShort();
 854         cl.stats[STAT_AMMO] = MSG_ReadByte();
 855
 856         cl.stats[STAT_SHELLS] = MSG_ReadByte();
 857         cl.stats[STAT_NAILS] = MSG_ReadByte();
 858         cl.stats[STAT_ROCKETS] = MSG_ReadByte();
 859         cl.stats[STAT_CELLS] = MSG_ReadByte();
 860
 861         i = MSG_ReadByte ();
 862
 863         if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
 864                 cl.stats[STAT_ACTIVEWEAPON] = (1<<i);
 865         else
 866                 cl.stats[STAT_ACTIVEWEAPON] = i;
 867
 868         cl.viewzoomold = cl.viewzoomnew; // for interpolation
 869         if (bits & SU_VIEWZOOM)
 870         {
 871                 i = MSG_ReadByte();
 872                 if (i < 2)
 873                         i = 2;
 874                 cl.viewzoomnew = (float) i * (1.0f / 255.0f);
 875         }
 876         else
 877                 cl.viewzoomnew = 1;
 878
 879 }
 880
 881 /*
 882 =====================
 883 CL_ParseStatic
 884 =====================
 885 */
 886 void CL_ParseStatic (int large)
 887 {
 888         entity_t *ent;
 889
 890         if (cl_num_static_entities >= cl_max_static_entities)
 891                 Host_Error ("Too many static entities");
 892         ent = &cl_static_entities[cl_num_static_entities++];
 893         CL_ParseBaseline (ent, large);
 894
 895 // copy it to the current state
 896         ent->render.model = cl.model_precache[ent->state_baseline.modelindex];
 897         ent->render.frame = ent->render.frame1 = ent->render.frame2 = ent->state_baseline.frame;
 898         ent->render.framelerp = 0;
 899         // make torchs play out of sync
 900         ent->render.frame1time = ent->render.frame2time = lhrandom(-10, -1);
 901         ent->render.colormap = -1; // no special coloring
 902         ent->render.skinnum = ent->state_baseline.skin;
 903         ent->render.effects = ent->state_baseline.effects;
 904         ent->render.alpha = 1;
 905         ent->render.scale = 1;
 906         ent->render.alpha = 1;
 907
 908         VectorCopy (ent->state_baseline.origin, ent->render.origin);
 909         VectorCopy (ent->state_baseline.angles, ent->render.angles);
 910
 911         if (ent->render.angles[0] || ent->render.angles[2])
 912         {
 913                 // pitch or roll
 914                 VectorAdd(ent->render.origin, ent->render.model->rotatedmins, ent->render.mins);
 915                 VectorAdd(ent->render.origin, ent->render.model->rotatedmaxs, ent->render.maxs);
 916         }
 917         else if (ent->render.angles[1])
 918         {
 919                 // yaw
 920                 VectorAdd(ent->render.origin, ent->render.model->yawmins, ent->render.mins);
 921                 VectorAdd(ent->render.origin, ent->render.model->yawmaxs, ent->render.maxs);
 922         }
 923         else
 924         {
 925                 VectorAdd(ent->render.origin, ent->render.model->normalmins, ent->render.mins);
 926                 VectorAdd(ent->render.origin, ent->render.model->normalmaxs, ent->render.maxs);
 927         }
 928
 929         // This is definitely cheating...
 930         if (ent->render.model == NULL)
 931                 cl_num_static_entities--;
 932 }
 933
 934 /*
 935 ===================
 936 CL_ParseStaticSound
 937 ===================
 938 */
 939 void CL_ParseStaticSound (int large)
 940 {
 941         vec3_t          org;
 942         int                     sound_num, vol, atten;
 943
 944         MSG_ReadVector(org);
 945         if (large)
 946                 sound_num = (unsigned short) MSG_ReadShort ();
 947         else
 948                 sound_num = MSG_ReadByte ();
 949         vol = MSG_ReadByte ();
 950         atten = MSG_ReadByte ();
 951
 952         S_StaticSound (cl.sound_precache[sound_num], org, vol, atten);
 953 }
 954
 955 void CL_ParseEffect (void)
 956 {
 957         vec3_t          org;
 958         int                     modelindex, startframe, framecount, framerate;
 959
 960         MSG_ReadVector(org);
 961         modelindex = MSG_ReadByte ();
 962         startframe = MSG_ReadByte ();
 963         framecount = MSG_ReadByte ();
 964         framerate = MSG_ReadByte ();
 965
 966         CL_Effect(org, modelindex, startframe, framecount, framerate);
 967 }
 968
 969 void CL_ParseEffect2 (void)
 970 {
 971         vec3_t          org;
 972         int                     modelindex, startframe, framecount, framerate;
 973
 974         MSG_ReadVector(org);
 975         modelindex = MSG_ReadShort ();
 976         startframe = MSG_ReadShort ();
 977         framecount = MSG_ReadByte ();
 978         framerate = MSG_ReadByte ();
 979
 980         CL_Effect(org, modelindex, startframe, framecount, framerate);
 981 }
 982
 983
 984 #define SHOWNET(x) if(cl_shownet.integer==2)Con_Printf ("%3i:%s\n", msg_readcount-1, x);
 985
 986 static qbyte cgamenetbuffer[65536];
 987
 988 /*
 989 =====================
 990 CL_ParseServerMessage
 991 =====================
 992 */
 993 void CL_ParseServerMessage (void)
 994 {
 995         int                     cmd;
 996         int                     i, entitiesupdated;
 997         qbyte           cmdlog[32];
 998         char            *cmdlogname[32], *temp;
 999         int                     cmdindex, cmdcount = 0;
1000
1001 //
1002 // if recording demos, copy the message out
1003 //
1004         if (cl_shownet.integer == 1)
1005                 Con_Printf ("%i ",net_message.cursize);
1006         else if (cl_shownet.integer == 2)
1007                 Con_Printf ("------------------\n");
1008
1009         cl.onground = false;    // unless the server says otherwise
1010 //
1011 // parse the message
1012 //
1013         MSG_BeginReading ();
1014
1015         entitiesupdated = false;
1016         CL_EntityUpdateSetup();
1017
1018         while (1)
1019         {
1020                 if (msg_badread)
1021                         Host_Error ("CL_ParseServerMessage: Bad server message");
1022
1023                 cmd = MSG_ReadByte ();
1024
1025                 if (cmd == -1)
1026                 {
1027                         SHOWNET("END OF MESSAGE");
1028                         break;          // end of message
1029                 }
1030
1031                 cmdindex = cmdcount & 31;
1032                 cmdcount++;
1033                 cmdlog[cmdindex] = cmd;
1034
1035                 // if the high bit of the command byte is set, it is a fast update
1036                 if (cmd & 128)
1037                 {
1038                         // 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)
1039                         temp = "entity";
1040                         cmdlogname[cmdindex] = temp;
1041                         SHOWNET("fast update");
1042                         if (cls.signon == SIGNONS - 1)
1043                         {       // first update is the final signon stage
1044                                 cls.signon = SIGNONS;
1045                                 CL_SignonReply ();
1046                         }
1047                         CL_ParseUpdate (cmd&127);
1048                         continue;
1049                 }
1050
1051                 SHOWNET(svc_strings[cmd]);
1052                 cmdlogname[cmdindex] = svc_strings[cmd];
1053                 if (!cmdlogname[cmdindex])
1054                 {
1055                         // 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)
1056                         temp = "<unknown>";
1057                         cmdlogname[cmdindex] = temp;
1058                 }
1059
1060                 // other commands
1061                 switch (cmd)
1062                 {
1063                 default:
1064                         {
1065                                 char description[32*64], temp[64];
1066                                 int count;
1067                                 strcpy(description, "packet dump: ");
1068                                 i = cmdcount - 32;
1069                                 if (i < 0)
1070                                         i = 0;
1071                                 count = cmdcount - i;
1072                                 i &= 31;
1073                                 while(count > 0)
1074                                 {
1075                                         sprintf(temp, "%3i:%s ", cmdlog[i], cmdlogname[i]);
1076                                         strcat(description, temp);
1077                                         count--;
1078                                         i++;
1079                                         i &= 31;
1080                                 }
1081                                 description[strlen(description)-1] = '\n'; // replace the last space with a newline
1082                                 Con_Printf("%s", description);
1083                                 Host_Error ("CL_ParseServerMessage: Illegible server message\n");
1084                         }
1085                         break;
1086
1087                 case svc_nop:
1088                         break;
1089
1090                 case svc_time:
1091                         // handle old protocols which do not have entity update ranges
1092                         entitiesupdated = true;
1093                         cl.mtime[1] = cl.mtime[0];
1094                         cl.mtime[0] = MSG_ReadFloat ();
1095                         break;
1096
1097                 case svc_clientdata:
1098                         i = MSG_ReadShort ();
1099                         CL_ParseClientdata (i);
1100                         break;
1101
1102                 case svc_version:
1103                         i = MSG_ReadLong ();
1104                         if (i != PROTOCOL_VERSION && i != DPPROTOCOL_VERSION1 && i != DPPROTOCOL_VERSION2 && i != DPPROTOCOL_VERSION3 && i != 250)
1105                                 Host_Error ("CL_ParseServerMessage: Server is protocol %i, not %i, %i, %i or %i", i, DPPROTOCOL_VERSION1, DPPROTOCOL_VERSION2, DPPROTOCOL_VERSION3, PROTOCOL_VERSION);
1106                         Nehahrademcompatibility = false;
1107                         if (i == 250)
1108                                 Nehahrademcompatibility = true;
1109                         if (cls.demoplayback && demo_nehahra.integer)
1110                                 Nehahrademcompatibility = true;
1111                         dpprotocol = i;
1112                         if (dpprotocol != DPPROTOCOL_VERSION1 && dpprotocol != DPPROTOCOL_VERSION2 && dpprotocol != DPPROTOCOL_VERSION3)
1113                                 dpprotocol = 0;
1114                         break;
1115
1116                 case svc_disconnect:
1117                         Host_EndGame ("Server disconnected\n");
1118
1119                 case svc_print:
1120                         Con_Printf ("%s", MSG_ReadString ());
1121                         break;
1122
1123                 case svc_centerprint:
1124                         SCR_CenterPrint (MSG_ReadString ());
1125                         break;
1126
1127                 case svc_stufftext:
1128                         Cbuf_AddText (MSG_ReadString ());
1129                         break;
1130
1131                 case svc_damage:
1132                         V_ParseDamage ();
1133                         break;
1134
1135                 case svc_serverinfo:
1136                         CL_ParseServerInfo ();
1137                         break;
1138
1139                 case svc_setangle:
1140                         for (i=0 ; i<3 ; i++)
1141                                 cl.viewangles[i] = MSG_ReadAngle ();
1142                         break;
1143
1144                 case svc_setview:
1145                         cl.viewentity = MSG_ReadShort ();
1146                         break;
1147
1148                 case svc_lightstyle:
1149                         i = MSG_ReadByte ();
1150                         if (i >= MAX_LIGHTSTYLES)
1151                                 Host_Error ("svc_lightstyle >= MAX_LIGHTSTYLES");
1152                         strncpy (cl_lightstyle[i].map,  MSG_ReadString(), MAX_STYLESTRING - 1);
1153                         cl_lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
1154                         cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
1155                         break;
1156
1157                 case svc_sound:
1158                         CL_ParseStartSoundPacket(false);
1159                         break;
1160
1161                 case svc_sound2:
1162                         CL_ParseStartSoundPacket(true);
1163                         break;
1164
1165                 case svc_stopsound:
1166                         i = MSG_ReadShort();
1167                         S_StopSound(i>>3, i&7);
1168                         break;
1169
1170                 case svc_updatename:
1171                         i = MSG_ReadByte ();
1172                         if (i >= cl.maxclients)
1173                                 Host_Error ("CL_ParseServerMessage: svc_updatename >= cl.maxclients");
1174                         strcpy (cl.scores[i].name, MSG_ReadString ());
1175                         break;
1176
1177                 case svc_updatefrags:
1178                         i = MSG_ReadByte ();
1179                         if (i >= cl.maxclients)
1180                                 Host_Error ("CL_ParseServerMessage: svc_updatefrags >= cl.maxclients");
1181                         cl.scores[i].frags = MSG_ReadShort ();
1182                         break;
1183
1184                 case svc_updatecolors:
1185                         i = MSG_ReadByte ();
1186                         if (i >= cl.maxclients)
1187                                 Host_Error ("CL_ParseServerMessage: svc_updatecolors >= cl.maxclients");
1188                         cl.scores[i].colors = MSG_ReadByte ();
1189                         break;
1190
1191                 case svc_particle:
1192                         CL_ParseParticleEffect ();
1193                         break;
1194
1195                 case svc_effect:
1196                         CL_ParseEffect ();
1197                         break;
1198
1199                 case svc_effect2:
1200                         CL_ParseEffect2 ();
1201                         break;
1202
1203                 case svc_spawnbaseline:
1204                         i = MSG_ReadShort ();
1205                         // must use CL_EntityNum() to force cl.num_entities up
1206                         CL_ParseBaseline (CL_EntityNum(i), false);
1207                         break;
1208                 case svc_spawnbaseline2:
1209                         i = MSG_ReadShort ();
1210                         // must use CL_EntityNum() to force cl.num_entities up
1211                         CL_ParseBaseline (CL_EntityNum(i), true);
1212                         break;
1213                 case svc_spawnstatic:
1214                         CL_ParseStatic (false);
1215                         break;
1216                 case svc_spawnstatic2:
1217                         CL_ParseStatic (true);
1218                         break;
1219                 case svc_temp_entity:
1220                         CL_ParseTEnt ();
1221                         break;
1222
1223                 case svc_setpause:
1224                         cl.paused = MSG_ReadByte ();
1225                         if (cl.paused)
1226                                 CDAudio_Pause ();
1227                         else
1228                                 CDAudio_Resume ();
1229                         break;
1230
1231                 case svc_signonnum:
1232                         i = MSG_ReadByte ();
1233                         if (i <= cls.signon)
1234                                 Host_Error ("Received signon %i when at %i", i, cls.signon);
1235                         cls.signon = i;
1236                         CL_SignonReply ();
1237                         break;
1238
1239                 case svc_killedmonster:
1240                         cl.stats[STAT_MONSTERS]++;
1241                         break;
1242
1243                 case svc_foundsecret:
1244                         cl.stats[STAT_SECRETS]++;
1245                         break;
1246
1247                 case svc_updatestat:
1248                         i = MSG_ReadByte ();
1249                         if (i < 0 || i >= MAX_CL_STATS)
1250                                 Host_Error ("svc_updatestat: %i is invalid", i);
1251                         cl.stats[i] = MSG_ReadLong ();
1252                         break;
1253
1254                 case svc_spawnstaticsound:
1255                         CL_ParseStaticSound (false);
1256                         break;
1257
1258                 case svc_spawnstaticsound2:
1259                         CL_ParseStaticSound (true);
1260                         break;
1261
1262                 case svc_cdtrack:
1263                         cl.cdtrack = MSG_ReadByte ();
1264                         cl.looptrack = MSG_ReadByte ();
1265                         if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
1266                                 CDAudio_Play ((qbyte)cls.forcetrack, true);
1267                         else
1268                                 CDAudio_Play ((qbyte)cl.cdtrack, true);
1269                         break;
1270
1271                 case svc_intermission:
1272                         cl.intermission = 1;
1273                         cl.completed_time = cl.time;
1274                         break;
1275
1276                 case svc_finale:
1277                         cl.intermission = 2;
1278                         cl.completed_time = cl.time;
1279                         SCR_CenterPrint (MSG_ReadString ());
1280                         break;
1281
1282                 case svc_cutscene:
1283                         cl.intermission = 3;
1284                         cl.completed_time = cl.time;
1285                         SCR_CenterPrint (MSG_ReadString ());
1286                         break;
1287
1288                 case svc_sellscreen:
1289                         Cmd_ExecuteString ("help", src_command);
1290                         break;
1291                 case svc_hidelmp:
1292                         SHOWLMP_decodehide();
1293                         break;
1294                 case svc_showlmp:
1295                         SHOWLMP_decodeshow();
1296                         break;
1297                 case svc_skybox:
1298                         R_SetSkyBox(MSG_ReadString());
1299                         break;
1300                 case svc_cgame:
1301                         {
1302                                 int length;
1303                                 length = (int) ((unsigned short) MSG_ReadShort());
1304                                 for (i = 0;i < length;i++)
1305                                         cgamenetbuffer[i] = MSG_ReadByte();
1306                                 if (!msg_badread)
1307                                         CL_CGVM_ParseNetwork(cgamenetbuffer, length);
1308                         }
1309                         break;
1310                 case svc_entities:
1311                         if (cls.signon == SIGNONS - 1)
1312                         {       // first update is the final signon stage
1313                                 cls.signon = SIGNONS;
1314                                 CL_SignonReply ();
1315                         }
1316                         CL_ReadEntityFrame();
1317                         break;
1318                 }
1319         }
1320
1321         if (entitiesupdated)
1322                 CL_EntityUpdateEnd();
1323 }
1324