Net code refactoring

4 files changed, 389 insertions, 983 deletions

diff --git a/inc/common/protocol.h b/inc/common/protocol.h
index 6ab42fc..a2c3bb6 100644
--- a/inc/common/protocol.h
+++ b/inc/common/protocol.h
@@ -221,17 +221,18 @@ typedef enum {
 #define PS_MASK             ((1<<PS_BITS)-1)
 
 // r1q2 protocol specific extra flags
-#define EPS_GUNOFFSET       (1<<0)
-#define EPS_GUNANGLES       (1<<1)
-#define EPS_M_VELOCITY2     (1<<2)
-#define EPS_M_ORIGIN2       (1<<3)
-#define EPS_VIEWANGLE2      (1<<4)
-#define EPS_STATS           (1<<5)
+#define EPS_GUNOFFSET       (1<<16)
+#define EPS_GUNANGLES       (1<<17)
+#define EPS_M_VELOCITY2     (1<<18)
+#define EPS_M_ORIGIN2       (1<<19)
+#define EPS_VIEWANGLE2      (1<<20)
+#define EPS_STATS           (1<<21)
 
 // q2pro protocol specific extra flags
-#define EPS_CLIENTNUM       (1<<6)
+#define EPS_CLIENTNUM       (1<<22)
 
-#define EPS_BITS            7
+#define EPS_OFFSET          16
+#define EPS_BITS            23
 #define EPS_MASK            ((1<<EPS_BITS)-1)
 
 //==============================================
diff --git a/src/client/parse.c b/src/client/parse.c
index ce77b2b..f622e42 100644
--- a/src/client/parse.c
+++ b/src/client/parse.c
@@ -320,7 +320,7 @@ static void CL_ParseFrame(int extrabits)
 #endif
         if (cls.serverProtocol == PROTOCOL_VERSION_Q2PRO) {
             // parse clientNum
-            if (extraflags & EPS_CLIENTNUM) {
+            if ((extraflags << EPS_OFFSET) & EPS_CLIENTNUM) {
                 frame.clientNum = MSG_ReadByte();
             } else if (oldframe) {
                 frame.clientNum = oldframe->clientNum;
diff --git a/src/common/msg.c b/src/common/msg.c
index c7cfc1e..b681c27 100644
--- a/src/common/msg.c
+++ b/src/common/msg.c
@@ -211,11 +211,201 @@ MSG_WriteAngle
 #define ANGLE2BYTE(x)   ((int)((x)*256.0f/360)&255)
 #define BYTE2ANGLE(x)   ((x)*(360.0f/256))
 
+#define	U8_ANGLE	(360.0/256)
+#define	S16_ANGLE	(360.0/65536)
+
+#define	S16_COORD	(1.0f/8)
+
 void MSG_WriteAngle(float f)
 {
     MSG_WriteByte(ANGLE2BYTE(f));
 }
 
+#define MSG_WriteU8(_c)		MSG_WriteByte(_c)
+#define MSG_WriteU16(_c)	MSG_WriteShort(_c)
+
+#define MSG_WriteS8(_c)		MSG_WriteChar(_c)
+#define MSG_WriteS16(_c)	MSG_WriteShort(_c)
+#define MSG_WriteS32(_c)	MSG_WriteLong(_c)
+
+#define MSG_ReadU8()		MSG_ReadByte()
+#define MSG_ReadU16()		MSG_ReadWord()
+
+#define MSG_ReadS8()		MSG_ReadChar()
+#define MSG_ReadS16()		MSG_ReadShort()
+#define MSG_ReadS32()		MSG_ReadLong()
+
+#define var_field_len(_mask)						\
+	(((bits & (_mask##8)) != 0) | (((bits & (_mask##16)) != 0) << 1))
+
+/* input macros: */
+
+#define read_varia(_field, _mask)					\
+do {									\
+    switch (var_field_len(_mask)) {					\
+    case 1:								\
+	to->_field = MSG_ReadByte();					\
+	break;								\
+    case 2:								\
+	to->_field = MSG_ReadShort();					\
+	break;								\
+    case 3:								\
+	to->_field = MSG_ReadLong();					\
+	break;								\
+    }									\
+} while (0)
+
+#define __read_field(_field, _type, _scale)				\
+do {									\
+    if (_scale)								\
+	to->_field = MSG_Read##_type() * (_scale);			\
+    else								\
+	to->_field = MSG_Read##_type();					\
+} while (0)
+
+#define read_field(_field, _mask, _type, _scale)			\
+do {									\
+    if (bits & _mask)							\
+	__read_field(_field, _type, _scale);				\
+} while (0)
+
+#define read_array(_field, _mask, _type, _scale, _nr)			\
+do {									\
+    if (bits & _mask)							\
+	for (unsigned _i = 0; _i < (_nr); _i++)				\
+	    __read_field(_field[_i], _type, _scale);			\
+} while (0)
+
+/* output macros: */
+
+#define write_field(_field, _mask, _type, _scale)			\
+do {									\
+    if (bits & _mask)							\
+	MSG_Write##_type(to->_field);					\
+} while (0)
+
+#define write_varia(_field, _mask)					\
+do {									\
+    switch (var_field_len(_mask)) {					\
+    case 1:								\
+	MSG_WriteByte(to->_field);					\
+	break;								\
+    case 2:								\
+	MSG_WriteShort(to->_field);					\
+	break;								\
+    case 3:								\
+	MSG_WriteLong(to->_field);					\
+	break;								\
+    }									\
+} while (0)
+
+#define write_array(_field, _mask, _type, _scale, _nr)			\
+do {									\
+    if (bits & _mask)							\
+	for (unsigned _i = 0; _i < (_nr); _i++)				\
+	    MSG_Write##_type(to->_field[_i]);				\
+} while (0)
+
+/* diff macros: */
+
+#define diff_field(_field, _mask, _type, _scale)			\
+do {									\
+    if (to->_field != from->_field)					\
+	bits |= _mask;							\
+} while (0)
+
+#define diff_varia(_field, _mask)					\
+do {									\
+    if (to->_field != from->_field) {					\
+        if (sizeof(to->_field) > 2 && to->_field & mask)		\
+            bits |= _mask##8 | _mask##16;				\
+        else if (to->_field & 0x0000ff00)				\
+            bits |= _mask##16;						\
+        else								\
+            bits |= _mask##8;						\
+    }									\
+} while (0)
+
+#define diff_array(_field, _mask, _type, _scale, _nr)			\
+do {									\
+    for (unsigned _i = 0; _i < (_nr); _i++)				\
+	if (to->_field[_i] != from->_field[_i])				\
+	    bits |= _mask;						\
+} while (0)
+
+/* pack macros: */
+
+#define pack_field(_field, _mask, _type, _scale)			\
+do {									\
+    if (_scale)								\
+	out->_field = in->_field * (1 / ((_scale) ?: 1));		\
+    else								\
+	out->_field = in->_field;					\
+} while (0)
+
+#define pack_array(_field, _mask, _type, _scale, _nr)			\
+do {									\
+    for (unsigned _i = 0; _i < (_nr); _i++)				\
+	pack_field(_field[_i], _mask, _type, _scale);			\
+} while (0)
+
+#define PLAYERSTATE_DEFAULT()						    \
+    _field(pmove.pm_type,	PS_M_TYPE,		U8,  0);	    \
+    _array(pmove.origin,	PS_M_ORIGIN,		S16, 0,		3); \
+    _array(pmove.velocity,	PS_M_VELOCITY,		S16, 0,		3); \
+    _field(pmove.pm_time,	PS_M_TIME,		U8,  0);	    \
+    _field(pmove.pm_flags,	PS_M_FLAGS,		U8,  0);	    \
+    _field(pmove.gravity,	PS_M_GRAVITY,		S16, 0);	    \
+    _array(pmove.delta_angles,	PS_M_DELTA_ANGLES,	S16, 0,		3); \
+    _array(viewoffset,		PS_VIEWOFFSET,		S8,  0.25f,	3); \
+    _array(viewangles,		PS_VIEWANGLES,		S16, S16_ANGLE, 3); \
+    _array(kick_angles,		PS_KICKANGLES,		S8,  0.25f,	3); \
+    _field(gunindex,		PS_WEAPONINDEX,		U8,  0);	    \
+    _field(gunindex,		PS_WEAPONFRAME,		U8,  0);	    \
+    _array(gunoffset,		PS_WEAPONFRAME,		S8,  0.25f,	3); \
+    _array(gunangles,		PS_WEAPONFRAME,		S8,  0.25f,	3); \
+    _array(blend,		PS_BLEND,		U8, (1 / 255.0f), 4);\
+    _field(fov,			PS_FOV,			U8,  0);	    \
+    _field(rdflags,		PS_RDFLAGS,		U8,  0)
+
+#define PLAYERSTATE_ENHANCED()						    \
+    _field(pmove.pm_type,	PS_M_TYPE,		U8,  0);	    \
+    _array(pmove.origin,	PS_M_ORIGIN,		S16, 0, 2);	    \
+    _field(pmove.origin[2],	EPS_M_ORIGIN2,		S16, 0);	    \
+    _array(pmove.velocity,	PS_M_VELOCITY,		S16, 0, 2);	    \
+    _field(pmove.velocity[2],	EPS_M_VELOCITY2,	S16, 0);	    \
+    _field(pmove.pm_time,	PS_M_TIME,		U8,  0);	    \
+    _field(pmove.pm_flags,	PS_M_FLAGS,		U8,  0);	    \
+    _field(pmove.gravity,	PS_M_GRAVITY,		S16, 0);	    \
+    _array(pmove.delta_angles,	PS_M_DELTA_ANGLES,	S16, 0, 3);	    \
+    _array(viewoffset,		PS_VIEWOFFSET,		S8,  0.25f,	3); \
+    _array(viewangles,		PS_VIEWANGLES,		S16, S16_ANGLE,	2); \
+    _field(viewangles[2],	EPS_VIEWANGLE2,		S16, S16_ANGLE);    \
+    _array(kick_angles,		PS_KICKANGLES,		S8,  0.25f,	3); \
+    _field(gunindex,		PS_WEAPONINDEX,		U8,  0);	    \
+    _field(gunframe,		PS_WEAPONFRAME,		U8,  0);	    \
+    _array(gunoffset,		EPS_GUNOFFSET,		S8,  0.25f,	3); \
+    _array(gunangles,		EPS_GUNANGLES,		S8,  0.25f,	3); \
+    _array(blend,		PS_BLEND,		U8, (1 / 255.0f), 4);\
+    _field(fov,			PS_FOV,			U8,  0);	    \
+    _field(rdflags,		PS_RDFLAGS,		U8,  0)
+
+#define PLAYERSTATE_PACKET()						    \
+    _field(pmove.pm_type,	PPS_M_TYPE,		U8,  0);	    \
+    _array(pmove.origin,	PPS_M_ORIGIN,		S16, 0, 2);	    \
+    _field(pmove.origin[2],	PPS_M_ORIGIN2,		S16, 0);	    \
+    _array(viewoffset,		PPS_VIEWOFFSET,		S8,  0.25f, 3);	    \
+    _array(viewangles,		PPS_VIEWANGLES,		S16, S16_ANGLE, 2); \
+    _field(viewangles[2],	PPS_VIEWANGLE2,		S16, S16_ANGLE);    \
+    _array(kick_angles,		PPS_KICKANGLES,		S8,  0.25f, 3);	    \
+    _field(gunindex,		PPS_WEAPONINDEX,	U8,  0);	    \
+    _field(gunframe,		PPS_WEAPONFRAME,	U8,  0);	    \
+    _array(gunoffset,		PPS_GUNOFFSET,		S8,  0.25f, 3);	    \
+    _array(gunangles,		PPS_GUNANGLES,		S8,  0.25f, 3);	    \
+    _array(blend,		PPS_BLEND,		U8, (1 / 255.0f), 4);\
+    _field(fov,			PPS_FOV,		U8,  0);	    \
+    _field(rdflags,		PPS_RDFLAGS,		U8,  0);	    \
+
 #if USE_CLIENT
 
 /*
@@ -508,6 +698,11 @@ void MSG_WriteDeltaEntity(const entity_packed_t *from,
 {
     uint32_t    bits, mask;
 
+    if (flags & MSG_ES_UMASK)
+        mask = 0xffff0000;
+    else
+        mask = 0xffff8000;  // don't confuse old clients
+
     if (!to) {
         if (!from)
             Com_Error(ERR_DROP, "%s: NULL", __func__);
@@ -540,109 +735,46 @@ void MSG_WriteDeltaEntity(const entity_packed_t *from,
 // send an update
     bits = 0;
 
-    if (!(flags & MSG_ES_FIRSTPERSON)) {
-        if (to->origin[0] != from->origin[0])
-            bits |= U_ORIGIN1;
-        if (to->origin[1] != from->origin[1])
-            bits |= U_ORIGIN2;
-        if (to->origin[2] != from->origin[2])
-            bits |= U_ORIGIN3;
-
-        if (flags & MSG_ES_SHORTANGLES) {
-            if (to->angles[0] != from->angles[0])
-                bits |= U_ANGLE1 | U_ANGLE16;
-            if (to->angles[1] != from->angles[1])
-                bits |= U_ANGLE2 | U_ANGLE16;
-            if (to->angles[2] != from->angles[2])
-                bits |= U_ANGLE3 | U_ANGLE16;
-        } else {
-            if (to->angles[0] != from->angles[0])
-                bits |= U_ANGLE1;
-            if (to->angles[1] != from->angles[1])
-                bits |= U_ANGLE2;
-            if (to->angles[2] != from->angles[2])
-                bits |= U_ANGLE3;
-        }
+    diff_field(modelindex,	U_MODEL,	U8,  0);
+    diff_field(modelindex2,	U_MODEL2,	U8,  0);
+    diff_field(modelindex3,	U_MODEL3,	U8,  0);
+    diff_field(modelindex4,	U_MODEL4,	U8,  0);
 
-        if (flags & MSG_ES_NEWENTITY) {
-            if (to->old_origin[0] != from->origin[0] ||
-                to->old_origin[1] != from->origin[1] ||
-                to->old_origin[2] != from->origin[2])
-                bits |= U_OLDORIGIN;
-        }
-    }
-
-    if (flags & MSG_ES_UMASK)
-        mask = 0xffff0000;
-    else
-        mask = 0xffff8000;  // don't confuse old clients
+    diff_varia(frame,		U_FRAME);
+    diff_varia(skinnum,		U_SKIN);
+    diff_varia(effects,		U_EFFECTS);
+    diff_varia(renderfx,	U_RENDERFX);
 
-    if (to->skinnum != from->skinnum) {
-        if (to->skinnum & mask)
-            bits |= U_SKIN8 | U_SKIN16;
-        else if (to->skinnum & 0x0000ff00)
-            bits |= U_SKIN16;
-        else
-            bits |= U_SKIN8;
-    }
+    if (!(flags & MSG_ES_FIRSTPERSON)) {
+	diff_field(origin[0],	U_ORIGIN1,	S16, 0);
+	diff_field(origin[1],	U_ORIGIN2,	S16, 0);
+	diff_field(origin[2],	U_ORIGIN3,	S16, 0);
 
-    if (to->frame != from->frame) {
-        if (to->frame & 0xff00)
-            bits |= U_FRAME16;
-        else
-            bits |= U_FRAME8;
-    }
+	diff_field(angles[0],	U_ANGLE1,	S16, 0);
+	diff_field(angles[1],	U_ANGLE2,	S16, 0);
+	diff_field(angles[2],	U_ANGLE3,	S16, 0);
 
-    if (to->effects != from->effects) {
-        if (to->effects & mask)
-            bits |= U_EFFECTS8 | U_EFFECTS16;
-        else if (to->effects & 0x0000ff00)
-            bits |= U_EFFECTS16;
-        else
-            bits |= U_EFFECTS8;
-    }
+        if ((flags & MSG_ES_SHORTANGLES) &&
+	    (bits & (U_ANGLE1|U_ANGLE2|U_ANGLE3)))
+	    bits |= U_ANGLE16;
 
-    if (to->renderfx != from->renderfx) {
-        if (to->renderfx & mask)
-            bits |= U_RENDERFX8 | U_RENDERFX16;
-        else if (to->renderfx & 0x0000ff00)
-            bits |= U_RENDERFX16;
-        else
-            bits |= U_RENDERFX8;
+        if (flags & MSG_ES_NEWENTITY)
+	    diff_array(old_origin, U_OLDORIGIN,	S16, 0, 3);
     }
 
-    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_FRAMELERP) {
         bits |= U_OLDORIGIN;
     } else if (to->renderfx & RF_BEAM) {
-        if (flags & MSG_ES_BEAMORIGIN) {
-            if (to->old_origin[0] != from->old_origin[0] ||
-                to->old_origin[1] != from->old_origin[1] ||
-                to->old_origin[2] != from->old_origin[2])
-                bits |= U_OLDORIGIN;
-        } else {
+        if (flags & MSG_ES_BEAMORIGIN)
+	    diff_array(old_origin, U_OLDORIGIN,	S16, 0, 3);
+        else
             bits |= U_OLDORIGIN;
-        }
     }
 
+    diff_field(sound,		U_SOUND,	U8,  0);
+    diff_field(event,		U_EVENT,	U8,  0);
+    diff_field(solid,		U_SOLID,	_,   0);
+
     //
     // write the message
     //
@@ -684,55 +816,24 @@ void MSG_WriteDeltaEntity(const entity_packed_t *from,
     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);
-    else 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);
+    write_field(modelindex,	U_MODEL,	U8,  0);
+    write_field(modelindex2,	U_MODEL2,	U8,  0);
+    write_field(modelindex3,	U_MODEL3,	U8,  0);
+    write_field(modelindex4,	U_MODEL4,	U8,  0);
 
-    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);
+    write_varia(frame,		U_FRAME);
+    write_varia(skinnum,	U_SKIN);
+    write_varia(effects,	U_EFFECTS);
+    write_varia(renderfx,	U_RENDERFX);
 
-    if (bits & U_ORIGIN1)
-        MSG_WriteShort(to->origin[0]);
-    if (bits & U_ORIGIN2)
-        MSG_WriteShort(to->origin[1]);
-    if (bits & U_ORIGIN3)
-        MSG_WriteShort(to->origin[2]);
+    write_field(origin[0],	U_ORIGIN1,	S16, 0);
+    write_field(origin[1],	U_ORIGIN2,	S16, 0);
+    write_field(origin[2],	U_ORIGIN3,	S16, 0);
 
     if ((flags & MSG_ES_SHORTANGLES) && (bits & U_ANGLE16)) {
-        if (bits & U_ANGLE1)
-            MSG_WriteShort(to->angles[0]);
-        if (bits & U_ANGLE2)
-            MSG_WriteShort(to->angles[1]);
-        if (bits & U_ANGLE3)
-            MSG_WriteShort(to->angles[2]);
+	write_field(angles[0],	U_ANGLE1,	S16, 0);
+	write_field(angles[1],	U_ANGLE2,	S16, 0);
+	write_field(angles[2],	U_ANGLE3,	S16, 0);
     } else {
         if (bits & U_ANGLE1)
             MSG_WriteByte(to->angles[0] >> 8);
@@ -742,16 +843,10 @@ void MSG_WriteDeltaEntity(const entity_packed_t *from,
             MSG_WriteByte(to->angles[2] >> 8);
     }
 
-    if (bits & U_OLDORIGIN) {
-        MSG_WriteShort(to->old_origin[0]);
-        MSG_WriteShort(to->old_origin[1]);
-        MSG_WriteShort(to->old_origin[2]);
-    }
+    write_array(old_origin,	U_OLDORIGIN,	S16, 0, 3);
+    write_field(sound,		U_SOUND,	U8,  0);
+    write_field(event,		U_EVENT,	U8,  0);
 
-    if (bits & U_SOUND)
-        MSG_WriteByte(to->sound);
-    if (bits & U_EVENT)
-        MSG_WriteByte(to->event);
     if (bits & U_SOLID) {
         if (flags & MSG_ES_LONGSOLID)
             MSG_WriteLong(to->solid);
@@ -764,30 +859,12 @@ void MSG_PackPlayer(player_packed_t *out, const player_state_t *in)
 {
     int i;
 
-    out->pmove = in->pmove;
-    out->viewangles[0] = ANGLE2SHORT(in->viewangles[0]);
-    out->viewangles[1] = ANGLE2SHORT(in->viewangles[1]);
-    out->viewangles[2] = ANGLE2SHORT(in->viewangles[2]);
-    out->viewoffset[0] = in->viewoffset[0] * 4;
-    out->viewoffset[1] = in->viewoffset[1] * 4;
-    out->viewoffset[2] = in->viewoffset[2] * 4;
-    out->kick_angles[0] = in->kick_angles[0] * 4;
-    out->kick_angles[1] = in->kick_angles[1] * 4;
-    out->kick_angles[2] = in->kick_angles[2] * 4;
-    out->gunoffset[0] = in->gunoffset[0] * 4;
-    out->gunoffset[1] = in->gunoffset[1] * 4;
-    out->gunoffset[2] = in->gunoffset[2] * 4;
-    out->gunangles[0] = in->gunangles[0] * 4;
-    out->gunangles[1] = in->gunangles[1] * 4;
-    out->gunangles[2] = in->gunangles[2] * 4;
-    out->gunindex = in->gunindex;
-    out->gunframe = in->gunframe;
-    out->blend[0] = in->blend[0] * 255;
-    out->blend[1] = in->blend[1] * 255;
-    out->blend[2] = in->blend[2] * 255;
-    out->blend[3] = in->blend[3] * 255;
-    out->fov = in->fov;
-    out->rdflags = in->rdflags;
+#define _field(_f, _m, _t, _s)		pack_field(_f, _m, _t, _s)
+#define _array(_f, _m, _t, _s, _n)	pack_array(_f, _m, _t, _s, _n)
+    PLAYERSTATE_DEFAULT();
+#undef _field
+#undef _array
+
     for (i = 0; i < MAX_STATS; i++)
         out->stats[i] = in->stats[i];
 }
@@ -795,7 +872,7 @@ void MSG_PackPlayer(player_packed_t *out, const player_state_t *in)
 void MSG_WriteDeltaPlayerstate_Default(const player_packed_t *from, const player_packed_t *to)
 {
     int     i;
-    int     pflags;
+    int     bits;
     int     statbits;
 
     if (!to)
@@ -807,158 +884,24 @@ void MSG_WriteDeltaPlayerstate_Default(const player_packed_t *from, const player
     //
     // 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 (to->viewoffset[0] != from->viewoffset[0] ||
-        to->viewoffset[1] != from->viewoffset[1] ||
-        to->viewoffset[2] != from->viewoffset[2])
-        pflags |= PS_VIEWOFFSET;
-
-    if (to->viewangles[0] != from->viewangles[0] ||
-        to->viewangles[1] != from->viewangles[1] ||
-        to->viewangles[2] != from->viewangles[2])
-        pflags |= PS_VIEWANGLES;
-
-    if (to->kick_angles[0] != from->kick_angles[0] ||
-        to->kick_angles[1] != from->kick_angles[1] ||
-        to->kick_angles[2] != from->kick_angles[2])
-        pflags |= PS_KICKANGLES;
-
-    if (to->blend[0] != from->blend[0] ||
-        to->blend[1] != from->blend[1] ||
-        to->blend[2] != from->blend[2] ||
-        to->blend[3] != from->blend[3])
-        pflags |= PS_BLEND;
-
-    if (to->fov != from->fov)
-        pflags |= PS_FOV;
-
-    if (to->rdflags != from->rdflags)
-        pflags |= PS_RDFLAGS;
-
-    if (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])
-        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);
+    bits = 0;
 
-    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]);
-    }
+#define _field(_f, _m, _t, _s)		diff_field(_f, _m, _t, _s)
+#define _array(_f, _m, _t, _s, _n)	diff_array(_f, _m, _t, _s, _n)
+    PLAYERSTATE_DEFAULT();
+#undef _field
+#undef _array
 
     //
-    // write the rest of the player_state_t
+    // write it
     //
-    if (pflags & PS_VIEWOFFSET) {
-        MSG_WriteChar(to->viewoffset[0]);
-        MSG_WriteChar(to->viewoffset[1]);
-        MSG_WriteChar(to->viewoffset[2]);
-    }
+    MSG_WriteShort(bits);
 
-    if (pflags & PS_VIEWANGLES) {
-        MSG_WriteShort(to->viewangles[0]);
-        MSG_WriteShort(to->viewangles[1]);
-        MSG_WriteShort(to->viewangles[2]);
-    }
-
-    if (pflags & PS_KICKANGLES) {
-        MSG_WriteChar(to->kick_angles[0]);
-        MSG_WriteChar(to->kick_angles[1]);
-        MSG_WriteChar(to->kick_angles[2]);
-    }
-
-    if (pflags & PS_WEAPONINDEX)
-        MSG_WriteByte(to->gunindex);
-
-    if (pflags & PS_WEAPONFRAME) {
-        MSG_WriteByte(to->gunframe);
-        MSG_WriteChar(to->gunoffset[0]);
-        MSG_WriteChar(to->gunoffset[1]);
-        MSG_WriteChar(to->gunoffset[2]);
-        MSG_WriteChar(to->gunangles[0]);
-        MSG_WriteChar(to->gunangles[1]);
-        MSG_WriteChar(to->gunangles[2]);
-    }
-
-    if (pflags & PS_BLEND) {
-        MSG_WriteByte(to->blend[0]);
-        MSG_WriteByte(to->blend[1]);
-        MSG_WriteByte(to->blend[2]);
-        MSG_WriteByte(to->blend[3]);
-    }
-
-    if (pflags & PS_FOV)
-        MSG_WriteByte(to->fov);
-
-    if (pflags & PS_RDFLAGS)
-        MSG_WriteByte(to->rdflags);
+#define _field(_f, _m, _t, _s)		write_field(_f, _m, _t, _s)
+#define _array(_f, _m, _t, _s, _n)	write_array(_f, _m, _t, _s, _n)
+    PLAYERSTATE_DEFAULT();
+#undef _field
+#undef _array
 
     // send stats
     statbits = 0;
@@ -977,7 +920,7 @@ int MSG_WriteDeltaPlayerstate_Enhanced(const player_packed_t    *from,
                                              msgPsFlags_t       flags)
 {
     int     i;
-    int     pflags, eflags;
+    int     bits;
     int     statbits;
 
     if (!to)
@@ -986,133 +929,56 @@ int MSG_WriteDeltaPlayerstate_Enhanced(const player_packed_t    *from,
     if (!from)
         from = &nullPlayerState;
 
-    //
-    // determine what needs to be sent
-    //
-    pflags = 0;
-    eflags = 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;
+    // save previous state
 
-    if (to->pmove.origin[2] != from->pmove.origin[2])
-        eflags |= 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])
-            eflags |= 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 (flags & MSG_PS_IGNORE_GUNINDEX)
+        to->gunindex = from->gunindex;
 
-    if (from->viewoffset[0] != to->viewoffset[0] ||
-        from->viewoffset[1] != to->viewoffset[1] ||
-        from->viewoffset[2] != to->viewoffset[2])
-        pflags |= PS_VIEWOFFSET;
+    if (flags & MSG_PS_IGNORE_GUNFRAMES) {
+        to->gunframe = from->gunframe;
 
-    if (!(flags & MSG_PS_IGNORE_VIEWANGLES)) {
-        if (from->viewangles[0] != to->viewangles[0] ||
-            from->viewangles[1] != to->viewangles[1])
-            pflags |= PS_VIEWANGLES;
+        to->gunoffset[0] = from->gunoffset[0];
+        to->gunoffset[1] = from->gunoffset[1];
+        to->gunoffset[2] = from->gunoffset[2];
 
-        if (from->viewangles[2] != to->viewangles[2])
-            eflags |= EPS_VIEWANGLE2;
-    } else {
-        // save previous state
-        to->viewangles[0] = from->viewangles[0];
-        to->viewangles[1] = from->viewangles[1];
-        to->viewangles[2] = from->viewangles[2];
+        to->gunangles[0] = from->gunangles[0];
+        to->gunangles[1] = from->gunangles[1];
+        to->gunangles[2] = from->gunangles[2];
     }
 
-    if (from->kick_angles[0] != to->kick_angles[0] ||
-        from->kick_angles[1] != to->kick_angles[1] ||
-        from->kick_angles[2] != to->kick_angles[2])
-        pflags |= PS_KICKANGLES;
-
-    if (!(flags & MSG_PS_IGNORE_BLEND)) {
-        if (from->blend[0] != to->blend[0] ||
-            from->blend[1] != to->blend[1] ||
-            from->blend[2] != to->blend[2] ||
-            from->blend[3] != to->blend[3])
-            pflags |= PS_BLEND;
-    } else {
-        // save previous state
+    if (flags & MSG_PS_IGNORE_BLEND) {
         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 (from->fov != to->fov)
-        pflags |= PS_FOV;
+    if (flags & MSG_PS_IGNORE_VIEWANGLES) {
+        to->viewangles[0] = from->viewangles[0];
+        to->viewangles[1] = from->viewangles[1];
+        to->viewangles[2] = from->viewangles[2];
+    }
 
-    if (to->rdflags != from->rdflags)
-        pflags |= PS_RDFLAGS;
+    if (flags & MSG_PS_IGNORE_DELTAANGLES)
+        VectorCopy(from->pmove.delta_angles, to->pmove.delta_angles);
 
-    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_PREDICTION) {
+        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_GUNFRAMES)) {
-        if (to->gunframe != from->gunframe)
-            pflags |= PS_WEAPONFRAME;
-
-        if (from->gunoffset[0] != to->gunoffset[0] ||
-            from->gunoffset[1] != to->gunoffset[1] ||
-            from->gunoffset[2] != to->gunoffset[2])
-            eflags |= EPS_GUNOFFSET;
-
-        if (from->gunangles[0] != to->gunangles[0] ||
-            from->gunangles[1] != to->gunangles[1] ||
-            from->gunangles[2] != to->gunangles[2])
-            eflags |= 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];
+    //
+    // determine what needs to be sent
+    //
+    bits = 0;
 
-        to->gunangles[0] = from->gunangles[0];
-        to->gunangles[1] = from->gunangles[1];
-        to->gunangles[2] = from->gunangles[2];
-    }
+#define _field(_f, _m, _t, _s)		diff_field(_f, _m, _t, _s)
+#define _array(_f, _m, _t, _s, _n)	diff_array(_f, _m, _t, _s, _n)
+    PLAYERSTATE_ENHANCED();
+#undef _field
+#undef _array
 
     statbits = 0;
     for (i = 0; i < MAX_STATS; i++)
@@ -1120,113 +986,28 @@ int MSG_WriteDeltaPlayerstate_Enhanced(const player_packed_t    *from,
             statbits |= 1 << i;
 
     if (statbits)
-        eflags |= EPS_STATS;
+        bits |= 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 (eflags & 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 (eflags & 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]);
-        MSG_WriteChar(to->viewoffset[1]);
-        MSG_WriteChar(to->viewoffset[2]);
-    }
+    MSG_WriteShort(bits & PS_MASK);
 
-    if (pflags & PS_VIEWANGLES) {
-        MSG_WriteShort(to->viewangles[0]);
-        MSG_WriteShort(to->viewangles[1]);
-    }
-
-    if (eflags & EPS_VIEWANGLE2)
-        MSG_WriteShort(to->viewangles[2]);
-
-    if (pflags & PS_KICKANGLES) {
-        MSG_WriteChar(to->kick_angles[0]);
-        MSG_WriteChar(to->kick_angles[1]);
-        MSG_WriteChar(to->kick_angles[2]);
-    }
-
-    if (pflags & PS_WEAPONINDEX)
-        MSG_WriteByte(to->gunindex);
-
-    if (pflags & PS_WEAPONFRAME)
-        MSG_WriteByte(to->gunframe);
-
-    if (eflags & EPS_GUNOFFSET) {
-        MSG_WriteChar(to->gunoffset[0]);
-        MSG_WriteChar(to->gunoffset[1]);
-        MSG_WriteChar(to->gunoffset[2]);
-    }
-
-    if (eflags & EPS_GUNANGLES) {
-        MSG_WriteChar(to->gunangles[0]);
-        MSG_WriteChar(to->gunangles[1]);
-        MSG_WriteChar(to->gunangles[2]);
-    }
-
-    if (pflags & PS_BLEND) {
-        MSG_WriteByte(to->blend[0]);
-        MSG_WriteByte(to->blend[1]);
-        MSG_WriteByte(to->blend[2]);
-        MSG_WriteByte(to->blend[3]);
-    }
-
-    if (pflags & PS_FOV)
-        MSG_WriteByte(to->fov);
-
-    if (pflags & PS_RDFLAGS)
-        MSG_WriteByte(to->rdflags);
+#define _field(_f, _m, _t, _s)		write_field(_f, _m, _t, _s)
+#define _array(_f, _m, _t, _s, _n)	write_array(_f, _m, _t, _s, _n)
+    PLAYERSTATE_ENHANCED();
+#undef _field
+#undef _array
 
     // send stats
-    if (eflags & EPS_STATS) {
+    if (bits & EPS_STATS) {
         MSG_WriteLong(statbits);
         for (i = 0; i < MAX_STATS; i++)
             if (statbits & (1 << i))
                 MSG_WriteShort(to->stats[i]);
     }
 
-    return eflags;
+    return bits;
 }
 
 #if USE_MVD_SERVER || USE_MVD_CLIENT
@@ -1245,7 +1026,7 @@ void MSG_WriteDeltaPlayerstate_Packet(const player_packed_t *from,
                                       msgPsFlags_t          flags)
 {
     int     i;
-    int     pflags;
+    int     bits;
     int     statbits;
 
     if (number < 0 || number >= MAX_CLIENTS)
@@ -1263,68 +1044,30 @@ void MSG_WriteDeltaPlayerstate_Packet(const player_packed_t *from,
     //
     // 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 (from->viewoffset[0] != to->viewoffset[0] ||
-        from->viewoffset[1] != to->viewoffset[1] ||
-        from->viewoffset[2] != to->viewoffset[2])
-        pflags |= PPS_VIEWOFFSET;
-
-    if (from->viewangles[0] != to->viewangles[0] ||
-        from->viewangles[1] != to->viewangles[1])
-        pflags |= PPS_VIEWANGLES;
-
-    if (from->viewangles[2] != to->viewangles[2])
-        pflags |= PPS_VIEWANGLE2;
-
-    if (from->kick_angles[0] != to->kick_angles[0] ||
-        from->kick_angles[1] != to->kick_angles[1] ||
-        from->kick_angles[2] != to->kick_angles[2])
-        pflags |= PPS_KICKANGLES;
-
-    if (!(flags & MSG_PS_IGNORE_BLEND)) {
-        if (from->blend[0] != to->blend[0] ||
-            from->blend[1] != to->blend[1] ||
-            from->blend[2] != to->blend[2] ||
-            from->blend[3] != to->blend[3])
-            pflags |= PPS_BLEND;
-    }
-
-    if (from->fov != to->fov)
-        pflags |= PPS_FOV;
+    bits = 0;
 
-    if (to->rdflags != from->rdflags)
-        pflags |= PPS_RDFLAGS;
+    diff_field(pmove.pm_type,		PPS_M_TYPE,		U8,  0);
+    diff_array(pmove.origin,		PPS_M_ORIGIN,		S16, 0, 2);
+    diff_field(pmove.origin[2],		PPS_M_ORIGIN2,		S16, 0);
+    diff_array(viewoffset,		PPS_VIEWOFFSET,		S8,  0, 3);
+    diff_array(viewangles,		PPS_VIEWANGLES,		S16, 0, 2);
+    diff_field(viewangles[2],		PPS_VIEWANGLE2,		S16, 0);
+    diff_array(kick_angles,		PPS_KICKANGLES,		S8,  0, 3);
 
-    if (!(flags & MSG_PS_IGNORE_GUNINDEX)) {
-        if (to->gunindex != from->gunindex)
-            pflags |= PPS_WEAPONINDEX;
-    }
+    if (!(flags & MSG_PS_IGNORE_GUNINDEX))
+	diff_field(gunindex,		PPS_WEAPONINDEX,	U8,  0);
 
     if (!(flags & MSG_PS_IGNORE_GUNFRAMES)) {
-        if (to->gunframe != from->gunframe)
-            pflags |= PPS_WEAPONFRAME;
+	diff_field(gunframe,		PPS_WEAPONFRAME,	U8,  0);
+	diff_array(gunoffset,		PPS_GUNOFFSET,		S8,  0, 3);
+	diff_array(gunangles,		PPS_GUNANGLES,		S8,  0, 3);
+    }
 
-        if (from->gunoffset[0] != to->gunoffset[0] ||
-            from->gunoffset[1] != to->gunoffset[1] ||
-            from->gunoffset[2] != to->gunoffset[2])
-            pflags |= PPS_GUNOFFSET;
+    if (!(flags & MSG_PS_IGNORE_BLEND))
+	diff_array(blend,		PPS_BLEND,		U8,  0, 4);
 
-        if (from->gunangles[0] != to->gunangles[0] ||
-            from->gunangles[1] != to->gunangles[1] ||
-            from->gunangles[2] != to->gunangles[2])
-            pflags |= PPS_GUNANGLES;
-    }
+    diff_field(fov,			PPS_FOV,		U8,  0);
+    diff_field(rdflags,			PPS_RDFLAGS,		U8,  0);
 
     statbits = 0;
     for (i = 0; i < MAX_STATS; i++)
@@ -1332,90 +1075,28 @@ void MSG_WriteDeltaPlayerstate_Packet(const player_packed_t *from,
             statbits |= 1 << i;
 
     if (statbits)
-        pflags |= PPS_STATS;
+        bits |= PPS_STATS;
 
-    if (!pflags && !(flags & MSG_PS_FORCE))
+    if (!bits && !(flags & MSG_PS_FORCE))
         return;
 
     if (flags & MSG_PS_REMOVE)
-        pflags |= PPS_REMOVE; // used for MVD stream only
+        bits |= PPS_REMOVE; // used for MVD stream only
 
     //
     // write it
     //
     MSG_WriteByte(number);
-    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]);
-        MSG_WriteChar(to->viewoffset[1]);
-        MSG_WriteChar(to->viewoffset[2]);
-    }
-
-    if (pflags & PPS_VIEWANGLES) {
-        MSG_WriteShort(to->viewangles[0]);
-        MSG_WriteShort(to->viewangles[1]);
-    }
-
-    if (pflags & PPS_VIEWANGLE2)
-        MSG_WriteShort(to->viewangles[2]);
-
-    if (pflags & PPS_KICKANGLES) {
-        MSG_WriteChar(to->kick_angles[0]);
-        MSG_WriteChar(to->kick_angles[1]);
-        MSG_WriteChar(to->kick_angles[2]);
-    }
-
-    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]);
-        MSG_WriteChar(to->gunoffset[1]);
-        MSG_WriteChar(to->gunoffset[2]);
-    }
-
-    if (pflags & PPS_GUNANGLES) {
-        MSG_WriteChar(to->gunangles[0]);
-        MSG_WriteChar(to->gunangles[1]);
-        MSG_WriteChar(to->gunangles[2]);
-    }
-
-    if (pflags & PPS_BLEND) {
-        MSG_WriteByte(to->blend[0]);
-        MSG_WriteByte(to->blend[1]);
-        MSG_WriteByte(to->blend[2]);
-        MSG_WriteByte(to->blend[3]);
-    }
-
-    if (pflags & PPS_FOV)
-        MSG_WriteByte(to->fov);
+    MSG_WriteShort(bits);
 
-    if (pflags & PPS_RDFLAGS)
-        MSG_WriteByte(to->rdflags);
+#define _field(_f, _m, _t, _s)		write_field(_f, _m, _t, _s)
+#define _array(_f, _m, _t, _s, _n)	write_array(_f, _m, _t, _s, _n)
+    PLAYERSTATE_PACKET();
+#undef _field
+#undef _array
 
     // send stats
-    if (pflags & PPS_STATS) {
+    if (bits & PPS_STATS) {
         MSG_WriteLong(statbits);
         for (i = 0; i < MAX_STATS; i++)
             if (statbits & (1 << i))
@@ -1914,82 +1595,33 @@ void MSG_ParseDeltaEntity(const entity_state_t *from,
         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();
-    }
+    read_field(modelindex,	U_MODEL,	U8,  0);
+    read_field(modelindex2,	U_MODEL2,	U8,  0);
+    read_field(modelindex3,	U_MODEL3,	U8,  0);
+    read_field(modelindex4,	U_MODEL4,	U8,  0);
 
-    if (bits & U_FRAME8)
-        to->frame = MSG_ReadByte();
-    if (bits & U_FRAME16)
-        to->frame = MSG_ReadShort();
+    read_varia(frame,		U_FRAME);
+    read_varia(skinnum,		U_SKIN);
+    read_varia(effects,		U_EFFECTS);
+    read_varia(renderfx,	U_RENDERFX);
 
-    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_ReadWord();
-
-    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();
-
-    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();
-
-    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();
-    }
+    read_field(origin[0],	U_ORIGIN1,	S16, S16_COORD);
+    read_field(origin[1],	U_ORIGIN2,	S16, S16_COORD);
+    read_field(origin[2],	U_ORIGIN3,	S16, S16_COORD);
 
     if ((flags & MSG_ES_SHORTANGLES) && (bits & U_ANGLE16)) {
-        if (bits & U_ANGLE1)
-            to->angles[0] = MSG_ReadAngle16();
-        if (bits & U_ANGLE2)
-            to->angles[1] = MSG_ReadAngle16();
-        if (bits & U_ANGLE3)
-            to->angles[2] = MSG_ReadAngle16();
+	read_field(angles[0],	U_ANGLE1,	S16, S16_ANGLE);
+	read_field(angles[1],	U_ANGLE2,	S16, S16_ANGLE);
+	read_field(angles[2],	U_ANGLE3,	S16, S16_ANGLE);
     } else {
-        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();
+	read_field(angles[0],	U_ANGLE1,	U8,  U8_ANGLE);
+	read_field(angles[1],	U_ANGLE2,	U8,  U8_ANGLE);
+	read_field(angles[2],	U_ANGLE3,	U8,  U8_ANGLE);
     }
 
-    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();
-    }
+    read_array(old_origin,	U_OLDORIGIN,	S16, S16_COORD, 3);
+    read_field(sound,		U_SOUND,	U8,  0);
+    read_field(event,		U_EVENT,	U8,  0);
 
     if (bits & U_SOLID) {
         if (flags & MSG_ES_LONGSOLID) {
@@ -2011,7 +1643,7 @@ MSG_ParseDeltaPlayerstate_Default
 */
 void MSG_ParseDeltaPlayerstate_Default(const player_state_t *from,
                                        player_state_t *to,
-                                       int            flags)
+                                       int            bits)
 {
     int         i;
     int         statbits;
@@ -2027,86 +1659,11 @@ void MSG_ParseDeltaPlayerstate_Default(const player_state_t *from,
         memcpy(to, from, 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();
+#define _field(_f, _m, _t, _s)		read_field(_f, _m, _t, _s)
+#define _array(_f, _m, _t, _s, _n)	read_array(_f, _m, _t, _s, _n)
+    PLAYERSTATE_DEFAULT();
+#undef _field
+#undef _array
 
     // parse stats
     statbits = MSG_ReadLong();
@@ -2115,7 +1672,6 @@ void MSG_ParseDeltaPlayerstate_Default(const player_state_t *from,
             to->stats[i] = MSG_ReadShort();
 }
 
-
 /*
 ===================
 MSG_ParseDeltaPlayerstate_Default
@@ -2123,11 +1679,12 @@ MSG_ParseDeltaPlayerstate_Default
 */
 void MSG_ParseDeltaPlayerstate_Enhanced(const player_state_t    *from,
                                         player_state_t    *to,
-                                        int               flags,
-                                        int               extraflags)
+                                        int               bits_lo,
+                                        int               bits_hi)
 {
     int         i;
     int         statbits;
+    int		bits = bits_lo | (bits_hi << EPS_OFFSET);
 
     if (!to) {
         Com_Error(ERR_DROP, "%s: NULL", __func__);
@@ -2140,104 +1697,14 @@ void MSG_ParseDeltaPlayerstate_Enhanced(const player_state_t    *from,
         memcpy(to, from, 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();
+#define _field(_f, _m, _t, _s)		read_field(_f, _m, _t, _s)
+#define _array(_f, _m, _t, _s, _n)	read_array(_f, _m, _t, _s, _n)
+    PLAYERSTATE_ENHANCED();
+#undef _field
+#undef _array
 
     // parse stats
-    if (extraflags & EPS_STATS) {
+    if (bits & EPS_STATS) {
         statbits = MSG_ReadLong();
         for (i = 0; i < MAX_STATS; i++) {
             if (statbits & (1 << i)) {
@@ -2259,7 +1726,7 @@ MSG_ParseDeltaPlayerstate_Packet
 */
 void MSG_ParseDeltaPlayerstate_Packet(const player_state_t *from,
                                       player_state_t *to,
-                                      int            flags)
+                                      int            bits)
 {
     int         i;
     int         statbits;
@@ -2275,80 +1742,14 @@ void MSG_ParseDeltaPlayerstate_Packet(const player_state_t *from,
         memcpy(to, from, 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();
+#define _field(_f, _m, _t, _s)		read_field(_f, _m, _t, _s)
+#define _array(_f, _m, _t, _s, _n)	read_array(_f, _m, _t, _s, _n)
+    PLAYERSTATE_PACKET();
+#undef _field
+#undef _array
 
     // parse stats
-    if (flags & PPS_STATS) {
+    if (bits & PPS_STATS) {
         statbits = MSG_ReadLong();
         for (i = 0; i < MAX_STATS; i++) {
             if (statbits & (1 << i)) {
@@ -2396,10 +1797,12 @@ void MSG_ShowDeltaPlayerstateBits_Default(int flags)
 #undef S
 }
 
-void MSG_ShowDeltaPlayerstateBits_Enhanced(int flags, int extraflags)
+void MSG_ShowDeltaPlayerstateBits_Enhanced(int flags_lo, int flags_hi)
 {
+    int flags = flags_lo | (flags_hi << EPS_OFFSET);
+
 #define SP(b,s) if(flags&PS_##b) SHOWBITS(s)
-#define SE(b,s) if(extraflags&EPS_##b) SHOWBITS(s)
+#define SE(b,s) if(flags&EPS_##b) SHOWBITS(s)
     SP(M_TYPE,          "pmove.pm_type");
     SP(M_ORIGIN,        "pmove.origin[0,1]");
     SE(M_ORIGIN2,       "pmove.origin[2]");
diff --git a/src/server/entities.c b/src/server/entities.c
index b04b148..2e77556 100644
--- a/src/server/entities.c
+++ b/src/server/entities.c
@@ -303,6 +303,8 @@ void SV_WriteFrameToClient_Enhanced(client_t *client)
         }
     }
 
+    extraflags >>= EPS_OFFSET;
+
     // save 3 high bits of extraflags
     *b1 = svc_frame | (((extraflags & 0x70) << 1));