// CL_SendMove
public static void SendMove(ref usercmd_t cmd)
{
cl.cmd = cmd; // cl.cmd = *cmd - struct copying!!!
MsgWriter msg = new MsgWriter(128);
//
// send the movement message
//
msg.WriteByte(Protocol.clc_move);
msg.WriteFloat((float)cl.mtime[0]); // so server can get ping times
msg.WriteAngle(cl.viewangles.X);
msg.WriteAngle(cl.viewangles.Y);
msg.WriteAngle(cl.viewangles.Z);
msg.WriteShort((short)cmd.forwardmove);
msg.WriteShort((short)cmd.sidemove);
msg.WriteShort((short)cmd.upmove);
//
// send button bits
//
int bits = 0;
if ((ClientInput.AttackBtn.state & 3) != 0)
bits |= 1;
ClientInput.AttackBtn.state &= ~2;
if ((ClientInput.JumpBtn.state & 3) != 0)
bits |= 2;
ClientInput.JumpBtn.state &= ~2;
msg.WriteByte(bits);
msg.WriteByte(ClientInput.Impulse);
ClientInput.Impulse = 0;
//
// deliver the message
//
if (cls.demoplayback)
return;
//
// allways dump the first two message, because it may contain leftover inputs
// from the last level
//
if (++cl.movemessages <= 2)
return;
if (Net.SendUnreliableMessage(cls.netcon, msg) == -1)
{
Con.Print("CL_SendMove: lost server connection\n");
Disconnect();
}
}
/// <summary>
/// Create an instance of <see cref="TraceManager"/> giving the <see cref="LogWriter"/>.
/// </summary>
/// <param name="logWriter">The <see cref="LogWriter"/> that is used to write trace messages.</param>
/// <param name="instrumentationProvider">The <see cref="ITracerInstrumentationProvider"/> used to determine if instrumentation should be enabled</param>
public TraceManager(MsgWriter logWriter, ITracerInstrumentationProvider instrumentationProvider)
{
if (logWriter == null)
{
throw new ArgumentNullException("logWriter");
}
this.logWriter = logWriter;
this.instrumentationProvider = instrumentationProvider;
}
/// <summary>
/// Create an instance of <see cref="TraceManager"/> giving the <see cref="LogWriter"/>.
/// </summary>
/// <param name="logWriter">The <see cref="LogWriter"/> that is used to write trace messages.</param>
public TraceManager(MsgWriter logWriter)
: this(logWriter, new NullTracerInstrumentationProvider())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Tracer"/> class with the given logical operation name and activity id.
/// </summary>
/// <remarks>
/// The activity id will override a previous activity id
/// </remarks>
/// <param name="operation">The operation for the <see cref="Tracer"/></param>
/// <param name="activityId">The activity id</param>
/// <param name="writer">The <see cref="MsgWriter"/> that is used to write trace messages</param>
/// <param name="instrumentationConfiguration">configuration source that is used to determine instrumentation should be enabled</param>
public Tracer(string operation, Guid activityId, MsgWriter writer, IConfigurationSource instrumentationConfiguration)
: this(operation, activityId, writer, GetTracerInstrumentationProvider(instrumentationConfiguration))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Tracer"/> class with the given logical operation name and activity id.
/// </summary>
/// <remarks>
/// This is meant to be used internally
/// </remarks>
/// <param name="operation">The operation for the <see cref="Tracer"/></param>
/// <param name="activityId">The activity id</param>
/// <param name="writer">The <see cref="MsgWriter"/> that is used to write trace messages</param>
/// <param name="instrumentationProvider">Instrumentation provider to use for firing logical instrumentation events from Tracer.</param>
/// <exception cref="ArgumentNullException"></exception>
internal Tracer(string operation, Guid activityId, MsgWriter writer, ITracerInstrumentationProvider instrumentationProvider)
{
this.instrumentationProvider = instrumentationProvider;
if (CheckTracingAvailable())
{
if (writer == null) throw new ArgumentNullException("writer", Resources.ExceptionWriterShouldNotBeNull);
this.previousActivityId = GetActivityId();
SetActivityId(activityId);
this.writer = writer;
Initialize(operation);
}
}
// CL_SendMove
public static void SendMove(ref usercmd_t cmd)
{
cl.cmd = cmd; // cl.cmd = *cmd - struct copying!!!
MsgWriter msg = new MsgWriter(128);
//
// send the movement message
//
msg.WriteByte(protocol.clc_move);
msg.WriteFloat((float)cl.mtime[0]); // so server can get ping times
msg.WriteAngle(cl.viewangles.X);
msg.WriteAngle(cl.viewangles.Y);
msg.WriteAngle(cl.viewangles.Z);
msg.WriteShort((short)cmd.forwardmove);
msg.WriteShort((short)cmd.sidemove);
msg.WriteShort((short)cmd.upmove);
//
// send button bits
//
int bits = 0;
if ((client_input.AttackBtn.state & 3) != 0)
{
bits |= 1;
}
client_input.AttackBtn.state &= ~2;
if ((client_input.JumpBtn.state & 3) != 0)
{
bits |= 2;
}
client_input.JumpBtn.state &= ~2;
msg.WriteByte(bits);
msg.WriteByte(client_input.Impulse);
client_input.Impulse = 0;
//
// deliver the message
//
if (cls.demoplayback)
{
return;
}
//
// allways dump the first two message, because it may contain leftover inputs
// from the last level
//
if (++cl.movemessages <= 2)
{
return;
}
if (net.SendUnreliableMessage(cls.netcon, msg) == -1)
{
Con.Print("CL_SendMove: lost server connection\n");
Disconnect();
}
}
public int SendMessage(qsocket_t sock, MsgWriter data)
{
if (sock.driverdata == null)
return -1;
qsocket_t sock2 = (qsocket_t)sock.driverdata;
if ((sock2.receiveMessageLength + data.Length + 4) > Net.NET_MAXMESSAGE)
Sys.Error("Loop_SendMessage: overflow\n");
// message type
int offset = sock2.receiveMessageLength;
sock2.receiveMessage[offset++] = 1;
// length
sock2.receiveMessage[offset++] = (byte)(data.Length & 0xff);
sock2.receiveMessage[offset++] = (byte)(data.Length >> 8);
// align
offset++;
// message
Buffer.BlockCopy(data.Data, 0, sock2.receiveMessage, offset, data.Length);
sock2.receiveMessageLength = IntAlign(sock2.receiveMessageLength + data.Length + 4);
sock.canSend = false;
return 1;
}
/// <summary>
/// NET_SendToAll
/// This is a reliable *blocking* send to all attached clients.
/// </summary>
public static int SendToAll(MsgWriter data, int blocktime)
{
bool[] state1 = new bool[QDef.MAX_SCOREBOARD];
bool[] state2 = new bool[QDef.MAX_SCOREBOARD];
int count = 0;
for (int i = 0; i < Server.svs.maxclients; i++)
{
Host.HostClient = Server.svs.clients[i];
if (Host.HostClient.netconnection == null)
continue;
if (Host.HostClient.active)
{
if (Host.HostClient.netconnection.driver == 0)
{
SendMessage(Host.HostClient.netconnection, data);
state1[i] = true;
state2[i] = true;
continue;
}
count++;
state1[i] = false;
state2[i] = false;
}
else
{
state1[i] = true;
state2[i] = true;
}
}
double start = Sys.GetFloatTime();
while (count > 0)
{
count = 0;
for (int i = 0; i < Server.svs.maxclients; i++)
{
Host.HostClient = Server.svs.clients[i];
if (!state1[i])
{
if (CanSendMessage(Host.HostClient.netconnection))
{
state1[i] = true;
SendMessage(Host.HostClient.netconnection, data);
}
else
{
GetMessage(Host.HostClient.netconnection);
}
count++;
continue;
}
if (!state2[i])
{
if (CanSendMessage(Host.HostClient.netconnection))
{
state2[i] = true;
}
else
{
GetMessage(Host.HostClient.netconnection);
}
count++;
continue;
}
}
if ((Sys.GetFloatTime() - start) > blocktime)
break;
}
return count;
}
public static int NET_SendToAll(MsgWriter data, int blocktime)
{
bool[] state1 = new bool[q_shared.MAX_SCOREBOARD];
bool[] state2 = new bool[q_shared.MAX_SCOREBOARD];
int count = 0;
for (int i = 0; i < svs.maxclients; i++)
{
host_client = svs.clients[i];
if (host_client.netconnection == null)
{
continue;
}
if (host_client.active)
{
if (host_client.netconnection.driver == 0)
{
NET_SendMessage(host_client.netconnection, data);
state1[i] = true;
state2[i] = true;
continue;
}
count++;
state1[i] = false;
state2[i] = false;
}
else
{
state1[i] = true;
state2[i] = true;
}
}
double start = Sys_FloatTime();
while (count > 0)
{
count = 0;
for (int i = 0; i < svs.maxclients; i++)
{
host_client = svs.clients[i];
if (!state1[i])
{
if (NET_CanSendMessage(host_client.netconnection))
{
state1[i] = true;
NET_SendMessage(host_client.netconnection, data);
}
else
{
NET_GetMessage(host_client.netconnection);
}
count++;
continue;
}
if (!state2[i])
{
if (NET_CanSendMessage(host_client.netconnection))
{
state2[i] = true;
}
else
{
NET_GetMessage(host_client.netconnection);
}
count++;
continue;
}
}
if ((Sys_FloatTime() - start) > blocktime)
{
break;
}
}
return(count);
}
public static void Host_ShutdownServer(bool crash)
{
if (!sv.active)
{
return;
}
sv.active = false;
// stop all client sounds immediately
if (cls.state == cactive_t.ca_connected)
{
CL_Disconnect();
}
// flush any pending messages - like the score!!!
double start = Sys_FloatTime();
int count;
do
{
count = 0;
for (int i = 0; i < svs.maxclients; i++)
{
host_client = svs.clients[i];
if (host_client.active && !host_client.message.IsEmpty)
{
if (NET_CanSendMessage(host_client.netconnection))
{
NET_SendMessage(host_client.netconnection, host_client.message);
host_client.message.Clear();
}
else
{
NET_GetMessage(host_client.netconnection);
count++;
}
}
}
if ((Sys_FloatTime() - start) > 3.0)
{
break;
}
}while (count > 0);
// make sure all the clients know we're disconnecting
MsgWriter writer = new MsgWriter(4);
writer.MSG_WriteByte(q_shared.svc_disconnect);
count = NET_SendToAll(writer, 5);
if (count != 0)
{
Con_Printf("Host_ShutdownServer: NET_SendToAll failed for {0} clients\n", count);
}
for (int i = 0; i < svs.maxclients; i++)
{
host_client = svs.clients[i];
if (host_client.active)
{
SV_DropClient(crash);
}
}
//
// clear structures
//
sv.Clear();
for (int i = 0; i < svs.clients.Length; i++)
{
svs.clients[i].Clear();
}
}
public int SendUnreliableMessage(qsocket_t sock, MsgWriter data)
{
throw new NotImplementedException();
}
/// <summary>
/// NET_SendToAll
/// This is a reliable *blocking* send to all attached clients.
/// </summary>
public static int SendToAll(MsgWriter data, int blocktime)
{
bool[] state1 = new bool[QDef.MAX_SCOREBOARD];
bool[] state2 = new bool[QDef.MAX_SCOREBOARD];
int count = 0;
for (int i = 0; i < Server.svs.maxclients; i++)
{
Host.HostClient = Server.svs.clients[i];
if (Host.HostClient.netconnection == null)
{
continue;
}
if (Host.HostClient.active)
{
if (Host.HostClient.netconnection.driver == 0)
{
SendMessage(Host.HostClient.netconnection, data);
state1[i] = true;
state2[i] = true;
continue;
}
count++;
state1[i] = false;
state2[i] = false;
}
else
{
state1[i] = true;
state2[i] = true;
}
}
double start = Sys.GetFloatTime();
while (count > 0)
{
count = 0;
for (int i = 0; i < Server.svs.maxclients; i++)
{
Host.HostClient = Server.svs.clients[i];
if (!state1[i])
{
if (CanSendMessage(Host.HostClient.netconnection))
{
state1[i] = true;
SendMessage(Host.HostClient.netconnection, data);
}
else
{
GetMessage(Host.HostClient.netconnection);
}
count++;
continue;
}
if (!state2[i])
{
if (CanSendMessage(Host.HostClient.netconnection))
{
state2[i] = true;
}
else
{
GetMessage(Host.HostClient.netconnection);
}
count++;
continue;
}
}
if ((Sys.GetFloatTime() - start) > blocktime)
{
break;
}
}
return(count);
}
public client_static_t()
{
this.demos = new string[Client.MAX_DEMOS];
this.message = new MsgWriter(1024); // like in Client_Init()
}
// vcrSendMessage
// NET_Init (void)
public static void Init()
{
for (int i2 = 0; i2 < _HostCache.Length; i2++)
{
_HostCache[i2] = new hostcache_t();
}
if (_Drivers == null)
{
if (Common.HasParam("-playback"))
{
_Drivers = new INetDriver[]
{
new NetVcr()
};
}
else
{
_Drivers = new INetDriver[]
{
new NetLoop(),
NetDatagram.Instance
};
}
}
if (_LanDrivers == null)
{
_LanDrivers = new INetLanDriver[]
{
NetTcpIp.Instance
};
}
if (Common.HasParam("-record"))
{
_IsRecording = true;
}
int i = Common.CheckParm("-port");
if (i == 0)
{
i = Common.CheckParm("-udpport");
}
if (i == 0)
{
i = Common.CheckParm("-ipxport");
}
if (i > 0)
{
if (i < Common.Argc - 1)
{
_DefHostPort = Common.atoi(Common.Argv(i + 1));
}
else
{
Sys.Error("Net.Init: you must specify a number after -port!");
}
}
HostPort = _DefHostPort;
if (Common.HasParam("-listen") || Client.cls.state == cactive_t.ca_dedicated)
{
_IsListening = true;
}
int numsockets = Server.svs.maxclientslimit;
if (Client.cls.state != cactive_t.ca_dedicated)
{
numsockets++;
}
_FreeSockets = new List <qsocket_t>(numsockets);
_ActiveSockets = new List <qsocket_t>(numsockets);
for (i = 0; i < numsockets; i++)
{
_FreeSockets.Add(new qsocket_t());
}
SetNetTime();
// allocate space for network message buffer
Message = new MsgWriter(NET_MAXMESSAGE); // SZ_Alloc (&net_message, NET_MAXMESSAGE);
Reader = new MsgReader(Net.Message);
if (_MessageTimeout == null)
{
_MessageTimeout = new Cvar("net_messagetimeout", "300");
_HostName = new Cvar("hostname", "UNNAMED");
}
Cmd.Add("slist", Slist_f);
Cmd.Add("listen", Listen_f);
Cmd.Add("maxplayers", MaxPlayers_f);
Cmd.Add("port", Port_f);
// initialize all the drivers
_DriverLevel = 0;
foreach (INetDriver driver in _Drivers)
{
driver.Init();
if (driver.IsInitialized && _IsListening)
{
driver.Listen(true);
}
_DriverLevel++;
}
//if (*my_ipx_address)
// Con_DPrintf("IPX address %s\n", my_ipx_address);
if (!String.IsNullOrEmpty(_MyTcpIpAddress))
{
Con.DPrint("TCP/IP address {0}\n", _MyTcpIpAddress);
}
}
/// <summary>
/// Host_Spawn_f
/// </summary>
private static void Spawn_f()
{
if (cmd.Source == cmd_source_t.src_command)
{
Con.Print("spawn is not valid from the console\n");
return;
}
if (host.HostClient.spawned)
{
Con.Print("Spawn not valid -- allready spawned\n");
return;
}
edict_t ent;
// run the entrance script
if (server.sv.loadgame)
{
// loaded games are fully inited allready
// if this is the last client to be connected, unpause
server.sv.paused = false;
}
else
{
// set up the edict
ent = host.HostClient.edict;
ent.Clear(); //memset(&ent.v, 0, progs.entityfields * 4);
ent.v.colormap = server.NumForEdict(ent);
ent.v.team = (host.HostClient.colors & 15) + 1;
ent.v.netname = progs.NewString(host.HostClient.name);
// copy spawn parms out of the client_t
progs.GlobalStruct.SetParams(host.HostClient.spawn_parms);
// call the spawn function
progs.GlobalStruct.time = (float)server.sv.time;
progs.GlobalStruct.self = server.EdictToProg(server.Player);
progs.Execute(progs.GlobalStruct.ClientConnect);
if ((sys.GetFloatTime() - host.HostClient.netconnection.connecttime) <= server.sv.time)
{
Con.DPrint("{0} entered the game\n", host.HostClient.name);
}
progs.Execute(progs.GlobalStruct.PutClientInServer);
}
// send all current names, colors, and frag counts
MsgWriter msg = host.HostClient.message;
msg.Clear();
// send time of update
msg.WriteByte(protocol.svc_time);
msg.WriteFloat((float)server.sv.time);
for (int i = 0; i < server.svs.maxclients; i++)
{
client_t client = server.svs.clients[i];
msg.WriteByte(protocol.svc_updatename);
msg.WriteByte(i);
msg.WriteString(client.name);
msg.WriteByte(protocol.svc_updatefrags);
msg.WriteByte(i);
msg.WriteShort(client.old_frags);
msg.WriteByte(protocol.svc_updatecolors);
msg.WriteByte(i);
msg.WriteByte(client.colors);
}
// send all current light styles
for (int i = 0; i < QDef.MAX_LIGHTSTYLES; i++)
{
msg.WriteByte(protocol.svc_lightstyle);
msg.WriteByte((char)i);
msg.WriteString(server.sv.lightstyles[i]);
}
//
// send some stats
//
msg.WriteByte(protocol.svc_updatestat);
msg.WriteByte(QStats.STAT_TOTALSECRETS);
msg.WriteLong((int)progs.GlobalStruct.total_secrets);
msg.WriteByte(protocol.svc_updatestat);
msg.WriteByte(QStats.STAT_TOTALMONSTERS);
msg.WriteLong((int)progs.GlobalStruct.total_monsters);
msg.WriteByte(protocol.svc_updatestat);
msg.WriteByte(QStats.STAT_SECRETS);
msg.WriteLong((int)progs.GlobalStruct.found_secrets);
msg.WriteByte(protocol.svc_updatestat);
msg.WriteByte(QStats.STAT_MONSTERS);
msg.WriteLong((int)progs.GlobalStruct.killed_monsters);
//
// send a fixangle
// 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 = server.EdictNum(1 + host.ClientNum);
msg.WriteByte(protocol.svc_setangle);
msg.WriteAngle(ent.v.angles.x);
msg.WriteAngle(ent.v.angles.y);
msg.WriteAngle(0);
server.WriteClientDataToMessage(server.Player, host.HostClient.message);
msg.WriteByte(protocol.svc_signonnum);
msg.WriteByte(3);
host.HostClient.sendsignon = true;
}
/// <summary>
/// NET_SendUnreliableMessage
/// returns 0 if the message connot be delivered reliably, but the connection
/// is still considered valid
/// returns 1 if the message was sent properly
/// returns -1 if the connection died
/// </summary>
public static int SendUnreliableMessage(qsocket_t sock, MsgWriter data)
{
if (sock == null)
return -1;
if (sock.disconnected)
{
Con.Print("NET_SendMessage: disconnected socket\n");
return -1;
}
SetNetTime();
int r = _Drivers[sock.driver].SendUnreliableMessage(sock, data);
if (r == 1 && sock.driver != 0)
_UnreliableMessagesSent++;
if (_IsRecording)
{
_VcrSendMessage.time = Host.Time;
_VcrSendMessage.op = VcrOp.VCR_OP_SENDMESSAGE;
_VcrSendMessage.session = 1;// (long)sock; Uze todo: ???????
_VcrSendMessage.ret = r;
byte[] buf = Sys.StructureToBytes(ref _VcrSendMessage);
Host.VcrWriter.Write(buf);
}
return r;
}
public Vector3 wishdir; // intended motion calced from cmd
#endregion Fields
#region Constructors
public client_t()
{
this.ping_times = new float[Server.NUM_PING_TIMES];
this.spawn_parms = new float[Server.NUM_SPAWN_PARMS];
this.message = new MsgWriter(QDef.MAX_MSGLEN);
}
public static void SV_WriteEntitiesToClient(edict_t clent, MsgWriter msg)
{
// find the client's PVS
Vector3 org = ToVector(ref clent.v.origin) + ToVector(ref clent.v.view_ofs);
byte[] pvs = SV_FatPVS(ref org);
// send over all entities (except the client) that touch the pvs
for (int e = 1; e < sv.num_edicts; e++)
{
edict_t ent = sv.edicts[e];
// ignore if not touching a PV leaf
if (ent != clent) // clent is ALLWAYS sent
{
// ignore ents without visible models
string mname = GetString(ent.v.model);
if (String.IsNullOrEmpty(mname))
{
continue;
}
int i;
for (i = 0; i < ent.num_leafs; i++)
{
if ((pvs[ent.leafnums[i] >> 3] & (1 << (ent.leafnums[i] & 7))) != 0)
{
break;
}
}
if (i == ent.num_leafs)
{
continue; // not visible
}
}
if (msg.Capacity - msg.Length < 16)
{
Con_Printf("packet overflow\n");
return;
}
// send an update
int bits = 0;
v3f miss;
Mathlib.VectorSubtract(ref ent.v.origin, ref ent.baseline.origin, out miss);
if (miss.x < -0.1f || miss.x > 0.1f)
{
bits |= q_shared.U_ORIGIN1;
}
if (miss.y < -0.1f || miss.y > 0.1f)
{
bits |= q_shared.U_ORIGIN2;
}
if (miss.z < -0.1f || miss.z > 0.1f)
{
bits |= q_shared.U_ORIGIN3;
}
if (ent.v.angles.x != ent.baseline.angles.x)
{
bits |= q_shared.U_ANGLE1;
}
if (ent.v.angles.y != ent.baseline.angles.y)
{
bits |= q_shared.U_ANGLE2;
}
if (ent.v.angles.z != ent.baseline.angles.z)
{
bits |= q_shared.U_ANGLE3;
}
if (ent.v.movetype == q_shared.MOVETYPE_STEP)
{
bits |= q_shared.U_NOLERP; // don't mess up the step animation
}
if (ent.baseline.colormap != ent.v.colormap)
{
bits |= q_shared.U_COLORMAP;
}
if (ent.baseline.skin != ent.v.skin)
{
bits |= q_shared.U_SKIN;
}
if (ent.baseline.frame != ent.v.frame)
{
bits |= q_shared.U_FRAME;
}
if (ent.baseline.effects != ent.v.effects)
{
bits |= q_shared.U_EFFECTS;
}
if (ent.baseline.modelindex != ent.v.modelindex)
{
bits |= q_shared.U_MODEL;
}
if (e >= 256)
{
bits |= q_shared.U_LONGENTITY;
}
if (bits >= 256)
{
bits |= q_shared.U_MOREBITS;
}
//
// write the message
//
msg.MSG_WriteByte(bits | q_shared.U_SIGNAL);
if ((bits & q_shared.U_MOREBITS) != 0)
{
msg.MSG_WriteByte(bits >> 8);
}
if ((bits & q_shared.U_LONGENTITY) != 0)
{
msg.MSG_WriteShort(e);
}
else
{
msg.MSG_WriteByte(e);
}
if ((bits & q_shared.U_MODEL) != 0)
{
msg.MSG_WriteByte((int)ent.v.modelindex);
}
if ((bits & q_shared.U_FRAME) != 0)
{
msg.MSG_WriteByte((int)ent.v.frame);
}
if ((bits & q_shared.U_COLORMAP) != 0)
{
msg.MSG_WriteByte((int)ent.v.colormap);
}
if ((bits & q_shared.U_SKIN) != 0)
{
msg.MSG_WriteByte((int)ent.v.skin);
}
if ((bits & q_shared.U_EFFECTS) != 0)
{
msg.MSG_WriteByte((int)ent.v.effects);
}
if ((bits & q_shared.U_ORIGIN1) != 0)
{
msg.MSG_WriteCoord(ent.v.origin.x);
}
if ((bits & q_shared.U_ANGLE1) != 0)
{
msg.MSG_WriteAngle(ent.v.angles.x);
}
if ((bits & q_shared.U_ORIGIN2) != 0)
{
msg.MSG_WriteCoord(ent.v.origin.y);
}
if ((bits & q_shared.U_ANGLE2) != 0)
{
msg.MSG_WriteAngle(ent.v.angles.y);
}
if ((bits & q_shared.U_ORIGIN3) != 0)
{
msg.MSG_WriteCoord(ent.v.origin.z);
}
if ((bits & q_shared.U_ANGLE3) != 0)
{
msg.MSG_WriteAngle(ent.v.angles.z);
}
}
}
public int SendMessage(qsocket_t sock, MsgWriter data)
{
if (Host.Time != _Next.time || _Next.op != VcrOp.VCR_OP_SENDMESSAGE || _Next.session != SocketToSession(sock))
Sys.Error("VCR missmatch");
int ret = Host.VcrReader.ReadInt32();
ReadNext();
return ret;
}
// NET_Init (void)
public static void Init()
{
for (int i2 = 0; i2 < _HostCache.Length; i2++)
_HostCache[i2] = new hostcache_t();
if (_Drivers == null)
{
if(Common.HasParam("-playback"))
{
_Drivers = new INetDriver[]
{
new NetVcr()
};
}
else
{
_Drivers = new INetDriver[]
{
new NetLoop(),
NetDatagram.Instance
};
}
}
if (_LanDrivers == null)
{
_LanDrivers = new INetLanDriver[]
{
NetTcpIp.Instance
};
}
if (Common.HasParam("-record"))
_IsRecording = true;
int i = Common.CheckParm("-port");
if (i == 0)
i = Common.CheckParm("-udpport");
if (i == 0)
i = Common.CheckParm("-ipxport");
if (i > 0)
{
if (i < Common.Argc - 1)
_DefHostPort = Common.atoi(Common.Argv(i + 1));
else
Sys.Error("Net.Init: you must specify a number after -port!");
}
HostPort = _DefHostPort;
if (Common.HasParam("-listen") || Client.cls.state == cactive_t.ca_dedicated)
_IsListening = true;
int numsockets = Server.svs.maxclientslimit;
if (Client.cls.state != cactive_t.ca_dedicated)
numsockets++;
_FreeSockets = new List<qsocket_t>(numsockets);
_ActiveSockets = new List<qsocket_t>(numsockets);
for (i = 0; i < numsockets; i++)
_FreeSockets.Add(new qsocket_t());
SetNetTime();
// allocate space for network message buffer
Message = new MsgWriter(NET_MAXMESSAGE); // SZ_Alloc (&net_message, NET_MAXMESSAGE);
Reader = new MsgReader(Net.Message);
if (_MessageTimeout == null)
{
_MessageTimeout = new Cvar("net_messagetimeout", "300");
_HostName = new Cvar("hostname", "UNNAMED");
}
Cmd.Add("slist", Slist_f);
Cmd.Add("listen", Listen_f);
Cmd.Add("maxplayers", MaxPlayers_f);
Cmd.Add("port", Port_f);
// initialize all the drivers
_DriverLevel = 0;
foreach (INetDriver driver in _Drivers)
{
driver.Init();
if (driver.IsInitialized && _IsListening)
{
driver.Listen(true);
}
_DriverLevel++;
}
//if (*my_ipx_address)
// Con_DPrintf("IPX address %s\n", my_ipx_address);
if (!String.IsNullOrEmpty(_MyTcpIpAddress))
Con.DPrint("TCP/IP address {0}\n", _MyTcpIpAddress);
}
public static void SV_SendServerinfo(client_t client)
{
MsgWriter writer = client.message;
writer.MSG_WriteByte(q_shared.svc_print);
writer.MSG_WriteString(String.Format("{0}\nVERSION {1,4:F2} SERVER ({2} CRC)", (char)2, q_shared.VERSION, pr_crc));
writer.MSG_WriteByte(q_shared.svc_serverinfo);
writer.MSG_WriteLong(q_shared.PROTOCOL_VERSION);
writer.MSG_WriteByte(svs.maxclients);
if (!(coop.value != 0) && deathmatch.value != 0)
{
writer.MSG_WriteByte(q_shared.GAME_DEATHMATCH);
}
else
{
writer.MSG_WriteByte(q_shared.GAME_COOP);
}
string message = GetString(sv.edicts[0].v.message);
writer.MSG_WriteString(message);
for (int i = 1; i < sv.model_precache.Length; i++)
{
string tmp = sv.model_precache[i];
if (String.IsNullOrEmpty(tmp))
{
break;
}
writer.MSG_WriteString(tmp);
}
writer.MSG_WriteByte(0);
for (int i = 1; i < sv.sound_precache.Length; i++)
{
string tmp = sv.sound_precache[i];
if (tmp == null)
{
break;
}
writer.MSG_WriteString(tmp);
}
writer.MSG_WriteByte(0);
// send music
writer.MSG_WriteByte(q_shared.svc_cdtrack);
writer.MSG_WriteByte((int)sv.edicts[0].v.sounds);
writer.MSG_WriteByte((int)sv.edicts[0].v.sounds);
// set view
writer.MSG_WriteByte(q_shared.svc_setview);
writer.MSG_WriteShort(NUM_FOR_EDICT(client.edict));
writer.MSG_WriteByte(q_shared.svc_signonnum);
writer.MSG_WriteByte(1);
client.sendsignon = true;
client.spawned = false; // need prespawn, spawn, etc
}
public int SendUnreliableMessage(qsocket_t sock, MsgWriter data)
{
throw new NotImplementedException();
}
public static void SV_WriteClientdataToMessage(edict_t ent, MsgWriter msg)
{
//
// send a damage message
//
if (ent.v.dmg_take != 0 || ent.v.dmg_save != 0)
{
edict_t other = PROG_TO_EDICT(ent.v.dmg_inflictor);
msg.MSG_WriteByte(q_shared.svc_damage);
msg.MSG_WriteByte((int)ent.v.dmg_save);
msg.MSG_WriteByte((int)ent.v.dmg_take);
msg.MSG_WriteCoord(other.v.origin.x + 0.5f * (other.v.mins.x + other.v.maxs.x));
msg.MSG_WriteCoord(other.v.origin.y + 0.5f * (other.v.mins.y + other.v.maxs.y));
msg.MSG_WriteCoord(other.v.origin.z + 0.5f * (other.v.mins.z + other.v.maxs.z));
ent.v.dmg_take = 0;
ent.v.dmg_save = 0;
}
//
// send the current viewpos offset from the view entity
//
SV_SetIdealPitch(); // how much to look up / down ideally
// a fixangle might get lost in a dropped packet. Oh well.
if (ent.v.fixangle != 0)
{
msg.MSG_WriteByte(q_shared.svc_setangle);
msg.MSG_WriteAngle(ent.v.angles.x);
msg.MSG_WriteAngle(ent.v.angles.y);
msg.MSG_WriteAngle(ent.v.angles.z);
ent.v.fixangle = 0;
}
int bits = 0;
if (ent.v.view_ofs.z != q_shared.DEFAULT_VIEWHEIGHT)
{
bits |= q_shared.SU_VIEWHEIGHT;
}
if (ent.v.idealpitch != 0)
{
bits |= q_shared.SU_IDEALPITCH;
}
// stuff the sigil bits into the high bits of items for sbar, or else
// mix in items2
float val = GetEdictFieldFloat(ent, "items2", 0);
int items;
if (val != 0)
{
items = (int)ent.v.items | ((int)val << 23);
}
else
{
items = (int)ent.v.items | ((int)pr_global_struct.serverflags << 28);
}
bits |= q_shared.SU_ITEMS;
if (((int)ent.v.flags & q_shared.FL_ONGROUND) != 0)
{
bits |= q_shared.SU_ONGROUND;
}
if (ent.v.waterlevel >= 2)
{
bits |= q_shared.SU_INWATER;
}
if (ent.v.punchangle.x != 0)
{
bits |= q_shared.SU_PUNCH1;
}
if (ent.v.punchangle.y != 0)
{
bits |= q_shared.SU_PUNCH2;
}
if (ent.v.punchangle.z != 0)
{
bits |= q_shared.SU_PUNCH3;
}
if (ent.v.velocity.x != 0)
{
bits |= q_shared.SU_VELOCITY1;
}
if (ent.v.velocity.y != 0)
{
bits |= q_shared.SU_VELOCITY2;
}
if (ent.v.velocity.z != 0)
{
bits |= q_shared.SU_VELOCITY3;
}
if (ent.v.weaponframe != 0)
{
bits |= q_shared.SU_WEAPONFRAME;
}
if (ent.v.armorvalue != 0)
{
bits |= q_shared.SU_ARMOR;
}
// if (ent.v.weapon)
bits |= q_shared.SU_WEAPON;
// send the data
msg.MSG_WriteByte(q_shared.svc_clientdata);
msg.MSG_WriteShort(bits);
if ((bits & q_shared.SU_VIEWHEIGHT) != 0)
{
msg.MSG_WriteChar((int)ent.v.view_ofs.z);
}
if ((bits & q_shared.SU_IDEALPITCH) != 0)
{
msg.MSG_WriteChar((int)ent.v.idealpitch);
}
if ((bits & q_shared.SU_PUNCH1) != 0)
{
msg.MSG_WriteChar((int)ent.v.punchangle.x);
}
if ((bits & q_shared.SU_VELOCITY1) != 0)
{
msg.MSG_WriteChar((int)(ent.v.velocity.x / 16));
}
if ((bits & q_shared.SU_PUNCH2) != 0)
{
msg.MSG_WriteChar((int)ent.v.punchangle.y);
}
if ((bits & q_shared.SU_VELOCITY2) != 0)
{
msg.MSG_WriteChar((int)(ent.v.velocity.y / 16));
}
if ((bits & q_shared.SU_PUNCH3) != 0)
{
msg.MSG_WriteChar((int)ent.v.punchangle.z);
}
if ((bits & q_shared.SU_VELOCITY3) != 0)
{
msg.MSG_WriteChar((int)(ent.v.velocity.z / 16));
}
// always sent
msg.MSG_WriteLong(items);
if ((bits & q_shared.SU_WEAPONFRAME) != 0)
{
msg.MSG_WriteByte((int)ent.v.weaponframe);
}
if ((bits & q_shared.SU_ARMOR) != 0)
{
msg.MSG_WriteByte((int)ent.v.armorvalue);
}
if ((bits & q_shared.SU_WEAPON) != 0)
{
msg.MSG_WriteByte(SV_ModelIndex(GetString(ent.v.weaponmodel)));
}
msg.MSG_WriteShort((int)ent.v.health);
msg.MSG_WriteByte((int)ent.v.currentammo);
msg.MSG_WriteByte((int)ent.v.ammo_shells);
msg.MSG_WriteByte((int)ent.v.ammo_nails);
msg.MSG_WriteByte((int)ent.v.ammo_rockets);
msg.MSG_WriteByte((int)ent.v.ammo_cells);
if (_GameKind == GameKind.StandardQuake)
{
msg.MSG_WriteByte((int)ent.v.weapon);
}
else
{
for (int i = 0; i < 32; i++)
{
if ((((int)ent.v.weapon) & (1 << i)) != 0)
{
msg.MSG_WriteByte(i);
break;
}
}
}
}
public override void WriteMessage(string message)
{
Console.WriteLine($"经过CompressedDecorate加持...");
MsgWriter.WriteMessage(message);
}
public static void NET_Init()
{
for (int i2 = 0; i2 < hostcache.Length; i2++)
{
hostcache[i2] = new hostcache_t();
}
if (net_drivers == null)
{
if (HasParam("-playback"))
{
net_drivers = new INetDriver[]
{
new NetVcr()
};
}
else
{
net_drivers = new INetDriver[]
{
new NetLoop(),
NetDatagram.Instance
};
}
}
if (net_landrivers == null)
{
net_landrivers = new INetLanDriver[]
{
NetTcpIp.Instance
};
}
if (HasParam("-record"))
{
recording = true;
}
int i = COM_CheckParm("-port");
if (i == 0)
{
i = COM_CheckParm("-udpport");
}
if (i == 0)
{
i = COM_CheckParm("-ipxport");
}
if (i > 0)
{
if (i < com_argv.Length - 1)
{
DEFAULTnet_hostport = atoi(Argv(i + 1));
}
else
{
Sys_Error("Net.Init: you must specify a number after -port!");
}
}
net_hostport = DEFAULTnet_hostport;
if (HasParam("-listen") || cls.state == cactive_t.ca_dedicated)
{
listening = true;
}
int numsockets = svs.maxclientslimit;
if (cls.state != cactive_t.ca_dedicated)
{
numsockets++;
}
net_freeSockets = new List <qsocket_t>(numsockets);
net_activeSockets = new List <qsocket_t>(numsockets);
for (i = 0; i < numsockets; i++)
{
net_freeSockets.Add(new qsocket_t());
}
SetNetTime();
// allocate space for network message buffer
Message = new MsgWriter(q_shared.NET_MAXMESSAGE); // SZ_Alloc (&net_message, NET_MAXMESSAGE);
Reader = new MsgReader(Message);
net_messagetimeout = new cvar_t("net_messagetimeout", "300");
hostname = new cvar_t("hostname", "UNNAMED");
Cmd_AddCommand("slist", NET_Slist_f);
Cmd_AddCommand("listen", NET_Listen_f);
Cmd_AddCommand("maxplayers", MaxPlayers_f);
Cmd_AddCommand("port", NET_Port_f);
// initialize all the drivers
net_driverlevel = 0;
foreach (INetDriver driver in net_drivers)
{
driver.Init();
if (driver.IsInitialized && listening)
{
driver.Datagram_Listen(true);
}
net_driverlevel++;
}
//if (*my_ipx_address)
// Con_DPrintf("IPX address %s\n", my_ipx_address);
if (!String.IsNullOrEmpty(my_tcpip_address))
{
Con_DPrintf("TCP/IP address {0}\n", my_tcpip_address);
}
}
public override void WriteMessage(string message)
{
Console.WriteLine($"经过DigitallySignedDecorate加持...");
MsgWriter.WriteMessage(message);
}
/// <summary>
/// Host_ShutdownServer
/// This only happens at the end of a game, not between levels
/// </summary>
public static void ShutdownServer(bool crash)
{
if (!Server.IsActive)
{
return;
}
Server.sv.active = false;
// stop all client sounds immediately
if (Client.cls.state == cactive_t.ca_connected)
{
Client.Disconnect();
}
// flush any pending messages - like the score!!!
double start = Sys.GetFloatTime();
int count;
do
{
count = 0;
for (int i = 0; i < Server.svs.maxclients; i++)
{
HostClient = Server.svs.clients[i];
if (HostClient.active && !HostClient.message.IsEmpty)
{
if (Net.CanSendMessage(HostClient.netconnection))
{
Net.SendMessage(HostClient.netconnection, HostClient.message);
HostClient.message.Clear();
}
else
{
Net.GetMessage(HostClient.netconnection);
count++;
}
}
}
if ((Sys.GetFloatTime() - start) > 3.0)
{
break;
}
}while (count > 0);
// make sure all the clients know we're disconnecting
MsgWriter writer = new MsgWriter(4);
writer.WriteByte(Protocol.svc_disconnect);
count = Net.SendToAll(writer, 5);
if (count != 0)
{
Con.Print("Host_ShutdownServer: NET_SendToAll failed for {0} clients\n", count);
}
for (int i = 0; i < Server.svs.maxclients; i++)
{
HostClient = Server.svs.clients[i];
if (HostClient.active)
{
Server.DropClient(crash);
}
}
//
// clear structures
//
Server.sv.Clear();
for (int i = 0; i < Server.svs.clients.Length; i++)
{
Server.svs.clients[i].Clear();
}
}
/// <summary>
/// SV_SendServerinfo
/// Sends the first message from the server to a connected client.
/// This will be sent on the initial connection and upon each server load.
/// </summary>
static void SendServerInfo(client_t client)
{
MsgWriter writer = client.message;
writer.WriteByte(Protocol.svc_print);
writer.WriteString(String.Format("{0}\nVERSION {1,4:F2} SERVER ({2} CRC)", (char)2, QDef.VERSION, Progs.Crc));
writer.WriteByte(Protocol.svc_serverinfo);
writer.WriteLong(Protocol.PROTOCOL_VERSION);
writer.WriteByte(svs.maxclients);
if (!Host.IsCoop && Host.Deathmatch != 0)
{
writer.WriteByte(Protocol.GAME_DEATHMATCH);
}
else
{
writer.WriteByte(Protocol.GAME_COOP);
}
string message = Progs.GetString(sv.edicts[0].v.message);
writer.WriteString(message);
for (int i = 1; i < sv.model_precache.Length; i++)
{
string tmp = sv.model_precache[i];
if (String.IsNullOrEmpty(tmp))
{
break;
}
writer.WriteString(tmp);
}
writer.WriteByte(0);
for (int i = 1; i < sv.sound_precache.Length; i++)
{
string tmp = sv.sound_precache[i];
if (tmp == null)
{
break;
}
writer.WriteString(tmp);
}
writer.WriteByte(0);
// send music
writer.WriteByte(Protocol.svc_cdtrack);
writer.WriteByte((int)sv.edicts[0].v.sounds);
writer.WriteByte((int)sv.edicts[0].v.sounds);
// set view
writer.WriteByte(Protocol.svc_setview);
writer.WriteShort(NumForEdict(client.edict));
writer.WriteByte(Protocol.svc_signonnum);
writer.WriteByte(1);
client.sendsignon = true;
client.spawned = false; // need prespawn, spawn, etc
}
public int SendUnreliableMessage(qsocket_t sock, MsgWriter data)
{
if (sock.driverdata == null)
return -1;
qsocket_t sock2 = (qsocket_t)sock.driverdata;
if ((sock2.receiveMessageLength + data.Length + sizeof(byte) + sizeof(short)) > Net.NET_MAXMESSAGE)
return 0;
int offset = sock2.receiveMessageLength;
// message type
sock2.receiveMessage[offset++] = 2;
// length
sock2.receiveMessage[offset++] = (byte)(data.Length & 0xff);
sock2.receiveMessage[offset++] = (byte)(data.Length >> 8);
// align
offset++;
// message
Buffer.BlockCopy(data.Data, 0, sock2.receiveMessage, offset, data.Length);
sock2.receiveMessageLength = IntAlign(sock2.receiveMessageLength + data.Length + 4);
return 1;
}
public client_t()
{
this.ping_times = new float[Server.NUM_PING_TIMES];
this.spawn_parms = new float[Server.NUM_SPAWN_PARMS];
this.message = new MsgWriter(QDef.MAX_MSGLEN);
}
/// <summary>
/// Initializes a new instance of the <see cref="Tracer"/> class with the given logical operation name and activity id.
/// </summary>
/// <remarks>
/// The activity id will override a previous activity id
/// </remarks>
/// <param name="operation">The operation for the <see cref="Tracer"/></param>
/// <param name="activityId">The activity id</param>
/// <param name="writer">The <see cref="MsgWriter"/> that is used to write trace messages</param>
/// <param name="serviceLocator"><see cref="IServiceLocator"/> used to retrieve the instrumentation provider for this tracer.</param>
public Tracer(string operation, Guid activityId, MsgWriter writer, IServiceLocator serviceLocator)
: this(operation, activityId, writer, GetTracerInstrumentationProvider(serviceLocator))
{
}
public MsgWriter message; // sizebuf_t message; // writing buffer to send to server
public client_static_t()
{
this.demos = new string[Client.MAX_DEMOS];
this.message = new MsgWriter(1024); // like in Client_Init()
}
/// <summary>
/// Initializes a new instance of the <see cref="Tracer"/> class with the given logical operation name and activity id.
/// </summary>
/// <remarks>
/// This is meant to be used internally
/// </remarks>
/// <param name="operation">The operation for the <see cref="Tracer"/></param>
/// <param name="writer">The <see cref="MsgWriter"/> that is used to write trace messages</param>
/// <param name="instrumentationProvider">Instrumentation provider to use for firing logical instrumentation events from Tracer.</param>
/// <exception cref="ArgumentNullException"></exception>
internal Tracer(string operation, MsgWriter writer, ITracerInstrumentationProvider instrumentationProvider)
{
this.instrumentationProvider = instrumentationProvider;
if (CheckTracingAvailable())
{
if (writer == null) throw new ArgumentNullException("writer", Resources.ExceptionWriterShouldNotBeNull);
if (GetActivityId().Equals(Guid.Empty))
{
this.previousActivityId = Guid.Empty;
SetActivityId(Guid.NewGuid());
}
else
{
this.previousActivityId = null;
}
this.writer = writer;
Initialize(operation);
}
}
/// <summary>
/// Creates a <see cref="MsgCallHandler"/> with default settings that writes
/// to the given <see cref="LogWriter"/>.
/// </summary>
/// <remarks>See the <see cref="LogCallHandlerDefaults"/> class for the default values.</remarks>
/// <param name="logWriter"><see cref="LogWriter"/> to write logs to.</param>
public MsgCallHandler(MsgWriter logWriter)
{
this.logWriter = logWriter;
}
/// <summary>
/// Creates a new <see cref="MsgCallHandler"/> that writes to the specified <see cref="LogWriter"/>
/// using the given logging settings.
/// </summary>
/// <param name="logWriter"><see cref="LogWriter"/> to write log entries to.</param>
/// <param name="eventId">EventId to include in log entries.</param>
/// <param name="logBeforeCall">Should the handler log information before calling the target?</param>
/// <param name="logAfterCall">Should the handler log information after calling the target?</param>
/// <param name="beforeMessage">Message to include in a before-call log entry.</param>
/// <param name="afterMessage">Message to include in an after-call log entry.</param>
/// <param name="includeParameters">Should the parameter values be included in the log entry?</param>
/// <param name="includeCallStack">Should the current call stack be included in the log entry?</param>
/// <param name="includeCallTime">Should the time to execute the target be included in the log entry?</param>
/// <param name="priority">Priority of the log entry.</param>
public MsgCallHandler(MsgWriter logWriter, int eventId,
bool logBeforeCall,
bool logAfterCall, string beforeMessage, string afterMessage,
bool includeParameters, bool includeCallStack,
bool includeCallTime, int priority)
{
this.logWriter = logWriter;
this.eventId = eventId;
this.logBeforeCall = logBeforeCall;
this.logAfterCall = logAfterCall;
this.beforeMessage = beforeMessage;
this.afterMessage = afterMessage;
this.includeParameters = includeParameters;
this.includeCallStack = includeCallStack;
this.includeCallTime = includeCallTime;
this.priority = priority;
}
/// <summary>
/// Creates a new <see cref="MsgCallHandler"/> that writes to the specified <see cref="LogWriter"/>
/// using the given logging settings.
/// </summary>
/// <param name="logWriter"><see cref="LogWriter"/> to write log entries to.</param>
/// <param name="eventId">EventId to include in log entries.</param>
/// <param name="logBeforeCall">Should the handler log information before calling the target?</param>
/// <param name="logAfterCall">Should the handler log information after calling the target?</param>
/// <param name="beforeMessage">Message to include in a before-call log entry.</param>
/// <param name="afterMessage">Message to include in an after-call log entry.</param>
/// <param name="includeParameters">Should the parameter values be included in the log entry?</param>
/// <param name="includeCallStack">Should the current call stack be included in the log entry?</param>
/// <param name="includeCallTime">Should the time to execute the target be included in the log entry?</param>
/// <param name="priority">Priority of the log entry.</param>
/// <param name="order">Order in which the handler will be executed.</param>
public MsgCallHandler(MsgWriter logWriter, int eventId,
bool logBeforeCall,
bool logAfterCall, string beforeMessage, string afterMessage,
bool includeParameters, bool includeCallStack,
bool includeCallTime, int priority,
int order)
: this(logWriter, eventId, logBeforeCall, logAfterCall, beforeMessage, afterMessage, includeParameters, includeCallStack, includeCallTime, priority)
{
this.order = order;
}
public server_t()
{
this.model_precache = new string[QDef.MAX_MODELS];
this.models = new model_t[QDef.MAX_MODELS];
this.sound_precache = new string[QDef.MAX_SOUNDS];
this.lightstyles = new string[QDef.MAX_LIGHTSTYLES];
this.datagram = new MsgWriter(QDef.MAX_DATAGRAM);
this.reliable_datagram = new MsgWriter(QDef.MAX_DATAGRAM);
this.signon = new MsgWriter(8192);
}
/// <summary>
/// Host_ShutdownServer
/// This only happens at the end of a game, not between levels
/// </summary>
public static void ShutdownServer(bool crash)
{
if (!Server.IsActive)
return;
Server.sv.active = false;
// stop all client sounds immediately
if (Client.cls.state == cactive_t.ca_connected)
Client.Disconnect();
// flush any pending messages - like the score!!!
double start = Sys.GetFloatTime();
int count;
do
{
count = 0;
for (int i = 0; i < Server.svs.maxclients; i++)
{
HostClient = Server.svs.clients[i];
if (HostClient.active && !HostClient.message.IsEmpty)
{
if (Net.CanSendMessage(HostClient.netconnection))
{
Net.SendMessage(HostClient.netconnection, HostClient.message);
HostClient.message.Clear();
}
else
{
Net.GetMessage(HostClient.netconnection);
count++;
}
}
}
if ((Sys.GetFloatTime() - start) > 3.0)
break;
}
while (count > 0);
// make sure all the clients know we're disconnecting
MsgWriter writer = new MsgWriter(4);
writer.WriteByte(Protocol.svc_disconnect);
count = Net.SendToAll(writer, 5);
if (count != 0)
Con.Print("Host_ShutdownServer: NET_SendToAll failed for {0} clients\n", count);
for (int i = 0; i < Server.svs.maxclients; i++)
{
HostClient = Server.svs.clients[i];
if (HostClient.active)
Server.DropClient(crash);
}
//
// clear structures
//
Server.sv.Clear();
for (int i = 0; i < Server.svs.clients.Length; i++)
Server.svs.clients[i].Clear();
}