msg.c File Reference

#include "shared/shared.h"
#include "common/msg.h"
#include "common/protocol.h"
#include "common/sizebuf.h"
#include "common/math.h"

Go to the source code of this file.

Macros
#define	COORD2SHORT(x)   ((int)((x)*8.0f))
#define	SHORT2COORD(x)   ((x)*(1.0f/8))
#define	ANGLE2BYTE(x)   ((int)((x)*256.0f/360)&255)
#define	BYTE2ANGLE(x)   ((x)*(360.0f/256))

Functions
void	MSG_Init (void)
void	MSG_BeginWriting (void)
void	MSG_WriteChar (int c)
void	MSG_WriteByte (int c)
void	MSG_WriteShort (int c)
void	MSG_WriteLong (int c)
void	MSG_WriteString (const char *string)
static void	MSG_WriteCoord (float f)
void	MSG_WritePos (const vec3_t pos)
void	MSG_WriteAngle (float f)
void	MSG_WriteDir (const vec3_t dir)
void	MSG_PackEntity (entity_packed_t *out, const entity_state_t *in, qboolean short_angles)
void	MSG_WriteDeltaEntity (const entity_packed_t *from, const entity_packed_t *to, msgEsFlags_t flags)
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	MSG_WriteDeltaPlayerstate_Enhanced (const player_packed_t *from, player_packed_t *to, msgPsFlags_t flags)
void	MSG_BeginReading (void)
byte *	MSG_ReadData (size_t len)
int	MSG_ReadChar (void)
int	MSG_ReadByte (void)
int	MSG_ReadShort (void)
int	MSG_ReadWord (void)
int	MSG_ReadLong (void)
size_t	MSG_ReadString (char *dest, size_t size)
size_t	MSG_ReadStringLine (char *dest, size_t size)
static float	MSG_ReadCoord (void)
void	MSG_ReadPos (vec3_t pos)
static float	MSG_ReadAngle (void)
static float	MSG_ReadAngle16 (void)
void	MSG_ReadDir (vec3_t dir)
void	MSG_ReadDeltaUsercmd (const usercmd_t *from, usercmd_t *to)
void	MSG_ReadDeltaUsercmd_Hacked (const usercmd_t *from, usercmd_t *to)
int	MSG_ReadBits (int bits)
void	MSG_ReadDeltaUsercmd_Enhanced (const usercmd_t *from, usercmd_t *to, int version)

Variables
sizebuf_t	msg_write
byte	msg_write_buffer [MAX_MSGLEN]
sizebuf_t	msg_read
byte	msg_read_buffer [MAX_MSGLEN]
const entity_packed_t	nullEntityState
const player_packed_t	nullPlayerState
const usercmd_t	nullUserCmd

Macro Definition Documentation

ANGLE2BYTE

#define ANGLE2BYTE

(

x

)

((int)((x)*256.0f/360)&255)

Definition at line 211 of file msg.c.

BYTE2ANGLE

#define BYTE2ANGLE

(

x

)

((x)*(360.0f/256))

Definition at line 212 of file msg.c.

COORD2SHORT

#define COORD2SHORT

(

x

)

((int)((x)*8.0f))

Definition at line 185 of file msg.c.

SHORT2COORD

#define SHORT2COORD

(

x

)

((x)*(1.0f/8))

Definition at line 186 of file msg.c.

Function Documentation

MSG_BeginReading()

void MSG_BeginReading

(

void

)

Definition at line 1437 of file msg.c.

{
    msg_read.readcount = 0;
    msg_read.bitpos = 0;
}

Referenced by CL_ConnectionlessPacket(), NetchanNew_Process(), NetchanOld_Process(), and SV_ConnectionlessPacket().

MSG_BeginWriting()

void MSG_BeginWriting

(

void

)

Definition at line 77 of file msg.c.

{
    msg_write.cursize = 0;
    msg_write.bitpos = 0;
    msg_write.overflowed = qfalse;
}

MSG_Init()

void MSG_Init

(

void

)

Definition at line 57 of file msg.c.

{
    SZ_TagInit(&msg_read, msg_read_buffer, MAX_MSGLEN, SZ_MSG_READ);
    SZ_TagInit(&msg_write, msg_write_buffer, MAX_MSGLEN, SZ_MSG_WRITE);
}

