Initial import of the new Q2PRO tree.

1 files changed, 2750 insertions, 0 deletions

diff --git a/source/q_msg.c b/source/q_msg.c
new file mode 100644
index 0000000..d35fa98
--- /dev/null
+++ b/source/q_msg.c
@@ -0,0 +1,2750 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+#include "config.h"
+#include "q_shared.h"
+#include "com_public.h"
+#include "protocol.h"
+#include "q_msg.h"
+
+sizebuf_t	msg_write;
+byte		msg_write_buffer[MAX_MSGLEN];
+
+sizebuf_t	msg_read;
+byte		msg_read_buffer[MAX_MSGLEN];
+
+/*
+==============================================================================
+
+			MESSAGE IO FUNCTIONS
+
+Handles byte ordering and avoids alignment errors
+==============================================================================
+*/
+
+static const entity_state_t	nullEntityState;
+static const player_state_t	nullPlayerState;
+static const usercmd_t		nullUserCmd;
+
+
+/*
+=============
+MSG_Init
+=============
+*/
+void MSG_Init( void ) {
+	// initialize default buffers
+	SZ_Init( &msg_read, msg_read_buffer, sizeof( msg_read_buffer ) );
+	SZ_Init( &msg_write, msg_write_buffer, sizeof( msg_write_buffer ) );
+
+	// don't allow them to overflow
+	msg_read.allowoverflow = qfalse;
+	msg_write.allowoverflow = qfalse;
+
+}
+
+
+//
+// writing functions
+//
+
+/*
+=============
+MSG_BeginWriting
+=============
+*/
+void MSG_BeginWriting( void ) {
+	msg_write.cursize = 0;
+	msg_write.bitpos = 0;
+	msg_write.overflowed = qfalse;
+}
+
+/*
+=============
+MSG_WriteChar
+=============
+*/
+void MSG_WriteChar( int c ) {
+	byte	*buf;
+	
+#ifdef PARANOID
+	if( c < -128 || c > 127 )
+		Com_Error( ERR_FATAL, "MSG_WriteChar: range error" );
+#endif
+
+	buf = SZ_GetSpace( &msg_write, 1 );
+	buf[0] = c;
+}
+
+/*
+=============
+MSG_WriteByte
+=============
+*/
+void MSG_WriteByte( int c ) {
+	byte	*buf;
+	
+#ifdef PARANOID
+	if( c < 0 || c > 255 )
+		Com_Error( ERR_FATAL, "MSG_WriteByte: range error" );
+#endif
+
+	buf = SZ_GetSpace( &msg_write, 1 );
+	buf[0] = c;
+}
+
+/*
+=============
+MSG_WriteShort
+=============
+*/
+void MSG_WriteShort( int c ) {
+	byte	*buf;
+	
+#ifdef PARANOID
+	if (c < ((short)0x8000) || c > (short)0x7fff)
+		Com_Error (ERR_FATAL, "MSG_WriteShort: range error");
+#endif
+
+	buf = SZ_GetSpace( &msg_write, 2 );
+	buf[0] = c & 0xff;
+	buf[1] = c >> 8;
+}
+
+/*
+=============
+MSG_WriteLong
+=============
+*/
+void MSG_WriteLong( int c ) {
+	byte	*buf;
+	
+	buf = SZ_GetSpace( &msg_write, 4 );
+	buf[0] = c & 0xff;
+	buf[1] = ( c >> 8 ) & 0xff;
+	buf[2] = ( c >> 16 ) & 0xff;
+	buf[3] = c >> 24;
+}
+
+/*
+=============
+MSG_WriteString
+=============
+*/
+void MSG_WriteString( const char *string ) {
+	int length;
+	int c;
+
+	if( !string ) {
+		MSG_WriteByte( 0 );
+		return;
+	}
+
+	length = strlen( string );
+	if( length > MAX_NET_STRING - 1 ) {
+		Com_WPrintf( "MSG_WriteString: overflow: %d chars", length );
+		MSG_WriteByte( 0 );
+		return;
+	}
+
+	while( *string ) {
+		c = *string++;
+		if( c == '\xFF' ) {
+			c = '.';
+		}
+		MSG_WriteByte( c );
+	}
+
+	MSG_WriteByte( 0 );
+}
+
+/*
+=============
+MSG_WriteCoord
+=============
+*/
+void MSG_WriteCoord( float f ) {
+	MSG_WriteShort( ( int )( f * 8 ) );
+}
+
+/*
+=============
+MSG_WritePos
+=============
+*/
+void MSG_WritePos( const vec3_t pos ) {
+	MSG_WriteShort( ( int )( pos[0] * 8 ) );
+	MSG_WriteShort( ( int )( pos[1] * 8 ) );
+	MSG_WriteShort( ( int )( pos[2] * 8 ) );
+}
+
+/*
+=============
+MSG_WriteAngle
+=============
+*/
+void MSG_WriteAngle( float f ) {
+	MSG_WriteByte( ( int )( f * 256 / 360 ) & 255 );
+}
+
+/*
+=============
+MSG_WriteAngle16
+=============
+*/
+void MSG_WriteAngle16( float f ) {
+	MSG_WriteShort( ANGLE2SHORT( f ) );
+}
+
+/*
+=============
+MSG_WriteDeltaUsercmd
+=============
+*/
+int MSG_WriteDeltaUsercmd( const usercmd_t *from, const usercmd_t *cmd ) {
+	int		bits;
+
+	if( !from ) {
+		from = &nullUserCmd;
+	}
+
+//
+// send the movement message
+//
+	bits = 0;
+	if( cmd->angles[0] != from->angles[0] )
+		bits |= CM_ANGLE1;
+	if( cmd->angles[1] != from->angles[1] )
+		bits |= CM_ANGLE2;
+	if( cmd->angles[2] != from->angles[2] )
+		bits |= CM_ANGLE3;
+	if( cmd->forwardmove != from->forwardmove )
+		bits |= CM_FORWARD;
+	if( cmd->sidemove != from->sidemove )
+		bits |= CM_SIDE;
+	if( cmd->upmove != from->upmove )
+		bits |= CM_UP;
+	if( cmd->buttons != from->buttons )
+		bits |= CM_BUTTONS;
+	if( cmd->impulse != from->impulse )
+		bits |= CM_IMPULSE;
+
+    MSG_WriteByte ( bits );
+
+	if( bits & CM_ANGLE1 )
+		MSG_WriteShort( cmd->angles[0] );
+	if( bits & CM_ANGLE2 )
+		MSG_WriteShort( cmd->angles[1] );
+	if( bits & CM_ANGLE3 )
+		MSG_WriteShort( cmd->angles[2] );
+	
+	if( bits & CM_FORWARD )
+		MSG_WriteShort( cmd->forwardmove );
+	if( bits & CM_SIDE )
+	  	MSG_WriteShort( cmd->sidemove );
+	if( bits & CM_UP )
+		MSG_WriteShort( cmd->upmove );
+
+ 	if( bits & CM_BUTTONS )
+	  	MSG_WriteByte( cmd->buttons );
+ 	if( bits & CM_IMPULSE )
+	    MSG_WriteByte( cmd->impulse );
+
+    MSG_WriteByte( cmd->msec );
+
+	return bits;
+}
+
+/*
+=============
+MSG_WriteBits
+=============
+*/
+void MSG_WriteBits( int value, int bits ) {
+	int i, bitpos;
+
+	if( bits == 0 || bits < -31 || bits > 32 ) {
+		Com_Error( ERR_FATAL, "MSG_WriteBits: bad bits: %d", bits );
+	}
+
+	if( msg_write.maxsize - msg_write.cursize < 4 ) {
+		Com_Error( ERR_FATAL, "MSG_WriteBits: overflow" );
+	}
+
+	if( bits < 0 ) {
+		bits = -bits;
+	}
+
+	bitpos = msg_write.bitpos;
+	if( ( bitpos & 7 ) == 0 ) {
+		// optimized case
+		switch( bits ) {
+		case 8:
+			MSG_WriteByte( value );
+			return;
+		case 16:
+			MSG_WriteShort( value );
+			return;
+		case 32:
+			MSG_WriteLong( value );
+			return;
+		default:
+			break;
+		}
+	}
+	for( i = 0; i < bits; i++, bitpos++ ) {
+		if( ( bitpos & 7 ) == 0 ) {
+			msg_write.data[ bitpos >> 3 ] = 0;
+		}
+		msg_write.data[ bitpos >> 3 ] |= ( value & 1 ) << ( bitpos & 7 );
+		value >>= 1;
+	}
+	msg_write.bitpos = bitpos;
+	msg_write.cursize = ( bitpos + 7 ) >> 3;
+}
+
+/*
+=============
+MSG_WriteDeltaUsercmd_Enhanced
+=============
+*/
+int MSG_WriteDeltaUsercmd_Enhanced( const usercmd_t *from, const usercmd_t *cmd ) {
+	int		bits, delta;
+
+	if( !from ) {
+		from = &nullUserCmd;
+	}
+
+//
+// send the movement message
+//
+	bits = 0;
+	if( cmd->angles[0] != from->angles[0] )
+		bits |= CM_ANGLE1;
+	if( cmd->angles[1] != from->angles[1] )
+		bits |= CM_ANGLE2;
+	if( cmd->angles[2] != from->angles[2] )
+		bits |= CM_ANGLE3;
+	if( cmd->forwardmove != from->forwardmove )
+		bits |= CM_FORWARD;
+	if( cmd->sidemove != from->sidemove )
+		bits |= CM_SIDE;
+	if( cmd->upmove != from->upmove )
+		bits |= CM_UP;
+	if( cmd->buttons != from->buttons )
+		bits |= CM_BUTTONS;
+	if( cmd->msec != from->msec )
+		bits |= CM_IMPULSE;
+
+	if( !bits ) {
+		MSG_WriteBits( 0, 1 );
+		return 0;
+	}
+
+	MSG_WriteBits( 1, 1 );
+    MSG_WriteBits( bits, 8 );
+
+	if( bits & CM_ANGLE1 ) {
+		delta = cmd->angles[0] - from->angles[0];
+		if( delta >= -128 && delta <= 127 ) {
+			MSG_WriteBits( 1, 1 );
+			MSG_WriteBits( delta, -8 );
+		} else {
+			MSG_WriteBits( 0, 1 );
+			MSG_WriteBits( cmd->angles[0], -16 );
+		}
+	}
+	if( bits & CM_ANGLE2 ) {
+		delta = cmd->angles[1] - from->angles[1];
+		if( delta >= -128 && delta <= 127 ) {
+			MSG_WriteBits( 1, 1 );
+			MSG_WriteBits( delta, -8 );
+		} else {
+			MSG_WriteBits( 0, 1 );
+			MSG_WriteBits( cmd->angles[1], -16 );
+		}
+	}
+	if( bits & CM_ANGLE3 ) {
+		MSG_WriteBits( cmd->angles[2], -16 );
+	}
+	
+	if( bits & CM_FORWARD ) {
+		MSG_WriteBits( cmd->forwardmove, -16 );
+	}
+	if( bits & CM_SIDE ) {
+		MSG_WriteBits( cmd->sidemove, -16 );
+	}
+	if( bits & CM_UP ) {
+		MSG_WriteBits( cmd->upmove, -16 );
+	}
+
+	if( bits & CM_BUTTONS ) {
+		MSG_WriteBits( cmd->buttons, 8 );
+	}
+	if( bits & CM_IMPULSE ) {
+		MSG_WriteBits( cmd->msec, 8 );
+	}
+
+	return bits;
+}
+
+void MSG_WriteDir( const vec3_t dir ) {
+	int		best;
+	
+	best = DirToByte( dir );
+	MSG_WriteByte( best );
+}
+
+void MSG_WriteData( const void *data, int length ) {
+	memcpy( SZ_GetSpace( &msg_write, length ), data, length );		
+}
+
+/* values transmitted over network are discrete, so
+ * we use special macros to check for delta conditions
+ */
+#define Delta_Angle( a, b ) \
+  ( ((int)((a)*256/360) & 255) != ((int)((b)*256/360) & 255) )
+
+#define Delta_Coord( a, b ) \
+  ( (int)((b)*8) != (int)((a)*8) )
+
+#define Delta_Pos( a, b ) \
+  ( (int)((b)[0]*8) != (int)((a)[0]*8) || \
+    (int)((b)[1]*8) != (int)((a)[1]*8) || \
+    (int)((b)[2]*8) != (int)((a)[2]*8) )
+
+#define Delta_VecChar( a, b ) \
+  ( (int)((b)[0]*4) != (int)((a)[0]*4) || \
+	(int)((b)[1]*4) != (int)((a)[1]*4) || \
+	(int)((b)[2]*4) != (int)((a)[2]*4) )
+
+#define Delta_Blend( a, b ) \
+  ( (int)((b)[0]*255) != (int)((a)[0]*255) || \
+    (int)((b)[1]*255) != (int)((a)[1]*255) || \
+    (int)((b)[2]*255) != (int)((a)[2]*255) || \
+    (int)((b)[3]*255) != (int)((a)[3]*255) )
+
+#define Delta_Angle16( a, b ) \
+	( ANGLE2SHORT(b) != ANGLE2SHORT(a) )
+
+#define Delta_VecAngle16( a, b ) \
+  ( ANGLE2SHORT((b)[0]) != ANGLE2SHORT((a)[0]) || \
+    ANGLE2SHORT((b)[1]) != ANGLE2SHORT((a)[1]) || \
+    ANGLE2SHORT((b)[2]) != ANGLE2SHORT((a)[2]) )
+
+#define Delta_Fov( a, b ) \
+	( (int)(b) != (int)(a) )
+
+/*
+==================
+MSG_WriteDeltaEntity
+
+Writes part of a packetentities message.
+Can delta from either a baseline or a previous packet_entity
+==================
+*/
+void MSG_WriteDeltaEntity( const entity_state_t *from, entity_state_t *to, msgEsFlags_t flags ) {
+	int		bits;
+
+	if( !to ) {
+	    if( !from ) {
+		    Com_Error( ERR_DROP, "MSG_WriteDeltaEntity: NULL" );
+	    }
+    	if( from->number < 1 || from->number >= MAX_EDICTS ) {
+	    	Com_Error( ERR_DROP, "MSG_WriteDeltaEntity: bad entity number %i", from->number );
+	    }
+		bits = U_REMOVE;
+		if( from->number >= 256 ) {
+			bits |= U_NUMBER16 | U_MOREBITS1;
+		}
+
+		MSG_WriteByte( bits & 255 );
+		if( bits & 0x0000ff00 )
+			MSG_WriteByte( ( bits >> 8 ) & 255 );
+
+		if( bits & U_NUMBER16 )
+			MSG_WriteShort( from->number );
+		else
+			MSG_WriteByte( from->number );
+
+		return; // remove entity
+	}
+
+	if( to->number < 1 || to->number >= MAX_EDICTS ) {
+		Com_Error( ERR_DROP, "MSG_WriteDeltaEntity: bad entity number %i", to->number );
+	}
+
+	if( !from ) {
+		from = &nullEntityState;
+	}
+
+// send an update
+	bits = 0;
+
+	if( !( flags & MSG_ES_FIRSTPERSON ) ) {
+		if( Delta_Coord( to->origin[0], from->origin[0] ) )
+			bits |= U_ORIGIN1;
+		if( Delta_Coord( to->origin[1], from->origin[1] ) )
+			bits |= U_ORIGIN2;
+		if( Delta_Coord( to->origin[2], from->origin[2] ) )
+			bits |= U_ORIGIN3;
+
+		if( Delta_Angle( to->angles[0], from->angles[0] ) )
+			bits |= U_ANGLE1;		
+		if( Delta_Angle( to->angles[1], from->angles[1] ) )
+			bits |= U_ANGLE2;
+		if( Delta_Angle( to->angles[2], from->angles[2] ) )
+			bits |= U_ANGLE3;
+	} else {
+        // save previous state
+		VectorCopy( from->origin, to->origin );
+		VectorCopy( from->angles, to->angles );
+	}
+		
+	if( to->skinnum != from->skinnum ) {
+        if( to->skinnum & 0xffff0000 ) {
+			bits |= U_SKIN8|U_SKIN16;
+        } else if( to->skinnum & 0x0000ff00 ) {
+			bits |= U_SKIN16;
+        } else {
+			bits |= U_SKIN8;
+        }
+	}
+		
+//if( !( flags & MSG_ES_FIRSTPERSON ) ) {
+	if( to->frame != from->frame ) {
+		if( to->frame < 256 )
+			bits |= U_FRAME8;
+		else
+			bits |= U_FRAME16;
+	}
+//}else{
+//    to->frame=from->frame;
+//}
+
+	if( to->effects != from->effects ) {
+        if( to->effects & 0xffff0000 ) {
+			bits |= U_EFFECTS8|U_EFFECTS16;
+        } else if( to->effects & 0x0000ff00 ) {
+			bits |= U_EFFECTS16;
+        } else {
+			bits |= U_EFFECTS8;
+        }
+	}
+	
+	if ( to->renderfx != from->renderfx ) {
+        if( to->renderfx & 0xffff0000 ) {
+			bits |= U_RENDERFX8|U_RENDERFX16;
+        } else if( to->renderfx & 0x0000ff00 ) {
+			bits |= U_RENDERFX16;
+        } else {
+			bits |= U_RENDERFX8;
+        }
+	}
+	
+	if ( to->solid != from->solid )
+		bits |= U_SOLID;
+
+	// event is not delta compressed, just 0 compressed
+	if ( to->event  )
+		bits |= U_EVENT;
+	
+	if ( to->modelindex != from->modelindex )
+		bits |= U_MODEL;
+	if ( to->modelindex2 != from->modelindex2 )
+		bits |= U_MODEL2;
+	if ( to->modelindex3 != from->modelindex3 )
+		bits |= U_MODEL3;
+	if ( to->modelindex4 != from->modelindex4 )
+		bits |= U_MODEL4;
+
+	if ( to->sound != from->sound )
+		bits |= U_SOUND;
+
+	if( ( to->renderfx & RF_BEAM ) )
+		bits |= U_OLDORIGIN;
+
+	if( flags & MSG_ES_NEWENTITY ) {
+		if( !( flags & MSG_ES_FIRSTPERSON ) ) {
+			if( Delta_Pos( to->old_origin, from->old_origin ) ) {
+				bits |= U_OLDORIGIN;
+			}
+		} else {
+			VectorCopy( from->old_origin, to->old_origin );
+		}
+	}
+
+	//
+	// write the message
+	//
+	if( !bits && !( flags & MSG_ES_FORCE ) )
+		return;		// nothing to send!
+
+	//----------
+
+	if (to->number >= 256)
+		bits |= U_NUMBER16;		// number8 is implicit otherwise
+
+	if (bits & 0xff000000)
+		bits |= U_MOREBITS3 | U_MOREBITS2 | U_MOREBITS1;
+	else if (bits & 0x00ff0000)
+		bits |= U_MOREBITS2 | U_MOREBITS1;
+	else if (bits & 0x0000ff00)
+		bits |= U_MOREBITS1;
+
+	MSG_WriteByte (bits&255 );
+
+	if (bits & 0xff000000) {
+		MSG_WriteByte ((bits>>8)&255 );
+		MSG_WriteByte ((bits>>16)&255 );
+		MSG_WriteByte ((bits>>24)&255 );
+	}
+	else if (bits & 0x00ff0000) {
+		MSG_WriteByte ((bits>>8)&255 );
+		MSG_WriteByte ((bits>>16)&255 );
+	}
+	else if (bits & 0x0000ff00) {
+		MSG_WriteByte ((bits>>8)&255 );
+	}
+
+	//----------
+
+	if (bits & U_NUMBER16)
+		MSG_WriteShort (to->number);
+	else
+		MSG_WriteByte (to->number);
+
+	if (bits & U_MODEL)
+		MSG_WriteByte (to->modelindex);
+	if (bits & U_MODEL2)
+		MSG_WriteByte (to->modelindex2);
+	if (bits & U_MODEL3)
+		MSG_WriteByte (to->modelindex3);
+	if (bits & U_MODEL4)
+		MSG_WriteByte (to->modelindex4);
+
+	if (bits & U_FRAME8)
+		MSG_WriteByte (to->frame);
+	if (bits & U_FRAME16)
+		MSG_WriteShort (to->frame);
+
+	if ((bits & (U_SKIN8|U_SKIN16)) == (U_SKIN8|U_SKIN16) )		//used for laser colors
+		MSG_WriteLong (to->skinnum);
+	else if (bits & U_SKIN8)
+		MSG_WriteByte (to->skinnum);
+	else if (bits & U_SKIN16)
+		MSG_WriteShort (to->skinnum);
+
+
+	if ( (bits & (U_EFFECTS8|U_EFFECTS16)) == (U_EFFECTS8|U_EFFECTS16) )
+		MSG_WriteLong (to->effects);
+	else if (bits & U_EFFECTS8)
+		MSG_WriteByte (to->effects);
+	else if (bits & U_EFFECTS16)
+		MSG_WriteShort (to->effects);
+
+	if ( (bits & (U_RENDERFX8|U_RENDERFX16)) == (U_RENDERFX8|U_RENDERFX16) )
+		MSG_WriteLong (to->renderfx);
+	else if (bits & U_RENDERFX8)
+		MSG_WriteByte (to->renderfx);
+	else if (bits & U_RENDERFX16)
+		MSG_WriteShort (to->renderfx);
+
+	if (bits & U_ORIGIN1)
+		MSG_WriteCoord (to->origin[0]);		
+	if (bits & U_ORIGIN2)
+		MSG_WriteCoord (to->origin[1]);
+	if (bits & U_ORIGIN3)
+		MSG_WriteCoord (to->origin[2]);
+
+	if (bits & U_ANGLE1)
+		MSG_WriteAngle(to->angles[0]);
+	if (bits & U_ANGLE2){
+		MSG_WriteAngle(to->angles[1]);
+	}
+	if (bits & U_ANGLE3)
+		MSG_WriteAngle(to->angles[2]);
+
+	if (bits & U_OLDORIGIN) {
+		MSG_WriteCoord (to->old_origin[0]);
+		MSG_WriteCoord (to->old_origin[1]);
+		MSG_WriteCoord (to->old_origin[2]);
+	}
+
+	if (bits & U_SOUND)
+		MSG_WriteByte (to->sound);
+	if (bits & U_EVENT)
+		MSG_WriteByte (to->event);
+	if (bits & U_SOLID)
+		MSG_WriteShort (to->solid);
+}
+
+/*
+==================
+MSG_WriteDeltaPlayerstate_Default
+==================
+*/
+void MSG_WriteDeltaPlayerstate_Default( const player_state_t *from, const player_state_t *to ) {
+	int				i;
+	int				pflags;
+	int				statbits;
+
+	if( !to ) {
+		Com_Error( ERR_DROP, "MSG_WriteDeltaPlayerstate_Default: NULL" );
+	}
+
+	if( !from ) {
+		from = &nullPlayerState;
+	}
+
+	//
+	// determine what needs to be sent
+	//
+	pflags = 0;
+
+	if( to->pmove.pm_type != from->pmove.pm_type )
+		pflags |= PS_M_TYPE;
+
+	if( to->pmove.origin[0] != from->pmove.origin[0] ||
+		to->pmove.origin[1] != from->pmove.origin[1] ||
+		to->pmove.origin[2] != from->pmove.origin[2] )
+	{
+		pflags |= PS_M_ORIGIN;
+	}
+
+	if( to->pmove.velocity[0] != from->pmove.velocity[0] ||
+		to->pmove.velocity[1] != from->pmove.velocity[1] ||
+		to->pmove.velocity[2] != from->pmove.velocity[2] )
+	{
+		pflags |= PS_M_VELOCITY;
+	}
+
+	if( to->pmove.pm_time != from->pmove.pm_time )
+		pflags |= PS_M_TIME;
+
+	if( to->pmove.pm_flags != from->pmove.pm_flags )
+		pflags |= PS_M_FLAGS;
+
+	if( to->pmove.gravity != from->pmove.gravity )
+		pflags |= PS_M_GRAVITY;
+
+	if( to->pmove.delta_angles[0] != from->pmove.delta_angles[0] ||
+		to->pmove.delta_angles[1] != from->pmove.delta_angles[1] ||
+		to->pmove.delta_angles[2] != from->pmove.delta_angles[2] )
+	{
+		pflags |= PS_M_DELTA_ANGLES;
+	}
+
+	if( Delta_VecChar( to->viewoffset, from->viewoffset ) ) {
+		pflags |= PS_VIEWOFFSET;
+	}
+
+	if( Delta_VecAngle16( to->viewangles, from->viewangles ) ) {
+		pflags |= PS_VIEWANGLES;
+	}
+
+	if( Delta_VecChar( to->kick_angles, from->kick_angles ) ) {
+		pflags |= PS_KICKANGLES;
+	}
+
+	if( Delta_Blend( to->blend, from->blend ) ) {
+		pflags |= PS_BLEND;
+	}
+
+	if( Delta_Fov( to->fov, from->fov ) )
+		pflags |= PS_FOV;
+
+	if( to->rdflags != from->rdflags )
+		pflags |= PS_RDFLAGS;
+
+	if( to->gunframe != from->gunframe ||
+		Delta_VecChar( to->gunoffset, from->gunoffset ) ||
+		Delta_VecChar( to->gunangles, from->gunangles ) )
+	{
+		pflags |= PS_WEAPONFRAME;
+	}
+
+	if( to->gunindex != from->gunindex )
+		pflags |= PS_WEAPONINDEX;
+
+
+	//
+	// write it
+	//
+	MSG_WriteShort( pflags );
+
+	//
+	// write the pmove_state_t
+	//
+	if( pflags & PS_M_TYPE )
+		MSG_WriteByte( to->pmove.pm_type );
+
+	if( pflags & PS_M_ORIGIN ) {
+		MSG_WriteShort( to->pmove.origin[0] );
+		MSG_WriteShort( to->pmove.origin[1] );
+		MSG_WriteShort( to->pmove.origin[2] );
+	}
+
+	if( pflags & PS_M_VELOCITY ) {
+		MSG_WriteShort( to->pmove.velocity[0] );
+		MSG_WriteShort( to->pmove.velocity[1] );
+		MSG_WriteShort( to->pmove.velocity[2] );
+	}
+
+	if( pflags & PS_M_TIME )
+		MSG_WriteByte( to->pmove.pm_time );
+
+	if( pflags & PS_M_FLAGS )
+		MSG_WriteByte( to->pmove.pm_flags );
+
+	if( pflags & PS_M_GRAVITY )
+		MSG_WriteShort( to->pmove.gravity );
+
+	if( pflags & PS_M_DELTA_ANGLES ) {
+		MSG_WriteShort( to->pmove.delta_angles[0] );
+		MSG_WriteShort( to->pmove.delta_angles[1] );
+		MSG_WriteShort( to->pmove.delta_angles[2] );
+	}
+
+	//
+	// write the rest of the player_state_t
+	//
+	if( pflags & PS_VIEWOFFSET ) {
+		MSG_WriteChar( to->viewoffset[0] * 4 );
+		MSG_WriteChar( to->viewoffset[1] * 4 );
+		MSG_WriteChar( to->viewoffset[2] * 4 );
+	}
+
+	if( pflags & PS_VIEWANGLES ) {
+		MSG_WriteAngle16( to->viewangles[0] );
+		MSG_WriteAngle16( to->viewangles[1] );
+		MSG_WriteAngle16( to->viewangles[2] );
+	}
+
+	if( pflags & PS_KICKANGLES ) {
+		MSG_WriteChar( to->kick_angles[0] * 4 );
+		MSG_WriteChar( to->kick_angles[1] * 4 );
+		MSG_WriteChar( to->kick_angles[2] * 4 );
+	}
+
+	if( pflags & PS_WEAPONINDEX ) {
+		MSG_WriteByte( to->gunindex );
+	}
+
+	if( pflags & PS_WEAPONFRAME ) {
+		MSG_WriteByte( to->gunframe );
+		MSG_WriteChar( to->gunoffset[0] * 4 );
+		MSG_WriteChar( to->gunoffset[1] * 4 );
+		MSG_WriteChar( to->gunoffset[2] * 4 );
+		MSG_WriteChar( to->gunangles[0] * 4 );
+		MSG_WriteChar( to->gunangles[1] * 4 );
+		MSG_WriteChar( to->gunangles[2] * 4 );
+	}
+
+	if( pflags & PS_BLEND ) {
+		MSG_WriteByte( to->blend[0] * 255 );
+		MSG_WriteByte( to->blend[1] * 255 );
+		MSG_WriteByte( to->blend[2] * 255 );
+		MSG_WriteByte( to->blend[3] * 255 );
+	}
+
+	if( pflags & PS_FOV )
+		MSG_WriteByte( to->fov );
+
+	if( pflags & PS_RDFLAGS )
+		MSG_WriteByte( to->rdflags );
+
+	// send stats
+	statbits = 0;
+	for( i = 0; i < MAX_STATS; i++ )
+		if( to->stats[i] != from->stats[i] )
+			statbits |= 1 << i;
+
+	MSG_WriteLong( statbits );
+	for( i = 0; i < MAX_STATS; i++ )
+		if( statbits & ( 1 << i ) )
+			MSG_WriteShort( to->stats[i] );
+}
+
+/*
+==================
+MSG_WriteDeltaPlayerstate_Enhanced
+==================
+*/
+int MSG_WriteDeltaPlayerstate_Enhanced( const player_state_t    *from,
+                                              player_state_t    *to,
+                                              msgPsFlags_t      flags )
+{
+	int				i;
+	int				pflags, extraflags;
+	int				statbits;
+
+	if( !to ) {
+		Com_Error( ERR_DROP, "MSG_WriteDeltaPlayerstate_Enhanced: NULL" );
+	}
+
+	if( !from ) {
+		from = &nullPlayerState;
+	}
+
+	//
+	// determine what needs to be sent
+	//
+	pflags = 0;
+	extraflags = 0;
+
+	if( to->pmove.pm_type != from->pmove.pm_type )
+		pflags |= PS_M_TYPE;
+
+	if( to->pmove.origin[0] != from->pmove.origin[0] ||
+		to->pmove.origin[1] != from->pmove.origin[1] )
+	{
+		pflags |= PS_M_ORIGIN;
+	}
+
+	if( to->pmove.origin[2] != from->pmove.origin[2] ) {
+		extraflags |= EPS_M_ORIGIN2;
+	}
+
+	if( !( flags & MSG_PS_IGNORE_PREDICTION ) ) {
+		if( to->pmove.velocity[0] != from->pmove.velocity[0] ||
+			to->pmove.velocity[1] != from->pmove.velocity[1] )
+		{
+			pflags |= PS_M_VELOCITY;
+		}
+
+		if( to->pmove.velocity[2] != from->pmove.velocity[2] ) {
+			extraflags |= EPS_M_VELOCITY2;
+		}
+
+		if( to->pmove.pm_time != from->pmove.pm_time )
+			pflags |= PS_M_TIME;
+
+		if( to->pmove.pm_flags != from->pmove.pm_flags )
+			pflags |= PS_M_FLAGS;
+
+		if( to->pmove.gravity != from->pmove.gravity )
+			pflags |= PS_M_GRAVITY;
+	} else {
+		// save previous state
+		VectorCopy( from->pmove.velocity, to->pmove.velocity );
+		to->pmove.pm_time = from->pmove.pm_time;
+		to->pmove.pm_flags = from->pmove.pm_flags;
+		to->pmove.gravity = from->pmove.gravity;
+	}
+
+	if( !( flags & MSG_PS_IGNORE_DELTAANGLES ) ) {
+		if( to->pmove.delta_angles[0] != from->pmove.delta_angles[0] ||
+			to->pmove.delta_angles[1] != from->pmove.delta_angles[1] ||
+			to->pmove.delta_angles[2] != from->pmove.delta_angles[2] )
+		{
+			pflags |= PS_M_DELTA_ANGLES;
+		}
+	} else {
+		// save previous state
+		VectorCopy( from->pmove.delta_angles, to->pmove.delta_angles );
+	}
+
+	if( Delta_VecChar( from->viewoffset, to->viewoffset ) ) {
+		pflags |= PS_VIEWOFFSET;
+	}
+
+	if( !( flags & MSG_PS_IGNORE_VIEWANGLES ) ) {
+		if( Delta_Angle16( from->viewangles[0], to->viewangles[0] ) ||
+			Delta_Angle16( from->viewangles[1], to->viewangles[1] ) )
+		{
+			pflags |= PS_VIEWANGLES;
+		}
+
+		if( Delta_Angle16( from->viewangles[2], to->viewangles[2] ) ) {
+			extraflags |= EPS_VIEWANGLE2;
+		}
+	} else {
+		// save previous state
+		to->viewangles[0] = from->viewangles[0];
+		to->viewangles[1] = from->viewangles[1];
+		to->viewangles[2] = from->viewangles[2];
+	}
+
+	if( Delta_VecChar( from->kick_angles, to->kick_angles ) ) {
+		pflags |= PS_KICKANGLES;
+	}
+
+	if( !( flags & MSG_PS_IGNORE_BLEND ) ) {
+		if( Delta_Blend( from->blend, to->blend ) ) {
+			pflags |= PS_BLEND;
+		}
+	} else {
+		// save previous state
+		to->blend[0] = from->blend[0];
+		to->blend[1] = from->blend[1];
+		to->blend[2] = from->blend[2];
+		to->blend[3] = from->blend[3];
+	}
+
+	if( Delta_Fov( from->fov, to->fov ) )
+		pflags |= PS_FOV;
+
+	if( to->rdflags != from->rdflags )
+		pflags |= PS_RDFLAGS;
+
+	if( !( flags & MSG_PS_IGNORE_GUNINDEX ) ) {
+		if( to->gunindex != from->gunindex )
+			pflags |= PS_WEAPONINDEX;
+	} else {
+		// save previous state
+		to->gunindex = from->gunindex;
+	}
+
+	if( !( flags & MSG_PS_IGNORE_GUNFRAMES ) ) {
+		if( to->gunframe != from->gunframe )
+			pflags |= PS_WEAPONFRAME;
+
+		if( Delta_VecChar( from->gunoffset, to->gunoffset ) ) {
+			extraflags |= EPS_GUNOFFSET;
+		}
+
+		if( Delta_VecChar( from->gunangles, to->gunangles ) ) {
+			extraflags |= EPS_GUNANGLES;
+		}
+	} else {
+		// save previous state 
+		to->gunframe = from->gunframe;
+
+		to->gunoffset[0] = from->gunoffset[0];
+		to->gunoffset[1] = from->gunoffset[1];
+		to->gunoffset[2] = from->gunoffset[2];
+
+		to->gunangles[0] = from->gunangles[0];
+		to->gunangles[1] = from->gunangles[1];
+		to->gunangles[2] = from->gunangles[2];
+	}
+
+	statbits = 0;
+	for( i = 0; i < MAX_STATS; i++ ) {
+		if( to->stats[i] != from->stats[i] ) {
+			statbits |= 1 << i;
+		}
+	}
+
+	if( statbits ) {
+		extraflags |= EPS_STATS;
+	}
+
+	//
+	// write it
+	//
+	MSG_WriteShort( pflags );
+
+	//
+	// write the pmove_state_t
+	//
+	if( pflags & PS_M_TYPE )
+		MSG_WriteByte( to->pmove.pm_type );
+
+	if( pflags & PS_M_ORIGIN ) {
+		MSG_WriteShort( to->pmove.origin[0] );
+		MSG_WriteShort( to->pmove.origin[1] );
+	}
+
+	if( extraflags & EPS_M_ORIGIN2 ) {
+		MSG_WriteShort( to->pmove.origin[2] );
+	}
+
+	if( pflags & PS_M_VELOCITY ) {
+		MSG_WriteShort( to->pmove.velocity[0] );
+		MSG_WriteShort( to->pmove.velocity[1] );
+	}
+
+	if( extraflags & EPS_M_VELOCITY2 ) {
+		MSG_WriteShort( to->pmove.velocity[2] );
+	}
+
+	if( pflags & PS_M_TIME ) {
+		MSG_WriteByte( to->pmove.pm_time );
+	}
+
+	if( pflags & PS_M_FLAGS ) {
+		MSG_WriteByte( to->pmove.pm_flags );
+	}
+
+	if( pflags & PS_M_GRAVITY ) {
+		MSG_WriteShort( to->pmove.gravity );
+	}
+
+	if( pflags & PS_M_DELTA_ANGLES ) {
+		MSG_WriteShort( to->pmove.delta_angles[0] );
+		MSG_WriteShort( to->pmove.delta_angles[1] );
+		MSG_WriteShort( to->pmove.delta_angles[2] );
+	}
+
+	//
+	// write the rest of the player_state_t
+	//
+	if( pflags & PS_VIEWOFFSET ) {
+		MSG_WriteChar( to->viewoffset[0] * 4 );
+		MSG_WriteChar( to->viewoffset[1] * 4 );
+		MSG_WriteChar( to->viewoffset[2] * 4 );
+	}
+
+	if( pflags & PS_VIEWANGLES ) {
+		MSG_WriteAngle16( to->viewangles[0] );
+		MSG_WriteAngle16( to->viewangles[1] );
+		
+	}
+
+	if( extraflags & EPS_VIEWANGLE2 ) {
+		MSG_WriteAngle16( to->viewangles[2] );
+	}
+
+	if( pflags & PS_KICKANGLES ) {
+		MSG_WriteChar( to->kick_angles[0] * 4 );
+		MSG_WriteChar( to->kick_angles[1] * 4 );
+		MSG_WriteChar( to->kick_angles[2] * 4 );
+	}
+
+	if( pflags & PS_WEAPONINDEX ) {
+		MSG_WriteByte( to->gunindex );
+	}
+
+	if( pflags & PS_WEAPONFRAME ) {
+		MSG_WriteByte( to->gunframe );
+	}
+
+	if( extraflags & EPS_GUNOFFSET ) {
+		MSG_WriteChar( to->gunoffset[0] * 4 );
+		MSG_WriteChar( to->gunoffset[1] * 4 );
+		MSG_WriteChar( to->gunoffset[2] * 4 );
+	}
+
+	if( extraflags & EPS_GUNANGLES ) {
+		MSG_WriteChar( to->gunangles[0] * 4 );
+		MSG_WriteChar( to->gunangles[1] * 4 );
+		MSG_WriteChar( to->gunangles[2] * 4 );
+	}
+
+	if( pflags & PS_BLEND ) {
+		MSG_WriteByte( to->blend[0] * 255 );
+		MSG_WriteByte( to->blend[1] * 255 );
+		MSG_WriteByte( to->blend[2] * 255 );
+		MSG_WriteByte( to->blend[3] * 255 );
+	}
+
+	if( pflags & PS_FOV )
+		MSG_WriteByte( to->fov );
+
+	if( pflags & PS_RDFLAGS )
+		MSG_WriteByte( to->rdflags );
+
+	// send stats
+	if( extraflags & EPS_STATS ) {
+		MSG_WriteLong( statbits );
+		for( i = 0; i < MAX_STATS; i++ ) {
+			if( statbits & ( 1 << i ) ) {
+				MSG_WriteShort( to->stats[i] );
+			}
+		}
+	}
+
+	return extraflags;
+}
+
+/*
+==================
+MSG_WriteDeltaPlayerstate_Packet
+
+Throw away most of the pmove_state_t fields as they are used only
+for client prediction, and not needed in MVDs.
+==================
+*/
+void MSG_WriteDeltaPlayerstate_Packet(  const player_state_t   *from,
+                                              player_state_t   *to,
+                                              msgPsFlags_t     flags )
+{
+	int				i;
+	int				pflags;
+	int				statbits;
+	int				playerNum;
+
+	if( !to ) {
+		if( !from ) {
+			Com_Error( ERR_DROP, "MSG_WriteDeltaPlayerstate_Packet: NULL" );
+		}
+	    playerNum = PPS_NUM( from );
+		MSG_WriteByte( playerNum );
+		MSG_WriteShort( PPS_REMOVE );
+		return;
+	}
+
+	playerNum = PPS_NUM( to );
+	if( playerNum < 0 || playerNum >= MAX_CLIENTS ) {
+		Com_Error( ERR_DROP, "MSG_WriteDeltaPlayerstate_Packet: bad player number %i", playerNum );
+	}
+
+	if( !from ) {
+		from = &nullPlayerState;
+	}
+
+	//
+	// determine what needs to be sent
+	//
+	pflags = 0;
+
+	if( to->pmove.pm_type != from->pmove.pm_type )
+		pflags |= PPS_M_TYPE;
+
+	if( to->pmove.origin[0] != from->pmove.origin[0] ||
+		to->pmove.origin[1] != from->pmove.origin[1] )
+	{
+		pflags |= PPS_M_ORIGIN;
+	}
+
+	if( to->pmove.origin[2] != from->pmove.origin[2] ) {
+		pflags |= PPS_M_ORIGIN2;
+	}
+
+	if( Delta_VecChar( from->viewoffset, to->viewoffset ) ) {
+		pflags |= PPS_VIEWOFFSET;
+	}
+
+	if( Delta_Angle16( from->viewangles[0], to->viewangles[0] ) ||
+		Delta_Angle16( from->viewangles[1], to->viewangles[1] ) )
+	{
+		pflags |= PPS_VIEWANGLES;
+	}
+
+	if( Delta_Angle16( from->viewangles[2], to->viewangles[2] ) ) {
+		pflags |= PPS_VIEWANGLE2;
+	}
+
+	if( Delta_VecChar( from->kick_angles, to->kick_angles ) ) {
+		pflags |= PPS_KICKANGLES;
+	}
+
+	if( !( flags & MSG_PS_IGNORE_BLEND ) ) {
+		if( Delta_Blend( from->blend, to->blend ) ) {
+			pflags |= PPS_BLEND;
+		}
+	} else {
+        // save previous state
+        Vector4Copy( from->blend, to->blend );
+    }
+
+	if( Delta_Fov( from->fov, to->fov ) )
+		pflags |= PPS_FOV;
+
+	if( to->rdflags != from->rdflags )
+		pflags |= PPS_RDFLAGS;
+
+	if( !( flags & MSG_PS_IGNORE_GUNINDEX ) ) {
+		if( to->gunindex != from->gunindex )
+			pflags |= PPS_WEAPONINDEX;
+	} else {
+        // save previous state
+        to->gunindex = from->gunindex;
+	}
+
+	if( !( flags & MSG_PS_IGNORE_GUNFRAMES ) ) {
+		if( to->gunframe != from->gunframe )
+			pflags |= PPS_WEAPONFRAME;
+
+		if( Delta_VecChar( from->gunoffset, to->gunoffset ) ) {
+			pflags |= PPS_GUNOFFSET;
+		}
+
+		if( Delta_VecChar( from->gunangles, to->gunangles ) ) {
+			pflags |= PPS_GUNANGLES;
+		}
+	} else {
+		// save previous state 
+		to->gunframe = from->gunframe;
+
+		to->gunoffset[0] = from->gunoffset[0];
+		to->gunoffset[1] = from->gunoffset[1];
+		to->gunoffset[2] = from->gunoffset[2];
+
+		to->gunangles[0] = from->gunangles[0];
+		to->gunangles[1] = from->gunangles[1];
+		to->gunangles[2] = from->gunangles[2];
+    }
+
+	statbits = 0;
+	for( i = 0; i < MAX_STATS; i++ ) {
+		if( to->stats[i] != from->stats[i] ) {
+			statbits |= 1 << i;
+		}
+	}
+
+	if( statbits ) {
+		pflags |= PPS_STATS;
+	}
+
+	if( !pflags && !( flags & MSG_PS_FORCE ) ) {
+		return;
+	}
+
+	//
+	// write it
+	//
+	MSG_WriteByte( playerNum );
+	MSG_WriteShort( pflags );
+
+	//
+	// write some part of the pmove_state_t
+	//
+	if( pflags & PPS_M_TYPE )
+		MSG_WriteByte( to->pmove.pm_type );
+
+	if( pflags & PPS_M_ORIGIN ) {
+		MSG_WriteShort( to->pmove.origin[0] );
+		MSG_WriteShort( to->pmove.origin[1] );
+	}
+
+	if( pflags & PPS_M_ORIGIN2 ) {
+		MSG_WriteShort( to->pmove.origin[2] );
+	}
+
+	//
+	// write the rest of the player_state_t
+	//
+	if( pflags & PPS_VIEWOFFSET ) {
+		MSG_WriteChar( to->viewoffset[0] * 4 );
+		MSG_WriteChar( to->viewoffset[1] * 4 );
+		MSG_WriteChar( to->viewoffset[2] * 4 );
+	}
+
+	if( pflags & PPS_VIEWANGLES ) {
+		MSG_WriteAngle16( to->viewangles[0] );
+		MSG_WriteAngle16( to->viewangles[1] );
+	}
+
+	if( pflags & PPS_VIEWANGLE2 ) {
+		MSG_WriteAngle16( to->viewangles[2] );
+	}
+
+	if( pflags & PPS_KICKANGLES ) {
+		MSG_WriteChar( to->kick_angles[0] * 4 );
+		MSG_WriteChar( to->kick_angles[1] * 4 );
+		MSG_WriteChar( to->kick_angles[2] * 4 );
+	}
+
+	if( pflags & PPS_WEAPONINDEX ) {
+		MSG_WriteByte( to->gunindex );
+	}
+
+	if( pflags & PPS_WEAPONFRAME ) {
+		MSG_WriteByte( to->gunframe );
+	}
+
+	if( pflags & PPS_GUNOFFSET ) {
+		MSG_WriteChar( to->gunoffset[0] * 4 );
+		MSG_WriteChar( to->gunoffset[1] * 4 );
+		MSG_WriteChar( to->gunoffset[2] * 4 );
+	}
+
+	if( pflags & PPS_GUNANGLES ) {
+		MSG_WriteChar( to->gunangles[0] * 4 );
+		MSG_WriteChar( to->gunangles[1] * 4 );
+		MSG_WriteChar( to->gunangles[2] * 4 );
+	}
+
+	if( pflags & PPS_BLEND ) {
+		MSG_WriteByte( to->blend[0] * 255 );
+		MSG_WriteByte( to->blend[1] * 255 );
+		MSG_WriteByte( to->blend[2] * 255 );
+		MSG_WriteByte( to->blend[3] * 255 );
+	}
+
+	if( pflags & PPS_FOV )
+		MSG_WriteByte( to->fov );
+
+	if( pflags & PPS_RDFLAGS )
+		MSG_WriteByte( to->rdflags );
+
+	// send stats
+	if( pflags & PPS_STATS ) {
+		MSG_WriteLong( statbits );
+		for( i = 0; i < MAX_STATS; i++ ) {
+			if( statbits & ( 1 << i ) ) {
+				MSG_WriteShort( to->stats[i] );
+			}
+		}
+	}
+}
+
+/*
+=============
+MSG_FlushTo
+=============
+*/
+void MSG_FlushTo( sizebuf_t *dest ) {
+	memcpy( SZ_GetSpace( dest, msg_write.cursize ), msg_write.data, msg_write.cursize );	
+	SZ_Clear( &msg_write );
+}
+
+void MSG_Printf( const char *fmt, ... ) {
+    char buffer[MAX_STRING_CHARS];
+	va_list		argptr;
+	int			length;
+
+	va_start( argptr, fmt );
+	length = Q_vsnprintf( buffer, sizeof( buffer ), fmt, argptr );
+	va_end( argptr );
+
+    MSG_WriteData( buffer, length );
+}
+
+//============================================================
+
+//
+// reading functions
+//
+
+void MSG_BeginReading( void ) {
+	msg_read.readcount = 0;
+	msg_read.bitpos = 0;
+}
+
+// returns -1 if no more characters are available
+int MSG_ReadChar (void)
+{
+	int	c;
+	
+	if (msg_read.readcount+1 > msg_read.cursize)
+		c = -1;
+	else
+		c = (signed char)msg_read.data[msg_read.readcount];
+	msg_read.readcount++;
+	msg_read.bitpos = msg_read.readcount << 3;
+	
+	return c;
+}
+
+int MSG_ReadByte( void )
+{
+	int	c;
+	
+	if (msg_read.readcount+1 > msg_read.cursize)
+		c = -1;
+	else
+		c = (unsigned char)msg_read.data[msg_read.readcount];
+	msg_read.readcount++;
+	msg_read.bitpos = msg_read.readcount << 3;
+	
+	return c;
+}
+
+int MSG_ReadShort( void )
+{
+	int	c;
+	
+	if (msg_read.readcount+2 > msg_read.cursize)
+		c = -1;
+	else		
+		c = (short)(msg_read.data[msg_read.readcount]
+		+ (msg_read.data[msg_read.readcount+1]<<8));
+	
+	msg_read.readcount += 2;
+	msg_read.bitpos = msg_read.readcount << 3;
+	
+	return c;
+}
+
+int MSG_ReadWord( void )
+{
+	int	c;
+	
+	if (msg_read.readcount+2 > msg_read.cursize)
+		c = -1;
+	else		
+		c = (unsigned short)(msg_read.data[msg_read.readcount]
+		+ (msg_read.data[msg_read.readcount+1]<<8));
+	
+	msg_read.readcount += 2;
+	msg_read.bitpos = msg_read.readcount << 3;
+	
+	return c;
+}
+
+int MSG_ReadLong ( void )
+{
+	int	c;
+	
+	if (msg_read.readcount+4 > msg_read.cursize)
+		c = -1;
+	else
+		c = msg_read.data[msg_read.readcount]
+		+ (msg_read.data[msg_read.readcount+1]<<8)
+		+ (msg_read.data[msg_read.readcount+2]<<16)
+		+ (msg_read.data[msg_read.readcount+3]<<24);
+	
+	msg_read.readcount += 4;
+	msg_read.bitpos = msg_read.readcount << 3;
+	
+	return c;
+}
+
+char *MSG_ReadStringLength( int *length ) {
+	static char	string[2][MAX_NET_STRING];
+	static int index;
+	char	*s;
+	int		l, c;
+	
+	s = string[index];
+	index ^= 1;
+
+	l = 0;
+	do {
+		c = MSG_ReadByte();
+		if( c == -1 || c == 0 ) {
+			break;
+		}
+		if( c == 0xFF ) {
+			c = '.';
+		}
+		s[l++] = c;
+	} while( l < MAX_NET_STRING - 1 );
+	
+	s[l] = 0;
+
+    if( length ) {
+        *length = l;
+    }
+	
+	return s;
+}
+
+char *MSG_ReadString( void ) {
+	static char	string[2][MAX_NET_STRING];
+	static int index;
+	char	*s;
+	int		l, c;
+	
+	s = string[index];
+	index ^= 1;
+
+	l = 0;
+	do {
+		c = MSG_ReadByte();
+		if( c == -1 || c == 0 ) {
+			break;
+		}
+		if( c == 0xFF ) {
+			c = '.';
+		}
+		s[l++] = c;
+	} while( l < MAX_NET_STRING - 1 );
+	
+	s[l] = 0;
+	
+	return s;
+}
+
+char *MSG_ReadStringLine( void ) {
+	static char	string[2][MAX_STRING_CHARS];
+	static int index;
+	char	*s;
+	int		l, c;
+	
+	s = string[index];
+	index ^= 1;
+
+	l = 0;
+	do {
+		c = MSG_ReadByte();
+		if( c == -1 || c == 0 || c == '\n' ) {
+			break;
+		}
+		if( c == 0xFF ) {
+			c = '.';
+		}
+		s[l++] = c;
+	} while( l < MAX_STRING_CHARS - 1 );
+	
+	s[l] = 0;
+	
+	return s;
+}
+
+float MSG_ReadCoord (void)
+{
+	return MSG_ReadShort() * (1.0/8);
+}
+
+void MSG_ReadPos ( vec3_t pos)
+{
+	pos[0] = MSG_ReadShort() * (1.0/8);
+	pos[1] = MSG_ReadShort() * (1.0/8);
+	pos[2] = MSG_ReadShort() * (1.0/8);
+}
+
+void MSG_ReadExactPos( vec3_t pos ) {
+	*( int * )&pos[0] = MSG_ReadLong();
+	*( int * )&pos[1] = MSG_ReadLong();
+	*( int * )&pos[2] = MSG_ReadLong();
+}
+
+float MSG_ReadAngle (void)
+{
+	return MSG_ReadChar() * (360.0/256);
+}
+
+float MSG_ReadAngle16 (void)
+{
+	return SHORT2ANGLE(MSG_ReadShort());
+}
+
+void MSG_ReadDir( vec3_t dir ) {
+	int		b;
+
+	b = MSG_ReadByte();
+	if( b < 0 || b >= NUMVERTEXNORMALS )
+		Com_Error( ERR_DROP, "MSG_ReadDir: out of range" );
+	VectorCopy( bytedirs[b], dir );
+}
+
+void MSG_ReadDeltaUsercmd( const usercmd_t *from, usercmd_t *to ) {
+	int bits;
+
+	if( from ) {
+		memcpy( to, from, sizeof( *to ) );
+	} else {
+		memset( to, 0, sizeof( *to ) );
+	}
+
+	bits = MSG_ReadByte();
+		
+// read current angles
+	if( bits & CM_ANGLE1 )
+		to->angles[0] = MSG_ReadShort();
+	if( bits & CM_ANGLE2 )
+		to->angles[1] = MSG_ReadShort();
+	if( bits & CM_ANGLE3 )
+		to->angles[2] = MSG_ReadShort();
+		
+// read movement
+	if( bits & CM_FORWARD )
+		to->forwardmove = MSG_ReadShort();
+	if( bits & CM_SIDE )
+		to->sidemove = MSG_ReadShort();
+	if( bits & CM_UP )
+		to->upmove = MSG_ReadShort();
+	
+// read buttons
+	if( bits & CM_BUTTONS )
+		to->buttons = MSG_ReadByte();
+
+	if( bits & CM_IMPULSE )
+		to->impulse = MSG_ReadByte();
+
+// read time to run command
+	to->msec = MSG_ReadByte();
+
+// read the light level
+	to->lightlevel = MSG_ReadByte();
+}
+
+int MSG_ReadBits( int bits ) {
+	int i, get, bitpos;
+	qboolean sgn;
+	int value;
+
+	if( bits == 0 || bits < -31 || bits > 32 ) {
+		Com_Error( ERR_FATAL, "MSG_ReadBits: bad bits: %d", bits );
+	}
+
+	bitpos = msg_read.bitpos;
+	if( ( bitpos & 7 ) == 0 ) {
+		// optimized case
+		switch( bits ) {
+		case -8:
+			value = MSG_ReadChar();
+			return value;
+		case 8:
+			value = MSG_ReadByte();
+			return value;
+		case -16:
+			value = MSG_ReadShort();
+			return value;
+		case 32:
+			value = MSG_ReadLong();
+			return value;
+		default:
+			break;
+		}
+	}
+
+	sgn = qfalse;
+	if( bits < 0 ) {
+		bits = -bits;
+		sgn = qtrue;
+	}
+
+	value = 0;
+	for( i = 0; i < bits; i++, bitpos++ ) {
+		get = ( msg_read.data[ bitpos >> 3 ] >> ( bitpos & 7 ) ) & 1;
+		value |= get << i;
+	}
+	msg_read.bitpos = bitpos;
+	msg_read.readcount = ( bitpos + 7 ) >> 3;
+
+	if( sgn ) {
+		if( value & ( 1 << ( bits - 1 ) ) ) {
+			value |= -1 ^ ( ( 1 << bits ) - 1 );
+		}
+	}
+
+	return value;
+}
+
+void MSG_ReadDeltaUsercmd_Enhanced( const usercmd_t *from, usercmd_t *to ) {
+	int bits;
+
+	if( from ) {
+		memcpy( to, from, sizeof( *to ) );
+	} else {
+		memset( to, 0, sizeof( *to ) );
+	}
+
+	if( !MSG_ReadBits( 1 ) ) {
+		return;
+	}
+
+	bits = MSG_ReadBits( 8 );
+		
+// read current angles
+	if( bits & CM_ANGLE1 ) {
+		if( MSG_ReadBits( 1 ) ) {
+			to->angles[0] += MSG_ReadBits( -8 );
+		} else {
+			to->angles[0] = MSG_ReadBits( -16 );
+		}
+	}
+	if( bits & CM_ANGLE2 ) {
+		if( MSG_ReadBits( 1 ) ) {
+			to->angles[1] += MSG_ReadBits( -8 );
+		} else {
+			to->angles[1] = MSG_ReadBits( -16 );
+		}
+	}
+	if( bits & CM_ANGLE3 ) {
+		to->angles[2] = MSG_ReadBits( -16 );
+	}
+		
+// read movement
+	if( bits & CM_FORWARD ) {
+		to->forwardmove = MSG_ReadBits( -16 );
+	}
+	if( bits & CM_SIDE ) {
+		to->sidemove = MSG_ReadBits( -16 );
+	}
+	if( bits & CM_UP ) {
+		to->upmove = MSG_ReadBits( -16 );
+	}
+	
+// read buttons
+	if( bits & CM_BUTTONS ) {
+		to->buttons = MSG_ReadBits( 8 );
+	}
+
+// read time to run command
+	if( bits & CM_IMPULSE ) {
+		to->msec = MSG_ReadBits( 8 );
+	}
+}
+
+
+void MSG_ReadData ( void *data, int len)
+{
+	int		i;
+
+	for (i=0 ; i<len ; i++)
+		((byte *)data)[i] = MSG_ReadByte ();
+}
+
+/*
+=================
+MSG_ParseEntityBits
+
+Returns the entity number and the header bits
+=================
+*/
+int MSG_ParseEntityBits( int *bits ) {
+	int     	b, total;
+	int			number;
+
+	total = MSG_ReadByte();
+	if( total & U_MOREBITS1 ) {
+		b = MSG_ReadByte(); 
+		total |= b<<8;
+	}
+	if( total & U_MOREBITS2 ) {
+		b = MSG_ReadByte();
+		total |= b<<16;
+	}
+	if( total & U_MOREBITS3 ) {
+		b = MSG_ReadByte();
+		total |= b<<24;
+	}
+
+	if( total & U_NUMBER16 )
+		number = MSG_ReadShort();
+	else
+		number = MSG_ReadByte();
+
+	*bits = total;
+
+	return number;
+}
+
+/*
+==================
+MSG_ParseDeltaEntity
+
+Can go from either a baseline or a previous packet_entity
+==================
+*/
+void MSG_ParseDeltaEntity( const entity_state_t *from, entity_state_t *to, int number, int bits ) {
+	if( !to ) {
+		Com_Error( ERR_DROP, "MSG_ParseDeltaEntity: NULL" );
+	}
+
+	if( number < 1 || number >= MAX_EDICTS ) {
+		Com_Error( ERR_DROP, "MSG_ParseDeltaEntity: bad entity number %i", number );
+	}
+
+	// set everything to the state we are delta'ing from
+	if( from ) {
+		memcpy( to, from, sizeof( *to ) );
+		VectorCopy( from->origin, to->old_origin );
+	} else {
+		memset( to, 0, sizeof( *to ) );
+		from = &nullEntityState;
+	}
+	
+	to->number = number;
+	to->event = 0;
+
+	if( !bits ) {
+		return;
+	}
+
+	if( bits & U_MODEL ) {
+		to->modelindex = MSG_ReadByte();
+	}
+	if( bits & U_MODEL2 ) {
+		to->modelindex2 = MSG_ReadByte();
+	}
+	if( bits & U_MODEL3 ) {
+		to->modelindex3 = MSG_ReadByte();
+	}
+	if( bits & U_MODEL4 ) {
+		to->modelindex4 = MSG_ReadByte();
+	}
+		
+	if( bits & U_FRAME8 )
+		to->frame = MSG_ReadByte();
+	if( bits & U_FRAME16 )
+		to->frame = MSG_ReadShort();
+
+	if( (bits & (U_SKIN8|U_SKIN16)) == (U_SKIN8|U_SKIN16) )		//used for laser colors
+		to->skinnum = MSG_ReadLong();
+	else if( bits & U_SKIN8 )
+		to->skinnum = MSG_ReadByte();
+	else if( bits & U_SKIN16 )
+		to->skinnum = MSG_ReadShort();
+
+	if( (bits & (U_EFFECTS8|U_EFFECTS16)) == (U_EFFECTS8|U_EFFECTS16) )
+		to->effects = MSG_ReadLong();
+	else if( bits & U_EFFECTS8 )
+		to->effects = MSG_ReadByte();
+	else if( bits & U_EFFECTS16 )
+		to->effects = MSG_ReadWord();//Short();
+
+	if( (bits & (U_RENDERFX8|U_RENDERFX16)) == (U_RENDERFX8|U_RENDERFX16) )
+		to->renderfx = MSG_ReadLong();
+	else if( bits & U_RENDERFX8 )
+		to->renderfx = MSG_ReadByte();
+	else if( bits & U_RENDERFX16 )
+		to->renderfx = MSG_ReadWord();//Short();
+
+	if( bits & U_ORIGIN1 ) {
+		to->origin[0] = MSG_ReadCoord();
+	}
+	if( bits & U_ORIGIN2 ) {
+		to->origin[1] = MSG_ReadCoord();
+	}
+	if( bits & U_ORIGIN3 ) {
+		to->origin[2] = MSG_ReadCoord();
+	}
+		
+	if( bits & U_ANGLE1 ) {
+		to->angles[0] = MSG_ReadAngle();
+	}
+	if( bits & U_ANGLE2 ) {
+		to->angles[1] = MSG_ReadAngle();
+	}
+	if( bits & U_ANGLE3 ) {
+		to->angles[2] = MSG_ReadAngle();
+	}
+
+	if( bits & U_OLDORIGIN ) {
+		MSG_ReadPos( to->old_origin );
+	}
+
+	if( bits & U_SOUND ) {
+		to->sound = MSG_ReadByte();
+	}
+
+	if( bits & U_EVENT ) {
+		to->event = MSG_ReadByte();
+	}
+
+	if( bits & U_SOLID ) {
+		to->solid = MSG_ReadWord();
+	}
+}
+
+/*
+===================
+MSG_ParseDeltaPlayerstate_Default
+===================
+*/
+void MSG_ParseDeltaPlayerstate_Default( const player_state_t *from, player_state_t *to, int flags ) {
+	int			i;
+	int			statbits;
+
+	if( !to ) {
+		Com_Error( ERR_DROP, "MSG_ParseDeltaPlayerstate_Default: NULL" );
+	}
+
+	// clear to old value before delta parsing
+	if( from ) {
+		memcpy( to, from, sizeof( *to ) );
+	} else {
+		memset( to, 0, sizeof( *to ) );
+	}
+
+	//
+	// parse the pmove_state_t
+	//
+	if( flags & PS_M_TYPE )
+		to->pmove.pm_type = MSG_ReadByte();
+
+	if( flags & PS_M_ORIGIN ) {
+		to->pmove.origin[0] = MSG_ReadShort();
+		to->pmove.origin[1] = MSG_ReadShort();
+		to->pmove.origin[2] = MSG_ReadShort();
+	}
+
+	if( flags & PS_M_VELOCITY ) {
+		to->pmove.velocity[0] = MSG_ReadShort();
+		to->pmove.velocity[1] = MSG_ReadShort();
+		to->pmove.velocity[2] = MSG_ReadShort();
+	}
+
+	if( flags & PS_M_TIME )
+		to->pmove.pm_time = MSG_ReadByte();
+
+	if( flags & PS_M_FLAGS )
+		to->pmove.pm_flags = MSG_ReadByte();
+
+	if( flags & PS_M_GRAVITY )
+		to->pmove.gravity = MSG_ReadShort();
+
+	if( flags & PS_M_DELTA_ANGLES ) {
+		to->pmove.delta_angles[0] = MSG_ReadShort();
+		to->pmove.delta_angles[1] = MSG_ReadShort();
+		to->pmove.delta_angles[2] = MSG_ReadShort();
+	}
+
+	//
+	// parse the rest of the player_state_t
+	//
+	if( flags & PS_VIEWOFFSET ) {
+		to->viewoffset[0] = MSG_ReadChar() * 0.25f;
+		to->viewoffset[1] = MSG_ReadChar() * 0.25f;
+		to->viewoffset[2] = MSG_ReadChar() * 0.25f;
+	}
+
+	if( flags & PS_VIEWANGLES ) {
+		to->viewangles[0] = MSG_ReadAngle16();
+		to->viewangles[1] = MSG_ReadAngle16();
+		to->viewangles[2] = MSG_ReadAngle16();
+	}
+
+	if( flags & PS_KICKANGLES ) {
+		to->kick_angles[0] = MSG_ReadChar() * 0.25f;
+		to->kick_angles[1] = MSG_ReadChar() * 0.25f;
+		to->kick_angles[2] = MSG_ReadChar() * 0.25f;
+	}
+
+	if( flags & PS_WEAPONINDEX ) {
+		to->gunindex = MSG_ReadByte();
+	}
+
+	if( flags & PS_WEAPONFRAME ) {
+		to->gunframe = MSG_ReadByte();
+		to->gunoffset[0] = MSG_ReadChar() * 0.25f;
+		to->gunoffset[1] = MSG_ReadChar() * 0.25f;
+		to->gunoffset[2] = MSG_ReadChar() * 0.25f;
+		to->gunangles[0] = MSG_ReadChar() * 0.25f;
+		to->gunangles[1] = MSG_ReadChar() * 0.25f;
+		to->gunangles[2] = MSG_ReadChar() * 0.25f;
+	}
+
+	if( flags & PS_BLEND ) {
+		to->blend[0] = MSG_ReadByte() / 255.0f;
+		to->blend[1] = MSG_ReadByte() / 255.0f;
+		to->blend[2] = MSG_ReadByte() / 255.0f;
+		to->blend[3] = MSG_ReadByte() / 255.0f;
+	}
+
+	if( flags & PS_FOV )
+		to->fov = MSG_ReadByte();
+
+	if( flags & PS_RDFLAGS )
+		to->rdflags = MSG_ReadByte();
+
+	// parse stats
+	statbits = MSG_ReadLong();
+	for( i = 0; i < MAX_STATS; i++ )
+		if( statbits & ( 1 << i ) )
+			to->stats[i] = MSG_ReadShort();
+}
+
+
+/*
+===================
+MSG_ParseDeltaPlayerstate_Default
+===================
+*/
+void MSG_ParseDeltaPlayerstate_Enhanced(    const player_state_t    *from,
+                                                  player_state_t    *to,
+                                                  int               flags,
+                                                  int               extraflags )
+{
+	int			i;
+	int			statbits;
+
+	if( !to ) {
+		Com_Error( ERR_DROP, "MSG_ParseDeltaPlayerstate_Enhanced: NULL" );
+	}
+
+	// clear to old value before delta parsing
+	if( from ) {
+		memcpy( to, from, sizeof( *to ) );
+	} else {
+		memset( to, 0, sizeof( *to ) );
+	}
+
+	//
+	// parse the pmove_state_t
+	//
+	if( flags & PS_M_TYPE )
+		to->pmove.pm_type = MSG_ReadByte();
+
+	if( flags & PS_M_ORIGIN ) {
+		to->pmove.origin[0] = MSG_ReadShort();
+		to->pmove.origin[1] = MSG_ReadShort();
+	}
+
+	if( extraflags & EPS_M_ORIGIN2 ) {
+		to->pmove.origin[2] = MSG_ReadShort();
+	}
+
+	if( flags & PS_M_VELOCITY ) {
+		to->pmove.velocity[0] = MSG_ReadShort();
+		to->pmove.velocity[1] = MSG_ReadShort();
+	}
+
+	if( extraflags & EPS_M_VELOCITY2 ) {
+		to->pmove.velocity[2] = MSG_ReadShort();
+	}
+
+	if( flags & PS_M_TIME )
+		to->pmove.pm_time = MSG_ReadByte();
+
+	if( flags & PS_M_FLAGS )
+		to->pmove.pm_flags = MSG_ReadByte();
+
+	if( flags & PS_M_GRAVITY )
+		to->pmove.gravity = MSG_ReadShort();
+
+	if( flags & PS_M_DELTA_ANGLES ) {
+		to->pmove.delta_angles[0] = MSG_ReadShort();
+		to->pmove.delta_angles[1] = MSG_ReadShort();
+		to->pmove.delta_angles[2] = MSG_ReadShort();
+	}
+
+	//
+	// parse the rest of the player_state_t
+	//
+	if( flags & PS_VIEWOFFSET ) {
+		to->viewoffset[0] = MSG_ReadChar() * 0.25f;
+		to->viewoffset[1] = MSG_ReadChar() * 0.25f;
+		to->viewoffset[2] = MSG_ReadChar() * 0.25f;
+	}
+
+	if( flags & PS_VIEWANGLES ) {
+		to->viewangles[0] = MSG_ReadAngle16();
+		to->viewangles[1] = MSG_ReadAngle16();
+	}
+
+	if( extraflags & EPS_VIEWANGLE2 ) {
+		to->viewangles[2] = MSG_ReadAngle16();
+	}
+
+	if( flags & PS_KICKANGLES ) {
+		to->kick_angles[0] = MSG_ReadChar() * 0.25f;
+		to->kick_angles[1] = MSG_ReadChar() * 0.25f;
+		to->kick_angles[2] = MSG_ReadChar() * 0.25f;
+	}
+
+	if( flags & PS_WEAPONINDEX ) {
+		to->gunindex = MSG_ReadByte();
+	}
+
+	if( flags & PS_WEAPONFRAME ) {
+		to->gunframe = MSG_ReadByte();
+	}
+
+	if( extraflags & EPS_GUNOFFSET ) {
+		to->gunoffset[0] = MSG_ReadChar() * 0.25f;
+		to->gunoffset[1] = MSG_ReadChar() * 0.25f;
+		to->gunoffset[2] = MSG_ReadChar() * 0.25f;
+	}
+
+	if( extraflags & EPS_GUNANGLES ) {
+		to->gunangles[0] = MSG_ReadChar() * 0.25f;
+		to->gunangles[1] = MSG_ReadChar() * 0.25f;
+		to->gunangles[2] = MSG_ReadChar() * 0.25f;
+	}
+
+	if( flags & PS_BLEND ) {
+		to->blend[0] = MSG_ReadByte() / 255.0f;
+		to->blend[1] = MSG_ReadByte() / 255.0f;
+		to->blend[2] = MSG_ReadByte() / 255.0f;
+		to->blend[3] = MSG_ReadByte() / 255.0f;
+	}
+
+	if( flags & PS_FOV )
+		to->fov = MSG_ReadByte();
+
+	if( flags & PS_RDFLAGS )
+		to->rdflags = MSG_ReadByte();
+
+	// parse stats
+	if( extraflags & EPS_STATS ) {
+		statbits = MSG_ReadLong();
+		for( i = 0; i < MAX_STATS; i++ ) {
+			if( statbits & ( 1 << i ) ) {
+				to->stats[i] = MSG_ReadShort();
+			}
+		}
+	}
+	
+}
+
+/*
+===================
+MSG_ParseDeltaPlayerstate_Packet
+===================
+*/
+void MSG_ParseDeltaPlayerstate_Packet( const player_state_t *from, player_state_t *to, int flags ) {
+	int			i;
+	int			statbits;
+
+	if( !to ) {
+		Com_Error( ERR_DROP, "MSG_ParseDeltaPlayerstate_Packet: NULL" );
+	}
+
+	// clear to old value before delta parsing
+	if( from ) {
+		memcpy( to, from, sizeof( *to ) );
+	} else {
+		memset( to, 0, sizeof( *to ) );
+	}
+
+	//
+	// parse the pmove_state_t
+	//
+	if( flags & PPS_M_TYPE )
+		to->pmove.pm_type = MSG_ReadByte();
+
+	if( flags & PPS_M_ORIGIN ) {
+		to->pmove.origin[0] = MSG_ReadShort();
+		to->pmove.origin[1] = MSG_ReadShort();
+	}
+
+	if( flags & PPS_M_ORIGIN2 ) {
+		to->pmove.origin[2] = MSG_ReadShort();
+	}
+
+	//
+	// parse the rest of the player_state_t
+	//
+	if( flags & PPS_VIEWOFFSET ) {
+		to->viewoffset[0] = MSG_ReadChar() * 0.25f;
+		to->viewoffset[1] = MSG_ReadChar() * 0.25f;
+		to->viewoffset[2] = MSG_ReadChar() * 0.25f;
+	}
+
+	if( flags & PPS_VIEWANGLES ) {
+		to->viewangles[0] = MSG_ReadAngle16();
+		to->viewangles[1] = MSG_ReadAngle16();
+	}
+
+	if( flags & PPS_VIEWANGLE2 ) {
+		to->viewangles[2] = MSG_ReadAngle16();
+	}
+
+	if( flags & PPS_KICKANGLES ) {
+		to->kick_angles[0] = MSG_ReadChar() * 0.25f;
+		to->kick_angles[1] = MSG_ReadChar() * 0.25f;
+		to->kick_angles[2] = MSG_ReadChar() * 0.25f;
+	}
+
+	if( flags & PPS_WEAPONINDEX ) {
+		to->gunindex = MSG_ReadByte();
+	}
+
+	if( flags & PPS_WEAPONFRAME ) {
+		to->gunframe = MSG_ReadByte();
+	}
+
+	if( flags & PPS_GUNOFFSET ) {
+		to->gunoffset[0] = MSG_ReadChar() * 0.25f;
+		to->gunoffset[1] = MSG_ReadChar() * 0.25f;
+		to->gunoffset[2] = MSG_ReadChar() * 0.25f;
+	}
+
+	if( flags & PPS_GUNANGLES ) {
+		to->gunangles[0] = MSG_ReadChar() * 0.25f;
+		to->gunangles[1] = MSG_ReadChar() * 0.25f;
+		to->gunangles[2] = MSG_ReadChar() * 0.25f;
+	}
+
+	if( flags & PPS_BLEND ) {
+		to->blend[0] = MSG_ReadByte() / 255.0f;
+		to->blend[1] = MSG_ReadByte() / 255.0f;
+		to->blend[2] = MSG_ReadByte() / 255.0f;
+		to->blend[3] = MSG_ReadByte() / 255.0f;
+	}
+
+	if( flags & PPS_FOV )
+		to->fov = MSG_ReadByte();
+
+	if( flags & PPS_RDFLAGS )
+		to->rdflags = MSG_ReadByte();
+
+	// parse stats
+	if( flags & PPS_STATS ) {
+		statbits = MSG_ReadLong();
+		for( i = 0; i < MAX_STATS; i++ ) {
+			if( statbits & ( 1 << i ) ) {
+				to->stats[i] = MSG_ReadShort();
+			}
+		}
+	}
+	
+}
+
+#define SHOWBITS( data ) \
+	do { Com_Printf( "%s ", data ); } while( 0 )
+
+void MSG_ShowDeltaEntityBits( int bits ) {
+	if( bits & U_MODEL ) {
+		SHOWBITS( "modelindex" );
+	}
+	if( bits & U_MODEL2 ) {
+		SHOWBITS( "modelindex2" );
+	}
+	if( bits & U_MODEL3 ) {
+		SHOWBITS( "modelindex3" );
+	}
+	if( bits & U_MODEL4 ) {
+		SHOWBITS( "modelindex4" );
+	}
+
+	if( bits & U_FRAME8 )
+		SHOWBITS( "frame8" );
+	if( bits & U_FRAME16 )
+		SHOWBITS( "frame16" );
+
+	if( ( bits & ( U_SKIN8 | U_SKIN16 ) ) == ( U_SKIN8 | U_SKIN16 ) )
+		SHOWBITS( "skinnum32" );
+	else if( bits & U_SKIN8 )
+		SHOWBITS( "skinnum8" );
+	else if( bits & U_SKIN16 )
+		SHOWBITS( "skinnum16" );
+
+	if( ( bits & ( U_EFFECTS8 | U_EFFECTS16 ) ) == ( U_EFFECTS8 | U_EFFECTS16 ) )
+		SHOWBITS( "effects32" );
+	else if( bits & U_EFFECTS8 )
+		SHOWBITS( "effects8" );
+	else if( bits & U_EFFECTS16 )
+		SHOWBITS( "effects16" );
+
+	if( ( bits & ( U_RENDERFX8 | U_RENDERFX16 ) ) == ( U_RENDERFX8 | U_RENDERFX16 ) )
+		SHOWBITS( "renderfx32" );
+	else if( bits & U_RENDERFX8 )
+		SHOWBITS( "renderfx8" );
+	else if( bits & U_RENDERFX16 )
+		SHOWBITS( "renderfx16" );
+
+	if( bits & U_ORIGIN1 ) {
+		SHOWBITS( "origin[0]" );
+	}
+	if( bits & U_ORIGIN2 ) {
+		SHOWBITS( "origin[1]" );
+	}
+	if( bits & U_ORIGIN3 ) {
+		SHOWBITS( "origin[2]" );
+	}
+		
+	if( bits & U_ANGLE1 ) {
+		SHOWBITS( "angles[0]" );
+	}
+	if( bits & U_ANGLE2 ) {
+		SHOWBITS( "angles[2]" );
+	}
+	if( bits & U_ANGLE3 ) {
+		SHOWBITS( "angles[3]" );
+	}
+
+	if( bits & U_OLDORIGIN ) {
+		SHOWBITS( "old_origin" );
+	}
+
+	if( bits & U_SOUND ) {
+		SHOWBITS( "sound" );
+	}
+
+	if( bits & U_EVENT ) {
+		SHOWBITS( "event" );
+	}
+
+	if( bits & U_SOLID ) {
+		SHOWBITS( "solid" );
+	}
+
+}
+
+void MSG_ShowDeltaPlayerstateBits_Default( int flags ) {
+	if( flags & PS_M_TYPE ) {
+		SHOWBITS( "pmove.pm_type" );
+	}
+
+	if( flags & PS_M_ORIGIN ) {
+		SHOWBITS( "pmove.origin" );
+	}
+
+	if( flags & PS_M_VELOCITY ) {
+		SHOWBITS( "pmove.velocity" );
+	}
+
+	if( flags & PS_M_TIME ) {
+		SHOWBITS( "pmove.pm_time" );
+	}
+
+	if( flags & PS_M_FLAGS ) {
+		SHOWBITS( "pmove.pm_flags" );
+	}
+
+	if( flags & PS_M_GRAVITY ) {
+		SHOWBITS( "pmove.gravity" );
+	}
+
+	if( flags & PS_M_DELTA_ANGLES ) {
+		SHOWBITS( "pmove.delta_angles" );
+	}
+
+	if( flags & PS_VIEWOFFSET ) {
+		SHOWBITS( "viewoffset" );
+	}
+
+	if( flags & PS_VIEWANGLES ) {
+		SHOWBITS( "viewangles" );
+	}
+
+	if( flags & PS_KICKANGLES ) {
+		SHOWBITS( "kick_angles" );
+	}
+
+	if( flags & PS_WEAPONINDEX ) {
+		SHOWBITS( "gunindex" );
+	}
+
+	if( flags & PS_WEAPONFRAME ) {
+		SHOWBITS( "gunframe" );
+	}
+
+	if( flags & PS_BLEND ) {
+		SHOWBITS( "blend" );
+	}
+
+	if( flags & PS_FOV ) {
+		SHOWBITS( "fov" );
+	}
+
+	if( flags & PS_RDFLAGS ) {
+		SHOWBITS( "rdflags" );
+	}
+	
+}
+
+void MSG_ShowDeltaPlayerstateBits_Enhanced( int flags ) {
+	int extraflags;
+
+	extraflags = flags >> PS_BITS;
+	flags &= PS_MASK;
+
+	if( flags & PS_M_TYPE ) {
+		SHOWBITS( "pmove.pm_type" );
+	}
+
+	if( flags & PS_M_ORIGIN ) {
+		SHOWBITS( "pmove.origin[0,1]" );
+	}
+
+	if( extraflags & EPS_M_ORIGIN2 ) {
+		SHOWBITS( "pmove.origin[2]" );
+	}
+
+	if( flags & PS_M_VELOCITY ) {
+		SHOWBITS( "pmove.velocity[0,1]" );
+	}
+
+	if( extraflags & EPS_M_VELOCITY2 ) {
+		SHOWBITS( "pmove.velocity[2]" );
+	}
+
+	if( flags & PS_M_TIME ) {
+		SHOWBITS( "pmove.pm_time" );
+	}
+
+	if( flags & PS_M_FLAGS ) {
+		SHOWBITS( "pmove.pm_flags" );
+	}
+
+	if( flags & PS_M_GRAVITY ) {
+		SHOWBITS( "pmove.gravity" );
+	}
+
+	if( flags & PS_M_DELTA_ANGLES ) {
+		SHOWBITS( "pmove.delta_angles" );
+	}
+
+	if( flags & PS_VIEWOFFSET ) {
+		SHOWBITS( "viewoffset" );
+	}
+
+	if( flags & PS_VIEWANGLES ) {
+		SHOWBITS( "viewangles[0,1]" );
+	}
+
+	if( extraflags & EPS_VIEWANGLE2 ) {
+		SHOWBITS( "viewangles[2]" );
+	}
+
+	if( flags & PS_KICKANGLES ) {
+		SHOWBITS( "kick_angles" );
+	}
+
+	if( flags & PS_WEAPONINDEX ) {
+		SHOWBITS( "gunindex" );
+	}
+
+	if( flags & PS_WEAPONFRAME ) {
+		SHOWBITS( "gunframe" );
+	}
+
+	if( extraflags & EPS_GUNOFFSET ) {
+		SHOWBITS( "gunoffset" );
+	}
+
+	if( extraflags & EPS_GUNANGLES ) {
+		SHOWBITS( "gunangles" );
+	}
+
+	if( flags & PS_BLEND ) {
+		SHOWBITS( "blend" );
+	}
+
+	if( flags & PS_FOV ) {
+		SHOWBITS( "fov" );
+	}
+
+	if( flags & PS_RDFLAGS ) {
+		SHOWBITS( "rdflags" );
+	}
+
+	if( extraflags & EPS_STATS ) {
+		SHOWBITS( "stats" );
+	}
+}
+
+void MSG_ShowDeltaPlayerstateBits_Packet( int flags ) {
+	if( flags & PPS_M_TYPE ) {
+		SHOWBITS( "pmove.pm_type" );
+	}
+
+	if( flags & PPS_M_ORIGIN ) {
+		SHOWBITS( "pmove.origin[0,1]" );
+	}
+
+	if( flags & PPS_M_ORIGIN2 ) {
+		SHOWBITS( "pmove.origin[2]" );
+	}
+
+	if( flags & PPS_VIEWOFFSET ) {
+		SHOWBITS( "viewoffset" );
+	}
+
+	if( flags & PPS_VIEWANGLES ) {
+		SHOWBITS( "viewangles[0,1]" );
+	}
+
+	if( flags & PPS_VIEWANGLE2 ) {
+		SHOWBITS( "viewangles[2]" );
+	}
+
+	if( flags & PPS_KICKANGLES ) {
+		SHOWBITS( "kick_angles" );
+	}
+
+	if( flags & PPS_WEAPONINDEX ) {
+		SHOWBITS( "gunindex" );
+	}
+
+	if( flags & PPS_WEAPONFRAME ) {
+		SHOWBITS( "gunframe" );
+	}
+
+	if( flags & PPS_GUNOFFSET ) {
+		SHOWBITS( "gunoffset" );
+	}
+
+	if( flags & PPS_GUNANGLES ) {
+		SHOWBITS( "gunangles" );
+	}
+
+	if( flags & PPS_BLEND ) {
+		SHOWBITS( "blend" );
+	}
+
+	if( flags & PPS_FOV ) {
+		SHOWBITS( "fov" );
+	}
+
+	if( flags & PPS_RDFLAGS ) {
+		SHOWBITS( "rdflags" );
+	}
+
+	if( flags & PPS_STATS ) {
+		SHOWBITS( "stats" );
+	}
+}
+
+void MSG_ShowDeltaUsercmdBits_Enhanced( int bits ) {
+	if( !bits ) {
+		SHOWBITS( "<none>" );
+		return;
+	}
+	if( bits & CM_ANGLE1 )
+		SHOWBITS( "angle1" );
+	if( bits & CM_ANGLE2 )
+		SHOWBITS( "angle2" );
+	if( bits & CM_ANGLE3 )
+		SHOWBITS( "angle3" );
+	
+	if( bits & CM_FORWARD )
+		SHOWBITS( "forward" );
+	if( bits & CM_SIDE )
+	  	SHOWBITS( "side" );
+	if( bits & CM_UP )
+		SHOWBITS( "up" );
+
+ 	if( bits & CM_BUTTONS )
+	  	SHOWBITS( "buttons" );
+ 	if( bits & CM_IMPULSE )
+	    SHOWBITS( "msec" );
+}
+
+static const char *const svc_strings[svc_num_types] = {
+	"svc_bad",
+
+	// these ops are known to the game dll
+	"svc_muzzleflash",
+	"svc_muzzleflash2",
+	"svc_temp_entity",
+	"svc_layout",
+	"svc_inventory",
+
+	// the rest are private to the client and server
+	"svc_nop",
+	"svc_disconnect",
+	"svc_reconnect",
+	"svc_sound",
+	"svc_print",
+	"svc_stufftext",
+	"svc_serverdata",
+	"svc_configstring",
+	"svc_spawnbaseline",
+	"svc_centerprint",
+	"svc_download",
+	"svc_playerinfo",
+	"svc_packetentities",
+	"svc_deltapacketentities",
+	"svc_frame",
+
+	// r1q2 specific operations
+	"svc_zpacket",
+	"svc_zdownload",
+
+    // q2pro specific operations
+    "svc_gamestate"
+};
+
+const char *MSG_ServerCommandString( int cmd ) {
+    const char *s;
+
+    if( cmd == -1 ) {
+        s = "END OF MESSAGE";
+    } else if( cmd >= 0 && cmd < svc_num_types ) {
+        s = svc_strings[cmd];
+    } else {
+		s = "UNKNOWN COMMAND";
+	}
+
+    return s;
+}
+
+//===========================================================================
+
+void SZ_Init( sizebuf_t *buf, void *data, int length ) {
+	memset( buf, 0, sizeof( *buf ) );
+	buf->data = data;
+	buf->maxsize = length;
+	buf->allowoverflow = qtrue;
+}
+
+void SZ_Clear( sizebuf_t *buf ) {
+	buf->cursize = 0;
+	buf->readcount = 0;
+	buf->bitpos = 0;
+	buf->overflowed = qfalse;
+}
+
+void *SZ_GetSpace( sizebuf_t *buf, int length ) {
+	void	*data;
+	
+	if( buf->cursize + length > buf->maxsize ) {
+		if( !buf->allowoverflow ) {
+			Com_Error( ERR_FATAL, "SZ_GetSpace: overflow without allowoverflow set" );
+		}
+		if( length > buf->maxsize ) {
+			Com_Error( ERR_FATAL, "SZ_GetSpace: %i is > full buffer size", length );
+		}
+			
+		Com_DPrintf( "SZ_GetSpace: overflow\n" );
+		SZ_Clear( buf ); 
+		buf->overflowed = qtrue;
+	}
+
+	data = buf->data + buf->cursize;
+	buf->cursize += length;
+	buf->bitpos = buf->cursize << 3;
+	
+	return data;
+}
+
+void SZ_Write( sizebuf_t *buf, const void *data, int length ) {
+	memcpy( SZ_GetSpace( buf, length ), data, length );		
+}
+
+void SZ_WriteByte( sizebuf_t *sb, int c ) {
+	byte	*buf;
+
+	buf = SZ_GetSpace( sb, 1 );
+	buf[0] = c;
+}
+
+void SZ_WriteShort( sizebuf_t *sb, int c ) {
+	byte	*buf;
+
+	buf = SZ_GetSpace( sb, 2 );
+	buf[0] = c & 0xff;
+	buf[1] = c >> 8;
+}
+
+void SZ_WriteLong( sizebuf_t *sb, int c ) {
+	byte	*buf;
+	
+	buf = SZ_GetSpace( sb, 4 );
+	buf[0] = c & 0xff;
+	buf[1] = ( c >> 8 ) & 0xff;
+	buf[2] = ( c >> 16 ) & 0xff;
+	buf[3] = c >> 24;
+}
+
+void SZ_WritePos( sizebuf_t *sb, const vec3_t pos ) {
+	SZ_WriteShort( sb, ( int )( pos[0] * 8 ) );
+	SZ_WriteShort( sb, ( int )( pos[1] * 8 ) );
+	SZ_WriteShort( sb, ( int )( pos[2] * 8 ) );
+}
+
+void SZ_WriteExactPos( sizebuf_t *sb, const vec3_t pos ) {
+	SZ_WriteLong( sb, *( int * )&pos[0] );
+	SZ_WriteLong( sb, *( int * )&pos[1] );
+	SZ_WriteLong( sb, *( int * )&pos[2] );
+}
+
+void SZ_WriteString( sizebuf_t *sb, const char *string ) {
+	int length;
+	int c;
+
+	if( !string ) {
+		SZ_WriteByte( sb, 0 );
+		return;
+	}
+
+	length = strlen( string );
+	if( length > MAX_NET_STRING - 1 ) {
+		Com_WPrintf( "SZ_WriteString: overflow: %d chars", length );
+		SZ_WriteByte( sb, 0 );
+		return;
+	}
+
+	while( *string ) {
+		c = *string++;
+		if( c == '\xFF' ) {
+			c = '.';
+		}
+		SZ_WriteByte( sb, c );
+	}
+
+	SZ_WriteByte( sb, 0 );
+}
+
+
+
+