mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-12-11 21:31:30 +00:00
b4ad695e16
I didn't like the way client/server code was poking around at the implementation. Instead, provide a couple of accessor functions for the same information.
1280 lines
31 KiB
C
1280 lines
31 KiB
C
/*
|
|
client.c
|
|
|
|
quakeworld client processing
|
|
|
|
Copyright (C) 2004 Bill Currie <bill@taniwha.org>
|
|
|
|
Author: Bill Currie
|
|
Date: 2004/02/20
|
|
|
|
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
|
|
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_STRING_H
|
|
# include <string.h>
|
|
#endif
|
|
#ifdef HAVE_STRINGS_H
|
|
# include <strings.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "QF/cbuf.h"
|
|
#include "QF/cmd.h"
|
|
#include "QF/checksum.h"
|
|
#include "QF/dstring.h"
|
|
#include "QF/hash.h"
|
|
#include "QF/idparse.h"
|
|
#include "QF/info.h"
|
|
#include "QF/sys.h"
|
|
#include "QF/va.h"
|
|
|
|
#include "qw/bothdefs.h"
|
|
#include "qw/msg_ucmd.h"
|
|
#include "qw/protocol.h"
|
|
|
|
#include "client.h"
|
|
#include "connection.h"
|
|
#include "qtv.h"
|
|
#include "server.h"
|
|
|
|
int client_count;
|
|
static client_t *clients;
|
|
|
|
typedef struct ucmd_s {
|
|
const char *name;
|
|
void (*func) (client_t *cl, void *userdata);
|
|
unsigned no_redirect:1;
|
|
unsigned overridable:1;
|
|
unsigned freeable:1;
|
|
void *userdata;
|
|
void (*on_free) (void *userdata);
|
|
} ucmd_t;
|
|
|
|
static void
|
|
client_drop (client_t *cl)
|
|
{
|
|
MSG_WriteByte (&cl->netchan.message, svc_disconnect);
|
|
qtv_printf ("Client %s removed\n", Info_ValueForKey (cl->userinfo, "name"));
|
|
cl->drop = 1;
|
|
}
|
|
|
|
static void
|
|
cl_new_f (client_t *cl, void *unused)
|
|
{
|
|
if (!cl->server) {
|
|
qtv_printf ("\"cmd list\" for a list of servers\n");
|
|
qtv_printf ("\"cmd connect <servername>\" to connect to a server\n");
|
|
} else {
|
|
Client_New (cl);
|
|
}
|
|
}
|
|
|
|
static void
|
|
cl_modellist_f (client_t *cl, void *unused)
|
|
{
|
|
server_t *sv = cl->server;
|
|
unsigned n;
|
|
char **s;
|
|
|
|
if (atoi (Cmd_Argv (1)) != sv->spawncount) {
|
|
qtv_printf ("modellist from different level\n");
|
|
Client_New (cl);
|
|
return;
|
|
}
|
|
n = atoi (Cmd_Argv (2));
|
|
if (n >= MAX_MODELS) {
|
|
qtv_printf ("invalid modellist index\n");
|
|
Client_New (cl);
|
|
return;
|
|
}
|
|
|
|
MSG_WriteByte (&cl->netchan.message, svc_modellist);
|
|
MSG_WriteByte (&cl->netchan.message, n);
|
|
for (s = sv->modellist + n;
|
|
*s && cl->netchan.message.cursize < (MAX_MSGLEN /2);
|
|
s++, n++)
|
|
MSG_WriteString (&cl->netchan.message, *s);
|
|
MSG_WriteByte (&cl->netchan.message, 0);
|
|
if (*s)
|
|
MSG_WriteByte (&cl->netchan.message, n);
|
|
else
|
|
MSG_WriteByte (&cl->netchan.message, 0);
|
|
}
|
|
|
|
static void
|
|
cl_soundlist_f (client_t *cl, void *unused)
|
|
{
|
|
server_t *sv = cl->server;
|
|
unsigned n;
|
|
char **s;
|
|
|
|
if (!cl->server)
|
|
return;
|
|
if (atoi (Cmd_Argv (1)) != sv->spawncount) {
|
|
qtv_printf ("soundlist from different level\n");
|
|
Client_New (cl);
|
|
return;
|
|
}
|
|
n = atoi (Cmd_Argv (2));
|
|
if (n >= MAX_SOUNDS) {
|
|
qtv_printf ("invalid soundlist index\n");
|
|
Client_New (cl);
|
|
return;
|
|
}
|
|
|
|
MSG_WriteByte (&cl->netchan.message, svc_soundlist);
|
|
MSG_WriteByte (&cl->netchan.message, n);
|
|
for (s = sv->soundlist + n;
|
|
*s && cl->netchan.message.cursize < (MAX_MSGLEN /2);
|
|
s++, n++)
|
|
MSG_WriteString (&cl->netchan.message, *s);
|
|
MSG_WriteByte (&cl->netchan.message, 0);
|
|
if (*s)
|
|
MSG_WriteByte (&cl->netchan.message, n);
|
|
else
|
|
MSG_WriteByte (&cl->netchan.message, 0);
|
|
}
|
|
|
|
static void
|
|
cl_prespawn_f (client_t *cl, void *unused)
|
|
{
|
|
const char *cmd;
|
|
server_t *sv = cl->server;
|
|
int buf, size;
|
|
sizebuf_t *msg;
|
|
|
|
if (!cl->server)
|
|
return;
|
|
if (atoi (Cmd_Argv (1)) != sv->spawncount) {
|
|
qtv_printf ("prespawn from different level\n");
|
|
Client_New (cl);
|
|
return;
|
|
}
|
|
buf = atoi (Cmd_Argv (2));
|
|
if (buf >= sv->num_signon_buffers)
|
|
buf = 0;
|
|
if (buf == sv->num_signon_buffers - 1)
|
|
cmd = va ("cmd spawn %i 0\n", cl->server->spawncount);
|
|
else
|
|
cmd = va ("cmd prespawn %i %i\n", cl->server->spawncount, buf + 1);
|
|
size = sv->signon_buffer_size[buf] + 1 + strlen (cmd) + 1;
|
|
msg = MSG_ReliableCheckBlock (&cl->backbuf, size);
|
|
SZ_Write (msg, sv->signon_buffers[buf], sv->signon_buffer_size[buf]);
|
|
MSG_WriteByte (msg, svc_stufftext);
|
|
MSG_WriteString (msg, cmd);
|
|
}
|
|
|
|
static void
|
|
cl_spawn_f (client_t *cl, void *unused)
|
|
{
|
|
const char *cmd;
|
|
server_t *sv = cl->server;
|
|
const char *info;
|
|
player_t *pl;
|
|
int i;
|
|
sizebuf_t *msg;
|
|
|
|
if (!cl->server)
|
|
return;
|
|
if (atoi (Cmd_Argv (1)) != sv->spawncount) {
|
|
qtv_printf ("spawn from different level\n");
|
|
Client_New (cl);
|
|
return;
|
|
}
|
|
for (i = 0, pl = sv->players; i < MAX_SV_PLAYERS; i++, pl++) {
|
|
if (!pl->info)
|
|
continue;
|
|
msg = MSG_ReliableCheckBlock (&cl->backbuf,
|
|
24 + Info_CurrentSize(pl->info));
|
|
MSG_WriteByte (msg, svc_updatefrags);
|
|
MSG_WriteByte (msg, i);
|
|
MSG_WriteShort (msg, pl->frags);
|
|
MSG_WriteByte (msg, svc_updateping);
|
|
MSG_WriteByte (msg, i);
|
|
MSG_WriteShort (msg, pl->ping);
|
|
MSG_WriteByte (msg, svc_updatepl);
|
|
MSG_WriteByte (msg, i);
|
|
MSG_WriteByte (msg, pl->pl);
|
|
MSG_WriteByte (msg, svc_updateentertime);
|
|
MSG_WriteByte (msg, i);
|
|
MSG_WriteFloat (msg, pl->time);
|
|
info = pl->info ? Info_MakeString (pl->info, 0) : "";
|
|
MSG_WriteByte (msg, svc_updateuserinfo);
|
|
MSG_WriteByte (msg, i);
|
|
MSG_WriteLong (msg, pl->uid);
|
|
MSG_WriteString (msg, info);
|
|
if (cl->backbuf.num_backbuf)
|
|
MSG_Reliable_FinishWrite (&cl->backbuf);
|
|
}
|
|
for (i = 0; i < MAX_LIGHTSTYLES; i++) {
|
|
MSG_ReliableWrite_Begin (&cl->backbuf, svc_lightstyle,
|
|
3 + (sv->lightstyles[i] ?
|
|
strlen (sv->lightstyles[i]) : 1));
|
|
MSG_ReliableWrite_Byte (&cl->backbuf, i);
|
|
MSG_ReliableWrite_String (&cl->backbuf, sv->lightstyles[i]);
|
|
}
|
|
MSG_ReliableWrite_Begin (&cl->backbuf, svc_updatestatlong, 6);
|
|
MSG_ReliableWrite_Byte (&cl->backbuf, STAT_TOTALSECRETS);
|
|
MSG_ReliableWrite_Long (&cl->backbuf,
|
|
sv->players[0].stats[STAT_TOTALSECRETS]);
|
|
MSG_ReliableWrite_Begin (&cl->backbuf, svc_updatestatlong, 6);
|
|
MSG_ReliableWrite_Byte (&cl->backbuf, STAT_TOTALMONSTERS);
|
|
MSG_ReliableWrite_Long (&cl->backbuf,
|
|
sv->players[0].stats[STAT_TOTALMONSTERS]);
|
|
MSG_ReliableWrite_Begin (&cl->backbuf, svc_updatestatlong, 6);
|
|
MSG_ReliableWrite_Byte (&cl->backbuf, STAT_SECRETS);
|
|
MSG_ReliableWrite_Long (&cl->backbuf, sv->players[0].stats[STAT_SECRETS]);
|
|
MSG_ReliableWrite_Begin (&cl->backbuf, svc_updatestatlong, 6);
|
|
MSG_ReliableWrite_Byte (&cl->backbuf, STAT_SECRETS);
|
|
MSG_ReliableWrite_Long (&cl->backbuf, sv->players[0].stats[STAT_SECRETS]);
|
|
cmd = "skins\n";
|
|
MSG_ReliableWrite_Begin (&cl->backbuf, svc_stufftext, strlen (cmd) + 2);
|
|
MSG_ReliableWrite_String (&cl->backbuf, cmd);
|
|
}
|
|
|
|
static void
|
|
cl_begin_f (client_t *cl, void *unused)
|
|
{
|
|
server_t *sv = cl->server;
|
|
|
|
if (!cl->server)
|
|
return;
|
|
if (atoi (Cmd_Argv (1)) != sv->spawncount) {
|
|
qtv_printf ("spawn from different level\n");
|
|
Client_New (cl);
|
|
return;
|
|
}
|
|
cl->connected = 1;
|
|
}
|
|
|
|
static void
|
|
cl_drop_f (client_t *cl, void *unused)
|
|
{
|
|
if (cl->server)
|
|
Server_Disconnect (cl);
|
|
client_drop (cl);
|
|
}
|
|
|
|
static void
|
|
cl_pings_f (client_t *cl, void *unused)
|
|
{
|
|
}
|
|
|
|
static void
|
|
cl_rate_f (client_t *cl, void *unused)
|
|
{
|
|
}
|
|
|
|
static void
|
|
cl_say_f (client_t *cl, void *unused)
|
|
{
|
|
}
|
|
|
|
static void
|
|
cl_setinfo_f (client_t *cl, void *unused)
|
|
{
|
|
}
|
|
|
|
static void
|
|
cl_serverinfo_f (client_t *cl, void *unused)
|
|
{
|
|
if (cl->server) {
|
|
Info_Print (cl->server->info);
|
|
return;
|
|
}
|
|
qtv_printf ("not connected to a server");
|
|
}
|
|
|
|
static void
|
|
cl_download_f (client_t *cl, void *unused)
|
|
{
|
|
qtv_printf ("download denied\n");
|
|
MSG_ReliableWrite_Begin (&cl->backbuf, svc_download, 4);
|
|
MSG_ReliableWrite_Short (&cl->backbuf, -1);
|
|
MSG_ReliableWrite_Byte (&cl->backbuf, 0);
|
|
}
|
|
|
|
static void
|
|
cl_nextdl_f (client_t *cl, void *unused)
|
|
{
|
|
}
|
|
|
|
static void
|
|
cl_ptrack_f (client_t *cl, void *unused)
|
|
{
|
|
int i;
|
|
|
|
if (Cmd_Argc () != 2) {
|
|
cl->spec_track = 0;
|
|
return;
|
|
}
|
|
i = atoi (Cmd_Argv (1));
|
|
if (i < 0 || i >= MAX_CLIENTS) {
|
|
cl->spec_track = 0;
|
|
qtv_printf ("Invalid client to track\n");
|
|
return;
|
|
}
|
|
cl->spec_track = 1 << i;
|
|
}
|
|
|
|
static void
|
|
cl_list_f (client_t *cl, void *unused)
|
|
{
|
|
Server_List ();
|
|
}
|
|
|
|
static void
|
|
cl_connect_f (client_t *cl, void *unused)
|
|
{
|
|
if (cl->server) {
|
|
qtv_printf ("already connected to server %s\n", cl->server->name);
|
|
qtv_printf ("\"cmd disconnect\" first\n");
|
|
return;
|
|
}
|
|
Server_Connect (Cmd_Argv (1), cl);
|
|
}
|
|
|
|
static void
|
|
cl_disconnect_f (client_t *cl, void *unused)
|
|
{
|
|
if (!cl->server) {
|
|
qtv_printf ("not connected to a server\n");
|
|
return;
|
|
}
|
|
client_drop (cl);
|
|
}
|
|
|
|
static ucmd_t ucmds[] = {
|
|
{"new", cl_new_f, 0, 0},
|
|
{"modellist", cl_modellist_f, 0, 0},
|
|
{"soundlist", cl_soundlist_f, 0, 0},
|
|
{"prespawn", cl_prespawn_f, 0, 0},
|
|
{"spawn", cl_spawn_f, 0, 0},
|
|
{"begin", cl_begin_f, 1, 0},
|
|
|
|
{"drop", cl_drop_f, 1, 0},
|
|
{"pings", cl_pings_f, 0, 0},
|
|
|
|
// issued by hand at client consoles
|
|
{"rate", cl_rate_f, 0, 0},
|
|
{"kill", 0, 1, 1},
|
|
{"pause", 0, 1, 0},
|
|
{"msg", 0, 0, 0},
|
|
|
|
{"say", cl_say_f, 1, 1},
|
|
{"say_team", cl_say_f, 1, 1},
|
|
|
|
{"setinfo", cl_setinfo_f, 1, 0},
|
|
|
|
{"serverinfo", cl_serverinfo_f, 0, 0},
|
|
|
|
{"download", cl_download_f, 1, 0},
|
|
{"nextdl", cl_nextdl_f, 0, 0},
|
|
|
|
{"ptrack", cl_ptrack_f, 0, 1}, // ZOID - used with autocam
|
|
|
|
{"snap", 0, 0, 0},
|
|
|
|
{"list", cl_list_f, 0, 0},
|
|
{"connect", cl_connect_f, 0, 0},
|
|
{"disconnect", cl_disconnect_f, 0, 0},
|
|
};
|
|
|
|
static hashtab_t *ucmd_table;
|
|
int (*ucmd_unknown)(void);
|
|
|
|
static void
|
|
client_exec_command (client_t *cl, const char *s)
|
|
{
|
|
ucmd_t *u;
|
|
|
|
COM_TokenizeString (s, qtv_args);
|
|
cmd_args = qtv_args;
|
|
|
|
u = (ucmd_t*) Hash_Find (ucmd_table, qtv_args->argv[0]->str);
|
|
|
|
if (!u) {
|
|
if (!ucmd_unknown || !ucmd_unknown ()) {
|
|
qtv_begin_redirect (RD_CLIENT, cl);
|
|
qtv_printf ("Bad user command: %s\n", qtv_args->argv[0]->str);
|
|
qtv_end_redirect ();
|
|
}
|
|
} else {
|
|
if (u->func) {
|
|
if (!u->no_redirect)
|
|
qtv_begin_redirect (RD_CLIENT, cl);
|
|
u->func (cl, u->userdata);
|
|
if (!u->no_redirect)
|
|
qtv_end_redirect ();
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
spectator_move (client_t *cl, usercmd_t *ucmd)
|
|
{
|
|
float frametime = ucmd->msec * 0.001;
|
|
float control, drop, friction, fmove, smove, speed, newspeed;
|
|
float currentspeed, addspeed, accelspeed, wishspeed;
|
|
int i;
|
|
vec3_t wishdir, wishvel;
|
|
vec3_t forward, right, up;
|
|
server_t *sv = cl->server;
|
|
|
|
AngleVectors (cl->state.cmd.angles, forward, right, up);
|
|
|
|
speed = DotProduct (cl->state.velocity, cl->state.velocity);
|
|
if (speed < 1) {
|
|
VectorZero (cl->state.velocity);
|
|
} else {
|
|
speed = sqrt (speed);
|
|
drop = 0;
|
|
|
|
friction = sv->movevars.friction * 1.5;
|
|
control = speed < sv->movevars.stopspeed ? sv->movevars.stopspeed
|
|
: speed;
|
|
drop += control * friction * frametime;
|
|
newspeed = speed - drop;
|
|
if (newspeed < 0)
|
|
newspeed = 0;
|
|
newspeed /= speed;
|
|
|
|
VectorScale (cl->state.velocity, newspeed, cl->state.velocity);
|
|
}
|
|
|
|
fmove = ucmd->forwardmove;
|
|
smove = ucmd->sidemove;
|
|
|
|
VectorNormalize (forward);
|
|
VectorNormalize (right);
|
|
|
|
for (i = 0; i < 3; i++)
|
|
wishvel[i] = forward[i] * fmove + right[i] * smove;
|
|
wishvel[2] += ucmd->upmove;
|
|
|
|
VectorCopy (wishvel, wishdir);
|
|
wishspeed = VectorNormalize (wishdir);
|
|
|
|
if (wishspeed > sv->movevars.spectatormaxspeed) {
|
|
VectorScale (wishvel, sv->movevars.spectatormaxspeed / wishspeed,
|
|
wishvel);
|
|
wishspeed = sv->movevars.spectatormaxspeed;
|
|
}
|
|
|
|
currentspeed = DotProduct (cl->state.velocity, wishdir);
|
|
addspeed = wishspeed - currentspeed;
|
|
if (addspeed <= 0)
|
|
return;
|
|
accelspeed = sv->movevars.accelerate * frametime * wishspeed;
|
|
if (accelspeed > addspeed)
|
|
accelspeed = addspeed;
|
|
|
|
VectorMultAdd (cl->state.velocity, accelspeed, wishdir,
|
|
cl->state.velocity);
|
|
VectorMultAdd (cl->state.origin, frametime, cl->state.velocity,
|
|
cl->state.origin);
|
|
}
|
|
|
|
static void
|
|
run_command (client_t *cl, usercmd_t *ucmd)
|
|
{
|
|
if (ucmd->msec > 50) {
|
|
usercmd_t cmd = *ucmd;
|
|
int oldmsec = ucmd->msec;
|
|
cmd.msec = oldmsec / 2;
|
|
run_command (cl, &cmd);
|
|
cmd.msec = oldmsec / 2;
|
|
cmd.impulse = 0;
|
|
run_command (cl, &cmd);
|
|
return;
|
|
}
|
|
|
|
VectorCopy (ucmd->angles, cl->state.cmd.angles);
|
|
|
|
spectator_move (cl, ucmd);
|
|
}
|
|
|
|
static void
|
|
client_parse_message (client_t *cl)
|
|
{
|
|
int c, size;
|
|
vec3_t o;
|
|
const char *s;
|
|
usercmd_t oldest, oldcmd, newcmd;
|
|
byte checksum, calculatedChecksum;
|
|
int checksumIndex, seq_hash;
|
|
qboolean move_issued = false;
|
|
|
|
// 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
|
|
|
|
seq_hash = cl->netchan.incoming_sequence;
|
|
cl->delta_sequence = -1;
|
|
while (1) {
|
|
if (net_message->badread) {
|
|
qtv_printf ("SV_ReadClientMessage: badread\n");
|
|
client_drop (cl);
|
|
return;
|
|
}
|
|
|
|
c = MSG_ReadByte (net_message);
|
|
if (c == -1)
|
|
return;
|
|
|
|
switch (c) {
|
|
default:
|
|
qtv_printf ("SV_ReadClientMessage: unknown command char\n");
|
|
client_drop (cl);
|
|
return;
|
|
case clc_nop:
|
|
break;
|
|
case clc_delta:
|
|
cl->delta_sequence = MSG_ReadByte (net_message);
|
|
break;
|
|
case clc_move:
|
|
checksumIndex = MSG_GetReadCount (net_message);
|
|
checksum = MSG_ReadByte (net_message);
|
|
// read loss percentage
|
|
/*cl->lossage = */MSG_ReadByte (net_message);
|
|
MSG_ReadDeltaUsercmd (net_message, &nullcmd, &oldest);
|
|
MSG_ReadDeltaUsercmd (net_message, &oldest, &oldcmd);
|
|
MSG_ReadDeltaUsercmd (net_message, &oldcmd, &newcmd);
|
|
if (!cl->server)
|
|
break;
|
|
if (move_issued)
|
|
break; // someone is trying to cheat...
|
|
move_issued = true;
|
|
// if (cl->state != cs_spawned)
|
|
// break;
|
|
// if the checksum fails, ignore the rest of the packet
|
|
calculatedChecksum =
|
|
COM_BlockSequenceCRCByte (net_message->message->data +
|
|
checksumIndex + 1,
|
|
MSG_GetReadCount (net_message) -
|
|
checksumIndex - 1, seq_hash);
|
|
if (calculatedChecksum != checksum) {
|
|
Sys_MaskPrintf (SYS_DEV,
|
|
"Failed command checksum for %s(%d) "
|
|
"(%d != %d)\n",
|
|
Info_ValueForKey (cl->userinfo, "name"),
|
|
cl->netchan.incoming_sequence, checksum,
|
|
calculatedChecksum);
|
|
return;
|
|
}
|
|
// if (!sv.paused) {
|
|
// SV_PreRunCmd ();
|
|
if (cl->netchan.net_drop < 20) {
|
|
while (cl->netchan.net_drop > 2) {
|
|
run_command (cl, &cl->lastcmd);
|
|
cl->netchan.net_drop--;
|
|
}
|
|
if (cl->netchan.net_drop > 1)
|
|
run_command (cl, &oldest);
|
|
if (cl->netchan.net_drop > 0)
|
|
run_command (cl, &oldcmd);
|
|
}
|
|
run_command (cl, &newcmd);
|
|
// SV_PostRunCmd ();
|
|
// }
|
|
cl->lastcmd = newcmd;
|
|
cl->lastcmd.buttons = 0; // avoid multiple fires on lag
|
|
break;
|
|
case clc_stringcmd:
|
|
s = MSG_ReadString (net_message);
|
|
client_exec_command (cl, s);
|
|
break;
|
|
case clc_tmove:
|
|
MSG_ReadCoordV (net_message, o);
|
|
VectorCopy (o, cl->state.origin);
|
|
break;
|
|
case clc_upload:
|
|
size = MSG_ReadShort (net_message);
|
|
MSG_ReadByte (net_message);
|
|
net_message->readcount += size;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
write_player (int num, plent_state_t *pl, server_t *sv, sizebuf_t *msg)
|
|
{
|
|
int i;
|
|
int pflags = (pl->flags & (PF_GIB | PF_DEAD))
|
|
| PF_MSEC | PF_COMMAND;
|
|
int qf_bits = 0;
|
|
|
|
if (pl->modelindex != sv->playermodel)
|
|
pflags |= PF_MODEL;
|
|
for (i = 0; i < 3; i++)
|
|
if (pl->velocity[i])
|
|
pflags |= PF_VELOCITY1 << i;
|
|
if (pl->effects & 0xff)
|
|
pflags |= PF_EFFECTS;
|
|
if (pl->skinnum)
|
|
pflags |= PF_SKINNUM;
|
|
|
|
qf_bits = 0;
|
|
#if 0
|
|
if (client->stdver > 1) {
|
|
if (sv_fields.alpha != -1 && pl->alpha)
|
|
qf_bits |= PF_ALPHA;
|
|
if (sv_fields.scale != -1 && pl->scale)
|
|
qf_bits |= PF_SCALE;
|
|
if (pl->effects & 0xff00)
|
|
qf_bits |= PF_EFFECTS2;
|
|
if (sv_fields.glow_size != -1 && pl->glow_size)
|
|
qf_bits |= PF_GLOWSIZE;
|
|
if (sv_fields.glow_color != -1 && pl->glow_color)
|
|
qf_bits |= PF_GLOWCOLOR;
|
|
if (sv_fields.colormod != -1
|
|
&& !VectorIsZero (pl->colormod))
|
|
qf_bits |= PF_COLORMOD;
|
|
if (pl->frame & 0xff00)
|
|
qf_bits |= PF_FRAME2;
|
|
if (qf_bits)
|
|
pflags |= PF_QF;
|
|
}
|
|
#endif
|
|
|
|
// if (cl->spectator) {
|
|
// // send only origin and velocity to spectators
|
|
// pflags &= PF_VELOCITY1 | PF_VELOCITY2 | PF_VELOCITY3;
|
|
// } else if (ent == clent) {
|
|
// // don't send a lot of data on personal entity
|
|
// pflags &= ~(PF_MSEC | PF_COMMAND);
|
|
// if (pl->weaponframe)
|
|
// pflags |= PF_WEAPONFRAME;
|
|
// }
|
|
|
|
// if (client->spec_track && client->spec_track - 1 == j
|
|
// && pl->weaponframe)
|
|
// pflags |= PF_WEAPONFRAME;
|
|
|
|
MSG_WriteByte (msg, svc_playerinfo);
|
|
MSG_WriteByte (msg, num);
|
|
MSG_WriteShort (msg, pflags);
|
|
|
|
MSG_WriteCoordV (msg, pl->origin);
|
|
|
|
MSG_WriteByte (msg, pl->frame);
|
|
|
|
if (pflags & PF_MSEC) {
|
|
//msec = 1000 * (sv.time - cl->localtime);
|
|
//if (msec > 255)
|
|
// msec = 255;
|
|
MSG_WriteByte (msg, pl->msec);
|
|
}
|
|
|
|
if (pflags & PF_COMMAND) {
|
|
MSG_WriteDeltaUsercmd (msg, &nullcmd, &pl->cmd);
|
|
}
|
|
|
|
for (i = 0; i < 3; i++)
|
|
if (pflags & (PF_VELOCITY1 << i))
|
|
MSG_WriteShort (msg, pl->velocity[i]);
|
|
|
|
if (pflags & PF_MODEL)
|
|
MSG_WriteByte (msg, pl->modelindex);
|
|
|
|
if (pflags & PF_SKINNUM)
|
|
MSG_WriteByte (msg, pl->skinnum);
|
|
|
|
if (pflags & PF_EFFECTS)
|
|
MSG_WriteByte (msg, pl->effects);
|
|
|
|
if (pflags & PF_WEAPONFRAME)
|
|
MSG_WriteByte (msg, pl->weaponframe);
|
|
|
|
if (pflags & PF_QF) {
|
|
MSG_WriteByte (msg, qf_bits);
|
|
if (qf_bits & PF_ALPHA)
|
|
MSG_WriteByte (msg, pl->alpha);
|
|
if (qf_bits & PF_SCALE)
|
|
MSG_WriteByte (msg, pl->scale);
|
|
if (qf_bits & PF_EFFECTS2)
|
|
MSG_WriteByte (msg, pl->effects >> 8);
|
|
if (qf_bits & PF_GLOWSIZE)
|
|
MSG_WriteByte (msg, pl->scale);
|
|
if (qf_bits & PF_GLOWCOLOR)
|
|
MSG_WriteByte (msg, pl->glow_color);
|
|
if (qf_bits & PF_COLORMOD)
|
|
MSG_WriteByte (msg, pl->colormod);
|
|
if (qf_bits & PF_FRAME2)
|
|
MSG_WriteByte (msg, pl->frame >> 8);
|
|
}
|
|
}
|
|
#if 0
|
|
#define MAX_NAILS 32
|
|
edict_t *nails[MAX_NAILS];
|
|
int numnails;
|
|
int nailcount;
|
|
|
|
static void
|
|
emit_nails (sizebuf_t *msg, qboolean recorder)
|
|
{
|
|
byte *buf; // [48 bits] xyzpy 12 12 12 4 8
|
|
int n, p, x, y, z, yaw;
|
|
int bpn = recorder ? 7 : 6; // bytes per nail
|
|
edict_t *ent;
|
|
|
|
if (!numnails)
|
|
return;
|
|
|
|
buf = SZ_GetSpace (msg, numnails * bpn + 2);
|
|
*buf++ = recorder ? svc_nails2 : svc_nails;
|
|
*buf++ = numnails;
|
|
|
|
for (n = 0; n < numnails; n++) {
|
|
ent = nails[n];
|
|
if (recorder) {
|
|
if (!ent->colormap) {
|
|
if (!((++nailcount) & 255))
|
|
nailcount++;
|
|
ent->colormap = nailcount&255;
|
|
}
|
|
*buf++ = (byte)ent->colormap;
|
|
}
|
|
|
|
x = ((int) (ent->origin[0] + 4096 + 1) >> 1) & 4095;
|
|
y = ((int) (ent->origin[1] + 4096 + 1) >> 1) & 4095;
|
|
z = ((int) (ent->origin[2] + 4096 + 1) >> 1) & 4095;
|
|
p = (int) (ent->angles[0] * (16.0 / 360.0)) & 15;
|
|
yaw = (int) (ent->angles[1] * (256.0 / 360.0)) & 255;
|
|
|
|
*buf++ = x;
|
|
*buf++ = (x >> 8) | (y << 4);
|
|
*buf++ = (y >> 4);
|
|
*buf++ = z;
|
|
*buf++ = (z >> 8) | (p << 4);
|
|
*buf++ = yaw;
|
|
}
|
|
}
|
|
#endif
|
|
static void
|
|
write_delta (entity_state_t *from, entity_state_t *to, sizebuf_t *msg,
|
|
qboolean force)//, int stdver)
|
|
{
|
|
int bits, i;
|
|
float miss;
|
|
|
|
// send an update
|
|
bits = 0;
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
miss = to->origin[i] - from->origin[i];
|
|
if (miss < -0.1 || miss > 0.1)
|
|
bits |= U_ORIGIN1 << i;
|
|
}
|
|
|
|
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 (to->colormap != from->colormap)
|
|
bits |= U_COLORMAP;
|
|
|
|
if (to->skinnum != from->skinnum)
|
|
bits |= U_SKIN;
|
|
|
|
if (to->frame != from->frame)
|
|
bits |= U_FRAME;
|
|
|
|
if (to->effects != from->effects)
|
|
bits |= U_EFFECTS;
|
|
|
|
if (to->modelindex != from->modelindex)
|
|
bits |= U_MODEL;
|
|
|
|
// LordHavoc: cleaned up Endy's coding style, and added missing effects
|
|
// Ender (QSG - Begin)
|
|
#if 0
|
|
if (stdver > 1) {
|
|
if (to->alpha != from->alpha)
|
|
bits |= U_ALPHA;
|
|
|
|
if (to->scale != from->scale)
|
|
bits |= U_SCALE;
|
|
|
|
if (to->effects > 255)
|
|
bits |= U_EFFECTS2;
|
|
|
|
if (to->glow_size != from->glow_size)
|
|
bits |= U_GLOWSIZE;
|
|
|
|
if (to->glow_color != from->glow_color)
|
|
bits |= U_GLOWCOLOR;
|
|
|
|
if (to->colormod != from->colormod)
|
|
bits |= U_COLORMOD;
|
|
|
|
if (to->frame > 255)
|
|
bits |= U_EFFECTS2;
|
|
}
|
|
if (bits >= 16777216)
|
|
bits |= U_EXTEND2;
|
|
|
|
if (bits >= 65536)
|
|
bits |= U_EXTEND1;
|
|
#endif
|
|
if (bits & 511)
|
|
bits |= U_MOREBITS;
|
|
|
|
if (to->flags & U_SOLID)
|
|
bits |= U_SOLID;
|
|
|
|
if (!bits && !force)
|
|
return; // nothing to send!
|
|
i = to->number | (bits & ~511);
|
|
// if (i & U_REMOVE)
|
|
// Sys_Error ("U_REMOVE");
|
|
MSG_WriteShort (msg, i);
|
|
|
|
if (bits & U_MOREBITS)
|
|
MSG_WriteByte (msg, bits & 255);
|
|
|
|
// LordHavoc: cleaned up Endy's tabs
|
|
// Ender (QSG - Begin)
|
|
if (bits & U_EXTEND1)
|
|
MSG_WriteByte (msg, bits >> 16);
|
|
if (bits & U_EXTEND2)
|
|
MSG_WriteByte (msg, bits >> 24);
|
|
// Ender (QSG - End)
|
|
|
|
if (bits & U_MODEL)
|
|
MSG_WriteByte (msg, to->modelindex);
|
|
if (bits & U_FRAME)
|
|
MSG_WriteByte (msg, to->frame);
|
|
if (bits & U_COLORMAP)
|
|
MSG_WriteByte (msg, to->colormap);
|
|
if (bits & U_SKIN)
|
|
MSG_WriteByte (msg, to->skinnum);
|
|
if (bits & U_EFFECTS)
|
|
MSG_WriteByte (msg, to->effects);
|
|
if (bits & U_ORIGIN1)
|
|
MSG_WriteCoord (msg, to->origin[0]);
|
|
if (bits & U_ANGLE1)
|
|
MSG_WriteAngle (msg, to->angles[0]);
|
|
if (bits & U_ORIGIN2)
|
|
MSG_WriteCoord (msg, to->origin[1]);
|
|
if (bits & U_ANGLE2)
|
|
MSG_WriteAngle (msg, to->angles[1]);
|
|
if (bits & U_ORIGIN3)
|
|
MSG_WriteCoord (msg, to->origin[2]);
|
|
if (bits & U_ANGLE3)
|
|
MSG_WriteAngle (msg, to->angles[2]);
|
|
|
|
// LordHavoc: cleaned up Endy's tabs, rearranged bytes, and implemented
|
|
// missing effects
|
|
// Ender (QSG - Begin)
|
|
if (bits & U_ALPHA)
|
|
MSG_WriteByte (msg, to->alpha);
|
|
if (bits & U_SCALE)
|
|
MSG_WriteByte (msg, to->scale);
|
|
if (bits & U_EFFECTS2)
|
|
MSG_WriteByte (msg, (to->effects >> 8));
|
|
if (bits & U_GLOWSIZE)
|
|
MSG_WriteByte (msg, to->glow_size);
|
|
if (bits & U_GLOWCOLOR)
|
|
MSG_WriteByte (msg, to->glow_color);
|
|
if (bits & U_COLORMOD)
|
|
MSG_WriteByte (msg, to->colormod);
|
|
if (bits & U_FRAME2)
|
|
MSG_WriteByte (msg, (to->frame >> 8));
|
|
// Ender (QSG - End)
|
|
}
|
|
|
|
static void
|
|
emit_entities (client_t *client, packet_entities_t *to, sizebuf_t *msg)
|
|
{
|
|
int newindex, oldindex, newnum, oldnum, oldmax;
|
|
entity_state_t *ent;
|
|
frame_t *fromframe;
|
|
packet_entities_t *from;
|
|
server_t *sv = client->server;
|
|
|
|
// this is the frame that we are going to delta update from
|
|
if (client->delta_sequence != -1) {
|
|
fromframe = &client->frames[client->delta_sequence & UPDATE_MASK];
|
|
from = &fromframe->entities;
|
|
oldmax = from->num_entities;
|
|
|
|
MSG_WriteByte (msg, svc_deltapacketentities);
|
|
MSG_WriteByte (msg, client->delta_sequence);
|
|
} else {
|
|
oldmax = 0; // no delta update
|
|
from = NULL;
|
|
|
|
MSG_WriteByte (msg, svc_packetentities);
|
|
}
|
|
|
|
newindex = 0;
|
|
oldindex = 0;
|
|
while (newindex < to->num_entities || oldindex < oldmax) {
|
|
newnum = newindex >= to->num_entities ? 9999 :
|
|
to->entities[newindex].number;
|
|
oldnum = oldindex >= oldmax ? 9999 : from->entities[oldindex].number;
|
|
|
|
if (newnum == oldnum) { // delta update from old position
|
|
write_delta (&from->entities[oldindex], &to->entities[newindex],
|
|
msg, false);//, client->stdver);
|
|
oldindex++;
|
|
newindex++;
|
|
continue;
|
|
}
|
|
|
|
if (newnum < oldnum) {
|
|
// this is a new entity, send it from the baseline
|
|
ent = sv->baselines + newnum;
|
|
write_delta (ent, &to->entities[newindex], msg, true);//,
|
|
//client->stdver);
|
|
newindex++;
|
|
continue;
|
|
}
|
|
|
|
if (newnum > oldnum) { // the old entity isn't present in
|
|
// the new message
|
|
MSG_WriteShort (msg, oldnum | U_REMOVE);
|
|
oldindex++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
MSG_WriteShort (msg, 0); // end of packetentities
|
|
}
|
|
|
|
static void
|
|
write_entities (client_t *client, sizebuf_t *msg)
|
|
{
|
|
//byte *pvs = 0;
|
|
//int i;
|
|
int e;
|
|
//vec3_t org;
|
|
frame_t *frame;
|
|
entity_state_t *ent;
|
|
entity_state_t *state;
|
|
packet_entities_t *pack;
|
|
server_t *sv = client->server;
|
|
|
|
// this is the frame we are creating
|
|
frame = &client->frames[client->netchan.incoming_sequence & UPDATE_MASK];
|
|
|
|
// find the client's PVS
|
|
//clent = client->edict;
|
|
//VectorAdd (SVvector (clent, origin), SVvector (clent, view_ofs), org);
|
|
//pvs = SV_FatPVS (org);
|
|
|
|
// put other visible entities into either a packet_entities or a nails
|
|
// message
|
|
pack = &frame->entities;
|
|
pack->num_entities = 0;
|
|
|
|
//numnails = 0;
|
|
|
|
for (e = MAX_CLIENTS + 1, ent = sv->entities + e; e < MAX_SV_ENTITIES;
|
|
e++, ent++) {
|
|
if (!sv->ent_valid[e])
|
|
continue;
|
|
if (ent->number && ent->number != e)
|
|
qtv_printf ("%d %d\n", e, ent->number);
|
|
#if 0
|
|
if (pvs) {
|
|
// ignore if not touching a PV leaf
|
|
for (i = 0; i < ent->num_leafs; i++)
|
|
if (pvs[ent->leafnums[i] >> 3] & (1 << (ent->leafnums[i] & 7)))
|
|
break;
|
|
|
|
if (i == ent->num_leafs)
|
|
continue; // not visible
|
|
}
|
|
#endif
|
|
// if (SV_AddNailUpdate (ent))
|
|
// continue; // added to the special update list
|
|
|
|
// add to the packetentities
|
|
if (pack->num_entities == MAX_PACKET_ENTITIES) {
|
|
qtv_printf ("mpe overflow\n");
|
|
continue; // all full
|
|
}
|
|
|
|
state = &pack->entities[pack->num_entities];
|
|
pack->num_entities++;
|
|
*state = *ent;
|
|
state->flags = 0;
|
|
}
|
|
// encode the packet entities as a delta from the
|
|
// last packetentities acknowledged by the client
|
|
emit_entities (client, pack, msg);
|
|
|
|
// now add the specialized nail update
|
|
//emit_nails (msg, 0);
|
|
}
|
|
|
|
static void
|
|
write_players (client_t *client, sizebuf_t *msg)
|
|
{
|
|
server_t *sv = client->server;
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_SV_PLAYERS; i++) {
|
|
if (!sv->players[i].info)
|
|
continue;
|
|
write_player (i, &sv->players[i].ent, sv, msg);
|
|
}
|
|
}
|
|
|
|
void
|
|
Client_SendMessages (client_t *cl)
|
|
{
|
|
byte buf[MAX_DATAGRAM];
|
|
sizebuf_t msg;
|
|
|
|
memset (&msg, 0, sizeof (msg));
|
|
msg.allowoverflow = true;
|
|
msg.maxsize = sizeof (buf);
|
|
msg.data = buf;
|
|
|
|
if (cl->backbuf.num_backbuf)
|
|
MSG_Reliable_Send (&cl->backbuf);
|
|
if (cl->connected) {
|
|
write_players (cl, &msg);
|
|
write_player (31, &cl->state, cl->server, &msg);
|
|
write_entities (cl, &msg);
|
|
if (cl->datagram.cursize) {
|
|
SZ_Write (&msg, cl->datagram.data, cl->datagram.cursize);
|
|
SZ_Clear (&cl->datagram);
|
|
}
|
|
}
|
|
Netchan_Transmit (&cl->netchan, msg.cursize, msg.data);
|
|
}
|
|
|
|
static void
|
|
client_handler (connection_t *con, void *object)
|
|
{
|
|
client_t *cl = (client_t *) object;
|
|
|
|
if (net_message->message->cursize < 11) {
|
|
qtv_printf ("%s: Runt packet\n", NET_AdrToString (net_from));
|
|
return;
|
|
}
|
|
if (Netchan_Process (&cl->netchan)) {
|
|
// this is a valid, sequenced packet, so process it
|
|
//svs.stats.packets++;
|
|
cl->send_message = true;
|
|
//if (cl->state != cs_zombie)
|
|
client_parse_message (cl);
|
|
}
|
|
}
|
|
|
|
static void
|
|
client_connect (connection_t *con, void *object)
|
|
{
|
|
challenge_t *ch = (challenge_t *) object;
|
|
client_t *cl;
|
|
const char *str;
|
|
info_t *userinfo;
|
|
int version, qport, challenge, seq;
|
|
int i;
|
|
|
|
MSG_BeginReading (net_message);
|
|
seq = MSG_ReadLong (net_message);
|
|
if (seq != -1) {
|
|
qtv_printf ("unexpected connected packet\n");
|
|
return;
|
|
}
|
|
str = MSG_ReadString (net_message);
|
|
COM_TokenizeString (str, qtv_args);
|
|
cmd_args = qtv_args;
|
|
if (strcmp (Cmd_Argv (0), "connect")) {
|
|
qtv_printf ("unexpected connected packet\n");
|
|
return;
|
|
}
|
|
version = atoi (Cmd_Argv (1));
|
|
if (version != PROTOCOL_VERSION) {
|
|
Netchan_OutOfBandPrint (net_from, "%c\nServer is version %s.\n",
|
|
A2C_PRINT, QW_VERSION);
|
|
qtv_printf ("* rejected connect from version %i\n", version);
|
|
return;
|
|
}
|
|
qport = atoi (Cmd_Argv (2));
|
|
challenge = atoi (Cmd_Argv (3));
|
|
if (!(con = Connection_Find (&net_from))
|
|
|| (ch = con->object)->challenge != challenge) {
|
|
Netchan_OutOfBandPrint (net_from, "%c\nBad challenge.\n",
|
|
A2C_PRINT);
|
|
return;
|
|
}
|
|
free (con->object);
|
|
userinfo = Info_ParseString (Cmd_Argv (4), 0, 0);
|
|
if (!userinfo) {
|
|
Netchan_OutOfBandPrint (net_from, "%c\nInvalid userinfo string.\n",
|
|
A2C_PRINT);
|
|
return;
|
|
}
|
|
|
|
cl = calloc (1, sizeof (client_t));
|
|
client_count++;
|
|
Netchan_Setup (&cl->netchan, con->address, qport, NC_QPORT_READ);
|
|
cl->clnext = clients;
|
|
clients = cl;
|
|
cl->userinfo = userinfo;
|
|
cl->name = Info_ValueForKey (userinfo, "name");
|
|
cl->backbuf.name = cl->name;
|
|
cl->backbuf.netchan = &cl->netchan;
|
|
cl->con = con;
|
|
con->object = cl;
|
|
con->handler = client_handler;
|
|
|
|
cl->datagram.allowoverflow = true;
|
|
cl->datagram.maxsize = sizeof (cl->datagram_buf);
|
|
cl->datagram.data = cl->datagram_buf;
|
|
|
|
for (i = 0; i < UPDATE_BACKUP; i++)
|
|
cl->frames[i].entities.entities = cl->packet_entities[i];
|
|
|
|
qtv_printf ("client %s (%s) connected\n",
|
|
Info_ValueForKey (userinfo, "name"),
|
|
NET_AdrToString (con->address));
|
|
|
|
Netchan_OutOfBandPrint (net_from, "%c", S2C_CONNECTION);
|
|
}
|
|
|
|
void
|
|
Client_NewConnection (void)
|
|
{
|
|
challenge_t *ch;
|
|
connection_t *con;
|
|
|
|
if ((con = Connection_Find (&net_from))) {
|
|
if (con->handler == client_handler)
|
|
return;
|
|
ch = con->object;
|
|
} else {
|
|
ch = malloc (sizeof (challenge_t));
|
|
}
|
|
ch->challenge = (rand () << 16) ^ rand ();
|
|
ch->time = realtime;
|
|
if (!con)
|
|
con = Connection_Add (&net_from, ch, 0);
|
|
Netchan_OutOfBandPrint (net_from, "%c%i QF", S2C_CHALLENGE, ch->challenge);
|
|
con->handler = client_connect;
|
|
}
|
|
|
|
static const char *
|
|
ucmds_getkey (void *_a, void *unused)
|
|
{
|
|
ucmd_t *a = (ucmd_t*)_a;
|
|
return a->name;
|
|
}
|
|
|
|
void
|
|
Client_Init (void)
|
|
{
|
|
size_t i;
|
|
|
|
ucmd_table = Hash_NewTable (251, ucmds_getkey, 0, 0);
|
|
for (i = 0; i < sizeof (ucmds) / sizeof (ucmds[0]); i++)
|
|
Hash_Add (ucmd_table, &ucmds[i]);
|
|
}
|
|
|
|
void
|
|
Client_New (client_t *cl)
|
|
{
|
|
server_t *sv = cl->server;
|
|
|
|
MSG_WriteByte (&cl->netchan.message, svc_serverdata);
|
|
MSG_WriteLong (&cl->netchan.message, PROTOCOL_VERSION);
|
|
MSG_WriteLong (&cl->netchan.message, sv->spawncount);
|
|
MSG_WriteString (&cl->netchan.message, sv->gamedir);
|
|
MSG_WriteByte (&cl->netchan.message, 0x80 | 31);
|
|
MSG_WriteString (&cl->netchan.message, sv->message);
|
|
MSG_WriteFloat (&cl->netchan.message, sv->movevars.gravity);
|
|
MSG_WriteFloat (&cl->netchan.message, sv->movevars.stopspeed);
|
|
MSG_WriteFloat (&cl->netchan.message, sv->movevars.maxspeed);
|
|
MSG_WriteFloat (&cl->netchan.message, sv->movevars.spectatormaxspeed);
|
|
MSG_WriteFloat (&cl->netchan.message, sv->movevars.accelerate);
|
|
MSG_WriteFloat (&cl->netchan.message, sv->movevars.airaccelerate);
|
|
MSG_WriteFloat (&cl->netchan.message, sv->movevars.wateraccelerate);
|
|
MSG_WriteFloat (&cl->netchan.message, sv->movevars.friction);
|
|
MSG_WriteFloat (&cl->netchan.message, sv->movevars.waterfriction);
|
|
MSG_WriteFloat (&cl->netchan.message, sv->movevars.entgravity);
|
|
MSG_WriteByte (&cl->netchan.message, svc_cdtrack);
|
|
MSG_WriteByte (&cl->netchan.message, sv->cdtrack);
|
|
MSG_WriteByte (&cl->netchan.message, svc_stufftext);
|
|
MSG_WriteString (&cl->netchan.message,
|
|
va ("fullserverinfo \"%s\"\n",
|
|
Info_MakeString (sv->info, 0)));
|
|
}
|
|
|
|
static void
|
|
delete_client (client_t *cl)
|
|
{
|
|
if (cl->server)
|
|
Server_Disconnect (cl);
|
|
Connection_Del (cl->con);
|
|
Info_Destroy (cl->userinfo);
|
|
client_count--;
|
|
free (cl);
|
|
}
|
|
|
|
void
|
|
Client_Frame (void)
|
|
{
|
|
client_t **c;
|
|
|
|
for (c = &clients; *c; ) {
|
|
client_t *cl = *c;
|
|
|
|
if (realtime - cl->netchan.last_received > 60) {
|
|
qtv_printf ("client %s timed out\n", (*c)->name);
|
|
client_drop (cl);
|
|
}
|
|
if (cl->netchan.message.overflowed) {
|
|
qtv_printf ("client %s overflowed\n", cl->name);
|
|
client_drop (cl);
|
|
}
|
|
if (cl->drop) {
|
|
qtv_printf ("client %s dropped\n", cl->name);
|
|
*c = cl->clnext;
|
|
delete_client (cl);
|
|
continue;
|
|
}
|
|
if (cl->send_message) {
|
|
Client_SendMessages (cl);
|
|
cl->send_message = false;
|
|
}
|
|
c = &(*c)->clnext;
|
|
}
|
|
}
|