Referenced by Com_Error(), and Qcommon_Init().

MSG_PackEntity()

void MSG_PackEntity	(	entity_packed_t *	out,
		const entity_state_t *	in,
		qboolean	short_angles
	)

Definition at line 468 of file msg.c.

{
    // allow 0 to accomodate empty baselines
    if (in->number < 0 || in->number >= MAX_EDICTS)
        Com_Error(ERR_DROP, "%s: bad number: %d", __func__, in->number);
 
    out->number = in->number;
    out->origin[0] = COORD2SHORT(in->origin[0]);
    out->origin[1] = COORD2SHORT(in->origin[1]);
    out->origin[2] = COORD2SHORT(in->origin[2]);
    if (short_angles) {
        out->angles[0] = ANGLE2SHORT(in->angles[0]);
        out->angles[1] = ANGLE2SHORT(in->angles[1]);
        out->angles[2] = ANGLE2SHORT(in->angles[2]);
    } else {
        // pack angles8 akin to angles16 to make delta compression happy when
        // precision suddenly changes between entity updates
        out->angles[0] = ANGLE2BYTE(in->angles[0]) << 8;
        out->angles[1] = ANGLE2BYTE(in->angles[1]) << 8;
        out->angles[2] = ANGLE2BYTE(in->angles[2]) << 8;
    }
    out->old_origin[0] = COORD2SHORT(in->old_origin[0]);
    out->old_origin[1] = COORD2SHORT(in->old_origin[1]);
    out->old_origin[2] = COORD2SHORT(in->old_origin[2]);
    out->modelindex = in->modelindex;
    out->modelindex2 = in->modelindex2;
    out->modelindex3 = in->modelindex3;
    out->modelindex4 = in->modelindex4;
    out->skinnum = in->skinnum;
    out->effects = in->effects;
    out->renderfx = in->renderfx;
    out->solid = in->solid;
    out->frame = in->frame;
    out->sound = in->sound;
    out->event = in->event;
}

Referenced by build_gamestate(), CL_GTV_EmitFrame(), CL_Record_f(), create_baselines(), emit_base_frame(), emit_frame(), emit_packet_entities(), and SV_BuildClientFrame().

MSG_PackPlayer()

void MSG_PackPlayer	(	player_packed_t *	out,
		const player_state_t *	in
	)

Definition at line 763 of file msg.c.

{
    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;
    for (i = 0; i < MAX_STATS; i++)
        out->stats[i] = in->stats[i];
}

Referenced by build_gamestate(), CL_GTV_EmitFrame(), emit_base_frame(), emit_delta_frame(), emit_frame(), and SV_BuildClientFrame().

MSG_ReadAngle()

static float MSG_ReadAngle ( void  )

inlinestatic

Definition at line 1587 of file msg.c.

{
    return BYTE2ANGLE(MSG_ReadChar());
}

MSG_ReadAngle16()

static float MSG_ReadAngle16 ( void  )

inlinestatic

Definition at line 1592 of file msg.c.

{
    return SHORT2ANGLE(MSG_ReadShort());
}

MSG_ReadBits()

int MSG_ReadBits

(

int

bits

)

Definition at line 1718 of file msg.c.

{
    int i, get;
    size_t 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;
}

Referenced by MSG_ReadDeltaUsercmd_Enhanced(), and SV_NewClientExecuteMove().

MSG_ReadByte()

int MSG_ReadByte

(

void

)

Definition at line 1475 of file msg.c.

{
    byte *buf = MSG_ReadData(1);
    int c;
 
    if (!buf) {
        c = -1;
    } else {
        c = (unsigned char)buf[0];
    }
 
    return c;
}

Referenced by AC_ParseClientAck(), AC_ParseMessage(), AC_ParseQueryReply(), CL_GetDemoInfo(), CL_ParseDownload(), CL_ParseFrame(), CL_ParseMuzzleFlashPacket(), CL_ParsePrint(), CL_ParseServerData(), CL_ParseServerMessage(), CL_ParseStartSoundPacket(), CL_ParseTEntPacket(), CL_SeekDemoMessage(), MSG_ReadBits(), MSG_ReadDeltaUsercmd(), MSG_ReadDeltaUsercmd_Hacked(), MSG_ReadDir(), MSG_ReadString(), MSG_ReadStringLine(), MVD_ParseFrame(), MVD_ParseMessage(), MVD_ParseMulticast(), MVD_ParsePacketPlayers(), MVD_ParsePrint(), MVD_ParseSound(), MVD_ParseUnicast(), MVD_UnicastPrint(), NetchanNew_Process(), NetchanOld_Process(), parse_message(), read_level_file(), read_server_file(), SV_ExecuteClientMessage(), SV_GetSaveInfo(), SV_NewClientExecuteMove(), and SV_OldClientExecuteMove().

