1 /*
2 ===========================================================================
3 Copyright (C) 1999 - 2005, Id Software, Inc.
4 Copyright (C) 2000 - 2013, Raven Software, Inc.
5 Copyright (C) 2001 - 2013, Activision, Inc.
6 Copyright (C) 2013 - 2015, OpenJK contributors
7
8 This file is part of the OpenJK source code.
9
10 OpenJK is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License version 2 as
12 published by the Free Software Foundation.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, see <http://www.gnu.org/licenses/>.
21 ===========================================================================
22 */
23
24 #include "q_shared.h"
25 #include "qcommon.h"
26 #include "../server/server.h"
27
28 /*
29 ==============================================================================
30
31 MESSAGE IO FUNCTIONS
32
33 Handles byte ordering and avoids alignment errors
34 ==============================================================================
35 */
36
37
MSG_Init(msg_t * buf,byte * data,int length)38 void MSG_Init( msg_t *buf, byte *data, int length ) {
39 memset (buf, 0, sizeof(*buf));
40 buf->data = data;
41 buf->maxsize = length;
42 }
43
MSG_Clear(msg_t * buf)44 void MSG_Clear( msg_t *buf ) {
45 buf->cursize = 0;
46 buf->overflowed = qfalse;
47 buf->bit = 0;
48 }
49
50
MSG_BeginReading(msg_t * msg)51 void MSG_BeginReading( msg_t *msg ) {
52 msg->readcount = 0;
53 msg->bit = 0;
54 }
55
56
MSG_ReadByteAlign(msg_t * buf)57 void MSG_ReadByteAlign( msg_t *buf ) {
58 // round up to the next byte
59 if ( buf->bit ) {
60 buf->bit = 0;
61 buf->readcount++;
62 }
63 }
64
MSG_GetSpace(msg_t * buf,int length)65 void *MSG_GetSpace( msg_t *buf, int length ) {
66 void *data;
67
68 // round up to the next byte
69 if ( buf->bit ) {
70 buf->bit = 0;
71 buf->cursize++;
72 }
73
74 if ( buf->cursize + length > buf->maxsize ) {
75 if ( !buf->allowoverflow ) {
76 Com_Error (ERR_FATAL, "MSG_GetSpace: overflow without allowoverflow set");
77 }
78 if ( length > buf->maxsize ) {
79 Com_Error (ERR_FATAL, "MSG_GetSpace: %i is > full buffer size", length);
80 }
81 Com_Printf ("MSG_GetSpace: overflow\n");
82 MSG_Clear (buf);
83 buf->overflowed = qtrue;
84 }
85
86 data = buf->data + buf->cursize;
87 buf->cursize += length;
88
89 return data;
90 }
91
MSG_WriteData(msg_t * buf,const void * data,int length)92 void MSG_WriteData( msg_t *buf, const void *data, int length ) {
93 memcpy (MSG_GetSpace(buf,length),data,length);
94 }
95
96
97 /*
98 =============================================================================
99
100 bit functions
101
102 =============================================================================
103 */
104
105 int overflows;
106
107 // negative bit values include signs
MSG_WriteBits(msg_t * msg,int value,int bits)108 void MSG_WriteBits( msg_t *msg, int value, int bits ) {
109 int put;
110 int fraction;
111
112 // this isn't an exact overflow check, but close enough
113 if ( msg->maxsize - msg->cursize < 4 ) {
114 msg->overflowed = qtrue;
115 #ifndef FINAL_BUILD
116 Com_Printf (S_COLOR_RED"MSG_WriteBits: buffer Full writing %d in %d bits\n", value, bits);
117 #endif
118 return;
119 }
120
121 if ( bits == 0 || bits < -31 || bits > 32 ) {
122 Com_Error( ERR_DROP, "MSG_WriteBits: bad bits %i", bits );
123 }
124
125 // check for overflows
126 if ( bits != 32 ) {
127 if ( bits > 0 ) {
128 if ( value > ( ( 1 << bits ) - 1 ) || value < 0 ) {
129 overflows++;
130 #ifndef FINAL_BUILD
131 #ifdef _DEBUG
132 Com_Printf (S_COLOR_RED"MSG_WriteBits: overflow writing %d in %d bits\n", value, bits);
133 #endif
134 #endif
135 }
136 } else {
137 int r;
138
139 r = 1 << (bits-1);
140
141 if ( value > r - 1 || value < -r ) {
142 overflows++;
143 #ifndef FINAL_BUILD
144 #ifdef _DEBUG
145 Com_Printf (S_COLOR_RED"MSG_WriteBits: overflow writing %d in %d bits\n", value, bits);
146 #endif
147 #endif
148 }
149 }
150 }
151 if ( bits < 0 ) {
152 bits = -bits;
153 }
154
155 while ( bits ) {
156 if ( msg->bit == 0 ) {
157 msg->data[msg->cursize] = 0;
158 msg->cursize++;
159 }
160 put = 8 - msg->bit;
161 if ( put > bits ) {
162 put = bits;
163 }
164 fraction = value & ( ( 1 << put ) - 1 );
165 msg->data[msg->cursize - 1] |= fraction << msg->bit;
166 bits -= put;
167 value >>= put;
168 msg->bit = ( msg->bit + put ) & 7;
169 }
170 }
171
MSG_ReadBits(msg_t * msg,int bits)172 int MSG_ReadBits( msg_t *msg, int bits ) {
173 int value;
174 int valueBits;
175 int get;
176 int fraction;
177 qboolean sgn;
178
179 value = 0;
180 valueBits = 0;
181
182 if ( bits < 0 ) {
183 bits = -bits;
184 sgn = qtrue;
185 } else {
186 sgn = qfalse;
187 }
188
189 while ( valueBits < bits ) {
190 if ( msg->bit == 0 ) {
191 msg->readcount++;
192 assert (msg->readcount <= msg->cursize);
193 }
194 get = 8 - msg->bit;
195 if ( get > (bits - valueBits) ) {
196 get = (bits - valueBits);
197 }
198 fraction = msg->data[msg->readcount - 1];
199 fraction >>= msg->bit;
200 fraction &= ( 1 << get ) - 1;
201 value |= fraction << valueBits;
202
203 valueBits += get;
204 msg->bit = ( msg->bit + get ) & 7;
205 }
206
207 if ( sgn ) {
208 if ( value & ( 1 << ( bits - 1 ) ) ) {
209 value |= -1 ^ ( ( 1 << bits ) - 1 );
210 }
211 }
212
213 return value;
214 }
215
216
217
218 //================================================================================
219
220 //
221 // writing functions
222 //
223
MSG_WriteByte(msg_t * sb,int c)224 void MSG_WriteByte( msg_t *sb, int c ) {
225 #ifdef PARANOID
226 if (c < 0 || c > 255)
227 Com_Error (ERR_FATAL, "MSG_WriteByte: range error");
228 #endif
229
230 MSG_WriteBits( sb, c, 8 );
231 }
232
MSG_WriteShort(msg_t * sb,int c)233 void MSG_WriteShort( msg_t *sb, int c ) {
234 #ifdef PARANOID
235 if (c < ((short)0x8000) || c > (short)0x7fff)
236 Com_Error (ERR_FATAL, "MSG_WriteShort: range error");
237 #endif
238
239 MSG_WriteBits( sb, c, 16 );
240 }
241
MSG_WriteSShort(msg_t * sb,int c)242 static void MSG_WriteSShort( msg_t *sb, int c ) {
243 MSG_WriteBits( sb, c, -16 );
244 }
245
MSG_WriteLong(msg_t * sb,int c)246 void MSG_WriteLong( msg_t *sb, int c ) {
247 MSG_WriteBits( sb, c, 32 );
248 }
249
MSG_WriteString(msg_t * sb,const char * s)250 void MSG_WriteString( msg_t *sb, const char *s ) {
251 if ( !s ) {
252 MSG_WriteData (sb, "", 1);
253 } else {
254 int l, i;
255 char string[MAX_STRING_CHARS];
256
257 l = strlen( s );
258 if ( l >= MAX_STRING_CHARS ) {
259 Com_Printf( "MSG_WriteString: MAX_STRING_CHARS" );
260 MSG_WriteData (sb, "", 1);
261 return;
262 }
263 Q_strncpyz( string, s, sizeof( string ) );
264
265 // get rid of 0xff chars, because old clients don't like them
266 for ( i = 0 ; i < l ; i++ ) {
267 if ( ((byte *)string)[i] > 127 ) {
268 string[i] = '.';
269 }
270 }
271
272 MSG_WriteData (sb, string, l+1);
273 }
274 }
275
276
277
278 //============================================================
279
280 //
281 // reading functions
282 //
283
284 // returns -1 if no more characters are available
MSG_ReadByte(msg_t * msg)285 int MSG_ReadByte( msg_t *msg ) {
286 int c;
287
288 if ( msg->readcount+1 > msg->cursize ) {
289 c = -1;
290 } else {
291 c = (unsigned char)MSG_ReadBits( msg, 8 );
292 }
293
294 return c;
295 }
296
MSG_ReadShort(msg_t * msg)297 int MSG_ReadShort( msg_t *msg ) {
298 int c;
299
300 if ( msg->readcount+2 > msg->cursize ) {
301 c = -1;
302 } else {
303 c = MSG_ReadBits( msg, 16 );
304 }
305
306 return c;
307 }
308
MSG_ReadSShort(msg_t * msg)309 static int MSG_ReadSShort( msg_t *msg ) {
310 int c;
311
312 if ( msg->readcount+2 > msg->cursize ) {
313 c = -1;
314 } else {
315 c = MSG_ReadBits( msg, -16 );
316 }
317
318 return c;
319 }
320
MSG_ReadLong(msg_t * msg)321 int MSG_ReadLong( msg_t *msg ) {
322 int c;
323
324 if ( msg->readcount+4 > msg->cursize ) {
325 c = -1;
326 } else {
327 c = MSG_ReadBits( msg, 32 );
328 }
329
330 return c;
331 }
332
MSG_ReadString(msg_t * msg)333 char *MSG_ReadString( msg_t *msg ) {
334 static const int STRING_SIZE = MAX_STRING_CHARS;
335 static char string[STRING_SIZE];
336 int l,c;
337
338 MSG_ReadByteAlign( msg );
339 l = 0;
340 do {
341 c = MSG_ReadByte(msg); // use ReadByte so -1 is out of bounds
342 if ( c == -1 || c == 0 ) {
343 break;
344 }
345 // translate all fmt spec to avoid crash bugs
346 if ( c == '%' ) {
347 c = '.';
348 }
349
350 string[l] = c;
351 l++;
352 } while (l < STRING_SIZE - 1);
353
354 string[l] = 0;
355
356 return string;
357 }
358
MSG_ReadStringLine(msg_t * msg)359 char *MSG_ReadStringLine( msg_t *msg ) {
360 static const int STRING_SIZE = MAX_STRING_CHARS;
361 static char string[STRING_SIZE];
362 int l,c;
363
364 MSG_ReadByteAlign( msg );
365 l = 0;
366 do {
367 c = MSG_ReadByte(msg); // use ReadByte so -1 is out of bounds
368 if (c == -1 || c == 0 || c == '\n') {
369 break;
370 }
371 // translate all fmt spec to avoid crash bugs
372 if ( c == '%' ) {
373 c = '.';
374 }
375 string[l] = c;
376 l++;
377 } while (l < STRING_SIZE - 1);
378
379 string[l] = 0;
380
381 return string;
382 }
383
384
MSG_ReadData(msg_t * msg,void * data,int len)385 void MSG_ReadData( msg_t *msg, void *data, int len ) {
386 int i;
387
388 MSG_ReadByteAlign( msg );
389 for (i=0 ; i<len ; i++) {
390 ((byte *)data)[i] = MSG_ReadByte (msg);
391 }
392 }
393
394
395 /*
396 =============================================================================
397
398 delta functions
399
400 =============================================================================
401 */
402
403 extern cvar_t *cl_shownet;
404
405 #define LOG(x) if( cl_shownet->integer == 4 ) { Com_Printf("%s ", x ); };
406
MSG_WriteDelta(msg_t * msg,int oldV,int newV,int bits)407 void MSG_WriteDelta( msg_t *msg, int oldV, int newV, int bits ) {
408 if ( oldV == newV ) {
409 MSG_WriteBits( msg, 0, 1 );
410 return;
411 }
412 MSG_WriteBits( msg, 1, 1 );
413 MSG_WriteBits( msg, newV, bits );
414 }
415
MSG_ReadDelta(msg_t * msg,int oldV,int bits)416 int MSG_ReadDelta( msg_t *msg, int oldV, int bits ) {
417 if ( MSG_ReadBits( msg, 1 ) ) {
418 return MSG_ReadBits( msg, bits );
419 }
420 return oldV;
421 }
422
MSG_WriteDeltaFloat(msg_t * msg,float oldV,float newV)423 void MSG_WriteDeltaFloat( msg_t *msg, float oldV, float newV ) {
424 byteAlias_t fi;
425 if ( oldV == newV ) {
426 MSG_WriteBits( msg, 0, 1 );
427 return;
428 }
429 fi.f = newV;
430 MSG_WriteBits( msg, 1, 1 );
431 MSG_WriteBits( msg, fi.i, 32 );
432 }
433
MSG_ReadDeltaFloat(msg_t * msg,float oldV)434 float MSG_ReadDeltaFloat( msg_t *msg, float oldV ) {
435 if ( MSG_ReadBits( msg, 1 ) ) {
436 byteAlias_t fi;
437
438 fi.i = MSG_ReadBits( msg, 32 );
439 return fi.f;
440 }
441 return oldV;
442 }
443
444
445 /*
446 ============================================================================
447
448 usercmd_t communication
449
450 ============================================================================
451 */
452
453 // ms is allways sent, the others are optional
454 #define CM_ANGLE1 (1<<0)
455 #define CM_ANGLE2 (1<<1)
456 #define CM_ANGLE3 (1<<2)
457 #define CM_FORWARD (1<<3)
458 #define CM_SIDE (1<<4)
459 #define CM_UP (1<<5)
460 #define CM_BUTTONS (1<<6)
461 #define CM_WEAPON (1<<7)
462
463 /*
464 =====================
465 MSG_WriteDeltaUsercmd
466 =====================
467 */
MSG_WriteDeltaUsercmd(msg_t * msg,usercmd_t * from,usercmd_t * to)468 void MSG_WriteDeltaUsercmd( msg_t *msg, usercmd_t *from, usercmd_t *to ) {
469 MSG_WriteDelta( msg, from->serverTime, to->serverTime, 32 );
470 MSG_WriteDelta( msg, from->angles[0], to->angles[0], 16 );
471 MSG_WriteDelta( msg, from->angles[1], to->angles[1], 16 );
472 MSG_WriteDelta( msg, from->angles[2], to->angles[2], 16 );
473 MSG_WriteDelta( msg, from->forwardmove, to->forwardmove, -8 );
474 MSG_WriteDelta( msg, from->rightmove, to->rightmove, -8 );
475 MSG_WriteDelta( msg, from->upmove, to->upmove, -8 );
476 MSG_WriteDelta( msg, from->buttons, to->buttons, 16 );//FIXME: We're only really using 9 bits...can this be changed to that?
477 MSG_WriteDelta( msg, from->weapon, to->weapon, 8 );
478 MSG_WriteDelta( msg, from->generic_cmd, to->generic_cmd, 8 );
479 }
480
481
482 /*
483 =====================
484 MSG_ReadDeltaUsercmd
485 =====================
486 */
MSG_ReadDeltaUsercmd(msg_t * msg,usercmd_t * from,usercmd_t * to)487 void MSG_ReadDeltaUsercmd( msg_t *msg, usercmd_t *from, usercmd_t *to ) {
488 to->serverTime = MSG_ReadDelta( msg, from->serverTime, 32);
489 to->angles[0] = MSG_ReadDelta( msg, from->angles[0], 16);
490 to->angles[1] = MSG_ReadDelta( msg, from->angles[1], 16);
491 to->angles[2] = MSG_ReadDelta( msg, from->angles[2], 16);
492 to->forwardmove = MSG_ReadDelta( msg, from->forwardmove, -8);
493 to->rightmove = MSG_ReadDelta( msg, from->rightmove, -8);
494 to->upmove = MSG_ReadDelta( msg, from->upmove, -8);
495 to->buttons = MSG_ReadDelta( msg, from->buttons, 16);//FIXME: We're only really using 9 bits...can this be changed to that?
496 to->weapon = MSG_ReadDelta( msg, from->weapon, 8);
497 to->generic_cmd = MSG_ReadDelta( msg, from->generic_cmd, 8);
498 }
499
500 /*
501 =============================================================================
502
503 entityState_t communication
504
505 =============================================================================
506 */
507
508 typedef struct {
509 const char *name;
510 size_t offset;
511 int bits; // 0 = float
512 } netField_t;
513
514 // using the stringizing operator to save typing...
515 #define NETF(x) #x,offsetof(entityState_t, x)
516
517 #if 0 // Removed by BTO (VV)
518 const netField_t entityStateFields[] =
519 {
520 { NETF(eType), 8 },
521 { NETF(eFlags), 32 },
522
523 { NETF(pos.trType), 8 },
524 { NETF(pos.trTime), 32 },
525 { NETF(pos.trDuration), 32 },
526 { NETF(pos.trBase[0]), 0 },
527 { NETF(pos.trBase[1]), 0 },
528 { NETF(pos.trBase[2]), 0 },
529 { NETF(pos.trDelta[0]), 0 },
530 { NETF(pos.trDelta[1]), 0 },
531 { NETF(pos.trDelta[2]), 0 },
532
533 { NETF(apos.trType), 8 },
534 { NETF(apos.trTime), 32 },
535 { NETF(apos.trDuration), 32 },
536 { NETF(apos.trBase[0]), 0 },
537 { NETF(apos.trBase[1]), 0 },
538 { NETF(apos.trBase[2]), 0 },
539 { NETF(apos.trDelta[0]), 0 },
540 { NETF(apos.trDelta[1]), 0 },
541 { NETF(apos.trDelta[2]), 0 },
542
543 { NETF(time), 32 },
544 { NETF(time2), 32 },
545
546 { NETF(origin[0]), 0 },
547 { NETF(origin[1]), 0 },
548 { NETF(origin[2]), 0 },
549
550 { NETF(origin2[0]), 0 },
551 { NETF(origin2[1]), 0 },
552 { NETF(origin2[2]), 0 },
553
554 { NETF(angles[0]), 0 },
555 { NETF(angles[1]), 0 },
556 { NETF(angles[2]), 0 },
557
558 { NETF(angles2[0]), 0 },
559 { NETF(angles2[1]), 0 },
560 { NETF(angles2[2]), 0 },
561
562 { NETF(otherEntityNum), GENTITYNUM_BITS },
563 //{ NETF(otherEntityNum2), GENTITYNUM_BITS },
564 { NETF(groundEntityNum), GENTITYNUM_BITS },
565
566 { NETF(constantLight), 32 },
567 { NETF(loopSound), 16 },
568 { NETF(modelindex), 9 }, //0 to 511
569 { NETF(modelindex2), 8 },
570 { NETF(modelindex3), 8 },
571 { NETF(clientNum), 32 },
572 { NETF(frame), 16 },
573
574 { NETF(solid), 24 },
575
576 { NETF(event), 10 },
577 { NETF(eventParm), 16 },
578
579 { NETF(powerups), 16 },
580 { NETF(weapon), 8 },
581 { NETF(legsAnim), 16 },
582 { NETF(legsAnimTimer), 8 },
583 { NETF(torsoAnim), 16 },
584 { NETF(torsoAnimTimer), 8 },
585 { NETF(scale), 8 },
586
587 { NETF(saberInFlight), 4 },
588 { NETF(saberActive), 4 },
589 { NETF(vehicleArmor), 32 },
590 { NETF(vehicleAngles[0]), 0 },
591 { NETF(vehicleAngles[1]), 0 },
592 { NETF(vehicleAngles[2]), 0 },
593 { NETF(m_iVehicleNum), 32 },
594
595 /*
596 Ghoul2 Insert Start
597 */
598 { NETF(modelScale[0]), 0 },
599 { NETF(modelScale[1]), 0 },
600 { NETF(modelScale[2]), 0 },
601 { NETF(radius), 16 },
602 { NETF(boltInfo), 32 },
603 //{ NETF(ghoul2), 32 },
604
605 { NETF(isPortalEnt), 1 },
606
607 };
608 #endif
609
610
611 // if (int)f == f and (int)f + ( 1<<(FLOAT_INT_BITS-1) ) < ( 1 << FLOAT_INT_BITS )
612 // the float will be sent with FLOAT_INT_BITS, otherwise all 32 bits will be sent
613 #define FLOAT_INT_BITS 13
614 #define FLOAT_INT_BIAS (1<<(FLOAT_INT_BITS-1))
615
MSG_WriteField(msg_t * msg,const int * toF,const netField_t * field)616 void MSG_WriteField (msg_t *msg, const int *toF, const netField_t *field)
617 {
618 int trunc;
619 float fullFloat;
620
621 if ( field->bits == -1)
622 { // a -1 in the bits field means it's a float that's always between -1 and 1
623 int temp = *(float *)toF * 32767;
624 MSG_WriteBits( msg, temp, -16 );
625 }
626 else
627 if ( field->bits == 0 ) {
628 // float
629 fullFloat = *(float *)toF;
630 trunc = (int)fullFloat;
631
632 if (fullFloat == 0.0f) {
633 MSG_WriteBits( msg, 0, 1 ); //it's a zero
634 } else {
635 MSG_WriteBits( msg, 1, 1 ); //not a zero
636 if ( trunc == fullFloat && trunc + FLOAT_INT_BIAS >= 0 &&
637 trunc + FLOAT_INT_BIAS < ( 1 << FLOAT_INT_BITS ) ) {
638 // send as small integer
639 MSG_WriteBits( msg, 0, 1 );
640 MSG_WriteBits( msg, trunc + FLOAT_INT_BIAS, FLOAT_INT_BITS );
641 } else {
642 // send as full floating point value
643 MSG_WriteBits( msg, 1, 1 );
644 MSG_WriteBits( msg, *toF, 32 );
645 }
646 }
647 } else {
648 if (*toF == 0) {
649 MSG_WriteBits( msg, 0, 1 ); //it's a zero
650 } else {
651 MSG_WriteBits( msg, 1, 1 ); //not a zero
652 // integer
653 MSG_WriteBits( msg, *toF, field->bits );
654 }
655 }
656 }
657
MSG_ReadField(msg_t * msg,int * toF,const netField_t * field,int print)658 void MSG_ReadField (msg_t *msg, int *toF, const netField_t *field, int print)
659 {
660 int trunc;
661
662 if ( field->bits == -1)
663 { // a -1 in the bits field means it's a float that's always between -1 and 1
664 int temp = MSG_ReadBits( msg, -16);
665 *(float *)toF = (float)temp / 32767;
666 }
667 else
668 if ( field->bits == 0 ) {
669 // float
670 if ( MSG_ReadBits( msg, 1 ) == 0 ) {
671 *(float *)toF = 0.0f;
672 } else {
673 if ( MSG_ReadBits( msg, 1 ) == 0 ) {
674 // integral float
675 trunc = MSG_ReadBits( msg, FLOAT_INT_BITS );
676 // bias to allow equal parts positive and negative
677 trunc -= FLOAT_INT_BIAS;
678 *(float *)toF = trunc;
679 if ( print ) {
680 Com_Printf( "%s:%i ", field->name, trunc );
681 }
682 } else {
683 // full floating point value
684 *toF = MSG_ReadBits( msg, 32 );
685 if ( print ) {
686 Com_Printf( "%s:%f ", field->name, *(float *)toF );
687 }
688 }
689 }
690 } else {
691 if ( MSG_ReadBits( msg, 1 ) == 0 ) {
692 *toF = 0;
693 } else {
694 // integer
695 *toF = MSG_ReadBits( msg, field->bits );
696 if ( print ) {
697 Com_Printf( "%s:%i ", field->name, *toF );
698 }
699 }
700 }
701 }
702
703
704 /*
705 ==================
706 MSG_WriteDeltaEntity
707
708
709 GENTITYNUM_BITS 1 : remove this entity
710 GENTITYNUM_BITS 0 1 SMALL_VECTOR_BITS <data>
711 GENTITYNUM_BITS 0 0 LARGE_VECTOR_BITS >data>
712
713 Writes part of a packetentities message, including the entity number.
714 Can delta from either a baseline or a previous packet_entity
715 If to is NULL, a remove entity update will be sent
716 If force is not set, then nothing at all will be generated if the entity is
717 identical, under the assumption that the in-order delta code will catch it.
718 ==================
719 */
720 #if 0 // Removed by BTO (VV)
721 void MSG_WriteDeltaEntity( msg_t *msg, struct entityState_s *from, struct entityState_s *to,
722 qboolean force ) {
723 int c;
724 int i;
725 const netField_t *field;
726 int *fromF, *toF;
727 int blah;
728 bool stuffChanged = false;
729 const int numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
730 byte changeVector[(numFields/8) + 1];
731
732
733 // all fields should be 32 bits to avoid any compiler packing issues
734 // the "number" field is not part of the field list
735 // if this assert fails, someone added a field to the entityState_t
736 // struct without updating the message fields
737 blah = sizeof( *from );
738 assert( numFields + 1 == blah/4);
739
740 c = msg->cursize;
741
742 // a NULL to is a delta remove message
743 if ( to == NULL ) {
744 if ( from == NULL ) {
745 return;
746 }
747 MSG_WriteBits( msg, from->number, GENTITYNUM_BITS );
748 MSG_WriteBits( msg, 1, 1 );
749 return;
750 }
751
752 if ( to->number < 0 || to->number >= MAX_GENTITIES ) {
753 Com_Error (ERR_FATAL, "MSG_WriteDeltaEntity: Bad entity number: %i", to->number );
754 }
755
756 memset(changeVector, 0, sizeof(changeVector));
757
758 // build the change vector as bytes so it is endien independent
759 for ( i = 0, field = entityStateFields ; i < numFields ; i++, field++ ) {
760 fromF = (int *)( (byte *)from + field->offset );
761 toF = (int *)( (byte *)to + field->offset );
762 if ( *fromF != *toF ) {
763 changeVector[ i>>3 ] |= 1 << ( i & 7 );
764 stuffChanged = true;
765 }
766 }
767
768 if ( stuffChanged )
769 {
770 MSG_WriteBits( msg, to->number, GENTITYNUM_BITS );
771 MSG_WriteBits( msg, 0, 1 ); // not removed
772 MSG_WriteBits( msg, 1, 1 ); // we have a delta
773
774 // we need to write the entire delta
775 for ( i = 0 ; i + 8 <= numFields ; i += 8 ) {
776 MSG_WriteByte( msg, changeVector[i>>3] );
777 }
778 if ( numFields & 7 ) {
779 MSG_WriteBits( msg, changeVector[i>>3], numFields & 7 );
780 }
781
782 for ( i = 0, field = entityStateFields ; i < numFields ; i++, field++ ) {
783 fromF = (int *)( (byte *)from + field->offset );
784 toF = (int *)( (byte *)to + field->offset );
785
786 if ( *fromF == *toF ) {
787 continue;
788 }
789
790 MSG_WriteField(msg, toF, field);
791 }
792 }
793 else
794 {
795 // nothing at all changed
796 // write two bits for no change
797 MSG_WriteBits( msg, to->number, GENTITYNUM_BITS );
798 MSG_WriteBits( msg, 0, 1 ); // not removed
799 MSG_WriteBits( msg, 0, 1 ); // no delta
800 }
801
802 c = msg->cursize - c;
803 }
804 #endif
805
806
807 extern serverStatic_t svs;
MSG_WriteEntity(msg_t * msg,struct entityState_s * to,int removeNum)808 void MSG_WriteEntity( msg_t *msg, struct entityState_s *to, int removeNum)
809 {
810
811 if ( to == NULL ) {
812 MSG_WriteBits(msg, removeNum, GENTITYNUM_BITS);
813 MSG_WriteBits(msg, 1, 1); //removed
814 return;
815 } else {
816 MSG_WriteBits(msg, to->number, GENTITYNUM_BITS);
817 MSG_WriteBits(msg, 0, 1); //not removed
818 }
819 assert(( to - svs.snapshotEntities ) >= 0 && ( to - svs.snapshotEntities ) < 512);
820 MSG_WriteLong(msg, to - svs.snapshotEntities);
821 }
822
MSG_ReadEntity(msg_t * msg,entityState_t * to)823 void MSG_ReadEntity( msg_t *msg, entityState_t *to)
824 {
825 // check for a remove
826 if ( MSG_ReadBits( msg, 1 ) == 1 ) {
827 memset( to, 0, sizeof( *to ) );
828 to->number = MAX_GENTITIES - 1;
829 return;
830 }
831
832 //No remove, read data
833 int index;
834 index = MSG_ReadLong(msg);
835 assert(index >= 0 && index < svs.numSnapshotEntities);
836 *to = svs.snapshotEntities[index];
837 }
838
839 /*
840 ==================
841 MSG_ReadDeltaEntity
842
843 The entity number has already been read from the message, which
844 is how the from state is identified.
845
846 If the delta removes the entity, entityState_t->number will be set to MAX_GENTITIES-1
847
848 Can go from either a baseline or a previous packet_entity
849 ==================
850 */
851 extern cvar_t *cl_shownet;
852
853 #if 0 // Removed by BTO (VV)
854 void MSG_ReadDeltaEntity( msg_t *msg, entityState_t *from, entityState_t *to, int number)
855 {
856 int i;
857 const netField_t *field;
858 int *fromF, *toF;
859 int print = 0;
860 int startBit, endBit;
861 const int numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
862 byte expandedVector[(numFields/8) + 1];
863
864 if ( number < 0 || number >= MAX_GENTITIES) {
865 Com_Error( ERR_DROP, "Bad delta entity number: %i", number );
866 }
867
868 if ( msg->bit == 0 ) {
869 startBit = msg->readcount * 8 - GENTITYNUM_BITS;
870 } else {
871 startBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
872 }
873
874 // check for a remove
875 if ( MSG_ReadBits( msg, 1 ) == 1 ) {
876 memset( to, 0, sizeof( *to ) );
877 to->number = MAX_GENTITIES - 1;
878 if ( cl_shownet->integer >= 2 || cl_shownet->integer == -1 ) {
879 Com_Printf( "%3i: #%-3i remove\n", msg->readcount, number );
880 }
881 return;
882 }
883
884 // check for no delta
885 if ( MSG_ReadBits( msg, 1 ) != 0 )
886 {
887 const int numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
888
889 // shownet 2/3 will interleave with other printed info, -1 will
890 // just print the delta records`
891 if ( cl_shownet->integer >= 2 || cl_shownet->integer == -1 ) {
892 print = 1;
893 Com_Printf( "%3i: #%-3i ", msg->readcount, to->number );
894 } else {
895 print = 0;
896 }
897
898 // we need to write the entire delta
899 for ( i = 0 ; i + 8 <= numFields ; i += 8 ) {
900 expandedVector[i>>3] = MSG_ReadByte( msg );
901 }
902 if ( numFields & 7 ) {
903 expandedVector[i>>3] = MSG_ReadBits( msg, numFields & 7 );
904 }
905
906 to->number = number;
907
908 for ( i = 0, field = entityStateFields ; i < numFields ; i++, field++ ) {
909 fromF = (int *)( (byte *)from + field->offset );
910 toF = (int *)( (byte *)to + field->offset );
911
912 if ( ! ( expandedVector[ i >> 3 ] & ( 1 << ( i & 7 ) ) ) ) {
913 // no change
914 *toF = *fromF;
915 } else {
916 MSG_ReadField(msg, toF, field, print);
917 }
918 }
919 }
920 else
921 {
922 memcpy(to, from,sizeof(entityState_t));
923 to->number = number;
924 }
925 if ( print ) {
926 if ( msg->bit == 0 ) {
927 endBit = msg->readcount * 8 - GENTITYNUM_BITS;
928 } else {
929 endBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
930 }
931 Com_Printf( " (%i bits)\n", endBit - startBit );
932 }
933 }
934 #endif
935
936 /*
937 Ghoul2 Insert End
938 */
939
940 /*
941 ============================================================================
942
943 plyer_state_t communication
944
945 ============================================================================
946 */
947
948 // using the stringizing operator to save typing...
949 #define PSF(x) #x,offsetof(playerState_t, x)
950
951 static const netField_t playerStateFields[] =
952 {
953 { PSF(commandTime), 32 },
954 { PSF(pm_type), 8 },
955 { PSF(bobCycle), 8 },
956
957 #ifdef JK2_MODE
958 { PSF(pm_flags), 17 },
959 #else
960 { PSF(pm_flags), 32 },
961 #endif // JK2_MODE
962
963 { PSF(pm_time), -16 },
964 { PSF(origin[0]), 0 },
965 { PSF(origin[1]), 0 },
966 { PSF(origin[2]), 0 },
967 { PSF(velocity[0]), 0 },
968 { PSF(velocity[1]), 0 },
969 { PSF(velocity[2]), 0 },
970 { PSF(weaponTime), -16 },
971 { PSF(weaponChargeTime), 32 }, //? really need 32 bits??
972 { PSF(gravity), 16 },
973 { PSF(leanofs), -8 },
974 { PSF(friction), 16 },
975 { PSF(speed), 16 },
976 { PSF(delta_angles[0]), 16 },
977 { PSF(delta_angles[1]), 16 },
978 { PSF(delta_angles[2]), 16 },
979 { PSF(groundEntityNum), GENTITYNUM_BITS },
980 //{ PSF(animationTimer), 16 },
981 { PSF(legsAnim), 16 },
982 { PSF(torsoAnim), 16 },
983 { PSF(movementDir), 4 },
984 { PSF(eFlags), 32 },
985 { PSF(eventSequence), 16 },
986 { PSF(events[0]), 8 },
987 { PSF(events[1]), 8 },
988 { PSF(eventParms[0]), -9 },
989 { PSF(eventParms[1]), -9 },
990 { PSF(externalEvent), 8 },
991 { PSF(externalEventParm), 8 },
992 { PSF(clientNum), 32 },
993 { PSF(weapon), 5 },
994 { PSF(weaponstate), 4 },
995 { PSF(batteryCharge), 16 },
996 { PSF(viewangles[0]), 0 },
997 { PSF(viewangles[1]), 0 },
998 { PSF(viewangles[2]), 0 },
999 { PSF(viewheight), -8 },
1000 { PSF(damageEvent), 8 },
1001 { PSF(damageYaw), 8 },
1002 { PSF(damagePitch), -8 },
1003 { PSF(damageCount), 8 },
1004 #ifdef JK2_MODE
1005 { PSF(saberColor), 8 },
1006 { PSF(saberActive), 8 },
1007 { PSF(saberLength), 32 },
1008 { PSF(saberLengthMax), 32 },
1009 #endif
1010 { PSF(forcePowersActive), 32},
1011 { PSF(saberInFlight), 8 },
1012 #ifdef JK2_MODE
1013 { PSF(vehicleModel), 32 },
1014 #endif
1015
1016 /*{ PSF(vehicleIndex), 32 }, // WOAH, what do we do with this stuff???
1017 { PSF(vehicleArmor), 32 },
1018 { PSF(vehicleAngles[0]), 0 },
1019 { PSF(vehicleAngles[1]), 0 },
1020 { PSF(vehicleAngles[2]), 0 },*/
1021
1022 { PSF(viewEntity), 32 },
1023 { PSF(serverViewOrg[0]), 0 },
1024 { PSF(serverViewOrg[1]), 0 },
1025 { PSF(serverViewOrg[2]), 0 },
1026
1027 #ifndef JK2_MODE
1028 { PSF(forceRageRecoveryTime), 32 },
1029 #endif // !JK2_MODE
1030 };
1031
1032 /*
1033 =============
1034 MSG_WriteDeltaPlayerstate
1035
1036 =============
1037 */
MSG_WriteDeltaPlayerstate(msg_t * msg,playerState_t * from,playerState_t * to)1038 void MSG_WriteDeltaPlayerstate( msg_t *msg, playerState_t *from, playerState_t *to ) {
1039 int i;
1040 playerState_t dummy;
1041 int statsbits;
1042 int persistantbits;
1043 int ammobits;
1044 int powerupbits;
1045 int numFields;
1046 int c;
1047 const netField_t *field;
1048 int *fromF, *toF;
1049
1050 if (!from) {
1051 from = &dummy;
1052 memset (&dummy, 0, sizeof(dummy));
1053 }
1054
1055 c = msg->cursize;
1056
1057 numFields = sizeof( playerStateFields ) / sizeof( playerStateFields[0] );
1058 for ( i = 0, field = playerStateFields ; i < numFields ; i++, field++ ) {
1059 fromF = (int *)( (byte *)from + field->offset );
1060 toF = (int *)( (byte *)to + field->offset );
1061
1062 if ( *fromF == *toF ) {
1063 MSG_WriteBits( msg, 0, 1 ); // no change
1064 continue;
1065 }
1066
1067 MSG_WriteBits( msg, 1, 1 ); // changed
1068 MSG_WriteField (msg, toF, field);
1069 }
1070 c = msg->cursize - c;
1071
1072
1073 //
1074 // send the arrays
1075 //
1076 statsbits = 0;
1077 for (i=0 ; i<MAX_STATS ; i++) {
1078 if (to->stats[i] != from->stats[i]) {
1079 statsbits |= 1<<i;
1080 }
1081 }
1082 if ( statsbits ) {
1083 MSG_WriteBits( msg, 1, 1 ); // changed
1084 MSG_WriteShort( msg, statsbits );
1085 for (i=0 ; i<MAX_STATS ; i++)
1086 if (statsbits & (1<<i) )
1087 MSG_WriteBits(msg, to->stats[i], 32);
1088 } else {
1089 MSG_WriteBits( msg, 0, 1 ); // no change
1090 }
1091
1092
1093 persistantbits = 0;
1094 for (i=0 ; i<MAX_PERSISTANT ; i++) {
1095 if (to->persistant[i] != from->persistant[i]) {
1096 persistantbits |= 1<<i;
1097 }
1098 }
1099 if ( persistantbits ) {
1100 MSG_WriteBits( msg, 1, 1 ); // changed
1101 MSG_WriteShort( msg, persistantbits );
1102 for (i=0 ; i<MAX_PERSISTANT ; i++)
1103 if (persistantbits & (1<<i) )
1104 MSG_WriteSShort (msg, to->persistant[i]);
1105 } else {
1106 MSG_WriteBits( msg, 0, 1 ); // no change
1107 }
1108
1109
1110 ammobits = 0;
1111 for (i=0 ; i<MAX_AMMO ; i++) {
1112 if (to->ammo[i] != from->ammo[i]) {
1113 ammobits |= 1<<i;
1114 }
1115 }
1116 if ( ammobits ) {
1117 MSG_WriteBits( msg, 1, 1 ); // changed
1118 MSG_WriteShort( msg, ammobits );
1119 for (i=0 ; i<MAX_AMMO ; i++)
1120 if (ammobits & (1<<i) )
1121 MSG_WriteSShort (msg, to->ammo[i]);
1122 } else {
1123 MSG_WriteBits( msg, 0, 1 ); // no change
1124 }
1125
1126 powerupbits = 0;
1127 for (i=0 ; i<MAX_POWERUPS ; i++) {
1128 if (to->powerups[i] != from->powerups[i]) {
1129 powerupbits |= 1<<i;
1130 }
1131 }
1132 if ( powerupbits ) {
1133 MSG_WriteBits( msg, 1, 1 ); // changed
1134 MSG_WriteShort( msg, powerupbits );
1135 for (i=0 ; i<MAX_POWERUPS ; i++)
1136 if (powerupbits & (1<<i) )
1137 MSG_WriteLong( msg, to->powerups[i] );
1138 } else {
1139 MSG_WriteBits( msg, 0, 1 ); // no change
1140 }
1141
1142
1143 statsbits = 0;
1144 for (i=0 ; i<MAX_INVENTORY ; i++)
1145 {
1146 if (to->inventory[i] != from->inventory[i])
1147 {
1148 statsbits |= 1<<i;
1149 }
1150 }
1151 if ( statsbits )
1152 {
1153 MSG_WriteBits( msg, 1, 1 ); // changed
1154 MSG_WriteShort( msg, statsbits );
1155 for (i=0 ; i<MAX_INVENTORY ; i++)
1156 {
1157 if (statsbits & (1<<i) )
1158 {
1159 MSG_WriteShort (msg, to->inventory[i]);
1160 }
1161 }
1162 }
1163 else
1164 {
1165 MSG_WriteBits( msg, 0, 1 ); // no change
1166 }
1167 }
1168
1169
1170 /*
1171 ===================
1172 MSG_ReadDeltaPlayerstate
1173 ===================
1174 */
MSG_ReadDeltaPlayerstate(msg_t * msg,playerState_t * from,playerState_t * to)1175 void MSG_ReadDeltaPlayerstate (msg_t *msg, playerState_t *from, playerState_t *to ) {
1176 int i;
1177 int bits;
1178 const netField_t *field;
1179 int numFields;
1180 int startBit, endBit;
1181 int print;
1182 int *fromF, *toF;
1183 playerState_t dummy;
1184
1185 if ( !from ) {
1186 from = &dummy;
1187 memset( &dummy, 0, sizeof( dummy ) );
1188 }
1189 *to = *from;
1190
1191 if ( msg->bit == 0 ) {
1192 startBit = msg->readcount * 8 - GENTITYNUM_BITS;
1193 } else {
1194 startBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
1195 }
1196
1197 // shownet 2/3 will interleave with other printed info, -2 will
1198 // just print the delta records
1199 if ( cl_shownet->integer >= 2 || cl_shownet->integer == -2 ) {
1200 print = 1;
1201 Com_Printf( "%3i: playerstate ", msg->readcount );
1202 } else {
1203 print = 0;
1204 }
1205
1206 numFields = sizeof( playerStateFields ) / sizeof( playerStateFields[0] );
1207 for ( i = 0, field = playerStateFields ; i < numFields ; i++, field++ ) {
1208 fromF = (int *)( (byte *)from + field->offset );
1209 toF = (int *)( (byte *)to + field->offset );
1210
1211 if ( ! MSG_ReadBits( msg, 1 ) ) {
1212 // no change
1213 *toF = *fromF;
1214 } else {
1215 MSG_ReadField( msg, toF, field, print);
1216 }
1217 }
1218
1219 // read the arrays
1220
1221 // parse stats
1222 if ( MSG_ReadBits( msg, 1 ) ) {
1223 LOG("PS_STATS");
1224 bits = MSG_ReadShort (msg);
1225 for (i=0 ; i<MAX_STATS ; i++) {
1226 if (bits & (1<<i) ) {
1227 to->stats[i] = MSG_ReadBits(msg,32);
1228 }
1229 }
1230 }
1231
1232 // parse persistant stats
1233 if ( MSG_ReadBits( msg, 1 ) ) {
1234 LOG("PS_PERSISTANT");
1235 bits = MSG_ReadShort (msg);
1236 for (i=0 ; i<MAX_PERSISTANT ; i++) {
1237 if (bits & (1<<i) ) {
1238 to->persistant[i] = MSG_ReadSShort(msg);
1239 }
1240 }
1241 }
1242
1243 // parse ammo
1244 if ( MSG_ReadBits( msg, 1 ) ) {
1245 LOG("PS_AMMO");
1246 bits = MSG_ReadShort (msg);
1247 for (i=0 ; i<MAX_AMMO ; i++) {
1248 if (bits & (1<<i) ) {
1249 to->ammo[i] = MSG_ReadSShort(msg);
1250 }
1251 }
1252 }
1253
1254 // parse powerups
1255 if ( MSG_ReadBits( msg, 1 ) ) {
1256 LOG("PS_POWERUPS");
1257 bits = MSG_ReadShort (msg);
1258 for (i=0 ; i<MAX_POWERUPS ; i++) {
1259 if (bits & (1<<i) ) {
1260 to->powerups[i] = MSG_ReadLong(msg);
1261 }
1262 }
1263 }
1264
1265 // parse inventory
1266 if ( MSG_ReadBits( msg, 1 ) ) {
1267 LOG("PS_INVENTORY");
1268 bits = MSG_ReadShort (msg);
1269 for (i=0 ; i<MAX_INVENTORY ; i++) {
1270 if (bits & (1<<i) ) {
1271 to->inventory[i] = MSG_ReadShort(msg);
1272 }
1273 }
1274 }
1275
1276 if ( print ) {
1277 if ( msg->bit == 0 ) {
1278 endBit = msg->readcount * 8 - GENTITYNUM_BITS;
1279 } else {
1280 endBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
1281 }
1282 Com_Printf( " (%i bits)\n", endBit - startBit );
1283 }
1284 }
1285
1286
1287 //===========================================================================
1288