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