diff options
Diffstat (limited to 'QW/server/sv_user.c')
| -rw-r--r-- | QW/server/sv_user.c | 1702 |
1 files changed, 1702 insertions, 0 deletions
diff --git a/QW/server/sv_user.c b/QW/server/sv_user.c new file mode 100644 index 0000000..a8e5570 --- /dev/null +++ b/QW/server/sv_user.c @@ -0,0 +1,1702 @@ +/* +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_user.c -- server code for moving users + +#include "qwsvdef.h" + +edict_t *sv_player; + +usercmd_t cmd; + +cvar_t cl_rollspeed = {"cl_rollspeed", "200"}; +cvar_t cl_rollangle = {"cl_rollangle", "2.0"}; +cvar_t sv_spectalk = {"sv_spectalk", "1"}; + +cvar_t sv_mapcheck = {"sv_mapcheck", "1"}; + +extern vec3_t player_mins; + +extern int fp_messages, fp_persecond, fp_secondsdead; +extern char fp_msg[]; +extern cvar_t pausable; + +/* +============================================================ + +USER STRINGCMD EXECUTION + +host_client and sv_player will be valid. +============================================================ +*/ + +/* +================ +SV_New_f + +Sends the first message from the server to a connected client. +This will be sent on the initial connection and upon each server load. +================ +*/ +void SV_New_f (void) +{ + char *gamedir; + int playernum; + + if (host_client->state == cs_spawned) + return; + + host_client->state = cs_connected; + host_client->connection_started = realtime; + + // send the info about the new client to all connected clients +// SV_FullClientUpdate (host_client, &sv.reliable_datagram); +// host_client->sendinfo = true; + + gamedir = Info_ValueForKey (svs.info, "*gamedir"); + if (!gamedir[0]) + gamedir = "qw"; + +//NOTE: This doesn't go through ClientReliableWrite since it's before the user +//spawns. These functions are written to not overflow + if (host_client->num_backbuf) { + Con_Printf("WARNING %s: [SV_New] Back buffered (%d0, clearing", host_client->name, host_client->netchan.message.cursize); + host_client->num_backbuf = 0; + SZ_Clear(&host_client->netchan.message); + } + + // send the serverdata + MSG_WriteByte (&host_client->netchan.message, svc_serverdata); + MSG_WriteLong (&host_client->netchan.message, PROTOCOL_VERSION); + MSG_WriteLong (&host_client->netchan.message, svs.spawncount); + MSG_WriteString (&host_client->netchan.message, gamedir); + + playernum = NUM_FOR_EDICT(host_client->edict)-1; + if (host_client->spectator) + playernum |= 128; + MSG_WriteByte (&host_client->netchan.message, playernum); + + // send full levelname + MSG_WriteString (&host_client->netchan.message, PR_GetString(sv.edicts->v.message)); + + // send the movevars + MSG_WriteFloat(&host_client->netchan.message, movevars.gravity); + MSG_WriteFloat(&host_client->netchan.message, movevars.stopspeed); + MSG_WriteFloat(&host_client->netchan.message, movevars.maxspeed); + MSG_WriteFloat(&host_client->netchan.message, movevars.spectatormaxspeed); + MSG_WriteFloat(&host_client->netchan.message, movevars.accelerate); + MSG_WriteFloat(&host_client->netchan.message, movevars.airaccelerate); + MSG_WriteFloat(&host_client->netchan.message, movevars.wateraccelerate); + MSG_WriteFloat(&host_client->netchan.message, movevars.friction); + MSG_WriteFloat(&host_client->netchan.message, movevars.waterfriction); + MSG_WriteFloat(&host_client->netchan.message, movevars.entgravity); + + // send music + MSG_WriteByte (&host_client->netchan.message, svc_cdtrack); + MSG_WriteByte (&host_client->netchan.message, sv.edicts->v.sounds); + + // send server info string + MSG_WriteByte (&host_client->netchan.message, svc_stufftext); + MSG_WriteString (&host_client->netchan.message, va("fullserverinfo \"%s\"\n", svs.info) ); +} + +/* +================== +SV_Soundlist_f +================== +*/ +void SV_Soundlist_f (void) +{ + char **s; + int n; + + if (host_client->state != cs_connected) + { + Con_Printf ("soundlist not valid -- allready spawned\n"); + return; + } + + // handle the case of a level changing while a client was connecting + if ( atoi(Cmd_Argv(1)) != svs.spawncount ) + { + Con_Printf ("SV_Soundlist_f from different level\n"); + SV_New_f (); + return; + } + + n = atoi(Cmd_Argv(2)); + +//NOTE: This doesn't go through ClientReliableWrite since it's before the user +//spawns. These functions are written to not overflow + if (host_client->num_backbuf) { + Con_Printf("WARNING %s: [SV_Soundlist] Back buffered (%d0, clearing", host_client->name, host_client->netchan.message.cursize); + host_client->num_backbuf = 0; + SZ_Clear(&host_client->netchan.message); + } + + MSG_WriteByte (&host_client->netchan.message, svc_soundlist); + MSG_WriteByte (&host_client->netchan.message, n); + for (s = sv.sound_precache+1 + n ; + *s && host_client->netchan.message.cursize < (MAX_MSGLEN/2); + s++, n++) + MSG_WriteString (&host_client->netchan.message, *s); + + MSG_WriteByte (&host_client->netchan.message, 0); + + // next msg + if (*s) + MSG_WriteByte (&host_client->netchan.message, n); + else + MSG_WriteByte (&host_client->netchan.message, 0); +} + +/* +================== +SV_Modellist_f +================== +*/ +void SV_Modellist_f (void) +{ + char **s; + int n; + + if (host_client->state != cs_connected) + { + Con_Printf ("modellist not valid -- allready spawned\n"); + return; + } + + // handle the case of a level changing while a client was connecting + if ( atoi(Cmd_Argv(1)) != svs.spawncount ) + { + Con_Printf ("SV_Modellist_f from different level\n"); + SV_New_f (); + return; + } + + n = atoi(Cmd_Argv(2)); + +//NOTE: This doesn't go through ClientReliableWrite since it's before the user +//spawns. These functions are written to not overflow + if (host_client->num_backbuf) { + Con_Printf("WARNING %s: [SV_Modellist] Back buffered (%d0, clearing", host_client->name, host_client->netchan.message.cursize); + host_client->num_backbuf = 0; + SZ_Clear(&host_client->netchan.message); + } + + MSG_WriteByte (&host_client->netchan.message, svc_modellist); + MSG_WriteByte (&host_client->netchan.message, n); + for (s = sv.model_precache+1+n ; + *s && host_client->netchan.message.cursize < (MAX_MSGLEN/2); + s++, n++) + MSG_WriteString (&host_client->netchan.message, *s); + MSG_WriteByte (&host_client->netchan.message, 0); + + // next msg + if (*s) + MSG_WriteByte (&host_client->netchan.message, n); + else + MSG_WriteByte (&host_client->netchan.message, 0); +} + +/* +================== +SV_PreSpawn_f +================== +*/ +void SV_PreSpawn_f (void) +{ + unsigned buf; + unsigned check; + + if (host_client->state != cs_connected) + { + Con_Printf ("prespawn not valid -- allready spawned\n"); + return; + } + + // handle the case of a level changing while a client was connecting + if ( atoi(Cmd_Argv(1)) != svs.spawncount ) + { + Con_Printf ("SV_PreSpawn_f from different level\n"); + SV_New_f (); + return; + } + + buf = atoi(Cmd_Argv(2)); + if (buf >= sv.num_signon_buffers) + buf = 0; + + if (!buf) { + // should be three numbers following containing checksums + check = atoi(Cmd_Argv(3)); + +// Con_DPrintf("Client check = %d\n", check); + + if (sv_mapcheck.value && check != sv.worldmodel->checksum && + check != sv.worldmodel->checksum2) { + SV_ClientPrintf (host_client, PRINT_HIGH, + "Map model file does not match (%s), %i != %i/%i.\n" + "You may need a new version of the map, or the proper install files.\n", + sv.modelname, check, sv.worldmodel->checksum, sv.worldmodel->checksum2); + SV_DropClient (host_client); + return; + } + host_client->checksum = check; + } + +//NOTE: This doesn't go through ClientReliableWrite since it's before the user +//spawns. These functions are written to not overflow + if (host_client->num_backbuf) { + Con_Printf("WARNING %s: [SV_PreSpawn] Back buffered (%d0, clearing", host_client->name, host_client->netchan.message.cursize); + host_client->num_backbuf = 0; + SZ_Clear(&host_client->netchan.message); + } + + SZ_Write (&host_client->netchan.message, + sv.signon_buffers[buf], + sv.signon_buffer_size[buf]); + + buf++; + if (buf == sv.num_signon_buffers) + { // all done prespawning + MSG_WriteByte (&host_client->netchan.message, svc_stufftext); + MSG_WriteString (&host_client->netchan.message, va("cmd spawn %i 0\n",svs.spawncount) ); + } + else + { // need to prespawn more + MSG_WriteByte (&host_client->netchan.message, svc_stufftext); + MSG_WriteString (&host_client->netchan.message, + va("cmd prespawn %i %i\n", svs.spawncount, buf) ); + } +} + +/* +================== +SV_Spawn_f +================== +*/ +void SV_Spawn_f (void) +{ + int i; + client_t *client; + edict_t *ent; + eval_t *val; + int n; + + if (host_client->state != cs_connected) + { + Con_Printf ("Spawn not valid -- allready spawned\n"); + return; + } + +// handle the case of a level changing while a client was connecting + if ( atoi(Cmd_Argv(1)) != svs.spawncount ) + { + Con_Printf ("SV_Spawn_f from different level\n"); + SV_New_f (); + return; + } + + n = atoi(Cmd_Argv(2)); + + // make sure n is valid + if ( n < 0 || n > MAX_CLIENTS ) + { + Con_Printf ("SV_Spawn_f invalid client start\n"); + SV_New_f (); + return; + } + + + +// send all current names, colors, and frag counts + // FIXME: is this a good thing? + SZ_Clear (&host_client->netchan.message); + +// send current status of all other players + + // normally this could overflow, but no need to check due to backbuf + for (i=n, client = svs.clients + n ; i<MAX_CLIENTS ; i++, client++) + SV_FullClientUpdateToClient (client, host_client); + +// send all current light styles + for (i=0 ; i<MAX_LIGHTSTYLES ; i++) + { + ClientReliableWrite_Begin (host_client, svc_lightstyle, + 3 + (sv.lightstyles[i] ? strlen(sv.lightstyles[i]) : 1)); + ClientReliableWrite_Byte (host_client, (char)i); + ClientReliableWrite_String (host_client, sv.lightstyles[i]); + } + + // set up the edict + ent = host_client->edict; + + memset (&ent->v, 0, progs->entityfields * 4); + ent->v.colormap = NUM_FOR_EDICT(ent); + ent->v.team = 0; // FIXME + ent->v.netname = PR_SetString(host_client->name); + + host_client->entgravity = 1.0; + val = GetEdictFieldValue(ent, "gravity"); + if (val) + val->_float = 1.0; + host_client->maxspeed = sv_maxspeed.value; + val = GetEdictFieldValue(ent, "maxspeed"); + if (val) + val->_float = sv_maxspeed.value; + +// +// force stats to be updated +// + memset (host_client->stats, 0, sizeof(host_client->stats)); + + ClientReliableWrite_Begin (host_client, svc_updatestatlong, 6); + ClientReliableWrite_Byte (host_client, STAT_TOTALSECRETS); + ClientReliableWrite_Long (host_client, pr_global_struct->total_secrets); + + ClientReliableWrite_Begin (host_client, svc_updatestatlong, 6); + ClientReliableWrite_Byte (host_client, STAT_TOTALMONSTERS); + ClientReliableWrite_Long (host_client, pr_global_struct->total_monsters); + + ClientReliableWrite_Begin (host_client, svc_updatestatlong, 6); + ClientReliableWrite_Byte (host_client, STAT_SECRETS); + ClientReliableWrite_Long (host_client, pr_global_struct->found_secrets); + + ClientReliableWrite_Begin (host_client, svc_updatestatlong, 6); + ClientReliableWrite_Byte (host_client, STAT_MONSTERS); + ClientReliableWrite_Long (host_client, pr_global_struct->killed_monsters); + + // get the client to check and download skins + // when that is completed, a begin command will be issued + ClientReliableWrite_Begin (host_client, svc_stufftext, 8); + ClientReliableWrite_String (host_client, "skins\n" ); + +} + +/* +================== +SV_SpawnSpectator +================== +*/ +void SV_SpawnSpectator (void) +{ + int i; + edict_t *e; + + VectorCopy (vec3_origin, sv_player->v.origin); + VectorCopy (vec3_origin, sv_player->v.view_ofs); + sv_player->v.view_ofs[2] = 22; + + // search for an info_playerstart to spawn the spectator at + for (i=MAX_CLIENTS-1 ; i<sv.num_edicts ; i++) + { + e = EDICT_NUM(i); + if (!strcmp(PR_GetString(e->v.classname), "info_player_start")) + { + VectorCopy (e->v.origin, sv_player->v.origin); + return; + } + } + +} + +/* +================== +SV_Begin_f +================== +*/ +void SV_Begin_f (void) +{ + unsigned pmodel = 0, emodel = 0; + int i; + + if (host_client->state == cs_spawned) + return; // don't begin again + + host_client->state = cs_spawned; + + // handle the case of a level changing while a client was connecting + if ( atoi(Cmd_Argv(1)) != svs.spawncount ) + { + Con_Printf ("SV_Begin_f from different level\n"); + SV_New_f (); + return; + } + + if (host_client->spectator) + { + SV_SpawnSpectator (); + + if (SpectatorConnect) { + // copy spawn parms out of the client_t + for (i=0 ; i< NUM_SPAWN_PARMS ; i++) + (&pr_global_struct->parm1)[i] = host_client->spawn_parms[i]; + + // call the spawn function + pr_global_struct->time = sv.time; + pr_global_struct->self = EDICT_TO_PROG(sv_player); + PR_ExecuteProgram (SpectatorConnect); + } + } + else + { + // copy spawn parms out of the client_t + for (i=0 ; i< NUM_SPAWN_PARMS ; i++) + (&pr_global_struct->parm1)[i] = host_client->spawn_parms[i]; + + // call the spawn function + pr_global_struct->time = sv.time; + pr_global_struct->self = EDICT_TO_PROG(sv_player); + PR_ExecuteProgram (pr_global_struct->ClientConnect); + + // actually spawn the player + pr_global_struct->time = sv.time; + pr_global_struct->self = EDICT_TO_PROG(sv_player); + PR_ExecuteProgram (pr_global_struct->PutClientInServer); + } + + // clear the net statistics, because connecting gives a bogus picture + host_client->netchan.frame_latency = 0; + host_client->netchan.frame_rate = 0; + host_client->netchan.drop_count = 0; + host_client->netchan.good_count = 0; + + //check he's not cheating + + pmodel = atoi(Info_ValueForKey (host_client->userinfo, "pmodel")); + emodel = atoi(Info_ValueForKey (host_client->userinfo, "emodel")); + + if (pmodel != sv.model_player_checksum || + emodel != sv.eyes_player_checksum) + SV_BroadcastPrintf (PRINT_HIGH, "%s WARNING: non standard player/eyes model detected\n", host_client->name); + + // if we are paused, tell the client + if (sv.paused) { + ClientReliableWrite_Begin (host_client, svc_setpause, 2); + ClientReliableWrite_Byte (host_client, sv.paused); + SV_ClientPrintf(host_client, PRINT_HIGH, "Server is paused.\n"); + } + +#if 0 +// +// send a fixangle over the reliable channel to make sure it gets there +// Never send a roll angle, because savegames can catch the server +// in a state where it is expecting the client to correct the angle +// and it won't happen if the game was just loaded, so you wind up +// with a permanent head tilt + ent = EDICT_NUM( 1 + (host_client - svs.clients) ); + MSG_WriteByte (&host_client->netchan.message, svc_setangle); + for (i=0 ; i < 2 ; i++) + MSG_WriteAngle (&host_client->netchan.message, ent->v.angles[i] ); + MSG_WriteAngle (&host_client->netchan.message, 0 ); +#endif +} + +//============================================================================= + +/* +================== +SV_NextDownload_f +================== +*/ +void SV_NextDownload_f (void) +{ + byte buffer[1024]; + int r; + int percent; + int size; + + if (!host_client->download) + return; + + r = host_client->downloadsize - host_client->downloadcount; + if (r > 768) + r = 768; + r = fread (buffer, 1, r, host_client->download); + ClientReliableWrite_Begin (host_client, svc_download, 6+r); + ClientReliableWrite_Short (host_client, r); + + host_client->downloadcount += r; + size = host_client->downloadsize; + if (!size) + size = 1; + percent = host_client->downloadcount*100/size; + ClientReliableWrite_Byte (host_client, percent); + ClientReliableWrite_SZ (host_client, buffer, r); + + if (host_client->downloadcount != host_client->downloadsize) + return; + + fclose (host_client->download); + host_client->download = NULL; + +} + +void OutofBandPrintf(netadr_t where, char *fmt, ...) +{ + va_list argptr; + char send[1024]; + + send[0] = 0xff; + send[1] = 0xff; + send[2] = 0xff; + send[3] = 0xff; + send[4] = A2C_PRINT; + va_start (argptr, fmt); + vsprintf (send+5, fmt, argptr); + va_end (argptr); + + NET_SendPacket (strlen(send)+1, send, where); +} + +/* +================== +SV_NextUpload +================== +*/ +void SV_NextUpload (void) +{ + byte buffer[1024]; + int r; + int percent; + int size; + client_t *client; + + if (!*host_client->uploadfn) { + SV_ClientPrintf(host_client, PRINT_HIGH, "Upload denied\n"); + ClientReliableWrite_Begin (host_client, svc_stufftext, 8); + ClientReliableWrite_String (host_client, "stopul"); + + // suck out rest of packet + size = MSG_ReadShort (); MSG_ReadByte (); + msg_readcount += size; + return; + } + + size = MSG_ReadShort (); + percent = MSG_ReadByte (); + + if (!host_client->upload) + { + host_client->upload = fopen(host_client->uploadfn, "wb"); + if (!host_client->upload) { + Sys_Printf("Can't create %s\n", host_client->uploadfn); + ClientReliableWrite_Begin (host_client, svc_stufftext, 8); + ClientReliableWrite_String (host_client, "stopul"); + *host_client->uploadfn = 0; + return; + } + Sys_Printf("Receiving %s from %d...\n", host_client->uploadfn, host_client->userid); + if (host_client->remote_snap) + OutofBandPrintf(host_client->snap_from, "Server receiving %s from %d...\n", host_client->uploadfn, host_client->userid); + } + + fwrite (net_message.data + msg_readcount, 1, size, host_client->upload); + msg_readcount += size; + +Con_DPrintf ("UPLOAD: %d received\n", size); + + if (percent != 100) { + ClientReliableWrite_Begin (host_client, svc_stufftext, 8); + ClientReliableWrite_String (host_client, "nextul\n"); + } else { + fclose (host_client->upload); + host_client->upload = NULL; + + Sys_Printf("%s upload completed.\n", host_client->uploadfn); + + if (host_client->remote_snap) { + char *p; + + if ((p = strchr(host_client->uploadfn, '/')) != NULL) + p++; + else + p = host_client->uploadfn; + OutofBandPrintf(host_client->snap_from, "%s upload completed.\nTo download, enter:\ndownload %s\n", + host_client->uploadfn, p); + } + } + +} + +/* +================== +SV_BeginDownload_f +================== +*/ +void SV_BeginDownload_f(void) +{ + char *name; + extern cvar_t allow_download; + extern cvar_t allow_download_skins; + extern cvar_t allow_download_models; + extern cvar_t allow_download_sounds; + extern cvar_t allow_download_maps; + extern int file_from_pak; // ZOID did file come from pak? + + name = Cmd_Argv(1); +// hacked by zoid to allow more conrol over download + // first off, no .. or global allow check + if (strstr (name, "..") || !allow_download.value + // leading dot is no good + || *name == '.' + // leading slash bad as well, must be in subdir + || *name == '/' + // next up, skin check + || (strncmp(name, "skins/", 6) == 0 && !allow_download_skins.value) + // now models + || (strncmp(name, "progs/", 6) == 0 && !allow_download_models.value) + // now sounds + || (strncmp(name, "sound/", 6) == 0 && !allow_download_sounds.value) + // now maps (note special case for maps, must not be in pak) + || (strncmp(name, "maps/", 6) == 0 && !allow_download_maps.value) + // MUST be in a subdirectory + || !strstr (name, "/") ) + { // don't allow anything with .. path + ClientReliableWrite_Begin (host_client, svc_download, 4); + ClientReliableWrite_Short (host_client, -1); + ClientReliableWrite_Byte (host_client, 0); + return; + } + + if (host_client->download) { + fclose (host_client->download); + host_client->download = NULL; + } + + // lowercase name (needed for casesen file systems) + { + char *p; + + for (p = name; *p; p++) + *p = (char)tolower(*p); + } + + + host_client->downloadsize = COM_FOpenFile (name, &host_client->download); + host_client->downloadcount = 0; + + if (!host_client->download + // special check for maps, if it came from a pak file, don't allow + // download ZOID + || (strncmp(name, "maps/", 5) == 0 && file_from_pak)) + { + if (host_client->download) { + fclose(host_client->download); + host_client->download = NULL; + } + + Sys_Printf ("Couldn't download %s to %s\n", name, host_client->name); + ClientReliableWrite_Begin (host_client, svc_download, 4); + ClientReliableWrite_Short (host_client, -1); + ClientReliableWrite_Byte (host_client, 0); + return; + } + + SV_NextDownload_f (); + Sys_Printf ("Downloading %s to %s\n", name, host_client->name); +} + +//============================================================================= + +/* +================== +SV_Say +================== +*/ +void SV_Say (qboolean team) +{ + client_t *client; + int j, tmp; + char *p; + char text[2048]; + char t1[32], *t2; + + if (Cmd_Argc () < 2) + return; + + if (team) + { + strncpy (t1, Info_ValueForKey (host_client->userinfo, "team"), 31); + t1[31] = 0; + } + + if (host_client->spectator && (!sv_spectalk.value || team)) + sprintf (text, "[SPEC] %s: ", host_client->name); + else if (team) + sprintf (text, "(%s): ", host_client->name); + else { + sprintf (text, "%s: ", host_client->name); + } + + if (fp_messages) { + if (!sv.paused && realtime<host_client->lockedtill) { + SV_ClientPrintf(host_client, PRINT_CHAT, + "You can't talk for %d more seconds\n", + (int) (host_client->lockedtill - realtime)); + return; + } + tmp = host_client->whensaidhead - fp_messages + 1; + if (tmp < 0) + tmp = 10+tmp; + if (!sv.paused && + host_client->whensaid[tmp] && (realtime-host_client->whensaid[tmp] < fp_persecond)) { + host_client->lockedtill = realtime + fp_secondsdead; + if (fp_msg[0]) + SV_ClientPrintf(host_client, PRINT_CHAT, + "FloodProt: %s\n", fp_msg); + else + SV_ClientPrintf(host_client, PRINT_CHAT, + "FloodProt: You can't talk for %d seconds.\n", fp_secondsdead); + return; + } + host_client->whensaidhead++; + if (host_client->whensaidhead > 9) + host_client->whensaidhead = 0; + host_client->whensaid[host_client->whensaidhead] = realtime; + } + + p = Cmd_Args(); + + if (*p == '"') + { + p++; + p[Q_strlen(p)-1] = 0; + } + + Q_strcat(text, p); + Q_strcat(text, "\n"); + + Sys_Printf ("%s", text); + + for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++) + { + if (client->state != cs_spawned) + continue; + if (host_client->spectator && !sv_spectalk.value) + if (!client->spectator) + continue; + + if (team) + { + // the spectator team + if (host_client->spectator) { + if (!client->spectator) + continue; + } else { + t2 = Info_ValueForKey (client->userinfo, "team"); + if (strcmp(t1, t2) || client->spectator) + continue; // on different teams + } + } + SV_ClientPrintf(client, PRINT_CHAT, "%s", text); + } +} + + +/* +================== +SV_Say_f +================== +*/ +void SV_Say_f(void) +{ + SV_Say (false); +} +/* +================== +SV_Say_Team_f +================== +*/ +void SV_Say_Team_f(void) +{ + SV_Say (true); +} + + + +//============================================================================ + +/* +================= +SV_Pings_f + +The client is showing the scoreboard, so send new ping times for all +clients +================= +*/ +void SV_Pings_f (void) +{ + client_t *client; + int j; + + for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++) + { + if (client->state != cs_spawned) + continue; + + ClientReliableWrite_Begin (host_client, svc_updateping, 4); + ClientReliableWrite_Byte (host_client, j); + ClientReliableWrite_Short (host_client, SV_CalcPing(client)); + ClientReliableWrite_Begin (host_client, svc_updatepl, 4); + ClientReliableWrite_Byte (host_client, j); + ClientReliableWrite_Byte (host_client, client->lossage); + } +} + + + +/* +================== +SV_Kill_f +================== +*/ +void SV_Kill_f (void) +{ + if (sv_player->v.health <= 0) + { + SV_ClientPrintf (host_client, PRINT_HIGH, "Can't suicide -- allready dead!\n"); + return; + } + + pr_global_struct->time = sv.time; + pr_global_struct->self = EDICT_TO_PROG(sv_player); + PR_ExecuteProgram (pr_global_struct->ClientKill); +} + +/* +================== +SV_TogglePause +================== +*/ +void SV_TogglePause (const char *msg) +{ + int i; + client_t *cl; + + sv.paused ^= 1; + + if (msg) + SV_BroadcastPrintf (PRINT_HIGH, "%s", msg); + + // send notification to all clients + for (i=0, cl = svs.clients ; i<MAX_CLIENTS ; i++, cl++) + { + if (!cl->state) + continue; + ClientReliableWrite_Begin (cl, svc_setpause, 2); + ClientReliableWrite_Byte (cl, sv.paused); + } +} + + +/* +================== +SV_Pause_f +================== +*/ +void SV_Pause_f (void) +{ + int i; + client_t *cl; + char st[sizeof(host_client->name) + 32]; + + if (!pausable.value) { + SV_ClientPrintf (host_client, PRINT_HIGH, "Pause not allowed.\n"); + return; + } + + if (host_client->spectator) { + SV_ClientPrintf (host_client, PRINT_HIGH, "Spectators can not pause.\n"); + return; + } + + if (sv.paused) + sprintf (st, "%s paused the game\n", host_client->name); + else + sprintf (st, "%s unpaused the game\n", host_client->name); + + SV_TogglePause(st); +} + + +/* +================= +SV_Drop_f + +The client is going to disconnect, so remove the connection immediately +================= +*/ +void SV_Drop_f (void) +{ + SV_EndRedirect (); + if (!host_client->spectator) + SV_BroadcastPrintf (PRINT_HIGH, "%s dropped\n", host_client->name); + SV_DropClient (host_client); +} + +/* +================= +SV_PTrack_f + +Change the bandwidth estimate for a client +================= +*/ +void SV_PTrack_f (void) +{ + int i; + edict_t *ent, *tent; + + if (!host_client->spectator) + return; + + if (Cmd_Argc() != 2) + { + // turn off tracking + host_client->spec_track = 0; + ent = EDICT_NUM(host_client - svs.clients + 1); + tent = EDICT_NUM(0); + ent->v.goalentity = EDICT_TO_PROG(tent); + return; + } + + i = atoi(Cmd_Argv(1)); + if (i < 0 || i >= MAX_CLIENTS || svs.clients[i].state != cs_spawned || + svs.clients[i].spectator) { + SV_ClientPrintf (host_client, PRINT_HIGH, "Invalid client to track\n"); + host_client->spec_track = 0; + ent = EDICT_NUM(host_client - svs.clients + 1); + tent = EDICT_NUM(0); + ent->v.goalentity = EDICT_TO_PROG(tent); + return; + } + host_client->spec_track = i + 1; // now tracking + + ent = EDICT_NUM(host_client - svs.clients + 1); + tent = EDICT_NUM(i + 1); + ent->v.goalentity = EDICT_TO_PROG(tent); +} + + +/* +================= +SV_Rate_f + +Change the bandwidth estimate for a client +================= +*/ +void SV_Rate_f (void) +{ + int rate; + + if (Cmd_Argc() != 2) + { + SV_ClientPrintf (host_client, PRINT_HIGH, "Current rate is %i\n", + (int)(1.0/host_client->netchan.rate + 0.5)); + return; + } + + rate = atoi(Cmd_Argv(1)); + if (rate < 500) + rate = 500; + if (rate > 10000) + rate = 10000; + + SV_ClientPrintf (host_client, PRINT_HIGH, "Net rate set to %i\n", rate); + host_client->netchan.rate = 1.0/rate; +} + + +/* +================= +SV_Msg_f + +Change the message level for a client +================= +*/ +void SV_Msg_f (void) +{ + if (Cmd_Argc() != 2) + { + SV_ClientPrintf (host_client, PRINT_HIGH, "Current msg level is %i\n", + host_client->messagelevel); + return; + } + + host_client->messagelevel = atoi(Cmd_Argv(1)); + + SV_ClientPrintf (host_client, PRINT_HIGH, "Msg level set to %i\n", host_client->messagelevel); +} + +/* +================== +SV_SetInfo_f + +Allow clients to change userinfo +================== +*/ +void SV_SetInfo_f (void) +{ + int i; + char oldval[MAX_INFO_STRING]; + + + if (Cmd_Argc() == 1) + { + Con_Printf ("User info settings:\n"); + Info_Print (host_client->userinfo); + return; + } + + if (Cmd_Argc() != 3) + { + Con_Printf ("usage: setinfo [ <key> <value> ]\n"); + return; + } + + if (Cmd_Argv(1)[0] == '*') + return; // don't set priveledged values + + strcpy(oldval, Info_ValueForKey(host_client->userinfo, Cmd_Argv(1))); + + Info_SetValueForKey (host_client->userinfo, Cmd_Argv(1), Cmd_Argv(2), MAX_INFO_STRING); +// name is extracted below in ExtractFromUserInfo +// strncpy (host_client->name, Info_ValueForKey (host_client->userinfo, "name") +// , sizeof(host_client->name)-1); +// SV_FullClientUpdate (host_client, &sv.reliable_datagram); +// host_client->sendinfo = true; + + if (!strcmp(Info_ValueForKey(host_client->userinfo, Cmd_Argv(1)), oldval)) + return; // key hasn't changed + + // process any changed values + SV_ExtractFromUserinfo (host_client); + + i = host_client - svs.clients; + MSG_WriteByte (&sv.reliable_datagram, svc_setinfo); + MSG_WriteByte (&sv.reliable_datagram, i); + MSG_WriteString (&sv.reliable_datagram, Cmd_Argv(1)); + MSG_WriteString (&sv.reliable_datagram, Info_ValueForKey(host_client->userinfo, Cmd_Argv(1))); +} + +/* +================== +SV_ShowServerinfo_f + +Dumps the serverinfo info string +================== +*/ +void SV_ShowServerinfo_f (void) +{ + Info_Print (svs.info); +} + +void SV_NoSnap_f(void) +{ + if (*host_client->uploadfn) { + *host_client->uploadfn = 0; + SV_BroadcastPrintf (PRINT_HIGH, "%s refused remote screenshot\n", host_client->name); + } +} + +typedef struct +{ + char *name; + void (*func) (void); +} ucmd_t; + +ucmd_t ucmds[] = +{ + {"new", SV_New_f}, + {"modellist", SV_Modellist_f}, + {"soundlist", SV_Soundlist_f}, + {"prespawn", SV_PreSpawn_f}, + {"spawn", SV_Spawn_f}, + {"begin", SV_Begin_f}, + + {"drop", SV_Drop_f}, + {"pings", SV_Pings_f}, + +// issued by hand at client consoles + {"rate", SV_Rate_f}, + {"kill", SV_Kill_f}, + {"pause", SV_Pause_f}, + {"msg", SV_Msg_f}, + + {"say", SV_Say_f}, + {"say_team", SV_Say_Team_f}, + + {"setinfo", SV_SetInfo_f}, + + {"serverinfo", SV_ShowServerinfo_f}, + + {"download", SV_BeginDownload_f}, + {"nextdl", SV_NextDownload_f}, + + {"ptrack", SV_PTrack_f}, //ZOID - used with autocam + + {"snap", SV_NoSnap_f}, + + {NULL, NULL} +}; + +/* +================== +SV_ExecuteUserCommand +================== +*/ +void SV_ExecuteUserCommand (char *s) +{ + ucmd_t *u; + + Cmd_TokenizeString (s); + sv_player = host_client->edict; + + SV_BeginRedirect (RD_CLIENT); + + for (u=ucmds ; u->name ; u++) + if (!strcmp (Cmd_Argv(0), u->name) ) + { + u->func (); + break; + } + + if (!u->name) + Con_Printf ("Bad user command: %s\n", Cmd_Argv(0)); + + SV_EndRedirect (); +} + +/* +=========================================================================== + +USER CMD EXECUTION + +=========================================================================== +*/ + +/* +=============== +V_CalcRoll + +Used by view and sv_user +=============== +*/ +float V_CalcRoll (vec3_t angles, vec3_t velocity) +{ + vec3_t forward, right, up; + float sign; + float side; + float value; + + AngleVectors (angles, forward, right, up); + side = DotProduct (velocity, right); + sign = side < 0 ? -1 : 1; + side = fabs(side); + + value = cl_rollangle.value; + + if (side < cl_rollspeed.value) + side = side * value / cl_rollspeed.value; + else + side = value; + + return side*sign; + +} + + + + +//============================================================================ + +vec3_t pmove_mins, pmove_maxs; + +/* +==================== +AddLinksToPmove + +==================== +*/ +void AddLinksToPmove ( areanode_t *node ) +{ + link_t *l, *next; + edict_t *check; + int pl; + int i; + physent_t *pe; + + pl = EDICT_TO_PROG(sv_player); + + // touch linked edicts + for (l = node->solid_edicts.next ; l != &node->solid_edicts ; l = next) + { + next = l->next; + check = EDICT_FROM_AREA(l); + + if (check->v.owner == pl) + continue; // player's own missile + if (check->v.solid == SOLID_BSP + || check->v.solid == SOLID_BBOX + || check->v.solid == SOLID_SLIDEBOX) + { + if (check == sv_player) + continue; + + for (i=0 ; i<3 ; i++) + if (check->v.absmin[i] > pmove_maxs[i] + || check->v.absmax[i] < pmove_mins[i]) + break; + if (i != 3) + continue; + if (pmove.numphysent == MAX_PHYSENTS) + return; + pe = &pmove.physents[pmove.numphysent]; + pmove.numphysent++; + + VectorCopy (check->v.origin, pe->origin); + pe->info = NUM_FOR_EDICT(check); + if (check->v.solid == SOLID_BSP) + pe->model = sv.models[(int)(check->v.modelindex)]; + else + { + pe->model = NULL; + VectorCopy (check->v.mins, pe->mins); + VectorCopy (check->v.maxs, pe->maxs); + } + } + } + +// recurse down both sides + if (node->axis == -1) + return; + + if ( pmove_maxs[node->axis] > node->dist ) + AddLinksToPmove ( node->children[0] ); + if ( pmove_mins[node->axis] < node->dist ) + AddLinksToPmove ( node->children[1] ); +} + + +/* +================ +AddAllEntsToPmove + +For debugging +================ +*/ +void AddAllEntsToPmove (void) +{ + int e; + edict_t *check; + int i; + physent_t *pe; + int pl; + + pl = EDICT_TO_PROG(sv_player); + check = NEXT_EDICT(sv.edicts); + for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check)) + { + if (check->free) + continue; + if (check->v.owner == pl) + continue; + if (check->v.solid == SOLID_BSP + || check->v.solid == SOLID_BBOX + || check->v.solid == SOLID_SLIDEBOX) + { + if (check == sv_player) + continue; + + for (i=0 ; i<3 ; i++) + if (check->v.absmin[i] > pmove_maxs[i] + || check->v.absmax[i] < pmove_mins[i]) + break; + if (i != 3) + continue; + pe = &pmove.physents[pmove.numphysent]; + + VectorCopy (check->v.origin, pe->origin); + pmove.physents[pmove.numphysent].info = e; + if (check->v.solid == SOLID_BSP) + pe->model = sv.models[(int)(check->v.modelindex)]; + else + { + pe->model = NULL; + VectorCopy (check->v.mins, pe->mins); + VectorCopy (check->v.maxs, pe->maxs); + } + + if (++pmove.numphysent == MAX_PHYSENTS) + break; + } + } +} + +/* +=========== +SV_PreRunCmd +=========== +Done before running a player command. Clears the touch array +*/ +byte playertouch[(MAX_EDICTS+7)/8]; + +void SV_PreRunCmd(void) +{ + memset(playertouch, 0, sizeof(playertouch)); +} + +/* +=========== +SV_RunCmd +=========== +*/ +void SV_RunCmd (usercmd_t *ucmd) +{ + edict_t *ent; + int i, n; + int oldmsec; + + cmd = *ucmd; + + // chop up very long commands + if (cmd.msec > 50) + { + oldmsec = ucmd->msec; + cmd.msec = oldmsec/2; + SV_RunCmd (&cmd); + cmd.msec = oldmsec/2; + cmd.impulse = 0; + SV_RunCmd (&cmd); + return; + } + + if (!sv_player->v.fixangle) + VectorCopy (ucmd->angles, sv_player->v.v_angle); + + sv_player->v.button0 = ucmd->buttons & 1; + sv_player->v.button2 = (ucmd->buttons & 2)>>1; + if (ucmd->impulse) + sv_player->v.impulse = ucmd->impulse; + +// +// angles +// show 1/3 the pitch angle and all the roll angle + if (sv_player->v.health > 0) + { + if (!sv_player->v.fixangle) + { + sv_player->v.angles[PITCH] = -sv_player->v.v_angle[PITCH]/3; + sv_player->v.angles[YAW] = sv_player->v.v_angle[YAW]; + } + sv_player->v.angles[ROLL] = + V_CalcRoll (sv_player->v.angles, sv_player->v.velocity)*4; + } + + host_frametime = ucmd->msec * 0.001; + if (host_frametime > 0.1) + host_frametime = 0.1; + + if (!host_client->spectator) + { + pr_global_struct->frametime = host_frametime; + + pr_global_struct->time = sv.time; + pr_global_struct->self = EDICT_TO_PROG(sv_player); + PR_ExecuteProgram (pr_global_struct->PlayerPreThink); + + SV_RunThink (sv_player); + } + + for (i=0 ; i<3 ; i++) + pmove.origin[i] = sv_player->v.origin[i] + (sv_player->v.mins[i] - player_mins[i]); + VectorCopy (sv_player->v.velocity, pmove.velocity); + VectorCopy (sv_player->v.v_angle, pmove.angles); + + pmove.spectator = host_client->spectator; + pmove.waterjumptime = sv_player->v.teleport_time; + pmove.numphysent = 1; + pmove.physents[0].model = sv.worldmodel; + pmove.cmd = *ucmd; + pmove.dead = sv_player->v.health <= 0; + pmove.oldbuttons = host_client->oldbuttons; + + movevars.entgravity = host_client->entgravity; + movevars.maxspeed = host_client->maxspeed; + + for (i=0 ; i<3 ; i++) + { + pmove_mins[i] = pmove.origin[i] - 256; + pmove_maxs[i] = pmove.origin[i] + 256; + } +#if 1 + AddLinksToPmove ( sv_areanodes ); +#else + AddAllEntsToPmove (); +#endif + +#if 0 +{ + int before, after; + +before = PM_TestPlayerPosition (pmove.origin); + PlayerMove (); +after = PM_TestPlayerPosition (pmove.origin); + +if (sv_player->v.health > 0 && before && !after ) + Con_Printf ("player %s got stuck in playermove!!!!\n", host_client->name); +} +#else + PlayerMove (); +#endif + + host_client->oldbuttons = pmove.oldbuttons; + sv_player->v.teleport_time = pmove.waterjumptime; + sv_player->v.waterlevel = waterlevel; + sv_player->v.watertype = watertype; + if (onground != -1) + { + sv_player->v.flags = (int)sv_player->v.flags | FL_ONGROUND; + sv_player->v.groundentity = EDICT_TO_PROG(EDICT_NUM(pmove.physents[onground].info)); + } + else + sv_player->v.flags = (int)sv_player->v.flags & ~FL_ONGROUND; + for (i=0 ; i<3 ; i++) + sv_player->v.origin[i] = pmove.origin[i] - (sv_player->v.mins[i] - player_mins[i]); + +#if 0 + // truncate velocity the same way the net protocol will + for (i=0 ; i<3 ; i++) + sv_player->v.velocity[i] = (int)pmove.velocity[i]; +#else + VectorCopy (pmove.velocity, sv_player->v.velocity); +#endif + + VectorCopy (pmove.angles, sv_player->v.v_angle); + + if (!host_client->spectator) + { + // link into place and touch triggers + SV_LinkEdict (sv_player, true); + + // touch other objects + for (i=0 ; i<pmove.numtouch ; i++) + { + n = pmove.physents[pmove.touchindex[i]].info; + ent = EDICT_NUM(n); + if (!ent->v.touch || (playertouch[n/8]&(1<<(n%8)))) + continue; + pr_global_struct->self = EDICT_TO_PROG(ent); + pr_global_struct->other = EDICT_TO_PROG(sv_player); + PR_ExecuteProgram (ent->v.touch); + playertouch[n/8] |= 1 << (n%8); + } + } +} + +/* +=========== +SV_PostRunCmd +=========== +Done after running a player command. +*/ +void SV_PostRunCmd(void) +{ + // run post-think + + if (!host_client->spectator) { + pr_global_struct->time = sv.time; + pr_global_struct->self = EDICT_TO_PROG(sv_player); + PR_ExecuteProgram (pr_global_struct->PlayerPostThink); + SV_RunNewmis (); + } else if (SpectatorThink) { + pr_global_struct->time = sv.time; + pr_global_struct->self = EDICT_TO_PROG(sv_player); + PR_ExecuteProgram (SpectatorThink); + } +} + + +/* +=================== +SV_ExecuteClientMessage + +The current net_message is parsed for the given client +=================== +*/ +void SV_ExecuteClientMessage (client_t *cl) +{ + int c; + char *s; + usercmd_t oldest, oldcmd, newcmd; + client_frame_t *frame; + vec3_t o; + qboolean move_issued = false; //only allow one move command + int checksumIndex; + byte checksum, calculatedChecksum; + int seq_hash; + + // calc ping time + frame = &cl->frames[cl->netchan.incoming_acknowledged & UPDATE_MASK]; + frame->ping_time = realtime - frame->senttime; + + // make sure the reply sequence number matches the incoming + // sequence number + if (cl->netchan.incoming_sequence >= cl->netchan.outgoing_sequence) + cl->netchan.outgoing_sequence = cl->netchan.incoming_sequence; + else + cl->send_message = false; // don't reply, sequences have slipped + + // save time for ping calculations + cl->frames[cl->netchan.outgoing_sequence & UPDATE_MASK].senttime = realtime; + cl->frames[cl->netchan.outgoing_sequence & UPDATE_MASK].ping_time = -1; + + host_client = cl; + sv_player = host_client->edict; + +// seq_hash = (cl->netchan.incoming_sequence & 0xffff) ; // ^ QW_CHECK_HASH; + seq_hash = cl->netchan.incoming_sequence; + + // mark time so clients will know how much to predict + // other players + cl->localtime = sv.time; + cl->delta_sequence = -1; // no delta unless requested + while (1) + { + if (msg_badread) + { + Con_Printf ("SV_ReadClientMessage: badread\n"); + SV_DropClient (cl); + return; + } + + c = MSG_ReadByte (); + if (c == -1) + break; + + switch (c) + { + default: + Con_Printf ("SV_ReadClientMessage: unknown command char\n"); + SV_DropClient (cl); + return; + + case clc_nop: + break; + + case clc_delta: + cl->delta_sequence = MSG_ReadByte (); + break; + + case clc_move: + if (move_issued) + return; // someone is trying to cheat... + + move_issued = true; + + checksumIndex = MSG_GetReadCount(); + checksum = (byte)MSG_ReadByte (); + + // read loss percentage + cl->lossage = MSG_ReadByte(); + + MSG_ReadDeltaUsercmd (&nullcmd, &oldest); + MSG_ReadDeltaUsercmd (&oldest, &oldcmd); + MSG_ReadDeltaUsercmd (&oldcmd, &newcmd); + + if ( cl->state != cs_spawned ) + break; + + // if the checksum fails, ignore the rest of the packet + calculatedChecksum = COM_BlockSequenceCRCByte( + net_message.data + checksumIndex + 1, + MSG_GetReadCount() - checksumIndex - 1, + seq_hash); + + if (calculatedChecksum != checksum) + { + Con_DPrintf ("Failed command checksum for %s(%d) (%d != %d)\n", + cl->name, cl->netchan.incoming_sequence, checksum, calculatedChecksum); + return; + } + + if (!sv.paused) { + SV_PreRunCmd(); + + if (net_drop < 20) + { + while (net_drop > 2) + { + SV_RunCmd (&cl->lastcmd); + net_drop--; + } + if (net_drop > 1) + SV_RunCmd (&oldest); + if (net_drop > 0) + SV_RunCmd (&oldcmd); + } + SV_RunCmd (&newcmd); + + SV_PostRunCmd(); + } + + cl->lastcmd = newcmd; + cl->lastcmd.buttons = 0; // avoid multiple fires on lag + break; + + + case clc_stringcmd: + s = MSG_ReadString (); + SV_ExecuteUserCommand (s); + break; + + case clc_tmove: + o[0] = MSG_ReadCoord(); + o[1] = MSG_ReadCoord(); + o[2] = MSG_ReadCoord(); + // only allowed by spectators + if (host_client->spectator) { + VectorCopy(o, sv_player->v.origin); + SV_LinkEdict(sv_player, false); + } + break; + + case clc_upload: + SV_NextUpload(); + break; + + } + } +} + +/* +============== +SV_UserInit +============== +*/ +void SV_UserInit (void) +{ + Cvar_RegisterVariable (&cl_rollspeed); + Cvar_RegisterVariable (&cl_rollangle); + Cvar_RegisterVariable (&sv_spectalk); + Cvar_RegisterVariable (&sv_mapcheck); +} + + |