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