MSG_ReadChar()

int MSG_ReadChar

(

void

)

Definition at line 1461 of file msg.c.

{
    byte *buf = MSG_ReadData(1);
    int c;
 
    if (!buf) {
        c = -1;
    } else {
        c = (signed char)buf[0];
    }
 
    return c;
}

Referenced by MSG_ReadAngle(), MSG_ReadBits(), and MSG_ReadDeltaUsercmd_Hacked().

MSG_ReadCoord()

static float MSG_ReadCoord ( void  )

inlinestatic

Definition at line 1575 of file msg.c.

{
    return SHORT2COORD(MSG_ReadShort());
}

Referenced by MSG_ReadPos().

MSG_ReadData()

byte* MSG_ReadData

(

size_t

len

)

Definition at line 1443 of file msg.c.

{
    byte *buf = msg_read.data + msg_read.readcount;
 
    msg_read.readcount += len;
    msg_read.bitpos = msg_read.readcount << 3;
 
    if (msg_read.readcount > msg_read.cursize) {
        if (!msg_read.allowunderflow) {
            Com_Error(ERR_DROP, "%s: read past end of message", __func__);
        }
        return NULL;
    }
 
    return buf;
}

Referenced by MSG_ReadByte(), MSG_ReadChar(), MSG_ReadLong(), MSG_ReadShort(), MSG_ReadWord(), and read_level_file().

MSG_ReadDeltaUsercmd()

void MSG_ReadDeltaUsercmd	(	const usercmd_t *	from,
		usercmd_t *	to
	)

Definition at line 1607 of file msg.c.

{
    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();
}

Referenced by SV_OldClientExecuteMove().

MSG_ReadDeltaUsercmd_Enhanced()

void MSG_ReadDeltaUsercmd_Enhanced	(	const usercmd_t *	from,
		usercmd_t *	to,
		int	version
	)

Definition at line 1773 of file msg.c.

{
    int bits, count;
 
    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 (version >= PROTOCOL_VERSION_Q2PRO_UCMD) {
        count = -10;
    } else {
        count = -16;
    }
 
    if (bits & CM_FORWARD) {
        to->forwardmove = MSG_ReadBits(count);
    }
    if (bits & CM_SIDE) {
        to->sidemove = MSG_ReadBits(count);
    }
    if (bits & CM_UP) {
        to->upmove = MSG_ReadBits(count);
    }
 
// read buttons
    if (bits & CM_BUTTONS) {
        int buttons = MSG_ReadBits(3);
        to->buttons = (buttons & 3) | ((buttons & 4) << 5);
    }
 
// read time to run command
    if (bits & CM_IMPULSE) {
        to->msec = MSG_ReadBits(8);
    }
}

Referenced by SV_NewClientExecuteMove().

MSG_ReadDeltaUsercmd_Hacked()

void MSG_ReadDeltaUsercmd_Hacked	(	const usercmd_t *	from,
		usercmd_t *	to
	)

Definition at line 1649 of file msg.c.

