summaryrefslogtreecommitdiff
path: root/source/sv_send.c
diff options
context:
space:
mode:
Diffstat (limited to 'source/sv_send.c')
-rw-r--r--source/sv_send.c748
1 files changed, 748 insertions, 0 deletions
diff --git a/source/sv_send.c b/source/sv_send.c
new file mode 100644
index 0000000..8d7d13e
--- /dev/null
+++ b/source/sv_send.c
@@ -0,0 +1,748 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+*/
+// sv_send.c
+
+#include "sv_local.h"
+#include "mvd_local.h"
+
+static int demo_msglen;
+static byte demo_data[MAX_PACKETLEN];
+
+/*
+=============================================================================
+
+MISC
+
+=============================================================================
+*/
+
+char sv_outputbuf[SV_OUTPUTBUF_LENGTH];
+
+void SV_FlushRedirect( int sv_redirected, char *outputbuf ) {
+ if( sv_redirected == RD_PACKET ) {
+ Netchan_OutOfBandPrint( NS_SERVER, &net_from, "print\n%s", outputbuf );
+ } else if( sv_redirected == RD_CLIENT ) {
+ MSG_WriteByte( svc_print );
+ MSG_WriteByte( PRINT_HIGH );
+ MSG_WriteString( outputbuf );
+ SV_ClientAddMessage( sv_client, MSG_RELIABLE|MSG_CLEAR );
+ }
+}
+
+/*
+=======================
+SV_RateDrop
+
+Returns qtrue if the client is over its current
+bandwidth estimation and should not be sent another packet
+=======================
+*/
+static qboolean SV_RateDrop( client_t *client ) {
+ int total;
+ int i;
+
+ // never drop over the loopback
+ if( !client->rate ) {
+ return qfalse;
+ }
+
+ total = 0;
+ for( i = 0; i < RATE_MESSAGES; i++ ) {
+ total += client->message_size[i];
+ }
+
+ if( total > client->rate ) {
+ client->surpressCount++;
+ client->message_size[sv.framenum % RATE_MESSAGES] = 0;
+ return qtrue;
+ }
+
+ return qfalse;
+}
+
+void SV_CalcSendTime( client_t *client, int messageSize ) {
+ int delta;
+
+ if( messageSize == -1 ) {
+ return;
+ }
+
+ // never drop over the loopback
+ if( !client->rate ) {
+ client->sendTime = 0;
+ return;
+ }
+
+ client->message_size[sv.framenum % RATE_MESSAGES] = messageSize;
+
+ delta = messageSize * 1000 / client->rate;
+ client->sendTime = svs.realtime + delta;
+}
+
+/*
+=============================================================================
+
+EVENT MESSAGES
+
+=============================================================================
+*/
+
+
+/*
+=================
+SV_ClientPrintf
+
+Sends text across to be displayed if the level passes.
+NOT archived in MVD stream.
+=================
+*/
+void SV_ClientPrintf( client_t *client, int level, const char *fmt, ... ) {
+ va_list argptr;
+ char string[MAX_STRING_CHARS];
+
+ if( level < client->messagelevel )
+ return;
+
+ va_start( argptr, fmt );
+ Q_vsnprintf( string, sizeof( string ), fmt, argptr );
+ va_end( argptr );
+
+ MSG_WriteByte( svc_print );
+ MSG_WriteByte( level );
+ MSG_WriteString( string );
+
+ SV_ClientAddMessage( client, MSG_RELIABLE|MSG_CLEAR );
+}
+
+/*
+=================
+SV_BroadcastPrintf
+
+Sends text to all active clients, including MVD clients.
+NOT archived in MVD stream.
+=================
+*/
+void SV_BroadcastPrintf( int level, const char *fmt, ... ) {
+ va_list argptr;
+ char string[MAX_STRING_CHARS];
+ client_t *client;
+ int i;
+
+ va_start( argptr, fmt );
+ Q_vsnprintf( string, sizeof( string ), fmt, argptr );
+ va_end( argptr );
+
+ MSG_WriteByte( svc_print );
+ MSG_WriteByte( level );
+ MSG_WriteString( string );
+
+ // echo to console
+ if( dedicated->integer ) {
+ // mask off high bits
+ for( i = 0; string[i]; i++ )
+ string[i] &= 127;
+ Com_Printf( "%s", string );
+ }
+
+ FOR_EACH_CLIENT( client ) {
+ if( client->state != cs_spawned )
+ continue;
+ if( level < client->messagelevel )
+ continue;
+ SV_ClientAddMessage( client, MSG_RELIABLE );
+ }
+
+ SZ_Clear( &msg_write );
+}
+
+/*
+=================
+SV_BroadcastCommand
+
+Sends command to all active clients.
+NOT archived in MVD stream.
+=================
+*/
+void SV_BroadcastCommand( const char *fmt, ... ) {
+ va_list argptr;
+ char string[MAX_STRING_CHARS];
+ client_t *client;
+
+ va_start( argptr, fmt );
+ Q_vsnprintf( string, sizeof( string ), fmt, argptr );
+ va_end( argptr );
+
+ MSG_WriteByte( svc_stufftext );
+ MSG_WriteString( string );
+
+ FOR_EACH_CLIENT( client ) {
+ SV_ClientAddMessage( client, MSG_RELIABLE );
+ }
+
+ SZ_Clear( &msg_write );
+}
+
+
+/*
+=================
+SV_Multicast
+
+Sends the contents of the write buffer to a subset of the clients,
+then clears the write buffer.
+
+Archived in MVD stream.
+
+MULTICAST_ALL same as broadcast (origin can be NULL)
+MULTICAST_PVS send to clients potentially visible from org
+MULTICAST_PHS send to clients potentially hearable from org
+=================
+*/
+void SV_Multicast( vec3_t origin, multicast_t to ) {
+ client_t *client;
+ byte *mask;
+ cleaf_t *leaf;
+ int leafnum;
+ int cluster;
+ int area1, area2;
+ int flags;
+ vec3_t org;
+ player_state_t *ps;
+
+ flags = 0;
+
+ switch( to ) {
+ case MULTICAST_ALL_R:
+ flags |= MSG_RELIABLE; // intentional fallthrough
+ case MULTICAST_ALL:
+ area1 = 0;
+ leafnum = 0;
+ cluster = 0;
+ mask = NULL;
+ break;
+ case MULTICAST_PHS_R:
+ flags |= MSG_RELIABLE; // intentional fallthrough
+ case MULTICAST_PHS:
+ leaf = CM_PointLeaf( &sv.cm, origin );
+ leafnum = leaf - sv.cm.cache->leafs;
+ area1 = CM_LeafArea( leaf );
+ cluster = CM_LeafCluster( leaf );
+ mask = CM_ClusterPHS( &sv.cm, cluster );
+ break;
+ case MULTICAST_PVS_R:
+ flags |= MSG_RELIABLE; // intentional fallthrough
+ case MULTICAST_PVS:
+ leaf = CM_PointLeaf( &sv.cm, origin );
+ leafnum = leaf - sv.cm.cache->leafs;
+ area1 = CM_LeafArea( leaf );
+ cluster = CM_LeafCluster( leaf );
+ mask = CM_ClusterPVS( &sv.cm, cluster );
+ break;
+ default:
+ Com_Error( ERR_DROP, "SV_Multicast: bad to: %i", to );
+ }
+
+ // send the data to all relevent clients
+ FOR_EACH_CLIENT( client ) {
+ if( client->state < cs_primed ) {
+ continue;
+ }
+ // do not send unreliables to connecting clients
+ if( !( flags & MSG_RELIABLE ) && ( client->state != cs_spawned ||
+ client->download || client->nodata ) )
+ {
+ continue;
+ }
+
+ if( mask ) {
+ // find the client's PVS
+ ps = &client->edict->client->ps;
+ VectorMA( ps->viewoffset, 0.125f, ps->pmove.origin, org );
+ leaf = CM_PointLeaf( &sv.cm, org );
+ area2 = CM_LeafArea( leaf );
+ if( !CM_AreasConnected( &sv.cm, area1, area2 ) ) {
+ continue;
+ }
+ cluster = CM_LeafCluster( leaf );
+ if( !Q_IsBitSet( mask, cluster ) ) {
+ continue;
+ }
+ }
+
+ SV_ClientAddMessage( client, flags );
+
+ }
+
+ if( svs.mvdummy ) {
+ SV_MvdMulticast( leafnum, mvd_multicast_all + to );
+ }
+
+ // clear the buffer
+ SZ_Clear( &msg_write );
+}
+
+
+
+/*
+=======================
+SV_ClientAddMessage
+
+Adds contents of the current write buffer to client's message list.
+Does NOT clean the buffer for multicast delivery purpose,
+unless told otherwise.
+=======================
+*/
+void SV_ClientAddMessage( client_t *client, int flags ) {
+ if( sv_debug_send->integer > 1 ) {
+ Com_Printf( S_COLOR_BLUE"%s: add%c: %d\n", client->name,
+ ( flags & MSG_RELIABLE ) ? 'r' : 'u', msg_write.cursize );
+ }
+
+ if( !msg_write.cursize ) {
+ return;
+ }
+
+ if( client->state > cs_zombie ) {
+ client->AddMessage( client, msg_write.data, msg_write.cursize,
+ ( flags & MSG_RELIABLE ) ? qtrue : qfalse );
+ }
+
+ if( flags & MSG_CLEAR ) {
+ SZ_Clear( &msg_write );
+ }
+}
+
+static inline void SV_PacketizedRemove( client_t *client, pmsg_t *msg ) {
+ List_Delete( &msg->entry );
+
+ if( msg->cursize > MSG_TRESHOLD ) {
+ Z_Free( msg );
+ } else {
+ List_Append( &client->freemsg, &msg->entry );
+ }
+}
+
+void SV_PacketizedClear( client_t *client ) {
+ pmsg_t *msg, *next;
+
+ LIST_FOR_EACH_SAFE( pmsg_t, msg, next, &client->usedmsg, entry ) {
+ SV_PacketizedRemove( client, msg );
+ }
+
+ LIST_FOR_EACH_SAFE( pmsg_t, msg, next, &client->relmsg, entry ) {
+ SV_PacketizedRemove( client, msg );
+ }
+}
+
+
+pmsg_t *SV_PacketizedAdd( client_t *client, byte *data,
+ int length, qboolean reliable )
+{
+ pmsg_t *msg;
+
+ if( length > MSG_TRESHOLD ) {
+ msg = SV_Malloc( sizeof( *msg ) + length - MSG_TRESHOLD );
+ } else {
+ if( LIST_EMPTY( &client->freemsg ) ) {
+ Com_WPrintf( "Out of message slots for %s!\n", client->name );
+ if( reliable ) {
+ SV_PacketizedClear( client );
+ SV_DropClient( client, "no slot for reliable message" );
+ }
+ return NULL;
+ }
+ msg = LIST_FIRST( pmsg_t, &client->freemsg, entry );
+ List_Remove( &msg->entry );
+ }
+
+ memcpy( msg->data, data, length );
+ msg->cursize = length;
+
+ if( reliable ) {
+ List_Append( &client->relmsg, &msg->entry );
+ } else {
+ List_Append( &client->usedmsg, &msg->entry );
+ }
+
+ return msg;
+}
+
+/*
+===============================================================================
+
+FRAME UPDATES - DEFAULT, R1Q2 AND Q2PRO CLIENTS (OLD NETCHAN)
+
+===============================================================================
+*/
+
+
+void SV_OldClientAddMessage( client_t *client, byte *data,
+ int length, qboolean reliable )
+{
+ if( length > client->netchan->maxpacketlen ) {
+ if( reliable ) {
+ SV_DropClient( client, "oversize reliable message" );
+ } else {
+ Com_DPrintf( "Dumped oversize unreliable for %s\n", client->name );
+ }
+ return;
+ }
+
+ SV_PacketizedAdd( client, data, length, reliable );
+}
+
+/*
+=======================
+SV_OldClient_SendReliableMessages
+
+This should be the only place data is
+ever written to client->netchan.message
+=======================
+*/
+void SV_OldClientWriteReliableMessages( client_t *client, int maxsize ) {
+ pmsg_t *msg, *next;
+ int count;
+
+ if( client->netchan->reliable_length ) {
+ if( sv_debug_send->integer > 1 ) {
+ Com_Printf( S_COLOR_BLUE"%s: unacked\n", client->name );
+ }
+ return; // there is still outgoing reliable message pending
+ }
+
+ // find at least one reliable message to send
+ count = 0;
+ LIST_FOR_EACH_SAFE( pmsg_t, msg, next, &client->relmsg, entry ) {
+ // stop if this msg doesn't fit (reliables must be delivered in order)
+ if( client->netchan->message.cursize + msg->cursize > maxsize ) {
+ if( !count ) {
+ Com_WPrintf( "Overflow on the first reliable message "
+ "for %s (should not happen).\n", client->name );
+ }
+ break;
+ }
+
+ if( sv_debug_send->integer > 1 ) {
+ Com_Printf( S_COLOR_BLUE"%s: wrt%d: %d\n",
+ client->name, count, msg->cursize );
+ }
+
+ SZ_Write( &client->netchan->message, msg->data, msg->cursize );
+ SV_PacketizedRemove( client, msg );
+ count++;
+ }
+}
+
+
+/*
+=======================
+OldClient_SendDatagram
+=======================
+*/
+void SV_OldClientWriteDatagram( client_t *client ) {
+ pmsg_t *msg, *next;
+ int cursize, maxsize;
+
+ maxsize = client->netchan->maxpacketlen;
+ if( client->netchan->reliable_length ) {
+ // there is still unacked reliable message pending
+ maxsize -= client->netchan->reliable_length;
+ } else {
+ // find at least one reliable message to send
+ // and make sure to reserve space for it
+ if( !LIST_EMPTY( &client->relmsg ) ) {
+ msg = LIST_FIRST( pmsg_t, &client->relmsg, entry );
+ maxsize -= msg->cursize;
+ }
+ }
+
+ // send over all the relevant entity_state_t
+ // and the player_state_t
+ client->WriteFrame( client );
+ if( msg_write.cursize > maxsize ) {
+ if( sv_debug_send->integer ) {
+ Com_Printf( S_COLOR_BLUE"Frame overflowed for %s: %d > %d\n",
+ client->name, msg_write.cursize, maxsize );
+ }
+ SZ_Clear( &msg_write );
+ }
+
+ // now try to write unreliable messages
+ // it is necessary for this to be after the WriteEntities
+ // so that entity references will be current
+ if( msg_write.cursize + 4 <= maxsize ) {
+ // temp entities first
+ LIST_FOR_EACH_SAFE( pmsg_t, msg, next, &client->usedmsg, entry ) {
+ if( msg->data[0] != svc_temp_entity ) {
+ continue;
+ }
+ // ignore some low-priority effects, these checks come from r1q2
+ if( msg->data[1] == TE_BLOOD || msg->data[1] == TE_SPLASH ) {
+ continue;
+ }
+ if( msg->data[1] == TE_GUNSHOT || msg->data[1] == TE_BULLET_SPARKS
+ || msg->data[1] == TE_SHOTGUN )
+ {
+ continue;
+ }
+
+ // if this msg fits, write it
+ if( msg_write.cursize + msg->cursize <= maxsize ) {
+ MSG_WriteData( msg->data, msg->cursize );
+ }
+
+ SV_PacketizedRemove( client, msg );
+ }
+
+ if( msg_write.cursize + 4 <= maxsize ) {
+ // then sounds
+ LIST_FOR_EACH_SAFE( pmsg_t, msg, next, &client->usedmsg, entry ) {
+ if( msg->data[0] != svc_sound ) {
+ continue;
+ }
+
+ // if this msg fits, write it
+ if( msg_write.cursize + msg->cursize <= maxsize ) {
+ MSG_WriteData( msg->data, msg->cursize );
+ }
+
+ SV_PacketizedRemove( client, msg );
+ }
+
+ if( msg_write.cursize + 4 <= maxsize ) {
+ // then everything else left
+ LIST_FOR_EACH_SAFE( pmsg_t, msg, next, &client->usedmsg, entry ) {
+ // if this msg fits, write it
+ if( msg_write.cursize + msg->cursize <= maxsize ) {
+ MSG_WriteData( msg->data, msg->cursize );
+ }
+
+ SV_PacketizedRemove( client, msg );
+ }
+ }
+ }
+ }
+
+ // write at least one reliable message
+ SV_OldClientWriteReliableMessages( client,
+ client->netchan->maxpacketlen - msg_write.cursize );
+
+ // send the datagram
+ cursize = client->netchan->Transmit( client->netchan,
+ msg_write.cursize, msg_write.data );
+
+ // record the size for rate estimation
+ SV_CalcSendTime( client, cursize );
+
+ SZ_Clear( &msg_write );
+}
+
+void SV_OldClientFinishFrame( client_t *client ) {
+ pmsg_t *msg, *next;
+
+ // clear all unreliable messages still left
+ LIST_FOR_EACH_SAFE( pmsg_t, msg, next, &client->usedmsg, entry ) {
+ SV_PacketizedRemove( client, msg );
+ }
+}
+
+/*
+===============================================================================
+
+FRAME UPDATES - Q2PRO CLIENTS (NEW NETCHAN)
+
+===============================================================================
+*/
+
+void SV_NewClientAddMessage( client_t *client, byte *data,
+ int length, qboolean reliable )
+{
+ sizebuf_t *buf = reliable ? &client->netchan->message : &client->datagram;
+ SZ_Write( buf, data, length );
+}
+
+void SV_NewClientWriteDatagram( client_t *client ) {
+ int cursize;
+ int i;
+
+ // send over all the relevant entity_state_t
+ // and the player_state_t
+ client->WriteFrame( client );
+
+ if( msg_write.overflowed ) {
+ // should never really happen
+ Com_WPrintf( "Frame overflowed for %s\n", client->name );
+ SZ_Clear( &msg_write );
+ }
+
+ // copy the accumulated multicast datagram
+ // for this client out to the message
+ // it is necessary for this to be after the WriteEntities
+ // so that entity references will be current
+ if( client->datagram.overflowed ) {
+ Com_WPrintf( "Datagram overflowed for %s\n", client->name );
+ } else if( msg_write.cursize + client->datagram.cursize > msg_write.maxsize ) {
+ Com_WPrintf( "Dumping datagram for %s\n", client->name );
+ } else {
+ MSG_WriteData( client->datagram.data, client->datagram.cursize );
+ }
+
+ if( sv_pad_packets->integer ) {
+ int pad = msg_write.cursize + sv_pad_packets->integer;
+
+ if( pad > msg_write.maxsize ) {
+ pad = msg_write.maxsize;
+ }
+ for( i = msg_write.cursize; i < pad; i++ ) {
+ MSG_WriteByte( svc_nop );
+ }
+ }
+
+ // send the datagram
+ cursize = client->netchan->Transmit( client->netchan,
+ msg_write.cursize, msg_write.data );
+
+ // record the size for rate estimation
+ SV_CalcSendTime( client, cursize );
+
+ // clear the write buffer
+ SZ_Clear( &msg_write );
+}
+
+void SV_NewClientFinishFrame( client_t *client ) {
+ SZ_Clear( &client->datagram );
+}
+
+/*
+===============================================================================
+
+COMMON STUFF
+
+===============================================================================
+*/
+
+/*
+==================
+SV_DemoCompleted
+==================
+*/
+void SV_DemoCompleted( void ) {
+ Com_DPrintf( "SV_DemoCompleted()\n" );
+ if( sv.demofile ) {
+ FS_FCloseFile( sv.demofile );
+ sv.demofile = 0;
+ }
+ SV_Nextserver();
+}
+
+
+/*
+=======================
+SV_SendClientMessages
+
+Called each game frame, sends svc_frame messages to spawned clients only.
+Clients in earlier connection state are handled in SV_SendAsyncPackets.
+=======================
+*/
+void SV_SendClientMessages( void ) {
+ client_t *client;
+ int msglen;
+ int r;
+
+ demo_msglen = 0;
+
+ // read the next demo message if needed
+ if( sv.state == ss_demo && sv.demofile ) {
+ // get the next message
+ r = FS_Read( &msglen, 4, sv.demofile );
+ if( r != 4 ) {
+ SV_DemoCompleted();
+ return;
+ }
+ msglen = LittleLong( msglen );
+ if( msglen == -1 ) {
+ SV_DemoCompleted();
+ return;
+ }
+ if( msglen < 0 || msglen > MAX_PACKETLEN )
+ Com_Error( ERR_DROP, "SV_SendClientMessages: bad demo msglen" );
+ r = FS_Read( demo_data, msglen, sv.demofile );
+ if( r != msglen ) {
+ SV_DemoCompleted();
+ return;
+ }
+ demo_msglen = msglen;
+
+ }
+
+ if( sv.state != ss_game && sv.state != ss_broadcast ) {
+ // send a demo message to each connected client
+ FOR_EACH_CLIENT( client ) {
+ if( client->netchan->type == NETCHAN_OLD ) {
+ SV_OldClientWriteReliableMessages( client,
+ client->netchan->maxpacketlen );
+ }
+ client->netchan->Transmit( client->netchan,
+ demo_msglen, demo_data );
+ }
+ return;
+ }
+
+ // send a message to each connected client
+ FOR_EACH_CLIENT( client ) {
+ if( client->state != cs_spawned || client->download || client->nodata )
+ goto finish;
+
+ // if the reliable message overflowed,
+ // drop the client (should never happen)
+ if( client->netchan->message.overflowed ) {
+ SZ_Clear( &client->netchan->message );
+ SV_DropClient( client, "overflowed" );
+ }
+
+ // don't overrun bandwidth
+ if( SV_RateDrop( client ) ) {
+ if( sv_debug_send->integer ) {
+ Com_Printf( "Frame %d surpressed for %s\n",
+ sv.framenum, client->name );
+ }
+ client->surpressCount++;
+ goto finish;
+ }
+
+ // don't write any frame data until all fragments are sent
+ if( client->netchan->fragment_pending ) {
+ msglen = client->netchan->TransmitNextFragment( client->netchan );
+ SV_CalcSendTime( client, msglen );
+ goto finish;
+ }
+
+ // build the new frame
+ client->BuildFrame( client );
+
+ // write it
+ client->WriteDatagram( client );
+
+finish:
+ // clear the unreliable datagram
+ client->FinishFrame( client );
+ }
+
+}
+
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-02 03:01:51 +0000