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 #include "cl_collision.h"
  24
  25 char *svc_strings[128] =
  26 {
  27         "svc_bad",
  28         "svc_nop",
  29         "svc_disconnect",
  30         "svc_updatestat",
  31         "svc_version",          // [long] server version
  32         "svc_setview",          // [short] entity number
  33         "svc_sound",                    // <see code>
  34         "svc_time",                     // [float] server time
  35         "svc_print",                    // [string] null terminated string
  36         "svc_stufftext",                // [string] stuffed into client's console buffer
  37                                                 // the string should be \n terminated
  38         "svc_setangle",         // [vec3] set the view angle to this absolute value
  39
  40         "svc_serverinfo",               // [long] version
  41                                                 // [string] signon string
  42                                                 // [string]..[0]model cache [string]...[0]sounds cache
  43                                                 // [string]..[0]item cache
  44         "svc_lightstyle",               // [byte] [string]
  45         "svc_updatename",               // [byte] [string]
  46         "svc_updatefrags",      // [byte] [short]
  47         "svc_clientdata",               // <shortbits + data>
  48         "svc_stopsound",                // <see code>
  49         "svc_updatecolors",     // [byte] [byte]
  50         "svc_particle",         // [vec3] <variable>
  51         "svc_damage",                   // [byte] impact [byte] blood [vec3] from
  52
  53         "svc_spawnstatic",
  54         "OBSOLETE svc_spawnbinary",
  55         "svc_spawnbaseline",
  56
  57         "svc_temp_entity",              // <variable>
  58         "svc_setpause",
  59         "svc_signonnum",
  60         "svc_centerprint",
  61         "svc_killedmonster",
  62         "svc_foundsecret",
  63         "svc_spawnstaticsound",
  64         "svc_intermission",
  65         "svc_finale",                   // [string] music [string] text
  66         "svc_cdtrack",                  // [byte] track [byte] looptrack
  67         "svc_sellscreen",
  68         "svc_cutscene",
  69         "svc_showlmp",  // [string] iconlabel [string] lmpfile [short] x [short] y
  70         "svc_hidelmp",  // [string] iconlabel
  71         "svc_skybox", // [string] skyname
  72         "", // 38
  73         "", // 39
  74         "", // 40
  75         "", // 41
  76         "", // 42
  77         "", // 43
  78         "", // 44
  79         "", // 45
  80         "", // 46
  81         "", // 47
  82         "", // 48
  83         "", // 49
  84         "svc_cgame", //                         50              // [short] length [bytes] data
  85         "svc_unusedlh1", //                     51              // unused
  86         "svc_effect", //                        52              // [vector] org [byte] modelindex [byte] startframe [byte] framecount [byte] framerate
  87         "svc_effect2", //                       53              // [vector] org [short] modelindex [short] startframe [byte] framecount [byte] framerate
  88         "svc_sound2", //                        54              // short soundindex instead of byte
  89         "svc_spawnbaseline2", //        55              // short modelindex instead of byte
  90         "svc_spawnstatic2", //          56              // short modelindex instead of byte
  91         "svc_entities", //                      57              // [int] deltaframe [int] thisframe [float vector] eye [variable length] entitydata
  92         "svc_unusedlh3", //                     58
  93         "svc_spawnstaticsound2", //     59              // [coord3] [short] samp [byte] vol [byte] aten
  94 };
  95
  96 //=============================================================================
  97
  98 cvar_t demo_nehahra = {0, "demo_nehahra", "0"};
  99 cvar_t developer_networkentities = {0, "developer_networkentities", "0"};
 100
 101 mempool_t *cl_scores_mempool;
 102
 103 /*
 104 ==================
 105 CL_ParseStartSoundPacket
 106 ==================
 107 */
 108 void CL_ParseStartSoundPacket(int largesoundindex)
 109 {
 110         vec3_t  pos;
 111         int     channel, ent;
 112         int     sound_num;
 113         int     volume;
 114         int     field_mask;
 115         float   attenuation;
 116
 117         field_mask = MSG_ReadByte();
 118
 119         if (field_mask & SND_VOLUME)
 120                 volume = MSG_ReadByte ();
 121         else
 122                 volume = DEFAULT_SOUND_PACKET_VOLUME;
 123
 124         if (field_mask & SND_ATTENUATION)
 125                 attenuation = MSG_ReadByte () / 64.0;
 126         else
 127                 attenuation = DEFAULT_SOUND_PACKET_ATTENUATION;
 128
 129         if (field_mask & SND_LARGEENTITY)
 130         {
 131                 ent = (unsigned short) MSG_ReadShort ();
 132                 channel = MSG_ReadByte ();
 133         }
 134         else
 135         {
 136                 channel = (unsigned short) MSG_ReadShort ();
 137                 ent = channel >> 3;
 138                 channel &= 7;
 139         }
 140
 141         if (largesoundindex || field_mask & SND_LARGESOUND)
 142                 sound_num = (unsigned short) MSG_ReadShort ();
 143         else
 144                 sound_num = MSG_ReadByte ();
 145
 146         if (sound_num >= MAX_SOUNDS)
 147                 Host_Error("CL_ParseStartSoundPacket: sound_num (%i) >= MAX_SOUNDS (%i)\n", sound_num, MAX_SOUNDS);
 148
 149
 150         if (ent >= MAX_EDICTS)
 151                 Host_Error ("CL_ParseStartSoundPacket: ent = %i", ent);
 152
 153         MSG_ReadVector(pos);
 154
 155         S_StartSound (ent, channel, cl.sound_precache[sound_num], pos, volume/255.0, attenuation);
 156 }
 157
 158 /*
 159 ==================
 160 CL_KeepaliveMessage
 161
 162 When the client is taking a long time to load stuff, send keepalive messages
 163 so the server doesn't disconnect.
 164 ==================
 165 */
 166
 167 static qbyte olddata[NET_MAXMESSAGE];
 168 void CL_KeepaliveMessage (void)
 169 {
 170         float time;
 171         static float lastmsg;
 172         int oldreadcount;
 173         qboolean oldbadread;
 174         sizebuf_t old;
 175
 176         // no need if server is local and definitely not if this is a demo
 177         if (sv.active || cls.demoplayback)
 178                 return;
 179
 180 // read messages from server, should just be nops
 181         oldreadcount = msg_readcount;
 182         oldbadread = msg_badread;
 183         old = net_message;
 184         memcpy(olddata, net_message.data, net_message.cursize);
 185
 186         NetConn_ClientFrame();
 187
 188         msg_readcount = oldreadcount;
 189         msg_badread = oldbadread;
 190         net_message = old;
 191         memcpy(net_message.data, olddata, net_message.cursize);
 192
 193         if (cls.netcon && NetConn_CanSendMessage(cls.netcon) && (time = Sys_DoubleTime()) - lastmsg >= 5)
 194         {
 195                 sizebuf_t       msg;
 196                 qbyte           buf[4];
 197                 lastmsg = time;
 198                 // write out a nop
 199                 // LordHavoc: must use unreliable because reliable could kill the sigon message!
 200                 Con_Printf("--> client to server keepalive\n");
 201                 msg.data = buf;
 202                 msg.maxsize = sizeof(buf);
 203                 msg.cursize = 0;
 204                 MSG_WriteChar(&msg, svc_nop);
 205                 NetConn_SendUnreliableMessage(cls.netcon, &msg);
 206                 // try not to utterly crush the computer with work, that's just rude
 207                 Sys_Sleep(1);
 208         }
 209 }
 210
 211 void CL_ParseEntityLump(char *entdata)
 212 {
 213         const char *data;
 214         char key[128], value[4096];
 215         FOG_clear(); // LordHavoc: no fog until set
 216         R_SetSkyBox(""); // LordHavoc: no environment mapped sky until set
 217         data = entdata;
 218         if (!data)
 219                 return;
 220         if (!COM_ParseToken(&data, false))
 221                 return; // error
 222         if (com_token[0] != '{')
 223                 return; // error
 224         while (1)
 225         {
 226                 if (!COM_ParseToken(&data, false))
 227                         return; // error
 228                 if (com_token[0] == '}')
 229                         break; // end of worldspawn
 230                 if (com_token[0] == '_')
 231                         strlcpy (key, com_token + 1, sizeof (key));
 232                 else
 233                         strlcpy (key, com_token, sizeof (key));
 234                 while (key[strlen(key)-1] == ' ') // remove trailing spaces
 235                         key[strlen(key)-1] = 0;
 236                 if (!COM_ParseToken(&data, false))
 237                         return; // error
 238                 strlcpy (value, com_token, sizeof (value));
 239                 if (!strcmp("sky", key))
 240                         R_SetSkyBox(value);
 241                 else if (!strcmp("skyname", key)) // non-standard, introduced by QuakeForge... sigh.
 242                         R_SetSkyBox(value);
 243                 else if (!strcmp("qlsky", key)) // non-standard, introduced by QuakeLives (EEK)
 244                         R_SetSkyBox(value);
 245                 else if (!strcmp("fog", key))
 246                         sscanf(value, "%f %f %f %f", &fog_density, &fog_red, &fog_green, &fog_blue);
 247                 else if (!strcmp("fog_density", key))
 248                         fog_density = atof(value);
 249                 else if (!strcmp("fog_red", key))
 250                         fog_red = atof(value);
 251                 else if (!strcmp("fog_green", key))
 252                         fog_green = atof(value);
 253                 else if (!strcmp("fog_blue", key))
 254                         fog_blue = atof(value);
 255         }
 256 }
 257
 258 /*
 259 =====================
 260 CL_SignonReply
 261
 262 An svc_signonnum has been received, perform a client side setup
 263 =====================
 264 */
 265 static void CL_SignonReply (void)
 266 {
 267         //char  str[8192];
 268
 269 Con_DPrintf ("CL_SignonReply: %i\n", cls.signon);
 270
 271         switch (cls.signon)
 272         {
 273         case 1:
 274                 MSG_WriteByte (&cls.message, clc_stringcmd);
 275                 MSG_WriteString (&cls.message, "prespawn");
 276                 break;
 277
 278         case 2:
 279                 MSG_WriteByte (&cls.message, clc_stringcmd);
 280                 MSG_WriteString (&cls.message, va("name \"%s\"\n", cl_name.string));
 281
 282                 MSG_WriteByte (&cls.message, clc_stringcmd);
 283                 MSG_WriteString (&cls.message, va("color %i %i\n", cl_color.integer >> 4, cl_color.integer & 15));
 284
 285                 if (cl_pmodel.integer)
 286                 {
 287                         MSG_WriteByte (&cls.message, clc_stringcmd);
 288                         MSG_WriteString (&cls.message, va("pmodel %i\n", cl_pmodel.integer));
 289                 }
 290
 291                 MSG_WriteByte (&cls.message, clc_stringcmd);
 292                 MSG_WriteString (&cls.message, va("rate %i\n", cl_rate.integer));
 293
 294                 MSG_WriteByte (&cls.message, clc_stringcmd);
 295                 MSG_WriteString (&cls.message, "spawn");
 296                 break;
 297
 298         case 3:
 299                 MSG_WriteByte (&cls.message, clc_stringcmd);
 300                 MSG_WriteString (&cls.message, "begin");
 301                 break;
 302
 303         case 4:
 304                 Con_ClearNotify();
 305                 break;
 306         }
 307 }
 308
 309 /*
 310 ==================
 311 CL_ParseServerInfo
 312 ==================
 313 */
 314 qbyte entlife[MAX_EDICTS];
 315 // FIXME: this is a lot of memory to be keeping around, this needs to be dynamically allocated and freed
 316 static char parse_model_precache[MAX_MODELS][MAX_QPATH];
 317 static char parse_sound_precache[MAX_SOUNDS][MAX_QPATH];
 318 void CL_ParseServerInfo (void)
 319 {
 320         char *str;
 321         int i;
 322         int nummodels, numsounds;
 323         entity_t *ent;
 324
 325         Con_DPrintf ("Serverinfo packet received.\n");
 326 //
 327 // wipe the client_state_t struct
 328 //
 329         CL_ClearState ();
 330
 331 // parse protocol version number
 332         i = MSG_ReadLong ();
 333         // hack for unmarked Nehahra movie demos which had a custom protocol
 334         if (i == PROTOCOL_QUAKE && cls.demoplayback && demo_nehahra.integer)
 335                 i = PROTOCOL_NEHAHRAMOVIE;
 336         if (i != PROTOCOL_QUAKE && i != PROTOCOL_DARKPLACES1 && i != PROTOCOL_DARKPLACES2 && i != PROTOCOL_DARKPLACES3 && i != PROTOCOL_DARKPLACES4 && i != PROTOCOL_DARKPLACES5 && i != PROTOCOL_NEHAHRAMOVIE)
 337         {
 338                 Host_Error("CL_ParseServerInfo: Server is protocol %i, not %i (Quake), %i (DP1), %i (DP2), %i (DP3), %i (DP4), %i (DP5), or %i (Nehahra movie)", i, PROTOCOL_QUAKE, PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_DARKPLACES5, PROTOCOL_NEHAHRAMOVIE);
 339                 return;
 340         }
 341         cl.protocol = i;
 342
 343 // parse maxclients
 344         cl.maxclients = MSG_ReadByte ();
 345         if (cl.maxclients < 1 || cl.maxclients > MAX_SCOREBOARD)
 346         {
 347                 Con_Printf("Bad maxclients (%u) from server\n", cl.maxclients);
 348                 return;
 349         }
 350         Mem_EmptyPool(cl_scores_mempool);
 351         cl.scores = Mem_Alloc(cl_scores_mempool, cl.maxclients*sizeof(*cl.scores));
 352
 353 // parse gametype
 354         cl.gametype = MSG_ReadByte ();
 355
 356 // parse signon message
 357         str = MSG_ReadString ();
 358         strlcpy (cl.levelname, str, sizeof(cl.levelname));
 359
 360 // seperate the printfs so the server message can have a color
 361         if (cl.protocol != PROTOCOL_NEHAHRAMOVIE) // no messages when playing the Nehahra movie
 362         {
 363                 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");
 364                 Con_Printf("%c%s\n", 2, str);
 365         }
 366
 367         // check memory integrity
 368         Mem_CheckSentinelsGlobal();
 369
 370         // disable until we get textures for it
 371         R_ResetSkyBox();
 372
 373         memset(cl.model_precache, 0, sizeof(cl.model_precache));
 374         memset(cl.sound_precache, 0, sizeof(cl.sound_precache));
 375
 376         // parse model precache list
 377         for (nummodels=1 ; ; nummodels++)
 378         {
 379                 str = MSG_ReadString();
 380                 if (!str[0])
 381                         break;
 382                 if (nummodels==MAX_MODELS)
 383                         Host_Error ("Server sent too many model precaches\n");
 384                 if (strlen(str) >= MAX_QPATH)
 385                         Host_Error ("Server sent a precache name of %i characters (max %i)", strlen(str), MAX_QPATH - 1);
 386                 strlcpy (parse_model_precache[nummodels], str, sizeof (parse_model_precache[nummodels]));
 387         }
 388         // parse sound precache list
 389         for (numsounds=1 ; ; numsounds++)
 390         {
 391                 str = MSG_ReadString();
 392                 if (!str[0])
 393                         break;
 394                 if (numsounds==MAX_SOUNDS)
 395                         Host_Error("Server sent too many sound precaches\n");
 396                 if (strlen(str) >= MAX_QPATH)
 397                         Host_Error("Server sent a precache name of %i characters (max %i)", strlen(str), MAX_QPATH - 1);
 398                 strlcpy (parse_sound_precache[numsounds], str, sizeof (parse_sound_precache[numsounds]));
 399         }
 400
 401         // touch all of the precached models that are still loaded so we can free
 402         // anything that isn't needed
 403         Mod_ClearUsed();
 404         for (i = 1;i < nummodels;i++)
 405         {
 406                 CL_KeepaliveMessage();
 407                 Mod_TouchModel(parse_model_precache[i]);
 408         }
 409         Mod_PurgeUnused();
 410
 411         // do the same for sounds
 412         S_ClearUsed();
 413         for (i = 1;i < numsounds;i++)
 414         {
 415                 CL_KeepaliveMessage();
 416                 S_TouchSound(parse_sound_precache[i]);
 417         }
 418         S_PurgeUnused();
 419
 420         // now we try to load everything that is new
 421
 422         // world model
 423         CL_KeepaliveMessage ();
 424         cl.model_precache[1] = Mod_ForName(parse_model_precache[1], false, false, true);
 425         if (cl.model_precache[1] == NULL)
 426                 Con_Printf("Map %s not found\n", parse_model_precache[1]);
 427
 428         // normal models
 429         for (i=2 ; i<nummodels ; i++)
 430         {
 431                 CL_KeepaliveMessage();
 432                 if ((cl.model_precache[i] = Mod_ForName(parse_model_precache[i], false, false, false)) == NULL)
 433                         Con_Printf("Model %s not found\n", parse_model_precache[i]);
 434         }
 435
 436         // sounds
 437         for (i=1 ; i<numsounds ; i++)
 438         {
 439                 CL_KeepaliveMessage();
 440                 cl.sound_precache[i] = S_PrecacheSound(parse_sound_precache[i], true);
 441         }
 442
 443         // local state
 444         ent = &cl_entities[0];
 445         // entire entity array was cleared, so just fill in a few fields
 446         ent->state_current.active = true;
 447         ent->render.model = cl.worldmodel = cl.model_precache[1];
 448         ent->render.scale = 1; // some of the renderer still relies on scale
 449         ent->render.alpha = 1;
 450         ent->render.flags = RENDER_SHADOW | RENDER_LIGHT;
 451         Matrix4x4_CreateFromQuakeEntity(&ent->render.matrix, 0, 0, 0, 0, 0, 0, 1);
 452         Matrix4x4_Invert_Simple(&ent->render.inversematrix, &ent->render.matrix);
 453         CL_BoundingBoxForEntity(&ent->render);
 454         // clear entlife array
 455         memset(entlife, 0, MAX_EDICTS);
 456
 457         cl_num_entities = 1;
 458
 459         R_Modules_NewMap();
 460         CL_CGVM_Start();
 461
 462         // noclip is turned off at start
 463         noclip_anglehack = false;
 464
 465         // check memory integrity
 466         Mem_CheckSentinelsGlobal();
 467 }
 468
 469 void CL_ValidateState(entity_state_t *s)
 470 {
 471         model_t *model;
 472
 473         if (!s->active)
 474                 return;
 475
 476         if (s->modelindex >= MAX_MODELS)
 477                 Host_Error("CL_ValidateState: modelindex (%i) >= MAX_MODELS (%i)\n", s->modelindex, MAX_MODELS);
 478
 479         // colormap is client index + 1
 480         if (s->colormap > cl.maxclients)
 481                 Host_Error ("CL_ValidateState: colormap (%i) > cl.maxclients (%i)", s->colormap, cl.maxclients);
 482
 483         model = cl.model_precache[s->modelindex];
 484         Mod_CheckLoaded(model);
 485         if (model && s->frame >= model->numframes)
 486         {
 487                 Con_DPrintf("CL_ValidateState: no such frame %i in \"%s\"\n", s->frame, model->name);
 488                 s->frame = 0;
 489         }
 490         if (model && s->skin > 0 && s->skin >= model->numskins)
 491         {
 492                 Con_DPrintf("CL_ValidateState: no such skin %i in \"%s\"\n", s->skin, model->name);
 493                 s->skin = 0;
 494         }
 495 }
 496
 497 void CL_MoveLerpEntityStates(entity_t *ent)
 498 {
 499         float odelta[3], adelta[3];
 500         VectorSubtract(ent->state_current.origin, ent->persistent.neworigin, odelta);
 501         VectorSubtract(ent->state_current.angles, ent->persistent.newangles, adelta);
 502         if (!ent->state_previous.active || cls.timedemo || DotProduct(odelta, odelta) > 1000*1000 || cl_nolerp.integer)
 503         {
 504                 // we definitely shouldn't lerp
 505                 ent->persistent.lerpdeltatime = 0;
 506                 ent->persistent.lerpstarttime = cl.mtime[1];
 507                 VectorCopy(ent->state_current.origin, ent->persistent.oldorigin);
 508                 VectorCopy(ent->state_current.angles, ent->persistent.oldangles);
 509                 VectorCopy(ent->state_current.origin, ent->persistent.neworigin);
 510                 VectorCopy(ent->state_current.angles, ent->persistent.newangles);
 511         }
 512         else if (ent->state_current.flags & RENDER_STEP)
 513         {
 514                 // monster interpolation
 515                 if (DotProduct(odelta, odelta) + DotProduct(adelta, adelta) > 0.01)
 516                 {
 517                         ent->persistent.lerpdeltatime = bound(0, cl.mtime[1] - ent->persistent.lerpstarttime, 0.1);
 518                         ent->persistent.lerpstarttime = cl.mtime[1];
 519                         VectorCopy(ent->persistent.neworigin, ent->persistent.oldorigin);
 520                         VectorCopy(ent->persistent.newangles, ent->persistent.oldangles);
 521                         VectorCopy(ent->state_current.origin, ent->persistent.neworigin);
 522                         VectorCopy(ent->state_current.angles, ent->persistent.newangles);
 523                 }
 524         }
 525         else
 526         {
 527                 // not a monster
 528                 ent->persistent.lerpstarttime = cl.mtime[1];
 529                 // no lerp if it's singleplayer
 530                 if (cl.islocalgame)
 531                         ent->persistent.lerpdeltatime = 0;
 532                 else
 533                         ent->persistent.lerpdeltatime = cl.mtime[0] - cl.mtime[1];
 534                 VectorCopy(ent->persistent.neworigin, ent->persistent.oldorigin);
 535                 VectorCopy(ent->persistent.newangles, ent->persistent.oldangles);
 536                 VectorCopy(ent->state_current.origin, ent->persistent.neworigin);
 537                 VectorCopy(ent->state_current.angles, ent->persistent.newangles);
 538         }
 539 }
 540
 541 /*
 542 ==================
 543 CL_ParseUpdate
 544
 545 Parse an entity update message from the server
 546 If an entities model or origin changes from frame to frame, it must be
 547 relinked.  Other attributes can change without relinking.
 548 ==================
 549 */
 550 void CL_ParseUpdate (int bits)
 551 {
 552         int num;
 553         entity_t *ent;
 554         entity_state_t new;
 555
 556         if (bits & U_MOREBITS)
 557                 bits |= (MSG_ReadByte()<<8);
 558         if ((bits & U_EXTEND1) && cl.protocol != PROTOCOL_NEHAHRAMOVIE)
 559         {
 560                 bits |= MSG_ReadByte() << 16;
 561                 if (bits & U_EXTEND2)
 562                         bits |= MSG_ReadByte() << 24;
 563         }
 564
 565         if (bits & U_LONGENTITY)
 566                 num = (unsigned) MSG_ReadShort ();
 567         else
 568                 num = (unsigned) MSG_ReadByte ();
 569
 570         if (num >= MAX_EDICTS)
 571                 Host_Error("CL_ParseUpdate: entity number (%i) >= MAX_EDICTS (%i)\n", num, MAX_EDICTS);
 572         if (num < 1)
 573                 Host_Error("CL_ParseUpdate: invalid entity number (%i)\n", num);
 574
 575         ent = cl_entities + num;
 576
 577         // note: this inherits the 'active' state of the baseline chosen
 578         // (state_baseline is always active, state_current may not be active if
 579         // the entity was missing in the last frame)
 580         if (bits & U_DELTA)
 581                 new = ent->state_current;
 582         else
 583         {
 584                 new = ent->state_baseline;
 585                 new.active = true;
 586         }
 587
 588         new.number = num;
 589         new.time = cl.mtime[0];
 590         new.flags = 0;
 591         if (bits & U_MODEL)             new.modelindex = (new.modelindex & 0xFF00) | MSG_ReadByte();
 592         if (bits & U_FRAME)             new.frame = (new.frame & 0xFF00) | MSG_ReadByte();
 593         if (bits & U_COLORMAP)  new.colormap = MSG_ReadByte();
 594         if (bits & U_SKIN)              new.skin = MSG_ReadByte();
 595         if (bits & U_EFFECTS)   new.effects = (new.effects & 0xFF00) | MSG_ReadByte();
 596         if (bits & U_ORIGIN1)   new.origin[0] = MSG_ReadCoord();
 597         if (bits & U_ANGLE1)    new.angles[0] = MSG_ReadAngle();
 598         if (bits & U_ORIGIN2)   new.origin[1] = MSG_ReadCoord();
 599         if (bits & U_ANGLE2)    new.angles[1] = MSG_ReadAngle();
 600         if (bits & U_ORIGIN3)   new.origin[2] = MSG_ReadCoord();
 601         if (bits & U_ANGLE3)    new.angles[2] = MSG_ReadAngle();
 602         if (bits & U_STEP)              new.flags |= RENDER_STEP;
 603         if (bits & U_ALPHA)             new.alpha = MSG_ReadByte();
 604         if (bits & U_SCALE)             new.scale = MSG_ReadByte();
 605         if (bits & U_EFFECTS2)  new.effects = (new.effects & 0x00FF) | (MSG_ReadByte() << 8);
 606         if (bits & U_GLOWSIZE)  new.glowsize = MSG_ReadByte();
 607         if (bits & U_GLOWCOLOR) new.glowcolor = MSG_ReadByte();
 608         // apparently the dpcrush demo uses this (unintended, and it uses white anyway)
 609         if (bits & U_COLORMOD)  MSG_ReadByte();
 610         if (bits & U_GLOWTRAIL) new.flags |= RENDER_GLOWTRAIL;
 611         if (bits & U_FRAME2)    new.frame = (new.frame & 0x00FF) | (MSG_ReadByte() << 8);
 612         if (bits & U_MODEL2)    new.modelindex = (new.modelindex & 0x00FF) | (MSG_ReadByte() << 8);
 613         if (bits & U_VIEWMODEL) new.flags |= RENDER_VIEWMODEL;
 614         if (bits & U_EXTERIORMODEL)     new.flags |= RENDER_EXTERIORMODEL;
 615
 616         // LordHavoc: to allow playback of the Nehahra movie
 617         if (cl.protocol == PROTOCOL_NEHAHRAMOVIE && (bits & U_EXTEND1))
 618         {
 619                 // LordHavoc: evil format
 620                 int i = MSG_ReadFloat();
 621                 int j = MSG_ReadFloat() * 255.0f;
 622                 if (i == 2)
 623                 {
 624                         i = MSG_ReadFloat();
 625                         if (i)
 626                                 new.effects |= EF_FULLBRIGHT;
 627                 }
 628                 if (j < 0)
 629                         new.alpha = 0;
 630                 else if (j == 0 || j >= 255)
 631                         new.alpha = 255;
 632                 else
 633                         new.alpha = j;
 634         }
 635
 636         if (new.active)
 637                 CL_ValidateState(&new);
 638
 639         ent->state_previous = ent->state_current;
 640         ent->state_current = new;
 641         if (ent->state_current.active)
 642         {
 643                 CL_MoveLerpEntityStates(ent);
 644                 cl_entities_active[ent->state_current.number] = true;
 645                 // mark as visible (no kill this frame)
 646                 entlife[ent->state_current.number] = 2;
 647         }
 648 }
 649
 650 static entity_frame_t entityframe;
 651 extern mempool_t *cl_entities_mempool;
 652 void CL_ReadEntityFrame(void)
 653 {
 654         if (cl.protocol == PROTOCOL_DARKPLACES1 || cl.protocol == PROTOCOL_DARKPLACES2 || cl.protocol == PROTOCOL_DARKPLACES3)
 655         {
 656                 int i;
 657                 entity_t *ent;
 658                 EntityFrame_Read(&cl.entitydatabase);
 659                 EntityFrame_FetchFrame(&cl.entitydatabase, EntityFrame_MostRecentlyRecievedFrameNum(&cl.entitydatabase), &entityframe);
 660                 for (i = 0;i < entityframe.numentities;i++)
 661                 {
 662                         // copy the states
 663                         ent = &cl_entities[entityframe.entitydata[i].number];
 664                         ent->state_previous = ent->state_current;
 665                         ent->state_current = entityframe.entitydata[i];
 666                         CL_MoveLerpEntityStates(ent);
 667                         // the entity lives again...
 668                         entlife[ent->state_current.number] = 2;
 669                         cl_entities_active[ent->state_current.number] = true;
 670                 }
 671         }
 672         else
 673         {
 674                 if (!cl.entitydatabase4)
 675                         cl.entitydatabase4 = EntityFrame4_AllocDatabase(cl_entities_mempool);
 676                 EntityFrame4_CL_ReadFrame(cl.entitydatabase4);
 677         }
 678 }
 679
 680 void CL_EntityUpdateSetup(void)
 681 {
 682 }
 683
 684 void CL_EntityUpdateEnd(void)
 685 {
 686         if (cl.protocol == PROTOCOL_QUAKE || cl.protocol == PROTOCOL_NEHAHRAMOVIE || cl.protocol == PROTOCOL_DARKPLACES1 || cl.protocol == PROTOCOL_DARKPLACES2 || cl.protocol == PROTOCOL_DARKPLACES3)
 687         {
 688                 int i;
 689                 // disable entities that disappeared this frame
 690                 for (i = 1;i < MAX_EDICTS;i++)
 691                 {
 692                         // clear only the entities that were active last frame but not this
 693                         // frame, don't waste time clearing all entities (which would cause
 694                         // cache misses)
 695                         if (entlife[i])
 696                         {
 697                                 entlife[i]--;
 698                                 if (!entlife[i])
 699                                         cl_entities[i].state_previous.active = cl_entities[i].state_current.active = 0;
 700                         }
 701                 }
 702         }
 703 }
 704
 705 /*
 706 ==================
 707 CL_ParseBaseline
 708 ==================
 709 */
 710 void CL_ParseBaseline (entity_t *ent, int large)
 711 {
 712         int i;
 713
 714         ClearStateToDefault(&ent->state_baseline);
 715         ent->state_baseline.active = true;
 716         if (large)
 717         {
 718                 ent->state_baseline.modelindex = (unsigned short) MSG_ReadShort ();
 719                 ent->state_baseline.frame = (unsigned short) MSG_ReadShort ();
 720         }
 721         else
 722         {
 723                 ent->state_baseline.modelindex = MSG_ReadByte ();
 724                 ent->state_baseline.frame = MSG_ReadByte ();
 725         }
 726         ent->state_baseline.colormap = MSG_ReadByte();
 727         ent->state_baseline.skin = MSG_ReadByte();
 728         for (i = 0;i < 3;i++)
 729         {
 730                 ent->state_baseline.origin[i] = MSG_ReadCoord ();
 731                 ent->state_baseline.angles[i] = MSG_ReadAngle ();
 732         }
 733         CL_ValidateState(&ent->state_baseline);
 734         ent->state_previous = ent->state_current = ent->state_baseline;
 735 }
 736
 737
 738 /*
 739 ==================
 740 CL_ParseClientdata
 741
 742 Server information pertaining to this client only
 743 ==================
 744 */
 745 void CL_ParseClientdata (int bits)
 746 {
 747         int i, j;
 748
 749         bits &= 0xFFFF;
 750         if (bits & SU_EXTEND1)
 751                 bits |= (MSG_ReadByte() << 16);
 752         if (bits & SU_EXTEND2)
 753                 bits |= (MSG_ReadByte() << 24);
 754
 755         if (bits & SU_VIEWHEIGHT)
 756                 cl.viewheight = MSG_ReadChar ();
 757         else
 758                 cl.viewheight = DEFAULT_VIEWHEIGHT;
 759
 760         if (bits & SU_IDEALPITCH)
 761                 cl.idealpitch = MSG_ReadChar ();
 762         else
 763                 cl.idealpitch = 0;
 764
 765         VectorCopy (cl.mvelocity[0], cl.mvelocity[1]);
 766         if (cl.protocol == PROTOCOL_DARKPLACES5)
 767         {
 768                 for (i = 0;i < 3;i++)
 769                 {
 770                         if (bits & (SU_PUNCH1<<i) )
 771                                 cl.punchangle[i] = MSG_ReadPreciseAngle();
 772                         else
 773                                 cl.punchangle[i] = 0;
 774                         if (bits & (SU_PUNCHVEC1<<i))
 775                                 cl.punchvector[i] = MSG_ReadFloat();
 776                         else
 777                                 cl.punchvector[i] = 0;
 778                         if (bits & (SU_VELOCITY1<<i) )
 779                                 cl.mvelocity[0][i] = MSG_ReadFloat();
 780                         else
 781                                 cl.mvelocity[0][i] = 0;
 782                 }
 783         }
 784         else
 785         {
 786                 for (i = 0;i < 3;i++)
 787                 {
 788                         if (bits & (SU_PUNCH1<<i) )
 789                         {
 790                                 if (cl.protocol == PROTOCOL_DARKPLACES1 || cl.protocol == PROTOCOL_DARKPLACES2 || cl.protocol == PROTOCOL_DARKPLACES3 || cl.protocol == PROTOCOL_DARKPLACES4 || cl.protocol == PROTOCOL_DARKPLACES5)
 791                                         cl.punchangle[i] = MSG_ReadPreciseAngle();
 792                                 else
 793                                         cl.punchangle[i] = MSG_ReadChar();
 794                         }
 795                         else
 796                                 cl.punchangle[i] = 0;
 797                         if (bits & (SU_PUNCHVEC1<<i))
 798                                 cl.punchvector[i] = MSG_ReadCoord();
 799                         else
 800                                 cl.punchvector[i] = 0;
 801                         if (bits & (SU_VELOCITY1<<i) )
 802                                 cl.mvelocity[0][i] = MSG_ReadChar()*16;
 803                         else
 804                                 cl.mvelocity[0][i] = 0;
 805                 }
 806         }
 807
 808         i = MSG_ReadLong ();
 809         if (cl.items != i)
 810         {       // set flash times
 811                 for (j=0 ; j<32 ; j++)
 812                         if ( (i & (1<<j)) && !(cl.items & (1<<j)))
 813                                 cl.item_gettime[j] = cl.time;
 814                 cl.items = i;
 815         }
 816
 817         cl.onground = (bits & SU_ONGROUND) != 0;
 818         cl.inwater = (bits & SU_INWATER) != 0;
 819
 820         cl.stats[STAT_WEAPONFRAME] = (bits & SU_WEAPONFRAME) ? MSG_ReadByte() : 0;
 821         cl.stats[STAT_ARMOR] = (bits & SU_ARMOR) ? MSG_ReadByte() : 0;
 822         cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? MSG_ReadByte() : 0;
 823         cl.stats[STAT_HEALTH] = MSG_ReadShort();
 824         cl.stats[STAT_AMMO] = MSG_ReadByte();
 825
 826         cl.stats[STAT_SHELLS] = MSG_ReadByte();
 827         cl.stats[STAT_NAILS] = MSG_ReadByte();
 828         cl.stats[STAT_ROCKETS] = MSG_ReadByte();
 829         cl.stats[STAT_CELLS] = MSG_ReadByte();
 830
 831         i = MSG_ReadByte ();
 832
 833         if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
 834                 i = (1<<i);
 835         // GAME_NEXUIZ hud needs weapon change time
 836         // GAME_NEXUIZ uses a bit number as it's STAT_ACTIVEWEAPON, not a bitfield
 837         // like other modes
 838         if (cl.stats[STAT_ACTIVEWEAPON] != i)
 839                 cl.weapontime = cl.time;
 840         cl.stats[STAT_ACTIVEWEAPON] = i;
 841
 842         cl.viewzoomold = cl.viewzoomnew; // for interpolation
 843         if (bits & SU_VIEWZOOM)
 844         {
 845                 i = MSG_ReadByte();
 846                 if (i < 2)
 847                         i = 2;
 848                 cl.viewzoomnew = (float) i * (1.0f / 255.0f);
 849         }
 850         else
 851                 cl.viewzoomnew = 1;
 852
 853 }
 854
 855 /*
 856 =====================
 857 CL_ParseStatic
 858 =====================
 859 */
 860 void CL_ParseStatic (int large)
 861 {
 862         entity_t *ent;
 863
 864         if (cl_num_static_entities >= cl_max_static_entities)
 865                 Host_Error ("Too many static entities");
 866         ent = &cl_static_entities[cl_num_static_entities++];
 867         CL_ParseBaseline (ent, large);
 868
 869 // copy it to the current state
 870         ent->render.model = cl.model_precache[ent->state_baseline.modelindex];
 871         ent->render.frame = ent->render.frame1 = ent->render.frame2 = ent->state_baseline.frame;
 872         ent->render.framelerp = 0;
 873         // make torchs play out of sync
 874         ent->render.frame1time = ent->render.frame2time = lhrandom(-10, -1);
 875         ent->render.colormap = -1; // no special coloring
 876         ent->render.skinnum = ent->state_baseline.skin;
 877         ent->render.effects = ent->state_baseline.effects;
 878         ent->render.alpha = 1;
 879         //ent->render.scale = 1;
 880
 881         //VectorCopy (ent->state_baseline.origin, ent->render.origin);
 882         //VectorCopy (ent->state_baseline.angles, ent->render.angles);
 883
 884         Matrix4x4_CreateFromQuakeEntity(&ent->render.matrix, ent->state_baseline.origin[0], ent->state_baseline.origin[1], ent->state_baseline.origin[2], ent->state_baseline.angles[0], ent->state_baseline.angles[1], ent->state_baseline.angles[2], 1);
 885         Matrix4x4_Invert_Simple(&ent->render.inversematrix, &ent->render.matrix);
 886         CL_BoundingBoxForEntity(&ent->render);
 887
 888         // This is definitely cheating...
 889         if (ent->render.model == NULL)
 890                 cl_num_static_entities--;
 891 }
 892
 893 /*
 894 ===================
 895 CL_ParseStaticSound
 896 ===================
 897 */
 898 void CL_ParseStaticSound (int large)
 899 {
 900         vec3_t          org;
 901         int                     sound_num, vol, atten;
 902
 903         MSG_ReadVector(org);
 904         if (large)
 905                 sound_num = (unsigned short) MSG_ReadShort ();
 906         else
 907                 sound_num = MSG_ReadByte ();
 908         vol = MSG_ReadByte ();
 909         atten = MSG_ReadByte ();
 910
 911         S_StaticSound (cl.sound_precache[sound_num], org, vol, atten);
 912 }
 913
 914 void CL_ParseEffect (void)
 915 {
 916         vec3_t          org;
 917         int                     modelindex, startframe, framecount, framerate;
 918
 919         MSG_ReadVector(org);
 920         modelindex = MSG_ReadByte ();
 921         startframe = MSG_ReadByte ();
 922         framecount = MSG_ReadByte ();
 923         framerate = MSG_ReadByte ();
 924
 925         CL_Effect(org, modelindex, startframe, framecount, framerate);
 926 }
 927
 928 void CL_ParseEffect2 (void)
 929 {
 930         vec3_t          org;
 931         int                     modelindex, startframe, framecount, framerate;
 932
 933         MSG_ReadVector(org);
 934         modelindex = MSG_ReadShort ();
 935         startframe = MSG_ReadShort ();
 936         framecount = MSG_ReadByte ();
 937         framerate = MSG_ReadByte ();
 938
 939         CL_Effect(org, modelindex, startframe, framecount, framerate);
 940 }
 941
 942 model_t *cl_model_bolt = NULL;
 943 model_t *cl_model_bolt2 = NULL;
 944 model_t *cl_model_bolt3 = NULL;
 945 model_t *cl_model_beam = NULL;
 946
 947 sfx_t *cl_sfx_wizhit;
 948 sfx_t *cl_sfx_knighthit;
 949 sfx_t *cl_sfx_tink1;
 950 sfx_t *cl_sfx_ric1;
 951 sfx_t *cl_sfx_ric2;
 952 sfx_t *cl_sfx_ric3;
 953 sfx_t *cl_sfx_r_exp3;
 954
 955 /*
 956 =================
 957 CL_ParseTEnt
 958 =================
 959 */
 960 void CL_InitTEnts (void)
 961 {
 962         cl_sfx_wizhit = S_PrecacheSound ("wizard/hit.wav", false);
 963         cl_sfx_knighthit = S_PrecacheSound ("hknight/hit.wav", false);
 964         cl_sfx_tink1 = S_PrecacheSound ("weapons/tink1.wav", false);
 965         cl_sfx_ric1 = S_PrecacheSound ("weapons/ric1.wav", false);
 966         cl_sfx_ric2 = S_PrecacheSound ("weapons/ric2.wav", false);
 967         cl_sfx_ric3 = S_PrecacheSound ("weapons/ric3.wav", false);
 968         cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav", false);
 969 }
 970
 971 void CL_ParseBeam (model_t *m, int lightning)
 972 {
 973         int i, ent;
 974         vec3_t start, end;
 975         beam_t *b;
 976
 977         ent = MSG_ReadShort ();
 978         MSG_ReadVector(start);
 979         MSG_ReadVector(end);
 980
 981         if (ent >= MAX_EDICTS)
 982         {
 983                 Con_Printf("CL_ParseBeam: invalid entity number %i\n", ent);
 984                 ent = 0;
 985         }
 986
 987         // override any beam with the same entity
 988         for (i = 0, b = cl_beams;i < cl_max_beams;i++, b++)
 989         {
 990                 if (b->entity == ent)
 991                 {
 992                         //b->entity = ent;
 993                         b->lightning = lightning;
 994                         b->relativestartvalid = (ent && cl_entities[ent].state_current.active) ? 2 : 0;
 995                         b->model = m;
 996                         b->endtime = cl.time + 0.2;
 997                         VectorCopy (start, b->start);
 998                         VectorCopy (end, b->end);
 999                         return;
1000                 }
1001         }
1002
1003         // find a free beam
1004         for (i = 0, b = cl_beams;i < cl_max_beams;i++, b++)
1005         {
1006                 if (!b->model || b->endtime < cl.time)
1007                 {
1008                         b->entity = ent;
1009                         b->lightning = lightning;
1010                         b->relativestartvalid = (ent && cl_entities[ent].state_current.active) ? 2 : 0;
1011                         b->model = m;
1012                         b->endtime = cl.time + 0.2;
1013                         VectorCopy (start, b->start);
1014                         VectorCopy (end, b->end);
1015                         return;
1016                 }
1017         }
1018         Con_Printf ("beam list overflow!\n");
1019 }
1020
1021 void CL_ParseTempEntity(void)
1022 {
1023         int type;
1024         vec3_t pos;
1025         vec3_t dir;
1026         vec3_t pos2;
1027         vec3_t color;
1028         int rnd;
1029         int colorStart, colorLength, count;
1030         float velspeed, radius;
1031         qbyte *tempcolor;
1032         matrix4x4_t tempmatrix;
1033
1034         type = MSG_ReadByte();
1035         switch (type)
1036         {
1037         case TE_WIZSPIKE:
1038                 // spike hitting wall
1039                 MSG_ReadVector(pos);
1040                 CL_FindNonSolidLocation(pos, pos, 4);
1041                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1042                 CL_AllocDlight(NULL, &tempmatrix, 150, 0.25f, 1.00f, 0.25f, 250, 0.2, 0, 0, false, 1);
1043                 CL_RunParticleEffect(pos, vec3_origin, 20, 30);
1044                 S_StartSound(-1, 0, cl_sfx_wizhit, pos, 1, 1);
1045                 break;
1046
1047         case TE_KNIGHTSPIKE:
1048                 // spike hitting wall
1049                 MSG_ReadVector(pos);
1050                 CL_FindNonSolidLocation(pos, pos, 4);
1051                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1052                 CL_AllocDlight(NULL, &tempmatrix, 150, 1.0f, 0.60f, 0.20f, 250, 0.2, 0, 0, false, 1);
1053                 CL_RunParticleEffect(pos, vec3_origin, 226, 20);
1054                 S_StartSound(-1, 0, cl_sfx_knighthit, pos, 1, 1);
1055                 break;
1056
1057         case TE_SPIKE:
1058                 // spike hitting wall
1059                 MSG_ReadVector(pos);
1060                 CL_FindNonSolidLocation(pos, pos, 4);
1061                 // LordHavoc: changed to spark shower
1062                 CL_SparkShower(pos, vec3_origin, 15);
1063                 if (rand() % 5)
1064                         S_StartSound(-1, 0, cl_sfx_tink1, pos, 1, 1);
1065                 else
1066                 {
1067                         rnd = rand() & 3;
1068                         if (rnd == 1)
1069                                 S_StartSound(-1, 0, cl_sfx_ric1, pos, 1, 1);
1070                         else if (rnd == 2)
1071                                 S_StartSound(-1, 0, cl_sfx_ric2, pos, 1, 1);
1072                         else
1073                                 S_StartSound(-1, 0, cl_sfx_ric3, pos, 1, 1);
1074                 }
1075                 break;
1076         case TE_SPIKEQUAD:
1077                 // quad spike hitting wall
1078                 MSG_ReadVector(pos);
1079                 CL_FindNonSolidLocation(pos, pos, 4);
1080                 // LordHavoc: changed to spark shower
1081                 CL_SparkShower(pos, vec3_origin, 15);
1082                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1083                 CL_AllocDlight(NULL, &tempmatrix, 200, 0.1f, 0.1f, 1.0f, 1000, 0.2, 0, 0, true, 1);
1084                 S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
1085                 if (rand() % 5)
1086                         S_StartSound(-1, 0, cl_sfx_tink1, pos, 1, 1);
1087                 else
1088                 {
1089                         rnd = rand() & 3;
1090                         if (rnd == 1)
1091                                 S_StartSound(-1, 0, cl_sfx_ric1, pos, 1, 1);
1092                         else if (rnd == 2)
1093                                 S_StartSound(-1, 0, cl_sfx_ric2, pos, 1, 1);
1094                         else
1095                                 S_StartSound(-1, 0, cl_sfx_ric3, pos, 1, 1);
1096                 }
1097                 break;
1098         case TE_SUPERSPIKE:
1099                 // super spike hitting wall
1100                 MSG_ReadVector(pos);
1101                 CL_FindNonSolidLocation(pos, pos, 4);
1102                 // LordHavoc: changed to dust shower
1103                 CL_SparkShower(pos, vec3_origin, 30);
1104                 if (rand() % 5)
1105                         S_StartSound(-1, 0, cl_sfx_tink1, pos, 1, 1);
1106                 else
1107                 {
1108                         rnd = rand() & 3;
1109                         if (rnd == 1)
1110                                 S_StartSound(-1, 0, cl_sfx_ric1, pos, 1, 1);
1111                         else if (rnd == 2)
1112                                 S_StartSound(-1, 0, cl_sfx_ric2, pos, 1, 1);
1113                         else
1114                                 S_StartSound(-1, 0, cl_sfx_ric3, pos, 1, 1);
1115                 }
1116                 break;
1117         case TE_SUPERSPIKEQUAD:
1118                 // quad super spike hitting wall
1119                 MSG_ReadVector(pos);
1120                 CL_FindNonSolidLocation(pos, pos, 4);
1121                 // LordHavoc: changed to dust shower
1122                 CL_SparkShower(pos, vec3_origin, 30);
1123                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1124                 CL_AllocDlight(NULL, &tempmatrix, 200, 0.1f, 0.1f, 1.0f, 1000, 0.2, 0, 0, true, 1);
1125                 if (rand() % 5)
1126                         S_StartSound(-1, 0, cl_sfx_tink1, pos, 1, 1);
1127                 else
1128                 {
1129                         rnd = rand() & 3;
1130                         if (rnd == 1)
1131                                 S_StartSound(-1, 0, cl_sfx_ric1, pos, 1, 1);
1132                         else if (rnd == 2)
1133                                 S_StartSound(-1, 0, cl_sfx_ric2, pos, 1, 1);
1134                         else
1135                                 S_StartSound(-1, 0, cl_sfx_ric3, pos, 1, 1);
1136                 }
1137                 break;
1138                 // LordHavoc: added for improved blood splatters
1139         case TE_BLOOD:
1140                 // blood puff
1141                 MSG_ReadVector(pos);
1142                 CL_FindNonSolidLocation(pos, pos, 4);
1143                 dir[0] = MSG_ReadChar();
1144                 dir[1] = MSG_ReadChar();
1145                 dir[2] = MSG_ReadChar();
1146                 count = MSG_ReadByte();
1147                 CL_BloodPuff(pos, dir, count);
1148                 break;
1149         case TE_SPARK:
1150                 // spark shower
1151                 MSG_ReadVector(pos);
1152                 CL_FindNonSolidLocation(pos, pos, 4);
1153                 dir[0] = MSG_ReadChar();
1154                 dir[1] = MSG_ReadChar();
1155                 dir[2] = MSG_ReadChar();
1156                 count = MSG_ReadByte();
1157                 CL_SparkShower(pos, dir, count);
1158                 break;
1159         case TE_PLASMABURN:
1160                 MSG_ReadVector(pos);
1161                 CL_FindNonSolidLocation(pos, pos, 4);
1162                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1163                 CL_AllocDlight(NULL, &tempmatrix, 200, 1, 1, 1, 1000, 0.2, 0, 0, true, 1);
1164                 CL_PlasmaBurn(pos);
1165                 break;
1166                 // LordHavoc: added for improved gore
1167         case TE_BLOODSHOWER:
1168                 // vaporized body
1169                 MSG_ReadVector(pos); // mins
1170                 MSG_ReadVector(pos2); // maxs
1171                 velspeed = MSG_ReadCoord(); // speed
1172                 count = MSG_ReadShort(); // number of particles
1173                 CL_BloodShower(pos, pos2, velspeed, count);
1174                 break;
1175         case TE_PARTICLECUBE:
1176                 // general purpose particle effect
1177                 MSG_ReadVector(pos); // mins
1178                 MSG_ReadVector(pos2); // maxs
1179                 MSG_ReadVector(dir); // dir
1180                 count = MSG_ReadShort(); // number of particles
1181                 colorStart = MSG_ReadByte(); // color
1182                 colorLength = MSG_ReadByte(); // gravity (1 or 0)
1183                 velspeed = MSG_ReadCoord(); // randomvel
1184                 CL_ParticleCube(pos, pos2, dir, count, colorStart, colorLength, velspeed);
1185                 break;
1186
1187         case TE_PARTICLERAIN:
1188                 // general purpose particle effect
1189                 MSG_ReadVector(pos); // mins
1190                 MSG_ReadVector(pos2); // maxs
1191                 MSG_ReadVector(dir); // dir
1192                 count = MSG_ReadShort(); // number of particles
1193                 colorStart = MSG_ReadByte(); // color
1194                 CL_ParticleRain(pos, pos2, dir, count, colorStart, 0);
1195                 break;
1196
1197         case TE_PARTICLESNOW:
1198                 // general purpose particle effect
1199                 MSG_ReadVector(pos); // mins
1200                 MSG_ReadVector(pos2); // maxs
1201                 MSG_ReadVector(dir); // dir
1202                 count = MSG_ReadShort(); // number of particles
1203                 colorStart = MSG_ReadByte(); // color
1204                 CL_ParticleRain(pos, pos2, dir, count, colorStart, 1);
1205                 break;
1206
1207         case TE_GUNSHOT:
1208                 // bullet hitting wall
1209                 MSG_ReadVector(pos);
1210                 CL_FindNonSolidLocation(pos, pos, 4);
1211                 // LordHavoc: changed to dust shower
1212                 CL_SparkShower(pos, vec3_origin, 15);
1213                 break;
1214
1215         case TE_GUNSHOTQUAD:
1216                 // quad bullet hitting wall
1217                 MSG_ReadVector(pos);
1218                 CL_FindNonSolidLocation(pos, pos, 4);
1219                 CL_SparkShower(pos, vec3_origin, 15);
1220                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1221                 CL_AllocDlight(NULL, &tempmatrix, 200, 0.1f, 0.1f, 1.0f, 1000, 0.2, 0, 0, true, 1);
1222                 break;
1223
1224         case TE_EXPLOSION:
1225                 // rocket explosion
1226                 MSG_ReadVector(pos);
1227                 CL_FindNonSolidLocation(pos, pos, 10);
1228                 CL_ParticleExplosion(pos);
1229                 // LordHavoc: boosted color from 1.0, 0.8, 0.4 to 1.25, 1.0, 0.5
1230                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1231                 CL_AllocDlight(NULL, &tempmatrix, 350, 1.25f, 1.0f, 0.5f, 700, 0.5, 0, 0, true, 1);
1232                 S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
1233                 break;
1234
1235         case TE_EXPLOSIONQUAD:
1236                 // quad rocket explosion
1237                 MSG_ReadVector(pos);
1238                 CL_FindNonSolidLocation(pos, pos, 10);
1239                 CL_ParticleExplosion(pos);
1240                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1241                 CL_AllocDlight(NULL, &tempmatrix, 600, 0.5f, 0.4f, 1.0f, 1200, 0.5, 0, 0, true, 1);
1242                 S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
1243                 break;
1244
1245         case TE_EXPLOSION3:
1246                 // Nehahra movie colored lighting explosion
1247                 MSG_ReadVector(pos);
1248                 CL_FindNonSolidLocation(pos, pos, 10);
1249                 CL_ParticleExplosion(pos);
1250                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1251                 CL_AllocDlight(NULL, &tempmatrix, 350, MSG_ReadCoord(), MSG_ReadCoord(), MSG_ReadCoord(), 700, 0.5, 0, 0, true, 1);
1252                 S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
1253                 break;
1254
1255         case TE_EXPLOSIONRGB:
1256                 // colored lighting explosion
1257                 MSG_ReadVector(pos);
1258                 CL_FindNonSolidLocation(pos, pos, 10);
1259                 CL_ParticleExplosion(pos);
1260                 color[0] = MSG_ReadByte() * (1.0 / 255.0);
1261                 color[1] = MSG_ReadByte() * (1.0 / 255.0);
1262                 color[2] = MSG_ReadByte() * (1.0 / 255.0);
1263                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1264                 CL_AllocDlight(NULL, &tempmatrix, 350, color[0], color[1], color[2], 700, 0.5, 0, 0, true, 1);
1265                 S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
1266                 break;
1267
1268         case TE_TAREXPLOSION:
1269                 // tarbaby explosion
1270                 MSG_ReadVector(pos);
1271                 CL_FindNonSolidLocation(pos, pos, 10);
1272                 CL_BlobExplosion(pos);
1273
1274                 S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
1275                 S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
1276                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1277                 CL_AllocDlight(NULL, &tempmatrix, 600, 0.8f, 0.4f, 1.0f, 1200, 0.5, 0, 0, true, 1);
1278                 break;
1279
1280         case TE_SMALLFLASH:
1281                 MSG_ReadVector(pos);
1282                 CL_FindNonSolidLocation(pos, pos, 10);
1283                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1284                 CL_AllocDlight(NULL, &tempmatrix, 200, 1, 1, 1, 1000, 0.2, 0, 0, true, 1);
1285                 break;
1286
1287         case TE_CUSTOMFLASH:
1288                 MSG_ReadVector(pos);
1289                 CL_FindNonSolidLocation(pos, pos, 4);
1290                 radius = MSG_ReadByte() * 8;
1291                 velspeed = (MSG_ReadByte() + 1) * (1.0 / 256.0);
1292                 color[0] = MSG_ReadByte() * (1.0 / 255.0);
1293                 color[1] = MSG_ReadByte() * (1.0 / 255.0);
1294                 color[2] = MSG_ReadByte() * (1.0 / 255.0);
1295                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1296                 CL_AllocDlight(NULL, &tempmatrix, radius, color[0], color[1], color[2], radius / velspeed, velspeed, 0, 0, true, 1);
1297                 break;
1298
1299         case TE_FLAMEJET:
1300                 MSG_ReadVector(pos);
1301                 MSG_ReadVector(dir);
1302                 count = MSG_ReadByte();
1303                 CL_Flames(pos, dir, count);
1304                 break;
1305
1306         case TE_LIGHTNING1:
1307                 // lightning bolts
1308                 if (!cl_model_bolt)
1309                         cl_model_bolt = Mod_ForName("progs/bolt.mdl", true, false, false);
1310                 CL_ParseBeam(cl_model_bolt, true);
1311                 break;
1312
1313         case TE_LIGHTNING2:
1314                 // lightning bolts
1315                 if (!cl_model_bolt2)
1316                         cl_model_bolt2 = Mod_ForName("progs/bolt2.mdl", true, false, false);
1317                 CL_ParseBeam(cl_model_bolt2, true);
1318                 break;
1319
1320         case TE_LIGHTNING3:
1321                 // lightning bolts
1322                 if (!cl_model_bolt3)
1323                         cl_model_bolt3 = Mod_ForName("progs/bolt3.mdl", true, false, false);
1324                 CL_ParseBeam(cl_model_bolt3, false);
1325                 break;
1326
1327 // PGM 01/21/97
1328         case TE_BEAM:
1329                 // grappling hook beam
1330                 if (!cl_model_beam)
1331                         cl_model_beam = Mod_ForName("progs/beam.mdl", true, false, false);
1332                 CL_ParseBeam(cl_model_beam, false);
1333                 break;
1334 // PGM 01/21/97
1335
1336 // LordHavoc: for compatibility with the Nehahra movie...
1337         case TE_LIGHTNING4NEH:
1338                 CL_ParseBeam(Mod_ForName(MSG_ReadString(), true, false, false), false);
1339                 break;
1340
1341         case TE_LAVASPLASH:
1342                 MSG_ReadVector(pos);
1343                 CL_LavaSplash(pos);
1344                 break;
1345
1346         case TE_TELEPORT:
1347                 MSG_ReadVector(pos);
1348                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1349                 CL_AllocDlight(NULL, &tempmatrix, 500, 1.0f, 1.0f, 1.0f, 1500, 99.0f, 0, 0, true, 1);
1350 //              CL_TeleportSplash(pos);
1351                 break;
1352
1353         case TE_EXPLOSION2:
1354                 // color mapped explosion
1355                 MSG_ReadVector(pos);
1356                 CL_FindNonSolidLocation(pos, pos, 10);
1357                 colorStart = MSG_ReadByte();
1358                 colorLength = MSG_ReadByte();
1359                 CL_ParticleExplosion2(pos, colorStart, colorLength);
1360                 tempcolor = (qbyte *)&palette_complete[(rand()%colorLength) + colorStart];
1361                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1362                 CL_AllocDlight(NULL, &tempmatrix, 350, tempcolor[0] * (1.0f / 255.0f), tempcolor[1] * (1.0f / 255.0f), tempcolor[2] * (1.0f / 255.0f), 700, 0.5, 0, 0, true, 1);
1363                 S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
1364                 break;
1365
1366         case TE_TEI_G3:
1367                 MSG_ReadVector(pos);
1368                 MSG_ReadVector(pos2);
1369                 MSG_ReadVector(dir);
1370                 CL_BeamParticle(pos, pos2, 12, 1, 0.3, 0.1, 1, 1);
1371                 CL_BeamParticle(pos, pos2, 5, 1, 0.9, 0.3, 1, 1);
1372                 break;
1373
1374         case TE_TEI_SMOKE:
1375                 MSG_ReadVector(pos);
1376                 MSG_ReadVector(dir);
1377                 count = MSG_ReadByte();
1378                 CL_FindNonSolidLocation(pos, pos, 4);
1379                 CL_Tei_Smoke(pos, dir, count);
1380                 break;
1381
1382         case TE_TEI_BIGEXPLOSION:
1383                 MSG_ReadVector(pos);
1384                 CL_FindNonSolidLocation(pos, pos, 10);
1385                 CL_ParticleExplosion(pos);
1386                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1387                 CL_AllocDlight(NULL, &tempmatrix, 500, 1.25f, 1.0f, 0.5f, 500, 9999, 0, 0, true, 1);
1388                 S_StartSound(-1, 0, cl_sfx_r_exp3, pos, 1, 1);
1389                 break;
1390
1391         case TE_TEI_PLASMAHIT:
1392                 MSG_ReadVector(pos);
1393                 MSG_ReadVector(dir);
1394                 count = MSG_ReadByte();
1395                 CL_FindNonSolidLocation(pos, pos, 5);
1396                 CL_Tei_PlasmaHit(pos, dir, count);
1397                 Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
1398                 CL_AllocDlight(NULL, &tempmatrix, 500, 0.3, 0.6, 1.0f, 2000, 9999, 0, 0, true, 1);
1399                 break;
1400
1401         default:
1402                 Host_Error("CL_ParseTempEntity: bad type %d (hex %02X)", type, type);
1403         }
1404 }
1405
1406 #define SHOWNET(x) if(cl_shownet.integer==2)Con_Printf ("%3i:%s\n", msg_readcount-1, x);
1407
1408 static qbyte cgamenetbuffer[65536];
1409
1410 /*
1411 =====================
1412 CL_ParseServerMessage
1413 =====================
1414 */
1415 int parsingerror = false;
1416 void CL_ParseServerMessage(void)
1417 {
1418         int                     cmd;
1419         int                     i, entitiesupdated;
1420         qbyte           cmdlog[32];
1421         char            *cmdlogname[32], *temp;
1422         int                     cmdindex, cmdcount = 0;
1423
1424         if (cls.demorecording)
1425                 CL_WriteDemoMessage ();
1426
1427         cl.last_received_message = realtime;
1428
1429 //
1430 // if recording demos, copy the message out
1431 //
1432         if (cl_shownet.integer == 1)
1433                 Con_Printf ("%f %i\n", realtime, net_message.cursize);
1434         else if (cl_shownet.integer == 2)
1435                 Con_Printf ("------------------\n");
1436
1437         cl.onground = false;    // unless the server says otherwise
1438 //
1439 // parse the message
1440 //
1441         //MSG_BeginReading ();
1442
1443         entitiesupdated = false;
1444
1445         parsingerror = true;
1446
1447         while (1)
1448         {
1449                 if (msg_badread)
1450                         Host_Error ("CL_ParseServerMessage: Bad server message");
1451
1452                 cmd = MSG_ReadByte ();
1453
1454                 if (cmd == -1)
1455                 {
1456                         SHOWNET("END OF MESSAGE");
1457                         break;          // end of message
1458                 }
1459
1460                 cmdindex = cmdcount & 31;
1461                 cmdcount++;
1462                 cmdlog[cmdindex] = cmd;
1463
1464                 // if the high bit of the command byte is set, it is a fast update
1465                 if (cmd & 128)
1466                 {
1467                         // 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)
1468                         temp = "entity";
1469                         cmdlogname[cmdindex] = temp;
1470                         SHOWNET("fast update");
1471                         if (cls.signon == SIGNONS - 1)
1472                         {
1473                                 // first update is the final signon stage
1474                                 cls.signon = SIGNONS;
1475                                 CL_SignonReply ();
1476                         }
1477                         CL_ParseUpdate (cmd&127);
1478                         continue;
1479                 }
1480
1481                 SHOWNET(svc_strings[cmd]);
1482                 cmdlogname[cmdindex] = svc_strings[cmd];
1483                 if (!cmdlogname[cmdindex])
1484                 {
1485                         // 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)
1486                         temp = "<unknown>";
1487                         cmdlogname[cmdindex] = temp;
1488                 }
1489
1490                 // other commands
1491                 switch (cmd)
1492                 {
1493                 default:
1494                         {
1495                                 char description[32*64], temp[64];
1496                                 int count;
1497                                 strcpy (description, "packet dump: ");
1498                                 i = cmdcount - 32;
1499                                 if (i < 0)
1500                                         i = 0;
1501                                 count = cmdcount - i;
1502                                 i &= 31;
1503                                 while(count > 0)
1504                                 {
1505                                         snprintf (temp, sizeof (temp), "%3i:%s ", cmdlog[i], cmdlogname[i]);
1506                                         strlcat (description, temp, sizeof (description));
1507                                         count--;
1508                                         i++;
1509                                         i &= 31;
1510                                 }
1511                                 description[strlen(description)-1] = '\n'; // replace the last space with a newline
1512                                 Con_Printf("%s", description);
1513                                 Host_Error ("CL_ParseServerMessage: Illegible server message\n");
1514                         }
1515                         break;
1516
1517                 case svc_nop:
1518                         if (cls.signon < SIGNONS)
1519                                 Con_Printf("<-- server to client keepalive\n");
1520                         break;
1521
1522                 case svc_time:
1523                         if (!entitiesupdated)
1524                         {
1525                                 // this is a new frame, we'll be seeing entities,
1526                                 // so prepare for entity updates
1527                                 CL_EntityUpdateSetup();
1528                                 entitiesupdated = true;
1529                         }
1530                         cl.mtime[1] = cl.mtime[0];
1531                         cl.mtime[0] = MSG_ReadFloat ();
1532                         break;
1533
1534                 case svc_clientdata:
1535                         i = MSG_ReadShort ();
1536                         CL_ParseClientdata (i);
1537                         break;
1538
1539                 case svc_version:
1540                         i = MSG_ReadLong ();
1541                         // hack for unmarked Nehahra movie demos which had a custom protocol
1542                         if (i == PROTOCOL_QUAKE && cls.demoplayback && demo_nehahra.integer)
1543                                 i = PROTOCOL_NEHAHRAMOVIE;
1544                         if (i != PROTOCOL_QUAKE && i != PROTOCOL_DARKPLACES1 && i != PROTOCOL_DARKPLACES2 && i != PROTOCOL_DARKPLACES3 && i != PROTOCOL_DARKPLACES4 && i != PROTOCOL_DARKPLACES5 && i != PROTOCOL_NEHAHRAMOVIE)
1545                                 Host_Error("CL_ParseServerMessage: Server is protocol %i, not %i (Quake), %i (DP1), %i (DP2), %i (DP3), %i (DP4), %i (DP5), or %i (Nehahra movie)", i, PROTOCOL_QUAKE, PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_DARKPLACES5, PROTOCOL_NEHAHRAMOVIE);
1546                         cl.protocol = i;
1547                         break;
1548
1549                 case svc_disconnect:
1550                         Host_EndGame ("Server disconnected\n");
1551
1552                 case svc_print:
1553                         Con_Printf ("%s", MSG_ReadString ());
1554                         break;
1555
1556                 case svc_centerprint:
1557                         SCR_CenterPrint (MSG_ReadString ());
1558                         break;
1559
1560                 case svc_stufftext:
1561                         Cbuf_AddText (MSG_ReadString ());
1562                         break;
1563
1564                 case svc_damage:
1565                         V_ParseDamage ();
1566                         break;
1567
1568                 case svc_serverinfo:
1569                         CL_ParseServerInfo ();
1570                         break;
1571
1572                 case svc_setangle:
1573                         for (i=0 ; i<3 ; i++)
1574                                 cl.viewangles[i] = MSG_ReadAngle ();
1575                         break;
1576
1577                 case svc_setview:
1578                         cl.viewentity = (unsigned short)MSG_ReadShort ();
1579                         if (cl.viewentity >= MAX_EDICTS)
1580                                 Host_Error("svc_setview >= MAX_EDICTS\n");
1581                         // LordHavoc: assume first setview recieved is the real player entity
1582                         if (!cl.playerentity)
1583                                 cl.playerentity = cl.viewentity;
1584                         break;
1585
1586                 case svc_lightstyle:
1587                         i = MSG_ReadByte ();
1588                         if (i >= MAX_LIGHTSTYLES)
1589                                 Host_Error ("svc_lightstyle >= MAX_LIGHTSTYLES");
1590                         strlcpy (cl_lightstyle[i].map,  MSG_ReadString(), sizeof (cl_lightstyle[i].map));
1591                         cl_lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
1592                         cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
1593                         break;
1594
1595                 case svc_sound:
1596                         CL_ParseStartSoundPacket(false);
1597                         break;
1598
1599                 case svc_sound2:
1600                         CL_ParseStartSoundPacket(true);
1601                         break;
1602
1603                 case svc_stopsound:
1604                         i = MSG_ReadShort();
1605                         S_StopSound(i>>3, i&7);
1606                         break;
1607
1608                 case svc_updatename:
1609                         i = MSG_ReadByte ();
1610                         if (i >= cl.maxclients)
1611                                 Host_Error ("CL_ParseServerMessage: svc_updatename >= cl.maxclients");
1612                         strlcpy (cl.scores[i].name, MSG_ReadString (), sizeof (cl.scores[i].name));
1613                         break;
1614
1615                 case svc_updatefrags:
1616                         i = MSG_ReadByte ();
1617                         if (i >= cl.maxclients)
1618                                 Host_Error ("CL_ParseServerMessage: svc_updatefrags >= cl.maxclients");
1619                         cl.scores[i].frags = MSG_ReadShort ();
1620                         break;
1621
1622                 case svc_updatecolors:
1623                         i = MSG_ReadByte ();
1624                         if (i >= cl.maxclients)
1625                                 Host_Error ("CL_ParseServerMessage: svc_updatecolors >= cl.maxclients");
1626                         cl.scores[i].colors = MSG_ReadByte ();
1627                         break;
1628
1629                 case svc_particle:
1630                         CL_ParseParticleEffect ();
1631                         break;
1632
1633                 case svc_effect:
1634                         CL_ParseEffect ();
1635                         break;
1636
1637                 case svc_effect2:
1638                         CL_ParseEffect2 ();
1639                         break;
1640
1641                 case svc_spawnbaseline:
1642                         i = MSG_ReadShort ();
1643                         if (i < 0 || i >= MAX_EDICTS)
1644                                 Host_Error ("CL_ParseServerMessage: svc_spawnbaseline: invalid entity number %i", i);
1645                         CL_ParseBaseline (cl_entities + i, false);
1646                         break;
1647                 case svc_spawnbaseline2:
1648                         i = MSG_ReadShort ();
1649                         if (i < 0 || i >= MAX_EDICTS)
1650                                 Host_Error ("CL_ParseServerMessage: svc_spawnbaseline2: invalid entity number %i", i);
1651                         CL_ParseBaseline (cl_entities + i, true);
1652                         break;
1653                 case svc_spawnstatic:
1654                         CL_ParseStatic (false);
1655                         break;
1656                 case svc_spawnstatic2:
1657                         CL_ParseStatic (true);
1658                         break;
1659                 case svc_temp_entity:
1660                         CL_ParseTempEntity ();
1661                         break;
1662
1663                 case svc_setpause:
1664                         cl.paused = MSG_ReadByte ();
1665                         if (cl.paused)
1666                                 CDAudio_Pause ();
1667                         else
1668                                 CDAudio_Resume ();
1669                         break;
1670
1671                 case svc_signonnum:
1672                         i = MSG_ReadByte ();
1673                         if (i <= cls.signon)
1674                                 Host_Error ("Received signon %i when at %i", i, cls.signon);
1675                         cls.signon = i;
1676                         CL_SignonReply ();
1677                         break;
1678
1679                 case svc_killedmonster:
1680                         cl.stats[STAT_MONSTERS]++;
1681                         break;
1682
1683                 case svc_foundsecret:
1684                         cl.stats[STAT_SECRETS]++;
1685                         break;
1686
1687                 case svc_updatestat:
1688                         i = MSG_ReadByte ();
1689                         if (i < 0 || i >= MAX_CL_STATS)
1690                                 Host_Error ("svc_updatestat: %i is invalid", i);
1691                         cl.stats[i] = MSG_ReadLong ();
1692                         break;
1693
1694                 case svc_spawnstaticsound:
1695                         CL_ParseStaticSound (false);
1696                         break;
1697
1698                 case svc_spawnstaticsound2:
1699                         CL_ParseStaticSound (true);
1700                         break;
1701
1702                 case svc_cdtrack:
1703                         cl.cdtrack = MSG_ReadByte ();
1704                         cl.looptrack = MSG_ReadByte ();
1705                         if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
1706                                 CDAudio_Play ((qbyte)cls.forcetrack, true);
1707                         else
1708                                 CDAudio_Play ((qbyte)cl.cdtrack, true);
1709                         break;
1710
1711                 case svc_intermission:
1712                         cl.intermission = 1;
1713                         cl.completed_time = cl.time;
1714                         break;
1715
1716                 case svc_finale:
1717                         cl.intermission = 2;
1718                         cl.completed_time = cl.time;
1719                         SCR_CenterPrint (MSG_ReadString ());
1720                         break;
1721
1722                 case svc_cutscene:
1723                         cl.intermission = 3;
1724                         cl.completed_time = cl.time;
1725                         SCR_CenterPrint (MSG_ReadString ());
1726                         break;
1727
1728                 case svc_sellscreen:
1729                         Cmd_ExecuteString ("help", src_command);
1730                         break;
1731                 case svc_hidelmp:
1732                         if (gamemode == GAME_TENEBRAE)
1733                         {
1734                                 // repeating particle effect
1735                                 MSG_ReadCoord();
1736                                 MSG_ReadCoord();
1737                                 MSG_ReadCoord();
1738                                 MSG_ReadCoord();
1739                                 MSG_ReadCoord();
1740                                 MSG_ReadCoord();
1741                                 MSG_ReadByte();
1742                                 MSG_ReadLong();
1743                                 MSG_ReadLong();
1744                                 MSG_ReadString();
1745                         }
1746                         else
1747                                 SHOWLMP_decodehide();
1748                         break;
1749                 case svc_showlmp:
1750                         if (gamemode == GAME_TENEBRAE)
1751                         {
1752                                 // particle effect
1753                                 MSG_ReadCoord();
1754                                 MSG_ReadCoord();
1755                                 MSG_ReadCoord();
1756                                 MSG_ReadByte();
1757                                 MSG_ReadString();
1758                         }
1759                         else
1760                                 SHOWLMP_decodeshow();
1761                         break;
1762                 case svc_skybox:
1763                         R_SetSkyBox(MSG_ReadString());
1764                         break;
1765                 case svc_cgame:
1766                         {
1767                                 int length;
1768                                 length = (int) ((unsigned short) MSG_ReadShort());
1769                                 for (i = 0;i < length;i++)
1770                                         cgamenetbuffer[i] = MSG_ReadByte();
1771                                 if (!msg_badread)
1772                                         CL_CGVM_ParseNetwork(cgamenetbuffer, length);
1773                         }
1774                         break;
1775                 case svc_entities:
1776                         if (cls.signon == SIGNONS - 1)
1777                         {
1778                                 // first update is the final signon stage
1779                                 cls.signon = SIGNONS;
1780                                 CL_SignonReply ();
1781                         }
1782                         CL_ReadEntityFrame();
1783                         break;
1784                 }
1785         }
1786
1787         if (entitiesupdated)
1788                 CL_EntityUpdateEnd();
1789
1790         parsingerror = false;
1791 }
1792
1793 void CL_Parse_DumpPacket(void)
1794 {
1795         if (!parsingerror)
1796                 return;
1797         Con_Printf("Packet dump:\n");
1798         SZ_HexDumpToConsole(&net_message);
1799         parsingerror = false;
1800 }
1801
1802 void CL_Parse_Init(void)
1803 {
1804         // LordHavoc: added demo_nehahra cvar
1805         cl_scores_mempool = Mem_AllocPool("client player info");
1806         Cvar_RegisterVariable (&demo_nehahra);
1807         if (gamemode == GAME_NEHAHRA)
1808                 Cvar_SetValue("demo_nehahra", 1);
1809         Cvar_RegisterVariable(&developer_networkentities);
1810 }