cl_parse.c

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