1 /*
2 ===========================================================================
3 Copyright (C) 1999-2005 Id Software, Inc.
4
5 This file is part of Quake III Arena source code.
6
7 Quake III Arena source code is free software; you can redistribute it
8 and/or modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 2 of the License,
10 or (at your option) any later version.
11
12 Quake III Arena source code is distributed in the hope that it will be
13 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Quake III Arena source code; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 ===========================================================================
21 */
22 #include "q_shared.h"
23 #include "qcommon.h"
24
25 static huffman_t msgHuff;
26
27 static qboolean msgInit = qfalse;
28
29 int pcount[256];
30
31 /*
32 ==============================================================================
33
34 MESSAGE IO FUNCTIONS
35
36 Handles byte ordering and avoids alignment errors
37 ==============================================================================
38 */
39
40 int oldsize = 0;
41
42 void MSG_initHuffman( void );
43
MSG_Init(msg_t * buf,byte * data,int length)44 void MSG_Init( msg_t *buf, byte *data, int length ) {
45 if (!msgInit) {
46 MSG_initHuffman();
47 }
48 Com_Memset (buf, 0, sizeof(*buf));
49 buf->data = data;
50 buf->maxsize = length;
51 }
52
MSG_InitOOB(msg_t * buf,byte * data,int length)53 void MSG_InitOOB( msg_t *buf, byte *data, int length ) {
54 if (!msgInit) {
55 MSG_initHuffman();
56 }
57 Com_Memset (buf, 0, sizeof(*buf));
58 buf->data = data;
59 buf->maxsize = length;
60 buf->oob = qtrue;
61 }
62
MSG_Clear(msg_t * buf)63 void MSG_Clear( msg_t *buf ) {
64 buf->cursize = 0;
65 buf->overflowed = qfalse;
66 buf->bit = 0; //<- in bits
67 }
68
69
MSG_Bitstream(msg_t * buf)70 void MSG_Bitstream( msg_t *buf ) {
71 buf->oob = qfalse;
72 }
73
MSG_BeginReading(msg_t * msg)74 void MSG_BeginReading( msg_t *msg ) {
75 msg->readcount = 0;
76 msg->bit = 0;
77 msg->oob = qfalse;
78 }
79
MSG_BeginReadingOOB(msg_t * msg)80 void MSG_BeginReadingOOB( msg_t *msg ) {
81 msg->readcount = 0;
82 msg->bit = 0;
83 msg->oob = qtrue;
84 }
85
MSG_Copy(msg_t * buf,byte * data,int length,msg_t * src)86 void MSG_Copy(msg_t *buf, byte *data, int length, msg_t *src)
87 {
88 if (length<src->cursize) {
89 Com_Error( ERR_DROP, "MSG_Copy: can't copy into a smaller msg_t buffer");
90 }
91 Com_Memcpy(buf, src, sizeof(msg_t));
92 buf->data = data;
93 Com_Memcpy(buf->data, src->data, src->cursize);
94 }
95
96 /*
97 =============================================================================
98
99 bit functions
100
101 =============================================================================
102 */
103
104 int overflows;
105
106 // negative bit values include signs
MSG_WriteBits(msg_t * msg,int value,int bits)107 void MSG_WriteBits( msg_t *msg, int value, int bits ) {
108 int i;
109 // FILE* fp;
110
111 oldsize += bits;
112
113 // this isn't an exact overflow check, but close enough
114 if ( msg->maxsize - msg->cursize < 4 ) {
115 msg->overflowed = qtrue;
116 return;
117 }
118
119 if ( bits == 0 || bits < -31 || bits > 32 ) {
120 Com_Error( ERR_DROP, "MSG_WriteBits: bad bits %i", bits );
121 }
122
123 // check for overflows
124 if ( bits != 32 ) {
125 if ( bits > 0 ) {
126 if ( value > ( ( 1 << bits ) - 1 ) || value < 0 ) {
127 overflows++;
128 }
129 } else {
130 int r;
131
132 r = 1 << (bits-1);
133
134 if ( value > r - 1 || value < -r ) {
135 overflows++;
136 }
137 }
138 }
139 if ( bits < 0 ) {
140 bits = -bits;
141 }
142 if (msg->oob) {
143 if (bits==8) {
144 msg->data[msg->cursize] = value;
145 msg->cursize += 1;
146 msg->bit += 8;
147 } else if (bits==16) {
148 unsigned short *sp = (unsigned short *)&msg->data[msg->cursize];
149 *sp = LittleShort(value);
150 msg->cursize += 2;
151 msg->bit += 16;
152 } else if (bits==32) {
153 unsigned int *ip = (unsigned int *)&msg->data[msg->cursize];
154 *ip = LittleLong(value);
155 msg->cursize += 4;
156 msg->bit += 32;
157 } else {
158 Com_Error(ERR_DROP, "can't read %d bits\n", bits);
159 }
160 } else {
161 // fp = fopen("c:\\netchan.bin", "a");
162 value &= (0xffffffff>>(32-bits));
163 if (bits&7) {
164 int nbits;
165 nbits = bits&7;
166 for(i=0;i<nbits;i++) {
167 Huff_putBit((value&1), msg->data, &msg->bit);
168 value = (value>>1);
169 }
170 bits = bits - nbits;
171 }
172 if (bits) {
173 for(i=0;i<bits;i+=8) {
174 // fwrite(bp, 1, 1, fp);
175 Huff_offsetTransmit (&msgHuff.compressor, (value&0xff), msg->data, &msg->bit);
176 value = (value>>8);
177 }
178 }
179 msg->cursize = (msg->bit>>3)+1;
180 // fclose(fp);
181 }
182 }
183
MSG_ReadBits(msg_t * msg,int bits)184 int MSG_ReadBits( msg_t *msg, int bits ) {
185 int value;
186 int get;
187 qboolean sgn;
188 int i, nbits;
189 // FILE* fp;
190
191 value = 0;
192
193 if ( bits < 0 ) {
194 bits = -bits;
195 sgn = qtrue;
196 } else {
197 sgn = qfalse;
198 }
199
200 if (msg->oob) {
201 if (bits==8) {
202 value = msg->data[msg->readcount];
203 msg->readcount += 1;
204 msg->bit += 8;
205 } else if (bits==16) {
206 unsigned short *sp = (unsigned short *)&msg->data[msg->readcount];
207 value = LittleShort(*sp);
208 msg->readcount += 2;
209 msg->bit += 16;
210 } else if (bits==32) {
211 unsigned int *ip = (unsigned int *)&msg->data[msg->readcount];
212 value = LittleLong(*ip);
213 msg->readcount += 4;
214 msg->bit += 32;
215 } else {
216 Com_Error(ERR_DROP, "can't read %d bits\n", bits);
217 }
218 } else {
219 nbits = 0;
220 if (bits&7) {
221 nbits = bits&7;
222 for(i=0;i<nbits;i++) {
223 value |= (Huff_getBit(msg->data, &msg->bit)<<i);
224 }
225 bits = bits - nbits;
226 }
227 if (bits) {
228 // fp = fopen("c:\\netchan.bin", "a");
229 for(i=0;i<bits;i+=8) {
230 Huff_offsetReceive (msgHuff.decompressor.tree, &get, msg->data, &msg->bit);
231 // fwrite(&get, 1, 1, fp);
232 value |= (get<<(i+nbits));
233 }
234 // fclose(fp);
235 }
236 msg->readcount = (msg->bit>>3)+1;
237 }
238 if ( sgn ) {
239 if ( value & ( 1 << ( bits - 1 ) ) ) {
240 value |= -1 ^ ( ( 1 << bits ) - 1 );
241 }
242 }
243
244 return value;
245 }
246
247
248
249 //================================================================================
250
251 //
252 // writing functions
253 //
254
MSG_WriteChar(msg_t * sb,int c)255 void MSG_WriteChar( msg_t *sb, int c ) {
256 #ifdef PARANOID
257 if (c < -128 || c > 127)
258 Com_Error (ERR_FATAL, "MSG_WriteChar: range error");
259 #endif
260
261 MSG_WriteBits( sb, c, 8 );
262 }
263
MSG_WriteByte(msg_t * sb,int c)264 void MSG_WriteByte( msg_t *sb, int c ) {
265 #ifdef PARANOID
266 if (c < 0 || c > 255)
267 Com_Error (ERR_FATAL, "MSG_WriteByte: range error");
268 #endif
269
270 MSG_WriteBits( sb, c, 8 );
271 }
272
MSG_WriteData(msg_t * buf,const void * data,int length)273 void MSG_WriteData( msg_t *buf, const void *data, int length ) {
274 int i;
275 for(i=0;i<length;i++) {
276 MSG_WriteByte(buf, ((byte *)data)[i]);
277 }
278 }
279
MSG_WriteShort(msg_t * sb,int c)280 void MSG_WriteShort( msg_t *sb, int c ) {
281 #ifdef PARANOID
282 if (c < ((short)0x8000) || c > (short)0x7fff)
283 Com_Error (ERR_FATAL, "MSG_WriteShort: range error");
284 #endif
285
286 MSG_WriteBits( sb, c, 16 );
287 }
288
MSG_WriteLong(msg_t * sb,int c)289 void MSG_WriteLong( msg_t *sb, int c ) {
290 MSG_WriteBits( sb, c, 32 );
291 }
292
MSG_WriteFloat(msg_t * sb,float f)293 void MSG_WriteFloat( msg_t *sb, float f ) {
294 union {
295 float f;
296 int l;
297 } dat;
298
299 dat.f = f;
300 MSG_WriteBits( sb, dat.l, 32 );
301 }
302
MSG_WriteString(msg_t * sb,const char * s)303 void MSG_WriteString( msg_t *sb, const char *s ) {
304 if ( !s ) {
305 MSG_WriteData (sb, "", 1);
306 } else {
307 int l,i;
308 char string[MAX_STRING_CHARS];
309
310 l = strlen( s );
311 if ( l >= MAX_STRING_CHARS ) {
312 Com_Printf( "MSG_WriteString: MAX_STRING_CHARS" );
313 MSG_WriteData (sb, "", 1);
314 return;
315 }
316 Q_strncpyz( string, s, sizeof( string ) );
317
318 // get rid of 0xff chars, because old clients don't like them
319 for ( i = 0 ; i < l ; i++ ) {
320 // if ( ((byte *)string)[i] > 127 ) {
321 if ( ((byte *)string)[i] == 0xff ) {
322 string[i] = '.';
323 }
324 }
325
326 MSG_WriteData (sb, string, l+1);
327 }
328 }
329
MSG_WriteBigString(msg_t * sb,const char * s)330 void MSG_WriteBigString( msg_t *sb, const char *s ) {
331 if ( !s ) {
332 MSG_WriteData (sb, "", 1);
333 } else {
334 int l,i;
335 char string[BIG_INFO_STRING];
336
337 l = strlen( s );
338 if ( l >= BIG_INFO_STRING ) {
339 Com_Printf( "MSG_WriteString: BIG_INFO_STRING" );
340 MSG_WriteData (sb, "", 1);
341 return;
342 }
343 Q_strncpyz( string, s, sizeof( string ) );
344
345 // get rid of 0xff chars, because old clients don't like them
346 for ( i = 0 ; i < l ; i++ ) {
347 // if ( ((byte *)string)[i] > 127 ) {
348 if ( ((byte *)string)[i] == 0xff ) {
349 string[i] = '.';
350 }
351 }
352
353 MSG_WriteData (sb, string, l+1);
354 }
355 }
356
MSG_WriteAngle(msg_t * sb,float f)357 void MSG_WriteAngle( msg_t *sb, float f ) {
358 MSG_WriteByte (sb, (int)(f*256/360) & 255);
359 }
360
MSG_WriteAngle16(msg_t * sb,float f)361 void MSG_WriteAngle16( msg_t *sb, float f ) {
362 MSG_WriteShort (sb, ANGLE2SHORT(f));
363 }
364
365
366 //============================================================
367
368 //
369 // reading functions
370 //
371
372 // returns -1 if no more characters are available
MSG_ReadChar(msg_t * msg)373 int MSG_ReadChar (msg_t *msg ) {
374 int c;
375
376 c = (signed char)MSG_ReadBits( msg, 8 );
377 if ( msg->readcount > msg->cursize ) {
378 c = -1;
379 }
380
381 return c;
382 }
383
MSG_ReadByte(msg_t * msg)384 int MSG_ReadByte( msg_t *msg ) {
385 int c;
386
387 c = (unsigned char)MSG_ReadBits( msg, 8 );
388 if ( msg->readcount > msg->cursize ) {
389 c = -1;
390 }
391 return c;
392 }
393
MSG_ReadShort(msg_t * msg)394 int MSG_ReadShort( msg_t *msg ) {
395 int c;
396
397 c = (short)MSG_ReadBits( msg, 16 );
398 if ( msg->readcount > msg->cursize ) {
399 c = -1;
400 }
401
402 return c;
403 }
404
MSG_ReadLong(msg_t * msg)405 int MSG_ReadLong( msg_t *msg ) {
406 int c;
407
408 c = MSG_ReadBits( msg, 32 );
409 if ( msg->readcount > msg->cursize ) {
410 c = -1;
411 }
412
413 return c;
414 }
415
MSG_ReadFloat(msg_t * msg)416 float MSG_ReadFloat( msg_t *msg ) {
417 union {
418 byte b[4];
419 float f;
420 int l;
421 } dat;
422
423 dat.l = MSG_ReadBits( msg, 32 );
424 if ( msg->readcount > msg->cursize ) {
425 dat.f = -1;
426 }
427
428 return dat.f;
429 }
430
MSG_ReadString(msg_t * msg)431 char *MSG_ReadString( msg_t *msg ) {
432 static char string[MAX_STRING_CHARS];
433 int l,c;
434
435 l = 0;
436 do {
437 c = MSG_ReadByte(msg); // use ReadByte so -1 is out of bounds
438 if ( c == -1 || c == 0 ) {
439 break;
440 }
441 // translate all fmt spec to avoid crash bugs
442 if ( c == '%' ) {
443 c = '.';
444 }
445 // don't allow higher ascii values
446 // if ( c > 127 ) {
447 if ( c == 0xff ) {
448 c = '.';
449 }
450
451 string[l] = c;
452 l++;
453 } while (l < sizeof(string)-1);
454
455 string[l] = 0;
456
457 return string;
458 }
459
MSG_ReadBigString(msg_t * msg)460 char *MSG_ReadBigString( msg_t *msg ) {
461 static char string[BIG_INFO_STRING];
462 int l,c;
463
464 l = 0;
465 do {
466 c = MSG_ReadByte(msg); // use ReadByte so -1 is out of bounds
467 if ( c == -1 || c == 0 ) {
468 break;
469 }
470 // translate all fmt spec to avoid crash bugs
471 if ( c == '%' ) {
472 c = '.';
473 }
474 // don't allow higher ascii values
475 // if ( c > 127 ) {
476 if ( c == 0xff ) {
477 c = '.';
478 }
479
480 string[l] = c;
481 l++;
482 } while (l < sizeof(string)-1);
483
484 string[l] = 0;
485
486 return string;
487 }
488
MSG_ReadStringLine(msg_t * msg)489 char *MSG_ReadStringLine( msg_t *msg ) {
490 static char string[MAX_STRING_CHARS];
491 int l,c;
492
493 l = 0;
494 do {
495 c = MSG_ReadByte(msg); // use ReadByte so -1 is out of bounds
496 if (c == -1 || c == 0 || c == '\n') {
497 break;
498 }
499 // translate all fmt spec to avoid crash bugs
500 if ( c == '%' ) {
501 c = '.';
502 }
503 // don't allow higher ascii values
504 // if ( c > 127 ) {
505 if ( c == 0xff ) {
506 c = '.';
507 }
508
509 string[l] = c;
510 l++;
511 } while (l < sizeof(string)-1);
512
513 string[l] = 0;
514
515 return string;
516 }
517
MSG_ReadAngle16(msg_t * msg)518 float MSG_ReadAngle16( msg_t *msg ) {
519 return SHORT2ANGLE(MSG_ReadShort(msg));
520 }
521
MSG_ReadData(msg_t * msg,void * data,int len)522 void MSG_ReadData( msg_t *msg, void *data, int len ) {
523 int i;
524
525 for (i=0 ; i<len ; i++) {
526 ((byte *)data)[i] = MSG_ReadByte (msg);
527 }
528 }
529
530
531 /*
532 =============================================================================
533
534 delta functions
535
536 =============================================================================
537 */
538
539 extern cvar_t *cl_shownet;
540
541 #define LOG(x) if( cl_shownet->integer == 4 ) { Com_Printf("%s ", x ); };
542
MSG_WriteDelta(msg_t * msg,int oldV,int newV,int bits)543 void MSG_WriteDelta( msg_t *msg, int oldV, int newV, int bits ) {
544 if ( oldV == newV ) {
545 MSG_WriteBits( msg, 0, 1 );
546 return;
547 }
548 MSG_WriteBits( msg, 1, 1 );
549 MSG_WriteBits( msg, newV, bits );
550 }
551
MSG_ReadDelta(msg_t * msg,int oldV,int bits)552 int MSG_ReadDelta( msg_t *msg, int oldV, int bits ) {
553 if ( MSG_ReadBits( msg, 1 ) ) {
554 return MSG_ReadBits( msg, bits );
555 }
556 return oldV;
557 }
558
MSG_WriteDeltaFloat(msg_t * msg,float oldV,float newV)559 void MSG_WriteDeltaFloat( msg_t *msg, float oldV, float newV ) {
560 if ( oldV == newV ) {
561 MSG_WriteBits( msg, 0, 1 );
562 return;
563 }
564 MSG_WriteBits( msg, 1, 1 );
565 MSG_WriteBits( msg, *(int *)&newV, 32 );
566 }
567
MSG_ReadDeltaFloat(msg_t * msg,float oldV)568 float MSG_ReadDeltaFloat( msg_t *msg, float oldV ) {
569 if ( MSG_ReadBits( msg, 1 ) ) {
570 float newV;
571
572 *(int *)&newV = MSG_ReadBits( msg, 32 );
573 return newV;
574 }
575 return oldV;
576 }
577
578 /*
579 =============================================================================
580
581 delta functions with keys
582
583 =============================================================================
584 */
585
586 int kbitmask[32] = {
587 0x00000001, 0x00000003, 0x00000007, 0x0000000F,
588 0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
589 0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF,
590 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
591 0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF,
592 0x001FFFFf, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF,
593 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF,
594 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF,
595 };
596
MSG_WriteDeltaKey(msg_t * msg,int key,int oldV,int newV,int bits)597 void MSG_WriteDeltaKey( msg_t *msg, int key, int oldV, int newV, int bits ) {
598 if ( oldV == newV ) {
599 MSG_WriteBits( msg, 0, 1 );
600 return;
601 }
602 MSG_WriteBits( msg, 1, 1 );
603 MSG_WriteBits( msg, newV ^ key, bits );
604 }
605
MSG_ReadDeltaKey(msg_t * msg,int key,int oldV,int bits)606 int MSG_ReadDeltaKey( msg_t *msg, int key, int oldV, int bits ) {
607 if ( MSG_ReadBits( msg, 1 ) ) {
608 return MSG_ReadBits( msg, bits ) ^ (key & kbitmask[bits]);
609 }
610 return oldV;
611 }
612
MSG_WriteDeltaKeyFloat(msg_t * msg,int key,float oldV,float newV)613 void MSG_WriteDeltaKeyFloat( msg_t *msg, int key, float oldV, float newV ) {
614 if ( oldV == newV ) {
615 MSG_WriteBits( msg, 0, 1 );
616 return;
617 }
618 MSG_WriteBits( msg, 1, 1 );
619 MSG_WriteBits( msg, (*(int *)&newV) ^ key, 32 );
620 }
621
MSG_ReadDeltaKeyFloat(msg_t * msg,int key,float oldV)622 float MSG_ReadDeltaKeyFloat( msg_t *msg, int key, float oldV ) {
623 if ( MSG_ReadBits( msg, 1 ) ) {
624 float newV;
625
626 *(int *)&newV = MSG_ReadBits( msg, 32 ) ^ key;
627 return newV;
628 }
629 return oldV;
630 }
631
632
633 /*
634 ============================================================================
635
636 usercmd_t communication
637
638 ============================================================================
639 */
640
641 // ms is allways sent, the others are optional
642 #define CM_ANGLE1 (1<<0)
643 #define CM_ANGLE2 (1<<1)
644 #define CM_ANGLE3 (1<<2)
645 #define CM_FORWARD (1<<3)
646 #define CM_SIDE (1<<4)
647 #define CM_UP (1<<5)
648 #define CM_BUTTONS (1<<6)
649 #define CM_WEAPON (1<<7)
650
651 /*
652 =====================
653 MSG_WriteDeltaUsercmd
654 =====================
655 */
MSG_WriteDeltaUsercmd(msg_t * msg,usercmd_t * from,usercmd_t * to)656 void MSG_WriteDeltaUsercmd( msg_t *msg, usercmd_t *from, usercmd_t *to ) {
657 if ( to->serverTime - from->serverTime < 256 ) {
658 MSG_WriteBits( msg, 1, 1 );
659 MSG_WriteBits( msg, to->serverTime - from->serverTime, 8 );
660 } else {
661 MSG_WriteBits( msg, 0, 1 );
662 MSG_WriteBits( msg, to->serverTime, 32 );
663 }
664 MSG_WriteDelta( msg, from->angles[0], to->angles[0], 16 );
665 MSG_WriteDelta( msg, from->angles[1], to->angles[1], 16 );
666 MSG_WriteDelta( msg, from->angles[2], to->angles[2], 16 );
667 MSG_WriteDelta( msg, from->forwardmove, to->forwardmove, 8 );
668 MSG_WriteDelta( msg, from->rightmove, to->rightmove, 8 );
669 MSG_WriteDelta( msg, from->upmove, to->upmove, 8 );
670 MSG_WriteDelta( msg, from->buttons, to->buttons, 16 );
671 MSG_WriteDelta( msg, from->weapon, to->weapon, 8 );
672 }
673
674
675 /*
676 =====================
677 MSG_ReadDeltaUsercmd
678 =====================
679 */
MSG_ReadDeltaUsercmd(msg_t * msg,usercmd_t * from,usercmd_t * to)680 void MSG_ReadDeltaUsercmd( msg_t *msg, usercmd_t *from, usercmd_t *to ) {
681 if ( MSG_ReadBits( msg, 1 ) ) {
682 to->serverTime = from->serverTime + MSG_ReadBits( msg, 8 );
683 } else {
684 to->serverTime = MSG_ReadBits( msg, 32 );
685 }
686 to->angles[0] = MSG_ReadDelta( msg, from->angles[0], 16);
687 to->angles[1] = MSG_ReadDelta( msg, from->angles[1], 16);
688 to->angles[2] = MSG_ReadDelta( msg, from->angles[2], 16);
689 to->forwardmove = MSG_ReadDelta( msg, from->forwardmove, 8);
690 to->rightmove = MSG_ReadDelta( msg, from->rightmove, 8);
691 to->upmove = MSG_ReadDelta( msg, from->upmove, 8);
692 to->buttons = MSG_ReadDelta( msg, from->buttons, 16);
693 to->weapon = MSG_ReadDelta( msg, from->weapon, 8);
694 }
695
696 /*
697 =====================
698 MSG_WriteDeltaUsercmd
699 =====================
700 */
MSG_WriteDeltaUsercmdKey(msg_t * msg,int key,usercmd_t * from,usercmd_t * to)701 void MSG_WriteDeltaUsercmdKey( msg_t *msg, int key, usercmd_t *from, usercmd_t *to ) {
702 if ( to->serverTime - from->serverTime < 256 ) {
703 MSG_WriteBits( msg, 1, 1 );
704 MSG_WriteBits( msg, to->serverTime - from->serverTime, 8 );
705 } else {
706 MSG_WriteBits( msg, 0, 1 );
707 MSG_WriteBits( msg, to->serverTime, 32 );
708 }
709 if (from->angles[0] == to->angles[0] &&
710 from->angles[1] == to->angles[1] &&
711 from->angles[2] == to->angles[2] &&
712 from->forwardmove == to->forwardmove &&
713 from->rightmove == to->rightmove &&
714 from->upmove == to->upmove &&
715 from->buttons == to->buttons &&
716 from->weapon == to->weapon) {
717 MSG_WriteBits( msg, 0, 1 ); // no change
718 oldsize += 7;
719 return;
720 }
721 key ^= to->serverTime;
722 MSG_WriteBits( msg, 1, 1 );
723 MSG_WriteDeltaKey( msg, key, from->angles[0], to->angles[0], 16 );
724 MSG_WriteDeltaKey( msg, key, from->angles[1], to->angles[1], 16 );
725 MSG_WriteDeltaKey( msg, key, from->angles[2], to->angles[2], 16 );
726 MSG_WriteDeltaKey( msg, key, from->forwardmove, to->forwardmove, 8 );
727 MSG_WriteDeltaKey( msg, key, from->rightmove, to->rightmove, 8 );
728 MSG_WriteDeltaKey( msg, key, from->upmove, to->upmove, 8 );
729 MSG_WriteDeltaKey( msg, key, from->buttons, to->buttons, 16 );
730 MSG_WriteDeltaKey( msg, key, from->weapon, to->weapon, 8 );
731 }
732
733
734 /*
735 =====================
736 MSG_ReadDeltaUsercmd
737 =====================
738 */
MSG_ReadDeltaUsercmdKey(msg_t * msg,int key,usercmd_t * from,usercmd_t * to)739 void MSG_ReadDeltaUsercmdKey( msg_t *msg, int key, usercmd_t *from, usercmd_t *to ) {
740 if ( MSG_ReadBits( msg, 1 ) ) {
741 to->serverTime = from->serverTime + MSG_ReadBits( msg, 8 );
742 } else {
743 to->serverTime = MSG_ReadBits( msg, 32 );
744 }
745 if ( MSG_ReadBits( msg, 1 ) ) {
746 key ^= to->serverTime;
747 to->angles[0] = MSG_ReadDeltaKey( msg, key, from->angles[0], 16);
748 to->angles[1] = MSG_ReadDeltaKey( msg, key, from->angles[1], 16);
749 to->angles[2] = MSG_ReadDeltaKey( msg, key, from->angles[2], 16);
750 to->forwardmove = MSG_ReadDeltaKey( msg, key, from->forwardmove, 8);
751 to->rightmove = MSG_ReadDeltaKey( msg, key, from->rightmove, 8);
752 to->upmove = MSG_ReadDeltaKey( msg, key, from->upmove, 8);
753 to->buttons = MSG_ReadDeltaKey( msg, key, from->buttons, 16);
754 to->weapon = MSG_ReadDeltaKey( msg, key, from->weapon, 8);
755 } else {
756 to->angles[0] = from->angles[0];
757 to->angles[1] = from->angles[1];
758 to->angles[2] = from->angles[2];
759 to->forwardmove = from->forwardmove;
760 to->rightmove = from->rightmove;
761 to->upmove = from->upmove;
762 to->buttons = from->buttons;
763 to->weapon = from->weapon;
764 }
765 }
766
767 /*
768 =============================================================================
769
770 entityState_t communication
771
772 =============================================================================
773 */
774
775 /*
776 =================
777 MSG_ReportChangeVectors_f
778
779 Prints out a table from the current statistics for copying to code
780 =================
781 */
MSG_ReportChangeVectors_f(void)782 void MSG_ReportChangeVectors_f( void ) {
783 int i;
784 for(i=0;i<256;i++) {
785 if (pcount[i]) {
786 Com_Printf("%d used %d\n", i, pcount[i]);
787 }
788 }
789 }
790
791 typedef struct {
792 char *name;
793 int offset;
794 int bits; // 0 = float
795 } netField_t;
796
797 // using the stringizing operator to save typing...
798 #define NETF(x) #x,(size_t)&((entityState_t*)0)->x
799
800 netField_t entityStateFields[] =
801 {
802 { NETF(pos.trTime), 32 },
803 { NETF(pos.trBase[0]), 0 },
804 { NETF(pos.trBase[1]), 0 },
805 { NETF(pos.trDelta[0]), 0 },
806 { NETF(pos.trDelta[1]), 0 },
807 { NETF(pos.trBase[2]), 0 },
808 { NETF(apos.trBase[1]), 0 },
809 { NETF(pos.trDelta[2]), 0 },
810 { NETF(apos.trBase[0]), 0 },
811 { NETF(event), 10 },
812 { NETF(angles2[1]), 0 },
813 { NETF(eType), 8 },
814 { NETF(torsoAnim), 8 },
815 { NETF(eventParm), 8 },
816 { NETF(legsAnim), 8 },
817 { NETF(groundEntityNum), GENTITYNUM_BITS },
818 { NETF(pos.trType), 8 },
819 { NETF(eFlags), 19 },
820 { NETF(otherEntityNum), GENTITYNUM_BITS },
821 { NETF(weapon), 8 },
822 { NETF(clientNum), 8 },
823 { NETF(angles[1]), 0 },
824 { NETF(pos.trDuration), 32 },
825 { NETF(apos.trType), 8 },
826 { NETF(origin[0]), 0 },
827 { NETF(origin[1]), 0 },
828 { NETF(origin[2]), 0 },
829 { NETF(solid), 24 },
830 { NETF(powerups), MAX_POWERUPS },
831 { NETF(modelindex), 8 },
832 { NETF(otherEntityNum2), GENTITYNUM_BITS },
833 { NETF(loopSound), 8 },
834 { NETF(generic1), 8 },
835 { NETF(origin2[2]), 0 },
836 { NETF(origin2[0]), 0 },
837 { NETF(origin2[1]), 0 },
838 { NETF(modelindex2), 8 },
839 { NETF(angles[0]), 0 },
840 { NETF(time), 32 },
841 { NETF(apos.trTime), 32 },
842 { NETF(apos.trDuration), 32 },
843 { NETF(apos.trBase[2]), 0 },
844 { NETF(apos.trDelta[0]), 0 },
845 { NETF(apos.trDelta[1]), 0 },
846 { NETF(apos.trDelta[2]), 0 },
847 { NETF(time2), 32 },
848 { NETF(angles[2]), 0 },
849 { NETF(angles2[0]), 0 },
850 { NETF(angles2[2]), 0 },
851 { NETF(constantLight), 32 },
852 { NETF(frame), 16 }
853 };
854
855
856 // if (int)f == f and (int)f + ( 1<<(FLOAT_INT_BITS-1) ) < ( 1 << FLOAT_INT_BITS )
857 // the float will be sent with FLOAT_INT_BITS, otherwise all 32 bits will be sent
858 #define FLOAT_INT_BITS 13
859 #define FLOAT_INT_BIAS (1<<(FLOAT_INT_BITS-1))
860
861 /*
862 ==================
863 MSG_WriteDeltaEntity
864
865 Writes part of a packetentities message, including the entity number.
866 Can delta from either a baseline or a previous packet_entity
867 If to is NULL, a remove entity update will be sent
868 If force is not set, then nothing at all will be generated if the entity is
869 identical, under the assumption that the in-order delta code will catch it.
870 ==================
871 */
MSG_WriteDeltaEntity(msg_t * msg,struct entityState_s * from,struct entityState_s * to,qboolean force)872 void MSG_WriteDeltaEntity( msg_t *msg, struct entityState_s *from, struct entityState_s *to,
873 qboolean force ) {
874 int i, lc;
875 int numFields;
876 netField_t *field;
877 int trunc;
878 float fullFloat;
879 int *fromF, *toF;
880
881 numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
882
883 // all fields should be 32 bits to avoid any compiler packing issues
884 // the "number" field is not part of the field list
885 // if this assert fails, someone added a field to the entityState_t
886 // struct without updating the message fields
887 assert( numFields + 1 == sizeof( *from )/4 );
888
889 // a NULL to is a delta remove message
890 if ( to == NULL ) {
891 if ( from == NULL ) {
892 return;
893 }
894 MSG_WriteBits( msg, from->number, GENTITYNUM_BITS );
895 MSG_WriteBits( msg, 1, 1 );
896 return;
897 }
898
899 if ( to->number < 0 || to->number >= MAX_GENTITIES ) {
900 Com_Error (ERR_FATAL, "MSG_WriteDeltaEntity: Bad entity number: %i", to->number );
901 }
902
903 lc = 0;
904 // build the change vector as bytes so it is endien independent
905 for ( i = 0, field = entityStateFields ; i < numFields ; i++, field++ ) {
906 fromF = (int *)( (byte *)from + field->offset );
907 toF = (int *)( (byte *)to + field->offset );
908 if ( *fromF != *toF ) {
909 lc = i+1;
910 }
911 }
912
913 if ( lc == 0 ) {
914 // nothing at all changed
915 if ( !force ) {
916 return; // nothing at all
917 }
918 // write two bits for no change
919 MSG_WriteBits( msg, to->number, GENTITYNUM_BITS );
920 MSG_WriteBits( msg, 0, 1 ); // not removed
921 MSG_WriteBits( msg, 0, 1 ); // no delta
922 return;
923 }
924
925 MSG_WriteBits( msg, to->number, GENTITYNUM_BITS );
926 MSG_WriteBits( msg, 0, 1 ); // not removed
927 MSG_WriteBits( msg, 1, 1 ); // we have a delta
928
929 MSG_WriteByte( msg, lc ); // # of changes
930
931 oldsize += numFields;
932
933 for ( i = 0, field = entityStateFields ; i < lc ; i++, field++ ) {
934 fromF = (int *)( (byte *)from + field->offset );
935 toF = (int *)( (byte *)to + field->offset );
936
937 if ( *fromF == *toF ) {
938 MSG_WriteBits( msg, 0, 1 ); // no change
939 continue;
940 }
941
942 MSG_WriteBits( msg, 1, 1 ); // changed
943
944 if ( field->bits == 0 ) {
945 // float
946 fullFloat = *(float *)toF;
947 trunc = (int)fullFloat;
948
949 if (fullFloat == 0.0f) {
950 MSG_WriteBits( msg, 0, 1 );
951 oldsize += FLOAT_INT_BITS;
952 } else {
953 MSG_WriteBits( msg, 1, 1 );
954 if ( trunc == fullFloat && trunc + FLOAT_INT_BIAS >= 0 &&
955 trunc + FLOAT_INT_BIAS < ( 1 << FLOAT_INT_BITS ) ) {
956 // send as small integer
957 MSG_WriteBits( msg, 0, 1 );
958 MSG_WriteBits( msg, trunc + FLOAT_INT_BIAS, FLOAT_INT_BITS );
959 } else {
960 // send as full floating point value
961 MSG_WriteBits( msg, 1, 1 );
962 MSG_WriteBits( msg, *toF, 32 );
963 }
964 }
965 } else {
966 if (*toF == 0) {
967 MSG_WriteBits( msg, 0, 1 );
968 } else {
969 MSG_WriteBits( msg, 1, 1 );
970 // integer
971 MSG_WriteBits( msg, *toF, field->bits );
972 }
973 }
974 }
975 }
976
977 /*
978 ==================
979 MSG_ReadDeltaEntity
980
981 The entity number has already been read from the message, which
982 is how the from state is identified.
983
984 If the delta removes the entity, entityState_t->number will be set to MAX_GENTITIES-1
985
986 Can go from either a baseline or a previous packet_entity
987 ==================
988 */
989 extern cvar_t *cl_shownet;
990
MSG_ReadDeltaEntity(msg_t * msg,entityState_t * from,entityState_t * to,int number)991 void MSG_ReadDeltaEntity( msg_t *msg, entityState_t *from, entityState_t *to,
992 int number) {
993 int i, lc;
994 int numFields;
995 netField_t *field;
996 int *fromF, *toF;
997 int print;
998 int trunc;
999 int startBit, endBit;
1000
1001 if ( number < 0 || number >= MAX_GENTITIES) {
1002 Com_Error( ERR_DROP, "Bad delta entity number: %i", number );
1003 }
1004
1005 if ( msg->bit == 0 ) {
1006 startBit = msg->readcount * 8 - GENTITYNUM_BITS;
1007 } else {
1008 startBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
1009 }
1010
1011 // check for a remove
1012 if ( MSG_ReadBits( msg, 1 ) == 1 ) {
1013 Com_Memset( to, 0, sizeof( *to ) );
1014 to->number = MAX_GENTITIES - 1;
1015 if ( cl_shownet->integer >= 2 || cl_shownet->integer == -1 ) {
1016 Com_Printf( "%3i: #%-3i remove\n", msg->readcount, number );
1017 }
1018 return;
1019 }
1020
1021 // check for no delta
1022 if ( MSG_ReadBits( msg, 1 ) == 0 ) {
1023 *to = *from;
1024 to->number = number;
1025 return;
1026 }
1027
1028 numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
1029 lc = MSG_ReadByte(msg);
1030
1031 // shownet 2/3 will interleave with other printed info, -1 will
1032 // just print the delta records`
1033 if ( cl_shownet->integer >= 2 || cl_shownet->integer == -1 ) {
1034 print = 1;
1035 Com_Printf( "%3i: #%-3i ", msg->readcount, to->number );
1036 } else {
1037 print = 0;
1038 }
1039
1040 to->number = number;
1041
1042 for ( i = 0, field = entityStateFields ; i < lc ; i++, field++ ) {
1043 fromF = (int *)( (byte *)from + field->offset );
1044 toF = (int *)( (byte *)to + field->offset );
1045
1046 if ( ! MSG_ReadBits( msg, 1 ) ) {
1047 // no change
1048 *toF = *fromF;
1049 } else {
1050 if ( field->bits == 0 ) {
1051 // float
1052 if ( MSG_ReadBits( msg, 1 ) == 0 ) {
1053 *(float *)toF = 0.0f;
1054 } else {
1055 if ( MSG_ReadBits( msg, 1 ) == 0 ) {
1056 // integral float
1057 trunc = MSG_ReadBits( msg, FLOAT_INT_BITS );
1058 // bias to allow equal parts positive and negative
1059 trunc -= FLOAT_INT_BIAS;
1060 *(float *)toF = trunc;
1061 if ( print ) {
1062 Com_Printf( "%s:%i ", field->name, trunc );
1063 }
1064 } else {
1065 // full floating point value
1066 *toF = MSG_ReadBits( msg, 32 );
1067 if ( print ) {
1068 Com_Printf( "%s:%f ", field->name, *(float *)toF );
1069 }
1070 }
1071 }
1072 } else {
1073 if ( MSG_ReadBits( msg, 1 ) == 0 ) {
1074 *toF = 0;
1075 } else {
1076 // integer
1077 *toF = MSG_ReadBits( msg, field->bits );
1078 if ( print ) {
1079 Com_Printf( "%s:%i ", field->name, *toF );
1080 }
1081 }
1082 }
1083 // pcount[i]++;
1084 }
1085 }
1086 for ( i = lc, field = &entityStateFields[lc] ; i < numFields ; i++, field++ ) {
1087 fromF = (int *)( (byte *)from + field->offset );
1088 toF = (int *)( (byte *)to + field->offset );
1089 // no change
1090 *toF = *fromF;
1091 }
1092
1093 if ( print ) {
1094 if ( msg->bit == 0 ) {
1095 endBit = msg->readcount * 8 - GENTITYNUM_BITS;
1096 } else {
1097 endBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
1098 }
1099 Com_Printf( " (%i bits)\n", endBit - startBit );
1100 }
1101 }
1102
1103
1104 /*
1105 ============================================================================
1106
1107 plyer_state_t communication
1108
1109 ============================================================================
1110 */
1111
1112 // using the stringizing operator to save typing...
1113 #define PSF(x) #x,(size_t)&((playerState_t*)0)->x
1114
1115 netField_t playerStateFields[] =
1116 {
1117 { PSF(commandTime), 32 },
1118 { PSF(origin[0]), 0 },
1119 { PSF(origin[1]), 0 },
1120 { PSF(bobCycle), 8 },
1121 { PSF(velocity[0]), 0 },
1122 { PSF(velocity[1]), 0 },
1123 { PSF(viewangles[1]), 0 },
1124 { PSF(viewangles[0]), 0 },
1125 { PSF(weaponTime), -16 },
1126 { PSF(origin[2]), 0 },
1127 { PSF(velocity[2]), 0 },
1128 { PSF(legsTimer), 8 },
1129 { PSF(pm_time), -16 },
1130 { PSF(eventSequence), 16 },
1131 { PSF(torsoAnim), 8 },
1132 { PSF(movementDir), 4 },
1133 { PSF(events[0]), 8 },
1134 { PSF(legsAnim), 8 },
1135 { PSF(events[1]), 8 },
1136 { PSF(pm_flags), 16 },
1137 { PSF(groundEntityNum), GENTITYNUM_BITS },
1138 { PSF(weaponstate), 4 },
1139 { PSF(eFlags), 16 },
1140 { PSF(externalEvent), 10 },
1141 { PSF(gravity), 16 },
1142 { PSF(speed), 16 },
1143 { PSF(delta_angles[1]), 16 },
1144 { PSF(externalEventParm), 8 },
1145 { PSF(viewheight), -8 },
1146 { PSF(damageEvent), 8 },
1147 { PSF(damageYaw), 8 },
1148 { PSF(damagePitch), 8 },
1149 { PSF(damageCount), 8 },
1150 { PSF(generic1), 8 },
1151 { PSF(pm_type), 8 },
1152 { PSF(delta_angles[0]), 16 },
1153 { PSF(delta_angles[2]), 16 },
1154 { PSF(torsoTimer), 12 },
1155 { PSF(eventParms[0]), 8 },
1156 { PSF(eventParms[1]), 8 },
1157 { PSF(clientNum), 8 },
1158 { PSF(weapon), 5 },
1159 { PSF(viewangles[2]), 0 },
1160 { PSF(grapplePoint[0]), 0 },
1161 { PSF(grapplePoint[1]), 0 },
1162 { PSF(grapplePoint[2]), 0 },
1163 { PSF(jumppad_ent), 10 },
1164 { PSF(loopSound), 16 }
1165 };
1166
1167 /*
1168 =============
1169 MSG_WriteDeltaPlayerstate
1170
1171 =============
1172 */
MSG_WriteDeltaPlayerstate(msg_t * msg,struct playerState_s * from,struct playerState_s * to)1173 void MSG_WriteDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct playerState_s *to ) {
1174 int i;
1175 playerState_t dummy;
1176 int statsbits;
1177 int persistantbits;
1178 int ammobits;
1179 int powerupbits;
1180 int numFields;
1181 int c;
1182 netField_t *field;
1183 int *fromF, *toF;
1184 float fullFloat;
1185 int trunc, lc;
1186
1187 if (!from) {
1188 from = &dummy;
1189 Com_Memset (&dummy, 0, sizeof(dummy));
1190 }
1191
1192 c = msg->cursize;
1193
1194 numFields = sizeof( playerStateFields ) / sizeof( playerStateFields[0] );
1195
1196 lc = 0;
1197 for ( i = 0, field = playerStateFields ; i < numFields ; i++, field++ ) {
1198 fromF = (int *)( (byte *)from + field->offset );
1199 toF = (int *)( (byte *)to + field->offset );
1200 if ( *fromF != *toF ) {
1201 lc = i+1;
1202 }
1203 }
1204
1205 MSG_WriteByte( msg, lc ); // # of changes
1206
1207 oldsize += numFields - lc;
1208
1209 for ( i = 0, field = playerStateFields ; i < lc ; i++, field++ ) {
1210 fromF = (int *)( (byte *)from + field->offset );
1211 toF = (int *)( (byte *)to + field->offset );
1212
1213 if ( *fromF == *toF ) {
1214 MSG_WriteBits( msg, 0, 1 ); // no change
1215 continue;
1216 }
1217
1218 MSG_WriteBits( msg, 1, 1 ); // changed
1219 // pcount[i]++;
1220
1221 if ( field->bits == 0 ) {
1222 // float
1223 fullFloat = *(float *)toF;
1224 trunc = (int)fullFloat;
1225
1226 if ( trunc == fullFloat && trunc + FLOAT_INT_BIAS >= 0 &&
1227 trunc + FLOAT_INT_BIAS < ( 1 << FLOAT_INT_BITS ) ) {
1228 // send as small integer
1229 MSG_WriteBits( msg, 0, 1 );
1230 MSG_WriteBits( msg, trunc + FLOAT_INT_BIAS, FLOAT_INT_BITS );
1231 } else {
1232 // send as full floating point value
1233 MSG_WriteBits( msg, 1, 1 );
1234 MSG_WriteBits( msg, *toF, 32 );
1235 }
1236 } else {
1237 // integer
1238 MSG_WriteBits( msg, *toF, field->bits );
1239 }
1240 }
1241 c = msg->cursize - c;
1242
1243
1244 //
1245 // send the arrays
1246 //
1247 statsbits = 0;
1248 for (i=0 ; i<MAX_STATS ; i++) {
1249 if (to->stats[i] != from->stats[i]) {
1250 statsbits |= 1<<i;
1251 }
1252 }
1253 persistantbits = 0;
1254 for (i=0 ; i<MAX_PERSISTANT ; i++) {
1255 if (to->persistant[i] != from->persistant[i]) {
1256 persistantbits |= 1<<i;
1257 }
1258 }
1259 ammobits = 0;
1260 for (i=0 ; i<MAX_WEAPONS ; i++) {
1261 if (to->ammo[i] != from->ammo[i]) {
1262 ammobits |= 1<<i;
1263 }
1264 }
1265 powerupbits = 0;
1266 for (i=0 ; i<MAX_POWERUPS ; i++) {
1267 if (to->powerups[i] != from->powerups[i]) {
1268 powerupbits |= 1<<i;
1269 }
1270 }
1271
1272 if (!statsbits && !persistantbits && !ammobits && !powerupbits) {
1273 MSG_WriteBits( msg, 0, 1 ); // no change
1274 oldsize += 4;
1275 return;
1276 }
1277 MSG_WriteBits( msg, 1, 1 ); // changed
1278
1279 if ( statsbits ) {
1280 MSG_WriteBits( msg, 1, 1 ); // changed
1281 MSG_WriteBits( msg, statsbits, MAX_STATS );
1282 for (i=0 ; i<MAX_STATS ; i++)
1283 if (statsbits & (1<<i) )
1284 MSG_WriteShort (msg, to->stats[i]);
1285 } else {
1286 MSG_WriteBits( msg, 0, 1 ); // no change
1287 }
1288
1289
1290 if ( persistantbits ) {
1291 MSG_WriteBits( msg, 1, 1 ); // changed
1292 MSG_WriteBits( msg, persistantbits, MAX_PERSISTANT );
1293 for (i=0 ; i<MAX_PERSISTANT ; i++)
1294 if (persistantbits & (1<<i) )
1295 MSG_WriteShort (msg, to->persistant[i]);
1296 } else {
1297 MSG_WriteBits( msg, 0, 1 ); // no change
1298 }
1299
1300
1301 if ( ammobits ) {
1302 MSG_WriteBits( msg, 1, 1 ); // changed
1303 MSG_WriteBits( msg, ammobits, MAX_WEAPONS );
1304 for (i=0 ; i<MAX_WEAPONS ; i++)
1305 if (ammobits & (1<<i) )
1306 MSG_WriteShort (msg, to->ammo[i]);
1307 } else {
1308 MSG_WriteBits( msg, 0, 1 ); // no change
1309 }
1310
1311
1312 if ( powerupbits ) {
1313 MSG_WriteBits( msg, 1, 1 ); // changed
1314 MSG_WriteBits( msg, powerupbits, MAX_POWERUPS );
1315 for (i=0 ; i<MAX_POWERUPS ; i++)
1316 if (powerupbits & (1<<i) )
1317 MSG_WriteLong( msg, to->powerups[i] );
1318 } else {
1319 MSG_WriteBits( msg, 0, 1 ); // no change
1320 }
1321 }
1322
1323
1324 /*
1325 ===================
1326 MSG_ReadDeltaPlayerstate
1327 ===================
1328 */
MSG_ReadDeltaPlayerstate(msg_t * msg,playerState_t * from,playerState_t * to)1329 void MSG_ReadDeltaPlayerstate (msg_t *msg, playerState_t *from, playerState_t *to ) {
1330 int i, lc;
1331 int bits;
1332 netField_t *field;
1333 int numFields;
1334 int startBit, endBit;
1335 int print;
1336 int *fromF, *toF;
1337 int trunc;
1338 playerState_t dummy;
1339
1340 if ( !from ) {
1341 from = &dummy;
1342 Com_Memset( &dummy, 0, sizeof( dummy ) );
1343 }
1344 *to = *from;
1345
1346 if ( msg->bit == 0 ) {
1347 startBit = msg->readcount * 8 - GENTITYNUM_BITS;
1348 } else {
1349 startBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
1350 }
1351
1352 // shownet 2/3 will interleave with other printed info, -2 will
1353 // just print the delta records
1354 if ( cl_shownet->integer >= 2 || cl_shownet->integer == -2 ) {
1355 print = 1;
1356 Com_Printf( "%3i: playerstate ", msg->readcount );
1357 } else {
1358 print = 0;
1359 }
1360
1361 numFields = sizeof( playerStateFields ) / sizeof( playerStateFields[0] );
1362 lc = MSG_ReadByte(msg);
1363
1364 for ( i = 0, field = playerStateFields ; i < lc ; i++, field++ ) {
1365 fromF = (int *)( (byte *)from + field->offset );
1366 toF = (int *)( (byte *)to + field->offset );
1367
1368 if ( ! MSG_ReadBits( msg, 1 ) ) {
1369 // no change
1370 *toF = *fromF;
1371 } else {
1372 if ( field->bits == 0 ) {
1373 // float
1374 if ( MSG_ReadBits( msg, 1 ) == 0 ) {
1375 // integral float
1376 trunc = MSG_ReadBits( msg, FLOAT_INT_BITS );
1377 // bias to allow equal parts positive and negative
1378 trunc -= FLOAT_INT_BIAS;
1379 *(float *)toF = trunc;
1380 if ( print ) {
1381 Com_Printf( "%s:%i ", field->name, trunc );
1382 }
1383 } else {
1384 // full floating point value
1385 *toF = MSG_ReadBits( msg, 32 );
1386 if ( print ) {
1387 Com_Printf( "%s:%f ", field->name, *(float *)toF );
1388 }
1389 }
1390 } else {
1391 // integer
1392 *toF = MSG_ReadBits( msg, field->bits );
1393 if ( print ) {
1394 Com_Printf( "%s:%i ", field->name, *toF );
1395 }
1396 }
1397 }
1398 }
1399 for ( i=lc,field = &playerStateFields[lc];i<numFields; i++, field++) {
1400 fromF = (int *)( (byte *)from + field->offset );
1401 toF = (int *)( (byte *)to + field->offset );
1402 // no change
1403 *toF = *fromF;
1404 }
1405
1406
1407 // read the arrays
1408 if (MSG_ReadBits( msg, 1 ) ) {
1409 // parse stats
1410 if ( MSG_ReadBits( msg, 1 ) ) {
1411 LOG("PS_STATS");
1412 bits = MSG_ReadBits (msg, MAX_STATS);
1413 for (i=0 ; i<MAX_STATS ; i++) {
1414 if (bits & (1<<i) ) {
1415 to->stats[i] = MSG_ReadShort(msg);
1416 }
1417 }
1418 }
1419
1420 // parse persistant stats
1421 if ( MSG_ReadBits( msg, 1 ) ) {
1422 LOG("PS_PERSISTANT");
1423 bits = MSG_ReadBits (msg, MAX_PERSISTANT);
1424 for (i=0 ; i<MAX_PERSISTANT ; i++) {
1425 if (bits & (1<<i) ) {
1426 to->persistant[i] = MSG_ReadShort(msg);
1427 }
1428 }
1429 }
1430
1431 // parse ammo
1432 if ( MSG_ReadBits( msg, 1 ) ) {
1433 LOG("PS_AMMO");
1434 bits = MSG_ReadBits (msg, MAX_WEAPONS);
1435 for (i=0 ; i<MAX_WEAPONS ; i++) {
1436 if (bits & (1<<i) ) {
1437 to->ammo[i] = MSG_ReadShort(msg);
1438 }
1439 }
1440 }
1441
1442 // parse powerups
1443 if ( MSG_ReadBits( msg, 1 ) ) {
1444 LOG("PS_POWERUPS");
1445 bits = MSG_ReadBits (msg, MAX_POWERUPS);
1446 for (i=0 ; i<MAX_POWERUPS ; i++) {
1447 if (bits & (1<<i) ) {
1448 to->powerups[i] = MSG_ReadLong(msg);
1449 }
1450 }
1451 }
1452 }
1453
1454 if ( print ) {
1455 if ( msg->bit == 0 ) {
1456 endBit = msg->readcount * 8 - GENTITYNUM_BITS;
1457 } else {
1458 endBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
1459 }
1460 Com_Printf( " (%i bits)\n", endBit - startBit );
1461 }
1462 }
1463
1464 int msg_hData[256] = {
1465 250315, // 0
1466 41193, // 1
1467 6292, // 2
1468 7106, // 3
1469 3730, // 4
1470 3750, // 5
1471 6110, // 6
1472 23283, // 7
1473 33317, // 8
1474 6950, // 9
1475 7838, // 10
1476 9714, // 11
1477 9257, // 12
1478 17259, // 13
1479 3949, // 14
1480 1778, // 15
1481 8288, // 16
1482 1604, // 17
1483 1590, // 18
1484 1663, // 19
1485 1100, // 20
1486 1213, // 21
1487 1238, // 22
1488 1134, // 23
1489 1749, // 24
1490 1059, // 25
1491 1246, // 26
1492 1149, // 27
1493 1273, // 28
1494 4486, // 29
1495 2805, // 30
1496 3472, // 31
1497 21819, // 32
1498 1159, // 33
1499 1670, // 34
1500 1066, // 35
1501 1043, // 36
1502 1012, // 37
1503 1053, // 38
1504 1070, // 39
1505 1726, // 40
1506 888, // 41
1507 1180, // 42
1508 850, // 43
1509 960, // 44
1510 780, // 45
1511 1752, // 46
1512 3296, // 47
1513 10630, // 48
1514 4514, // 49
1515 5881, // 50
1516 2685, // 51
1517 4650, // 52
1518 3837, // 53
1519 2093, // 54
1520 1867, // 55
1521 2584, // 56
1522 1949, // 57
1523 1972, // 58
1524 940, // 59
1525 1134, // 60
1526 1788, // 61
1527 1670, // 62
1528 1206, // 63
1529 5719, // 64
1530 6128, // 65
1531 7222, // 66
1532 6654, // 67
1533 3710, // 68
1534 3795, // 69
1535 1492, // 70
1536 1524, // 71
1537 2215, // 72
1538 1140, // 73
1539 1355, // 74
1540 971, // 75
1541 2180, // 76
1542 1248, // 77
1543 1328, // 78
1544 1195, // 79
1545 1770, // 80
1546 1078, // 81
1547 1264, // 82
1548 1266, // 83
1549 1168, // 84
1550 965, // 85
1551 1155, // 86
1552 1186, // 87
1553 1347, // 88
1554 1228, // 89
1555 1529, // 90
1556 1600, // 91
1557 2617, // 92
1558 2048, // 93
1559 2546, // 94
1560 3275, // 95
1561 2410, // 96
1562 3585, // 97
1563 2504, // 98
1564 2800, // 99
1565 2675, // 100
1566 6146, // 101
1567 3663, // 102
1568 2840, // 103
1569 14253, // 104
1570 3164, // 105
1571 2221, // 106
1572 1687, // 107
1573 3208, // 108
1574 2739, // 109
1575 3512, // 110
1576 4796, // 111
1577 4091, // 112
1578 3515, // 113
1579 5288, // 114
1580 4016, // 115
1581 7937, // 116
1582 6031, // 117
1583 5360, // 118
1584 3924, // 119
1585 4892, // 120
1586 3743, // 121
1587 4566, // 122
1588 4807, // 123
1589 5852, // 124
1590 6400, // 125
1591 6225, // 126
1592 8291, // 127
1593 23243, // 128
1594 7838, // 129
1595 7073, // 130
1596 8935, // 131
1597 5437, // 132
1598 4483, // 133
1599 3641, // 134
1600 5256, // 135
1601 5312, // 136
1602 5328, // 137
1603 5370, // 138
1604 3492, // 139
1605 2458, // 140
1606 1694, // 141
1607 1821, // 142
1608 2121, // 143
1609 1916, // 144
1610 1149, // 145
1611 1516, // 146
1612 1367, // 147
1613 1236, // 148
1614 1029, // 149
1615 1258, // 150
1616 1104, // 151
1617 1245, // 152
1618 1006, // 153
1619 1149, // 154
1620 1025, // 155
1621 1241, // 156
1622 952, // 157
1623 1287, // 158
1624 997, // 159
1625 1713, // 160
1626 1009, // 161
1627 1187, // 162
1628 879, // 163
1629 1099, // 164
1630 929, // 165
1631 1078, // 166
1632 951, // 167
1633 1656, // 168
1634 930, // 169
1635 1153, // 170
1636 1030, // 171
1637 1262, // 172
1638 1062, // 173
1639 1214, // 174
1640 1060, // 175
1641 1621, // 176
1642 930, // 177
1643 1106, // 178
1644 912, // 179
1645 1034, // 180
1646 892, // 181
1647 1158, // 182
1648 990, // 183
1649 1175, // 184
1650 850, // 185
1651 1121, // 186
1652 903, // 187
1653 1087, // 188
1654 920, // 189
1655 1144, // 190
1656 1056, // 191
1657 3462, // 192
1658 2240, // 193
1659 4397, // 194
1660 12136, // 195
1661 7758, // 196
1662 1345, // 197
1663 1307, // 198
1664 3278, // 199
1665 1950, // 200
1666 886, // 201
1667 1023, // 202
1668 1112, // 203
1669 1077, // 204
1670 1042, // 205
1671 1061, // 206
1672 1071, // 207
1673 1484, // 208
1674 1001, // 209
1675 1096, // 210
1676 915, // 211
1677 1052, // 212
1678 995, // 213
1679 1070, // 214
1680 876, // 215
1681 1111, // 216
1682 851, // 217
1683 1059, // 218
1684 805, // 219
1685 1112, // 220
1686 923, // 221
1687 1103, // 222
1688 817, // 223
1689 1899, // 224
1690 1872, // 225
1691 976, // 226
1692 841, // 227
1693 1127, // 228
1694 956, // 229
1695 1159, // 230
1696 950, // 231
1697 7791, // 232
1698 954, // 233
1699 1289, // 234
1700 933, // 235
1701 1127, // 236
1702 3207, // 237
1703 1020, // 238
1704 927, // 239
1705 1355, // 240
1706 768, // 241
1707 1040, // 242
1708 745, // 243
1709 952, // 244
1710 805, // 245
1711 1073, // 246
1712 740, // 247
1713 1013, // 248
1714 805, // 249
1715 1008, // 250
1716 796, // 251
1717 996, // 252
1718 1057, // 253
1719 11457, // 254
1720 13504, // 255
1721 };
1722
MSG_initHuffman(void)1723 void MSG_initHuffman( void ) {
1724 int i,j;
1725
1726 msgInit = qtrue;
1727 Huff_Init(&msgHuff);
1728 for(i=0;i<256;i++) {
1729 for (j=0;j<msg_hData[i];j++) {
1730 Huff_addRef(&msgHuff.compressor, (byte)i); // Do update
1731 Huff_addRef(&msgHuff.decompressor, (byte)i); // Do update
1732 }
1733 }
1734 }
1735
1736 /*
1737 void MSG_NUinitHuffman() {
1738 byte *data;
1739 int size, i, ch;
1740 int array[256];
1741
1742 msgInit = qtrue;
1743
1744 Huff_Init(&msgHuff);
1745 // load it in
1746 size = FS_ReadFile( "netchan/netchan.bin", (void **)&data );
1747
1748 for(i=0;i<256;i++) {
1749 array[i] = 0;
1750 }
1751 for(i=0;i<size;i++) {
1752 ch = data[i];
1753 Huff_addRef(&msgHuff.compressor, ch); // Do update
1754 Huff_addRef(&msgHuff.decompressor, ch); // Do update
1755 array[ch]++;
1756 }
1757 Com_Printf("msg_hData {\n");
1758 for(i=0;i<256;i++) {
1759 if (array[i] == 0) {
1760 Huff_addRef(&msgHuff.compressor, i); // Do update
1761 Huff_addRef(&msgHuff.decompressor, i); // Do update
1762 }
1763 Com_Printf("%d, // %d\n", array[i], i);
1764 }
1765 Com_Printf("};\n");
1766 FS_FreeFile( data );
1767 Cbuf_AddText( "condump dump.txt\n" );
1768 }
1769 */
1770
1771 //===========================================================================
1772