cl_parse.c

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