{
    int bits, buttons = 0;
 
    if (from) {
        memcpy(to, from, sizeof(*to));
    } else {
        memset(to, 0, sizeof(*to));
    }
 
    bits = MSG_ReadByte();
 
// read buttons
    if (bits & CM_BUTTONS) {
        buttons = MSG_ReadByte();
        to->buttons = buttons & BUTTON_MASK;
    }
 
// read current angles
    if (bits & CM_ANGLE1) {
        if (buttons & BUTTON_ANGLE1) {
            to->angles[0] = MSG_ReadChar() * 64;
        } else {
            to->angles[0] = MSG_ReadShort();
        }
    }
    if (bits & CM_ANGLE2) {
        if (buttons & BUTTON_ANGLE2) {
            to->angles[1] = MSG_ReadChar() * 256;
        } else {
            to->angles[1] = MSG_ReadShort();
        }
    }
    if (bits & CM_ANGLE3)
        to->angles[2] = MSG_ReadShort();
 
// read movement
    if (bits & CM_FORWARD) {
        if (buttons & BUTTON_FORWARD) {
            to->forwardmove = MSG_ReadChar() * 5;
        } else {
            to->forwardmove = MSG_ReadShort();
        }
    }
    if (bits & CM_SIDE) {
        if (buttons & BUTTON_SIDE) {
            to->sidemove = MSG_ReadChar() * 5;
        } else {
            to->sidemove = MSG_ReadShort();
        }
    }
    if (bits & CM_UP) {
        if (buttons & BUTTON_UP) {
            to->upmove = MSG_ReadChar() * 5;
        } else {
            to->upmove = MSG_ReadShort();
        }
    }
 
    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();
}

Referenced by SV_OldClientExecuteMove().

MSG_ReadDir()

void MSG_ReadDir

(

vec3_t

dir

)

Definition at line 1597 of file msg.c.

{
    int     b;
 
    b = MSG_ReadByte();
    if (b < 0 || b >= NUMVERTEXNORMALS)
        Com_Error(ERR_DROP, "MSG_ReadDir: out of range");
    VectorCopy(bytedirs[b], dir);
}

Referenced by CL_ParseTEntPacket().

MSG_ReadLong()

int MSG_ReadLong

(

void

)

Definition at line 1517 of file msg.c.

{
    byte *buf = MSG_ReadData(4);
    int c;
 
    if (!buf) {
        c = -1;
    } else {
        c = LittleLongMem(buf);
    }
 
    return c;
}

Referenced by AC_ParseClient(), CL_ConnectionlessPacket(), CL_GetDemoInfo(), CL_ParseFrame(), CL_ParseServerData(), CL_ParseSetting(), CL_ParseTEntPacket(), MSG_ReadBits(), MVD_ParseServerData(), NetchanNew_Process(), NetchanOld_Process(), parse_hello(), read_level_file(), read_server_file(), SV_ConnectionlessPacket(), SV_GetSaveInfo(), SV_NewClientExecuteMove(), and SV_OldClientExecuteMove().

MSG_ReadPos()

void MSG_ReadPos

(

vec3_t

pos

)

Definition at line 1580 of file msg.c.

{
    pos[0] = MSG_ReadCoord();
    pos[1] = MSG_ReadCoord();
    pos[2] = MSG_ReadCoord();
}

Referenced by CL_ParseStartSoundPacket(), and CL_ParseTEntPacket().

MSG_ReadShort()

int MSG_ReadShort

(

void

)

Definition at line 1489 of file msg.c.

{
    byte *buf = MSG_ReadData(2);
    int c;
 
    if (!buf) {
        c = -1;
    } else {
        c = (signed short)LittleShortMem(buf);
    }
 
    return c;
}

Referenced by CL_GetDemoInfo(), CL_ParseDownload(), CL_ParseFrame(), CL_ParseGamestate(), CL_ParseInventory(), CL_ParseMuzzleFlashPacket(), CL_ParseServerData(), CL_ParseServerMessage(), CL_ParseStartSoundPacket(), CL_ParseTEntPacket(), CL_SeekDemoMessage(), MSG_ReadAngle16(), MSG_ReadBits(), MSG_ReadCoord(), MSG_ReadDeltaUsercmd(), MSG_ReadDeltaUsercmd_Hacked(), MVD_ParseConfigstring(), MVD_ParsePacketPlayers(), MVD_ParseServerData(), MVD_ParseSound(), MVD_UnicastString(), NetchanNew_Process(), NetchanOld_Process(), parse_stream_start(), read_level_file(), and SV_ParseClientSetting().

MSG_ReadString()

size_t MSG_ReadString	(	char *	dest,
		size_t	size
	)

Definition at line 1531 of file msg.c.

{
    int     c;
    size_t  len = 0;
 
    while (1) {
        c = MSG_ReadByte();
        if (c == -1 || c == 0) {
            break;
        }
        if (len + 1 < size) {
            *dest++ = c;
        }
        len++;
    }
    if (size) {
        *dest = 0;
    }
 
    return len;
}

