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