qf/newtree
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/newtree synced 2025-05-30 00:30:38 +00:00
Code Issues Projects Releases Packages Wiki Activity

Initial revision

Browse source
This commit is contained in:
Joseph Carter 2000-05-10 11:29:38 +00:00
commit d859383680
169 changed files with 86447 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

165
source/sv_nchan.c Normal file
View file

@ -0,0 +1,165 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// sv_nchan.c, user reliable data stream writes
#include "qwsvdef.h"
// check to see if client block will fit, if not, rotate buffers
void ClientReliableCheckBlock(client_t *cl, int maxsize)
{
if (cl->num_backbuf ||
cl->netchan.message.cursize >
cl->netchan.message.maxsize - maxsize - 1) {
// we would probably overflow the buffer, save it for next
if (!cl->num_backbuf) {
memset(&cl->backbuf, 0, sizeof(cl->backbuf));
cl->backbuf.allowoverflow = true;
cl->backbuf.data = cl->backbuf_data[0];
cl->backbuf.maxsize = sizeof(cl->backbuf_data[0]);
cl->backbuf_size[0] = 0;
cl->num_backbuf++;
}
if (cl->backbuf.cursize > cl->backbuf.maxsize - maxsize - 1) {
if (cl->num_backbuf == MAX_BACK_BUFFERS) {
Con_Printf ("WARNING: MAX_BACK_BUFFERS for %s\n", cl->name);
cl->backbuf.cursize = 0; // don't overflow without allowoverflow set
cl->netchan.message.overflowed = true; // this will drop the client
return;
}
memset(&cl->backbuf, 0, sizeof(cl->backbuf));
cl->backbuf.allowoverflow = true;
cl->backbuf.data = cl->backbuf_data[cl->num_backbuf];
cl->backbuf.maxsize = sizeof(cl->backbuf_data[cl->num_backbuf]);
cl->backbuf_size[cl->num_backbuf] = 0;
cl->num_backbuf++;
}
}
}
// begin a client block, estimated maximum size
void ClientReliableWrite_Begin(client_t *cl, int c, int maxsize)
{
ClientReliableCheckBlock(cl, maxsize);
ClientReliableWrite_Byte(cl, c);
}
void ClientReliable_FinishWrite(client_t *cl)
{
if (cl->num_backbuf) {
cl->backbuf_size[cl->num_backbuf - 1] = cl->backbuf.cursize;
if (cl->backbuf.overflowed) {
Con_Printf ("WARNING: backbuf [%d] reliable overflow for %s\n",cl->num_backbuf,cl->name);
cl->netchan.message.overflowed = true; // this will drop the client
}
}
}
void ClientReliableWrite_Angle(client_t *cl, float f)
{
if (cl->num_backbuf) {
MSG_WriteAngle(&cl->backbuf, f);
ClientReliable_FinishWrite(cl);
} else
MSG_WriteAngle(&cl->netchan.message, f);
}
void ClientReliableWrite_Angle16(client_t *cl, float f)
{
if (cl->num_backbuf) {
MSG_WriteAngle16(&cl->backbuf, f);
ClientReliable_FinishWrite(cl);
} else
MSG_WriteAngle16(&cl->netchan.message, f);
}
void ClientReliableWrite_Byte(client_t *cl, int c)
{
if (cl->num_backbuf) {
MSG_WriteByte(&cl->backbuf, c);
ClientReliable_FinishWrite(cl);
} else
MSG_WriteByte(&cl->netchan.message, c);
}
void ClientReliableWrite_Char(client_t *cl, int c)
{
if (cl->num_backbuf) {
MSG_WriteChar(&cl->backbuf, c);
ClientReliable_FinishWrite(cl);
} else
MSG_WriteChar(&cl->netchan.message, c);
}
void ClientReliableWrite_Float(client_t *cl, float f)
{
if (cl->num_backbuf) {
MSG_WriteFloat(&cl->backbuf, f);
ClientReliable_FinishWrite(cl);
} else
MSG_WriteFloat(&cl->netchan.message, f);
}
void ClientReliableWrite_Coord(client_t *cl, float f)
{
if (cl->num_backbuf) {
MSG_WriteCoord(&cl->backbuf, f);
ClientReliable_FinishWrite(cl);
} else
MSG_WriteCoord(&cl->netchan.message, f);
}
void ClientReliableWrite_Long(client_t *cl, int c)
{
if (cl->num_backbuf) {
MSG_WriteLong(&cl->backbuf, c);
ClientReliable_FinishWrite(cl);
} else
MSG_WriteLong(&cl->netchan.message, c);
}
void ClientReliableWrite_Short(client_t *cl, int c)
{
if (cl->num_backbuf) {
MSG_WriteShort(&cl->backbuf, c);
ClientReliable_FinishWrite(cl);
} else
MSG_WriteShort(&cl->netchan.message, c);
}
void ClientReliableWrite_String(client_t *cl, char *s)
{
if (cl->num_backbuf) {
MSG_WriteString(&cl->backbuf, s);
ClientReliable_FinishWrite(cl);
} else
MSG_WriteString(&cl->netchan.message, s);
}
void ClientReliableWrite_SZ(client_t *cl, void *data, int len)
{
if (cl->num_backbuf) {
SZ_Write(&cl->backbuf, data, len);
ClientReliable_FinishWrite(cl);
} else
SZ_Write(&cl->netchan.message, data, len);
}