Referenced by AC_ParseError(), AC_ParseFileViolation(), AC_ParseViolation(), CL_GetDemoInfo(), CL_ParseCenterPrint(), CL_ParseConfigstring(), CL_ParseInfoMessage(), CL_ParseLayout(), CL_ParsePrint(), CL_ParsePrintMessage(), CL_ParseServerData(), CL_ParseStuffText(), CL_SeekDemoMessage(), MVD_ParseConfigstring(), MVD_ParsePrint(), MVD_ParseServerData(), MVD_UnicastLayout(), MVD_UnicastPrint(), MVD_UnicastString(), MVD_UnicastStuff(), parse_hello(), parse_stringcmd(), read_level_file(), read_server_file(), SV_GetSaveInfo(), SV_ParseClientCommand(), SV_ParseDeltaUserinfo(), and SV_ParseFullUserinfo().

MSG_ReadStringLine()

size_t MSG_ReadStringLine	(	char *	dest,
		size_t	size
	)

Definition at line 1553 of file msg.c.

{
    int     c;
    size_t  len = 0;
 
    while (1) {
        c = MSG_ReadByte();
        if (c == -1 || c == 0 || c == '\n') {
            break;
        }
        if (len + 1 < size) {
            *dest++ = c;
        }
        len++;
    }
    if (size) {
        *dest = 0;
    }
 
    return len;
}

Referenced by CL_ConnectionlessPacket(), and SV_ConnectionlessPacket().

MSG_ReadWord()

int MSG_ReadWord

(

void

)

Definition at line 1503 of file msg.c.

{
    byte *buf = MSG_ReadData(2);
    int c;
 
    if (!buf) {
        c = -1;
    } else {
        c = (unsigned short)LittleShortMem(buf);
    }
 
    return c;
}

Referenced by AC_ParseClient(), CL_ParseZPacket(), MVD_ParseMulticast(), and parse_hello().

MSG_WriteAngle()

void MSG_WriteAngle

(

float

f

)

Definition at line 214 of file msg.c.

{
    MSG_WriteByte(ANGLE2BYTE(f));
}

Referenced by SV_InitGameProgs().

MSG_WriteByte()

void MSG_WriteByte

(

int

c

)

Definition at line 107 of file msg.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;
}

Referenced by AC_Announce(), AC_ClientConnect(), AC_ClientDisconnect(), AC_ClientQuery(), AC_SendChecks(), AC_SendHello(), AC_SendPing(), AC_SendPrefs(), AC_WriteString(), CL_ClientCommand(), CL_ConnectionlessPacket(), CL_Disconnect(), CL_EmitDemoSnapshot(), CL_GTV_EmitFrame(), CL_Record_f(), CL_SendBatchedCmd(), CL_SendDefaultCmd(), CL_SendUserinfo(), CL_UpdateBlendSetting(), CL_UpdateFootstepsSetting(), CL_UpdateGibSetting(), CL_UpdateGunSetting(), CL_UpdatePredictSetting(), CL_UpdateRecordingSetting(), demo_emit_snapshot(), emit_base_frame(), emit_delta_frame(), emit_frame(), emit_gamestate(), emit_snd(), gtv_forward_cmd(), handle_filtercmd(), MSG_WriteAngle(), MSG_WriteDeltaEntity(), MSG_WriteDeltaPlayerstate_Default(), MSG_WriteDeltaPlayerstate_Enhanced(), MSG_WriteDir(), MSG_WriteString(), MVD_BroadcastPrintf(), MVD_ChangeLevel(), MVD_LayoutChannels(), MVD_LayoutClients(), MVD_LayoutFollow(), MVD_LayoutMenu(), MVD_LayoutScores(), MVD_ParseSound(), MVD_SwitchChannel(), MVD_UpdateConfigstring(), PF_bprintf(), PF_centerprintf(), PF_configstring(), PF_cprintf(), PF_PositionedSound(), PF_StartSound(), redirect(), stuff_cmds(), SV_BeginDownload_f(), SV_BroadcastCommand(), SV_BroadcastPrintf(), SV_ClientCommand(), SV_ClientPrintf(), SV_DropClient(), SV_FinalMessage(), SV_FlushRedirect(), SV_InitGameProgs(), SV_New_f(), SV_StopDownload_f(), SV_Stuff_f(), SV_StuffAll_f(), SV_WriteFrameToClient_Default(), SV_WriteFrameToClient_Enhanced(), write_cs_list(), write_datagram_new(), write_level_file(), write_plain_baselines(), write_plain_configstrings(), and write_server_file().

