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