/* sv_send.c (description) 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: Free Software Foundation, Inc. 59 Temple Place - Suite 330 Boston, MA 02111-1307, USA $Id$ */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifdef HAVE_STRING_H # include #endif #include #include #include #include "compat.h" #include "QF/console.h" #include "QF/cvar.h" #include "QF/msg.h" #include "QF/sys.h" #include "QF/sound.h" // FIXME: DEFAULT_SOUND_PACKET_* #include "bothdefs.h" #include "server.h" #include "sv_progs.h" #define CHAN_AUTO 0 #define CHAN_WEAPON 1 #define CHAN_VOICE 2 #define CHAN_ITEM 3 #define CHAN_BODY 4 /* Con_Printf redirection */ char outputbuf[8000]; redirect_t sv_redirected; int con_printf_no_log; extern cvar_t *sv_phs; extern cvar_t *sv_timestamps; extern cvar_t *sv_timefmt; /* SV_FlushRedirect */ void SV_FlushRedirect (void) { char send[8000 + 6]; if (sv_redirected == RD_PACKET) { send[0] = 0xff; send[1] = 0xff; send[2] = 0xff; send[3] = 0xff; send[4] = A2C_PRINT; memcpy (send + 5, outputbuf, strlen (outputbuf) + 1); NET_SendPacket (strlen (send) + 1, send, net_from); } else if (sv_redirected == RD_CLIENT) { ClientReliableWrite_Begin (host_client, svc_print, strlen (outputbuf) + 3); ClientReliableWrite_Byte (host_client, PRINT_HIGH); ClientReliableWrite_String (host_client, outputbuf); } // clear it outputbuf[0] = 0; } /* SV_BeginRedirect Send Con_Printf data to the remote client instead of the console */ void SV_BeginRedirect (redirect_t rd) { sv_redirected = rd; outputbuf[0] = 0; } void SV_EndRedirect (void) { SV_FlushRedirect (); sv_redirected = RD_NONE; } /* Con_Printf Handles cursor positioning, line wrapping, etc */ #define MAXPRINTMSG 4096 void Con_Printf (char *fmt, ...) { static int pending = 0; // partial line being printed va_list argptr; char msg[MAXPRINTMSG]; char msg2[MAXPRINTMSG]; char msg3[MAXPRINTMSG]; time_t mytime = 0; struct tm *local = NULL; qboolean timestamps = false; va_start (argptr, fmt); vsnprintf (msg, sizeof (msg), fmt, argptr); va_end (argptr); if (sv_redirected) { // Add to redirected message if (strlen (msg) + strlen (outputbuf) > sizeof (outputbuf) - 1) SV_FlushRedirect (); strncat (outputbuf, msg, sizeof (outputbuf) - strlen (outputbuf)); } if (!con_printf_no_log) { // We want to output to console and maybe logfile if (sv_timestamps && sv_timefmt && sv_timefmt->string && sv_timestamps->int_val && !pending) timestamps = true; if (timestamps) { mytime = time (NULL); local = localtime (&mytime); strftime (msg3, sizeof (msg3), sv_timefmt->string, local); snprintf (msg2, sizeof (msg2), "%s%s", msg3, msg); } else { snprintf (msg2, sizeof (msg2), "%s", msg); } if (msg2[strlen (msg2) - 1] != '\n') { pending = 1; } else { pending = 0; } Con_Print (msg2); // also echo to debugging console if (sv_logfile) Qprintf (sv_logfile, "%s", msg2); } } /* Con_DPrintf A Con_Printf that only shows up if the "developer" cvar is set */ void Con_DPrintf (char *fmt, ...) { va_list argptr; char msg[MAXPRINTMSG]; if (!developer->int_val) return; va_start (argptr, fmt); vsnprintf (msg, sizeof (msg), fmt, argptr); va_end (argptr); Con_Printf ("%s", msg); } /* EVENT MESSAGES */ static void SV_PrintToClient (client_t *cl, int level, char *string) { ClientReliableWrite_Begin (cl, svc_print, strlen (string) + 3); ClientReliableWrite_Byte (cl, level); ClientReliableWrite_String (cl, string); } /* SV_ClientPrintf Sends text across to be displayed if the level passes */ void SV_ClientPrintf (client_t *cl, int level, char *fmt, ...) { va_list argptr; char string[1024]; if (level < cl->messagelevel) return; va_start (argptr, fmt); vsnprintf (string, sizeof (string), fmt, argptr); va_end (argptr); SV_PrintToClient (cl, level, string); } /* SV_BroadcastPrintf Sends text to all active clients */ void SV_BroadcastPrintf (int level, char *fmt, ...) { va_list argptr; char string[1024]; client_t *cl; int i; va_start (argptr, fmt); vsnprintf (string, sizeof (string), fmt, argptr); va_end (argptr); Con_Printf ("%s", string); // print to the console for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++) { if (level < cl->messagelevel) continue; if (!cl->state) continue; SV_PrintToClient (cl, level, string); } } /* SV_BroadcastCommand Sends text to all active clients */ void SV_BroadcastCommand (char *fmt, ...) { va_list argptr; char string[1024]; if (!sv.state) return; va_start (argptr, fmt); vsnprintf (string, sizeof (string), fmt, argptr); va_end (argptr); MSG_WriteByte (&sv.reliable_datagram, svc_stufftext); MSG_WriteString (&sv.reliable_datagram, string); } /* SV_Multicast Sends the contents of sv.multicast to a subset of the clients, then clears sv.multicast. MULTICAST_ALL same as broadcast MULTICAST_PVS send to clients potentially visible from org MULTICAST_PHS send to clients potentially hearable from org */ void SV_Multicast (vec3_t origin, int to) { client_t *client; byte *mask; mleaf_t *leaf; int leafnum; int j; qboolean reliable; leaf = Mod_PointInLeaf (origin, sv.worldmodel); if (!leaf) leafnum = 0; else leafnum = leaf - sv.worldmodel->leafs; reliable = false; switch (to) { case MULTICAST_ALL_R: reliable = true; // intentional fallthrough case MULTICAST_ALL: mask = sv.pvs; // leaf 0 is everything; break; case MULTICAST_PHS_R: reliable = true; // intentional fallthrough case MULTICAST_PHS: mask = sv.phs + leafnum * 4 * ((sv.worldmodel->numleafs + 31) >> 5); break; case MULTICAST_PVS_R: reliable = true; // intentional fallthrough case MULTICAST_PVS: mask = sv.pvs + leafnum * 4 * ((sv.worldmodel->numleafs + 31) >> 5); break; default: mask = NULL; SV_Error ("SV_Multicast: bad to:%i", to); } // send the data to all relevent clients for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++) { if (client->state != cs_spawned) continue; if (to == MULTICAST_PHS_R || to == MULTICAST_PHS) { vec3_t delta; VectorSubtract (origin, SVFIELD (client->edict, origin, vector), delta); if (Length (delta) <= 1024) goto inrange; } leaf = Mod_PointInLeaf (SVFIELD (client->edict, origin, vector), sv.worldmodel); if (leaf) { // -1 is because pvs rows are 1 based, not 0 based like leafs leafnum = leaf - sv.worldmodel->leafs - 1; if (!(mask[leafnum >> 3] & (1 << (leafnum & 7)))) { // Con_Printf ("supressed multicast\n"); continue; } } inrange: if (reliable) { ClientReliableCheckBlock (client, sv.multicast.cursize); ClientReliableWrite_SZ (client, sv.multicast.data, sv.multicast.cursize); } else SZ_Write (&client->datagram, sv.multicast.data, sv.multicast.cursize); } SZ_Clear (&sv.multicast); } /* SV_StartSound Each entity can have eight independant sound sources, like voice, weapon, feet, etc. Channel 0 is an auto-allocate channel, the others override anything already running on that entity/channel pair. An attenuation of 0 will play full volume everywhere in the level. Larger attenuations will drop off. (max 4 attenuation) */ void SV_StartSound (edict_t *entity, int channel, char *sample, int volume, float attenuation) { int sound_num; int field_mask; int i; int ent; vec3_t origin; qboolean use_phs; qboolean reliable = false; if (volume < 0 || volume > 255) SV_Error ("SV_StartSound: volume = %i", volume); if (attenuation < 0 || attenuation > 4) SV_Error ("SV_StartSound: attenuation = %f", attenuation); if (channel < 0 || channel > 15) SV_Error ("SV_StartSound: channel = %i", channel); // find precache number for sound for (sound_num = 1; sound_num < MAX_SOUNDS && sv.sound_precache[sound_num]; sound_num++) if (!strcmp (sample, sv.sound_precache[sound_num])) break; if (sound_num == MAX_SOUNDS || !sv.sound_precache[sound_num]) { Con_Printf ("SV_StartSound: %s not precacheed\n", sample); return; } ent = NUM_FOR_EDICT (&sv_pr_state, entity); if ((channel & 8) || !sv_phs->int_val) // no PHS flag { if (channel & 8) reliable = true; // sounds that break the phs are // reliable use_phs = false; channel &= 7; } else use_phs = true; // if (channel == CHAN_BODY || channel == CHAN_VOICE) // reliable = true; channel = (ent << 3) | channel; field_mask = 0; if (volume != DEFAULT_SOUND_PACKET_VOLUME) channel |= SND_VOLUME; if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION) channel |= SND_ATTENUATION; // use the entity origin unless it is a bmodel if (SVFIELD (entity, solid, float) == SOLID_BSP) { for (i = 0; i < 3; i++) origin[i] = SVFIELD (entity, origin, vector)[i] + 0.5 * (SVFIELD (entity, mins, vector)[i] + SVFIELD (entity, maxs, vector)[i]); } else { VectorCopy (SVFIELD (entity, origin, vector), origin); } MSG_WriteByte (&sv.multicast, svc_sound); MSG_WriteShort (&sv.multicast, channel); if (channel & SND_VOLUME) MSG_WriteByte (&sv.multicast, volume); if (channel & SND_ATTENUATION) MSG_WriteByte (&sv.multicast, attenuation * 64); MSG_WriteByte (&sv.multicast, sound_num); for (i = 0; i < 3; i++) MSG_WriteCoord (&sv.multicast, origin[i]); if (use_phs) SV_Multicast (origin, reliable ? MULTICAST_PHS_R : MULTICAST_PHS); else SV_Multicast (origin, reliable ? MULTICAST_ALL_R : MULTICAST_ALL); } /* FRAME UPDATES */ int sv_nailmodel, sv_supernailmodel, sv_playermodel; void SV_FindModelNumbers (void) { int i; sv_nailmodel = -1; sv_supernailmodel = -1; sv_playermodel = -1; for (i = 0; i < MAX_MODELS; i++) { if (!sv.model_precache[i]) break; if (!strcmp (sv.model_precache[i], "progs/spike.mdl")) sv_nailmodel = i; if (!strcmp (sv.model_precache[i], "progs/s_spike.mdl")) sv_supernailmodel = i; if (!strcmp (sv.model_precache[i], "progs/player.mdl")) sv_playermodel = i; } } /* SV_WriteClientdataToMessage */ void SV_WriteClientdataToMessage (client_t *client, sizebuf_t *msg) { int i; edict_t *other; edict_t *ent; ent = client->edict; // send the chokecount for r_netgraph if (client->chokecount) { MSG_WriteByte (msg, svc_chokecount); MSG_WriteByte (msg, client->chokecount); client->chokecount = 0; } // send a damage message if the player got hit this frame if (SVFIELD (ent, dmg_take, float) || SVFIELD (ent, dmg_save, float)) { other = PROG_TO_EDICT (&sv_pr_state, SVFIELD (ent, dmg_inflictor, entity)); MSG_WriteByte (msg, svc_damage); MSG_WriteByte (msg, SVFIELD (ent, dmg_save, float)); MSG_WriteByte (msg, SVFIELD (ent, dmg_take, float)); for (i = 0; i < 3; i++) MSG_WriteCoord (msg, SVFIELD (other, origin, vector)[i] + 0.5 * (SVFIELD (other, mins, vector)[i] + SVFIELD (other, maxs, vector)[i])); SVFIELD (ent, dmg_take, float) = 0; SVFIELD (ent, dmg_save, float) = 0; } // a fixangle might get lost in a dropped packet. Oh well. if (SVFIELD (ent, fixangle, float)) { MSG_WriteByte (msg, svc_setangle); for (i = 0; i < 3; i++) MSG_WriteAngle (msg, SVFIELD (ent, angles, vector)[i]); SVFIELD (ent, fixangle, float) = 0; } } /* SV_UpdateClientStats Performs a delta update of the stats array. This should only be performed when a reliable message can be delivered this frame. */ void SV_UpdateClientStats (client_t *client) { edict_t *ent; int stats[MAX_CL_STATS]; int i; ent = client->edict; memset (stats, 0, sizeof (stats)); // if we are a spectator and we are tracking a player, we get his stats // so our status bar reflects his if (client->spectator && client->spec_track > 0) ent = svs.clients[client->spec_track - 1].edict; stats[STAT_HEALTH] = SVFIELD (ent, health, float); stats[STAT_WEAPON] = SV_ModelIndex (PR_GetString (&sv_pr_state, SVFIELD (ent, weaponmodel, string))); stats[STAT_AMMO] = SVFIELD (ent, currentammo, float); stats[STAT_ARMOR] = SVFIELD (ent, armorvalue, float); stats[STAT_SHELLS] = SVFIELD (ent, ammo_shells, float); stats[STAT_NAILS] = SVFIELD (ent, ammo_nails, float); stats[STAT_ROCKETS] = SVFIELD (ent, ammo_rockets, float); stats[STAT_CELLS] = SVFIELD (ent, ammo_cells, float); if (!client->spectator) stats[STAT_ACTIVEWEAPON] = SVFIELD (ent, weapon, float); // stuff the sigil bits into the high bits of items for sbar stats[STAT_ITEMS] = (int) SVFIELD (ent, items, float) | ((int) *sv_globals.serverflags << 28); // Extensions to the QW 2.40 protocol for Mega2k --KB stats[STAT_VIEWHEIGHT] = (int) SVFIELD (ent, view_ofs, vector)[2]; // FIXME: this should become a * key! --KB if (SVFIELD (ent, movetype, float) == MOVETYPE_FLY && !atoi (Info_ValueForKey (svs.info, "playerfly"))) SVFIELD (ent, movetype, float) = MOVETYPE_WALK; stats[STAT_FLYMODE] = (SVFIELD (ent, movetype, float) == MOVETYPE_FLY); for (i = 0; i < MAX_CL_STATS; i++) if (stats[i] != client->stats[i]) { client->stats[i] = stats[i]; if (stats[i] >= 0 && stats[i] <= 255) { ClientReliableWrite_Begin (client, svc_updatestat, 3); ClientReliableWrite_Byte (client, i); ClientReliableWrite_Byte (client, stats[i]); } else { ClientReliableWrite_Begin (client, svc_updatestatlong, 6); ClientReliableWrite_Byte (client, i); ClientReliableWrite_Long (client, stats[i]); } } } /* SV_SendClientDatagram */ qboolean SV_SendClientDatagram (client_t *client) { byte buf[MAX_DATAGRAM]; sizebuf_t msg; msg.data = buf; msg.maxsize = sizeof (buf); msg.cursize = 0; msg.allowoverflow = true; msg.overflowed = false; // add the client specific data to the datagram SV_WriteClientdataToMessage (client, &msg); // send over all the objects that are in the PVS // this will include clients, a packetentities, and // possibly a nails update SV_WriteEntitiesToClient (client, &msg); // copy the accumulated multicast datagram // for this client out to the message if (client->datagram.overflowed) Con_Printf ("WARNING: datagram overflowed for %s\n", client->name); else SZ_Write (&msg, client->datagram.data, client->datagram.cursize); SZ_Clear (&client->datagram); // send deltas over reliable stream if (Netchan_CanReliable (&client->netchan)) SV_UpdateClientStats (client); if (msg.overflowed) { Con_Printf ("WARNING: msg overflowed for %s\n", client->name); SZ_Clear (&msg); } // send the datagram Netchan_Transmit (&client->netchan, msg.cursize, buf); return true; } /* SV_UpdateToReliableMessages */ void SV_UpdateToReliableMessages (void) { int i, j; client_t *client; pr_type_t *val; edict_t *ent; // check for changes to be sent over the reliable streams to all clients for (i = 0, host_client = svs.clients; i < MAX_CLIENTS; i++, host_client++) { if (host_client->state != cs_spawned) continue; if (host_client->sendinfo) { host_client->sendinfo = false; SV_FullClientUpdate (host_client, &sv.reliable_datagram); } if (host_client->old_frags != SVFIELD (host_client->edict, frags, float)) { for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++) { if (client->state < cs_connected) continue; ClientReliableWrite_Begin (client, svc_updatefrags, 4); ClientReliableWrite_Byte (client, i); ClientReliableWrite_Short (client, SVFIELD (host_client->edict, frags, float)); } host_client->old_frags = SVFIELD (host_client->edict, frags, float); } // maxspeed/entgravity changes ent = host_client->edict; val = GetEdictFieldValue (&sv_pr_state, ent, "gravity"); if (val && host_client->entgravity != val->float_var) { host_client->entgravity = val->float_var; ClientReliableWrite_Begin (host_client, svc_entgravity, 5); ClientReliableWrite_Float (host_client, host_client->entgravity); } val = GetEdictFieldValue (&sv_pr_state, ent, "maxspeed"); if (val && host_client->maxspeed != val->float_var) { host_client->maxspeed = val->float_var; ClientReliableWrite_Begin (host_client, svc_maxspeed, 5); ClientReliableWrite_Float (host_client, host_client->maxspeed); } } if (sv.datagram.overflowed) SZ_Clear (&sv.datagram); // append the broadcast messages to each client messages for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++) { if (client->state < cs_connected) continue; // reliables go to all connected or // spawned ClientReliableCheckBlock (client, sv.reliable_datagram.cursize); ClientReliableWrite_SZ (client, sv.reliable_datagram.data, sv.reliable_datagram.cursize); if (client->state != cs_spawned) continue; // datagrams only go to spawned SZ_Write (&client->datagram, sv.datagram.data, sv.datagram.cursize); } SZ_Clear (&sv.reliable_datagram); SZ_Clear (&sv.datagram); } #if defined(_WIN32) && !defined(__GNUC__) #pragma optimize( "", off ) #endif /* SV_SendClientMessages */ void SV_SendClientMessages (void) { int i, j; client_t *c; // update frags, names, etc SV_UpdateToReliableMessages (); // build individual updates for (i = 0, c = svs.clients; i < MAX_CLIENTS; i++, c++) { if (!c->state) continue; if (c->drop) { SV_DropClient (c); c->drop = false; continue; } // check to see if we have a backbuf to stick in the reliable if (c->num_backbuf) { // will it fit? if (c->netchan.message.cursize + c->backbuf_size[0] < c->netchan.message.maxsize) { Con_DPrintf ("%s: backbuf %d bytes\n", c->name, c->backbuf_size[0]); // it'll fit SZ_Write (&c->netchan.message, c->backbuf_data[0], c->backbuf_size[0]); // move along, move along for (j = 1; j < c->num_backbuf; j++) { memcpy (c->backbuf_data[j - 1], c->backbuf_data[j], c->backbuf_size[j]); c->backbuf_size[j - 1] = c->backbuf_size[j]; } c->num_backbuf--; if (c->num_backbuf) { memset (&c->backbuf, 0, sizeof (c->backbuf)); c->backbuf.data = c->backbuf_data[c->num_backbuf - 1]; c->backbuf.cursize = c->backbuf_size[c->num_backbuf - 1]; c->backbuf.maxsize = sizeof (c->backbuf_data[c->num_backbuf - 1]); } } } // if the reliable message overflowed, // drop the client if (c->netchan.message.overflowed) { extern void Analyze_Server_Packet (byte *data, int len); Analyze_Server_Packet (c->netchan.message.data, c->netchan.message.cursize); SZ_Clear (&c->netchan.message); SZ_Clear (&c->datagram); SV_BroadcastPrintf (PRINT_HIGH, "%s overflowed\n", c->name); Con_Printf ("WARNING: reliable overflow for %s\n", c->name); SV_DropClient (c); c->send_message = true; c->netchan.cleartime = 0; // don't choke this message } // only send messages if the client has sent one // and the bandwidth is not choked if (!c->send_message) continue; c->send_message = false; // try putting this after choke? if (!sv.paused && !Netchan_CanPacket (&c->netchan)) { c->chokecount++; continue; // bandwidth choke } if (c->state == cs_spawned) SV_SendClientDatagram (c); else Netchan_Transmit (&c->netchan, 0, NULL); // just update // reliable } } #if defined(_WIN32) && !defined(__GNUC__) #pragma optimize( "", on ) #endif /* SV_SendMessagesToAll FIXME: does this sequence right? */ void SV_SendMessagesToAll (void) { int i; client_t *c; for (i = 0, c = svs.clients; i < MAX_CLIENTS; i++, c++) if (c->state) // FIXME: should this only send to // active? c->send_message = true; SV_SendClientMessages (); }