MSG_WriteChar()

void MSG_WriteChar

(

int

c

)

Definition at line 89 of file msg.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;
}

Referenced by MSG_WriteDeltaPlayerstate_Default(), MSG_WriteDeltaPlayerstate_Enhanced(), and SV_InitGameProgs().

MSG_WriteCoord()

static void MSG_WriteCoord ( float  f )

inlinestatic

Definition at line 188 of file msg.c.

{
    MSG_WriteShort(COORD2SHORT(f));
}

Referenced by MSG_WritePos().

MSG_WriteDeltaEntity()

void MSG_WriteDeltaEntity	(	const entity_packed_t *	from,
		const entity_packed_t *	to,
		msgEsFlags_t	flags
	)

Definition at line 505 of file msg.c.

{
    uint32_t    bits, mask;
 
    if (!to) {
        if (!from)
            Com_Error(ERR_DROP, "%s: NULL", __func__);
 
        if (from->number < 1 || from->number >= MAX_EDICTS)
            Com_Error(ERR_DROP, "%s: bad number: %d", __func__, from->number);
 
        bits = U_REMOVE;
        if (from->number & 0xff00)
            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, "%s: bad number: %d", __func__, to->number);
 
    if (!from)
        from = &nullEntityState;
 
// 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;
        }
 
        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
 
    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 (to->frame != from->frame) {
        if (to->frame & 0xff00)
            bits |= U_FRAME16;
        else
            bits |= U_FRAME8;
    }
 
    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 (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 (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 {
            bits |= U_OLDORIGIN;
        }
    }
 
    //
    // write the message
    //
    if (!bits && !(flags & MSG_ES_FORCE))
        return;     // nothing to send!
 
    if (flags & MSG_ES_REMOVE)
        bits |= U_REMOVE; // used for MVD stream only
 
    //----------
 
    if (to->number & 0xff00)
        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);
    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);
 
    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_WriteShort(to->origin[0]);
    if (bits & U_ORIGIN2)
        MSG_WriteShort(to->origin[1]);
    if (bits & U_ORIGIN3)
        MSG_WriteShort(to->origin[2]);
 
    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]);
    } else {
        if (bits & U_ANGLE1)
            MSG_WriteByte(to->angles[0] >> 8);
        if (bits & U_ANGLE2)
            MSG_WriteByte(to->angles[1] >> 8);
        if (bits & U_ANGLE3)
            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]);
    }
 
    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);
        else
            MSG_WriteShort(to->solid);
    }
}

Referenced by CL_GTV_EmitFrame(), CL_Record_f(), emit_base_frame(), emit_frame(), emit_gamestate(), emit_packet_entities(), SV_EmitPacketEntities(), and write_baseline().

MSG_WriteDeltaPlayerstate_Default()

void MSG_WriteDeltaPlayerstate_Default	(	const player_packed_t *	from,
		const player_packed_t *	to
	)

Definition at line 795 of file msg.c.

{
    int     i;
    int     pflags;
    int     statbits;
 
    if (!to)
        Com_Error(ERR_DROP, "%s: NULL", __func__);
 
    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 (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);
 
    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]);
    }
 
    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);
 
    // 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]);
}

Referenced by emit_delta_frame(), and SV_WriteFrameToClient_Default().

MSG_WriteDeltaPlayerstate_Enhanced()

int MSG_WriteDeltaPlayerstate_Enhanced	(	const player_packed_t *	from,
		player_packed_t *	to,
		msgPsFlags_t	flags
	)

Definition at line 975 of file msg.c.

{
    int     i;
    int     pflags, eflags;
    int     statbits;
 
    if (!to)
        Com_Error(ERR_DROP, "%s: NULL", __func__);
 
    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;
 
    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 (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_VIEWANGLES)) {
        if (from->viewangles[0] != to->viewangles[0] ||
            from->viewangles[1] != to->viewangles[1])
            pflags |= PS_VIEWANGLES;
 
        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];
    }
 
    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
        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 (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 (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];
 
        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)
        eflags |= 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]);
    }
 
    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);
 
    // send stats
    if (eflags & EPS_STATS) {
        MSG_WriteLong(statbits);
        for (i = 0; i < MAX_STATS; i++)
            if (statbits & (1 << i))
                MSG_WriteShort(to->stats[i]);
    }
 
    return eflags;
}

Referenced by SV_WriteFrameToClient_Enhanced().

MSG_WriteDir()

void MSG_WriteDir

(

const vec3_t

dir

)

Definition at line 460 of file msg.c.

{
    int     best;
 
    best = DirToByte(dir);
    MSG_WriteByte(best);
}

Referenced by SV_InitGameProgs().

MSG_WriteLong()

void MSG_WriteLong

(

int

c

)

Definition at line 144 of file msg.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;
}

Referenced by AC_ClientConnect(), AC_ClientDisconnect(), AC_ClientQuery(), AC_SendChecks(), AC_SendHello(), AC_SendPrefs(), CL_Record_f(), CL_SendBatchedCmd(), CL_SendDefaultCmd(), emit_delta_frame(), emit_gamestate(), MSG_WriteDeltaEntity(), MSG_WriteDeltaPlayerstate_Default(), MSG_WriteDeltaPlayerstate_Enhanced(), parse_hello(), redirect(), send_hello(), SV_InitGameProgs(), SV_New_f(), SV_WriteFrameToClient_Default(), SV_WriteFrameToClient_Enhanced(), write_level_file(), and write_server_file().

MSG_WritePos()

void MSG_WritePos

(

const vec3_t

pos

)

Definition at line 198 of file msg.c.

{
    MSG_WriteCoord(pos[0]);
    MSG_WriteCoord(pos[1]);
    MSG_WriteCoord(pos[2]);
}

Referenced by MVD_ParseSound(), PF_PositionedSound(), PF_StartSound(), and SV_InitGameProgs().

MSG_WriteShort()

void MSG_WriteShort

(

int

c

)

Definition at line 125 of file msg.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;
}

Referenced by AC_ClientConnect(), AC_ClientDisconnect(), AC_ClientQuery(), AC_SendChecks(), AC_SendHello(), AC_SendPing(), AC_SendPrefs(), CL_EmitDemoSnapshot(), CL_GTV_EmitFrame(), CL_Record_f(), CL_UpdateBlendSetting(), CL_UpdateFootstepsSetting(), CL_UpdateGibSetting(), CL_UpdateGunSetting(), CL_UpdatePredictSetting(), CL_UpdateRecordingSetting(), demo_emit_snapshot(), emit_base_frame(), emit_frame(), emit_gamestate(), emit_packet_entities(), emit_snd(), MSG_WriteCoord(), MSG_WriteDeltaEntity(), MSG_WriteDeltaPlayerstate_Default(), MSG_WriteDeltaPlayerstate_Enhanced(), MVD_ParseSound(), MVD_UpdateConfigstring(), PF_configstring(), PF_PositionedSound(), PF_StartSound(), send_hello(), send_stream_start(), SV_BeginDownload_f(), SV_EmitPacketEntities(), SV_InitGameProgs(), SV_New_f(), SV_StopDownload_f(), write_cs_list(), write_level_file(), and write_plain_configstrings().

MSG_WriteString()

void MSG_WriteString

(

const char *

string

)

Definition at line 160 of file msg.c.

{
    size_t length;
 
    if (!string) {
        MSG_WriteByte(0);
        return;
    }
 
    length = strlen(string);
    if (length >= MAX_NET_STRING) {
        Com_WPrintf("%s: overflow: %"PRIz" chars", __func__, length);
        MSG_WriteByte(0);
        return;
    }
 
    MSG_WriteData(string, length + 1);
}

Referenced by CL_ClientCommand(), CL_EmitDemoSnapshot(), CL_Record_f(), CL_SendUserinfo(), emit_gamestate(), MVD_ChangeLevel(), MVD_LayoutScores(), MVD_SwitchChannel(), MVD_UpdateConfigstring(), redirect(), send_hello(), SV_FinalMessage(), SV_InitGameProgs(), SV_New_f(), SV_Stuff_f(), SV_StuffAll_f(), write_cs_list(), and write_server_file().

Variable Documentation

msg_read

sizebuf_t msg_read

Definition at line 37 of file msg.c.

Referenced by AC_ParseClient(), AC_ParseClientAck(), AC_ParseFileViolation(), AC_ParseMessage(), AC_ParseQueryReply(), AC_ParseViolation(), CL_PacketEvent(), CL_ParseDownload(), CL_ParseFrame(), CL_ParseGamestate(), CL_ParsePacketEntities(), CL_ParseServerMessage(), CL_ParseZPacket(), CL_Seek_f(), CL_SeekDemoMessage(), demo_read_message(), demo_skip_map(), FIFO_ReadMessage(), MSG_BeginReading(), MSG_Init(), MSG_ReadBits(), MSG_ReadData(), MVD_ParseFrame(), MVD_ParseMessage(), MVD_ParseMulticast(), MVD_ParsePacketEntities(), MVD_ParsePacketPlayers(), MVD_ParseServerData(), MVD_ParseUnicast(), MVD_Seek_f(), MVD_UnicastPrint(), MVD_UnicastString(), MVD_UnicastStuff(), MVD_WriteDemoMessage(), NET_GetUdpPackets(), NetchanNew_Process(), NetchanOld_Process(), parse_message(), parse_stream_data(), read_binary_file(), read_first_message(), read_level_file(), read_next_message(), read_server_file(), SV_ExecuteClientMessage(), SV_NewClientExecuteMove(), SV_PacketEvent(), and SV_ParseDeltaUserinfo().

msg_read_buffer

byte msg_read_buffer[MAX_MSGLEN]

Definition at line 38 of file msg.c.

Referenced by CL_ParseZPacket(), demo_load_message(), demo_read_message(), demo_skip_map(), FIFO_ReadMessage(), MSG_Init(), NET_GetUdpPackets(), read_binary_file(), read_first_message(), and read_next_message().

msg_write

sizebuf_t msg_write

Definition at line 34 of file msg.c.

Referenced by AC_Announce(), AC_Flush(), AC_Write(), CL_Disconnect(), CL_EmitDemoFrame(), CL_EmitDemoSnapshot(), CL_GTV_EmitFrame(), CL_GTV_Resume(), CL_Record_f(), CL_SendBatchedCmd(), CL_SendDefaultCmd(), compress_message(), demo_emit_snapshot(), filter_unicast_data(), gtv_forward_cmd(), MSG_BeginWriting(), MSG_Init(), MSG_WriteByte(), MSG_WriteChar(), MSG_WriteLong(), MSG_WriteShort(), MVD_BroadcastPrintf(), MVD_ChangeLevel(), MVD_Frame(), MVD_StreamedRecord_f(), MVD_UpdateConfigstring(), parse_hello(), parse_stream_start(), PF_bprintf(), PF_configstring(), PF_cprintf(), PF_Unicast(), rec_frame(), rec_start(), rec_write(), redirect(), repack_unreliables(), resume_streams(), send_hello(), send_stream_start(), SV_BroadcastCommand(), SV_BroadcastPrintf(), SV_ClientAddMessage(), SV_FinalMessage(), SV_Multicast(), SV_MvdEndFrame(), SV_MvdMapChanged(), SV_MvdMulticast(), SV_MvdUnicast(), SV_RunGameFrame(), SV_StuffAll_f(), SV_WriteFrameToClient_Enhanced(), write_datagram_new(), write_datagram_old(), write_level_file(), write_message(), write_msg(), write_plain_baselines(), write_plain_configstrings(), write_server_file(), and write_snd().

msg_write_buffer

byte msg_write_buffer[MAX_MSGLEN]

Definition at line 35 of file msg.c.

Referenced by MSG_Init().

nullEntityState

const entity_packed_t nullEntityState

Definition at line 40 of file msg.c.

Referenced by MSG_WriteDeltaEntity(), and SV_EmitPacketEntities().

nullPlayerState

const player_packed_t nullPlayerState

Definition at line 41 of file msg.c.

Referenced by MSG_WriteDeltaPlayerstate_Default(), and MSG_WriteDeltaPlayerstate_Enhanced().

nullUserCmd

const usercmd_t nullUserCmd

Definition at line 42 of file msg.c.