void INetworkClientListener.NetworkClientDidDisconnect()
{
ThreadChecker.AssertReliableChannel();
this.router.dispatcher.Enqueue(() => this.listener?.GameClientDidDisconnect());
this._playerCollection.Clear();
this.localPlayer = null;
}
void IMessageAckHelperListener <NatIdentifierResponseMessage> .MessageAckHelperReceivedExpectedResponse(NetEndPoint from, NatIdentifierResponseMessage message)
{
ThreadChecker.AssertUnreliableChannel();
this.router.dispatcher.Enqueue(() => new NatIdentifierResponseExecutor <TPlayer>().Execute(this, message));
this.natIdentifierAckHelper = null;
}
private static void ThreadPoolWorker(object state)
{
Thread.CurrentThread.Name = "ReliableChannel Thread";
ThreadChecker.ConfigureReliable(Thread.CurrentThread);
ReliableChannel[] channels = new ReliableChannel[100];
int channelCount = 0;
do
{
lock (socketLock) {
aliveSockets.CopyTo(channels);
channelCount = aliveSockets.Count;
}
for (int index = 0; index < channelCount; index++)
{
var channel = channels[index];
try {
channel.socket.Receive();
channel.writer.Use(channel.socket.Send);
} catch (ObjectDisposedException) {
ioRunning = false;
} catch (Exception ex) {
Logging.Logger.Log($"Exception thrown in ThreadPool\n{ex}");
}
}
} while (ioRunning);
Logging.Logger.Log("ReliableChannel ThreadPool EXITING");
ThreadChecker.ConfigureReliable(null);
}
private void ThreadPoolWorker(object state)
{
Thread.CurrentThread.Name = "UnreliableChannel Thread";
ThreadChecker.ConfigureUnreliable(Thread.CurrentThread);
bool shouldRun = true;
NetEndPoint to = new NetEndPoint();
void SendTo(byte[] bytes, int count)
{
this.socket.Send(bytes, count, to);
}
NetEndPoint[] endPoints = new NetEndPoint[100];
int endPointCount = 0;
do
{
lock (this) { shouldRun = this.socket != null; }
try {
this.socket.Receive();
if (this.sendInfoCollection.TryDequeue(out SendInfo info))
{
var message = info.message;
to = info.to;
if (!this.writerCollection.TryGetValue(to, out MessageStreamWriter writer))
{
writer = new MessageStreamWriter();
this.writerCollection.TryAdd(to, writer);
lock (this.lockToken) {
this.netEndPointWriters.Add(to);
}
}
writer.Write(message);
}
lock (this.lockToken) {
this.netEndPointWriters.CopyTo(endPoints);
endPointCount = this.netEndPointWriters.Count;
}
for (int index = 0; index < endPointCount; index++)
{
to = endPoints[index];
var writer = this.writerCollection[to];
writer.Use(SendTo);
}
} catch (ObjectDisposedException) {
shouldRun = false;
} catch (Exception ex) {
Logger.Log($"Exception thrown in ThreadPool\n{ex}");
}
} while (shouldRun);
Logger.Log("UnreliableChannel ThreadPool EXITING");
ThreadChecker.ConfigureUnreliable(null);
}
void IMessageAckHelperListener <NatIdentifierResponseMessage> .MessageAckHelperFailed()
{
ThreadChecker.AssertUnreliableChannel();
this.Disconnect();
this.natIdentifierAckHelper = null;
}
public void Close()
{
ThreadChecker.AssertMainThread();
this.tcpSocket.Close();
this.udpSocket.Close();
}
void IGameServerClientAcceptorListener <TPlayer> .ClientAcceptorPlayerDidConnect(TPlayer player)
{
ThreadChecker.AssertReliableChannel();
player.listener = this.router;
this._playerCollection.Add(player.playerId, player);
this.router.dispatcher.Enqueue(() => this.listener?.GameServerPlayerDidConnect(player, Channel.reliable));
}
public void Send(ITypedMessage message, NetEndPoint to)
{
ThreadChecker.AssertMainThread();
this.sendInfoCollection.Enqueue(new SendInfo {
message = message, to = to
});
}
void IRemoteClientListener.RemoteClientDidDisconnect(int playerId)
{
ThreadChecker.AssertReliableChannel();
var player = this._playerCollection.Remove(playerId);
this.router.dispatcher.Enqueue(() => this.listener?.GameClientPlayerDidDisconnect(player));
}
public void Stop()
{
ThreadChecker.AssertMainThread();
ReliableChannel.StopIO();
this.tcpSocket.Stop();
this.unreliableChannel.StopIO();
}
private void SendPredicate(TPlayer player, SendValue value)
{
ThreadChecker.AssertMainThread();
if (value.predicate(player))
{
player.Send(value.message, value.channel);
}
}
public void SendBroadcast(ITypedMessage message, Predicate <TPlayer> predicate, Channel channel)
{
ThreadChecker.AssertMainThread();
var sendValue = new SendValue()
{
message = message, predicate = predicate, channel = channel
};
this._playerCollection.ForEach(SendPredicate, sendValue);
}
void IGameServerClientAcceptorListener <TPlayer> .ClientAcceptorPlayerDidDisconnect(TPlayer player)
{
ThreadChecker.AssertReliableChannel();
player.listener = null;
this._playerCollection.Remove(player.playerId);
if (player.remoteIdentifiedEndPoint.HasValue)
{
this.networkServer.Unregister(player.remoteIdentifiedEndPoint.Value);
}
this.router.dispatcher.Enqueue(() => this.listener?.GameServerPlayerDidDisconnect(player));
}
void INetworkClientListener.NetworkClientDidReceiveMessage(MessageContainer container, NetEndPoint from)
{
ThreadChecker.AssertUnreliableChannel();
if (this.natIdentifierAckHelper != null)
{
this.natIdentifierAckHelper.Route(from, container);
}
else
{
this.router.Route(container);
}
}
void ITcpServerListener <TcpSocket> .SocketDidDisconnect(TcpSocket socket)
{
ThreadChecker.AssertReliableChannel();
var channel = this.socketCollection.Remove(socket);
if (channel == null)
{
return;
}
ReliableChannel.Remove(channel);
this.listener?.NetworkServerPlayerDidDisconnect(channel);
}
void IUnreliableChannelListener.ChannelDidReceiveMessage(UnreliableChannel channel, MessageContainer container, NetEndPoint from)
{
ThreadChecker.AssertUnreliableChannel();
if (this.identifiedCollection.TryGetPlayer(from, out INetworkServerMessageListener listener))
{
listener?.NetworkServerDidReceiveMessage(container);
}
else
{
this.listener?.NetworkServerDidReceiveUnidentifiedMessage(container, from);
}
}
void INetworkServerListener.NetworkServerDidReceiveUnidentifiedMessage(MessageContainer container, NetEndPoint from)
{
ThreadChecker.AssertUnreliableChannel();
if (container.Is((int)MessageType.natIdentifier))
{
var executor = new Executor <
NatIdentifierRequestExecutor <TPlayer>,
GameServerMessageRouter <TPlayer> .ServerModel <NetEndPoint>,
NatIdentifierRequestMessage
>(new GameServerMessageRouter <TPlayer> .ServerModel <NetEndPoint>(this, from), container);
this.router.dispatcher.Enqueue(executor.Execute);
}
}
public void Start(NetEndPoint endPoint)
{
ThreadChecker.AssertMainThread();
this.tcpSocket.Bind(endPoint);
this.tcpSocket.Start();
this.udpSocket.Bind(endPoint);
this.listeningOnEndPoint = this.tcpSocket.localEndPoint;
ReliableChannel.StartIO();
this.unreliableChannel.StartIO();
}
public void Start()
{
this.socket.Listen(0);
ThreadPool.QueueUserWorkItem(_ => {
Thread.CurrentThread.Name = "TcpSocket Accept Thread";
ThreadChecker.ConfigureAccept(Thread.CurrentThread);
do
{
this.Accept();
} while (this.socket != null);
Logger.Log("TcpSocket Accept Thread EXITING!");
ThreadChecker.ConfigureAccept(null);
});
}
public void Send(ITypedMessage message, Channel channel)
{
ThreadChecker.AssertMainThread();
switch (channel)
{
case Channel.reliable:
this.networkClient.reliableChannel.Send(message);
break;
case Channel.unreliable:
var remote = this.networkClient.remoteEndPoint;
this.networkClient.unreliableChannel.Send(message, remote);
break;
}
}
void IUdpSocketIOListener.SocketDidWriteBytes(UdpSocket socket, int count, NetEndPoint to)
{
ThreadChecker.AssertUnreliableChannel();
if (this.writerCollection.TryGetValue(to, out MessageStreamWriter writer))
{
writer.DidWrite(count);
}
else
{
if (Logger.IsLoggingEnabled)
{
Logger.Log($"SocketDidWriteBytes did not find writer for endPoint-{to}");
}
}
}
public GameClient(NetworkClient networkClient, GameClientMessageRouter <TPlayer> router)
{
ThreadChecker.AssertMainThread();
this.networkClient = networkClient;
this.networkClient.listener = this;
this.natIdentifierAckHelper = new MessageAckHelper <NatIdentifierRequestMessage, NatIdentifierResponseMessage>(
this.networkClient.unreliableChannel, router, 10, 2F
)
{
listener = this
};
this.router = router;
this.router.Configure(this);
}
void ITcpServerListener <TcpSocket> .SocketDidAccept(TcpSocket socket)
{
ThreadChecker.AssertAcceptThread();
if (socket == null)
{
return;
}
socket.serverListener = this;
var reliable = new ReliableChannel(socket);
ReliableChannel.Add(reliable);
this.socketCollection.Add(socket, reliable);
this.listener?.NetworkServerDidAcceptPlayer(reliable, this.unreliableChannel);
}
void IUdpSocketIOListener.SocketDidReceiveBytes(UdpSocket socket, byte[] bytes, int count, NetEndPoint from)
{
ThreadChecker.AssertUnreliableChannel();
if (!this.readerCollection.TryGetValue(from, out MessageStreamReader reader))
{
reader = new MessageStreamReader();
this.readerCollection.TryAdd(from, reader);
}
reader.Add(bytes, count);
MessageContainer?container;
while ((container = reader.Decode()) != null)
{
this.listener?.ChannelDidReceiveMessage(this, container.Value, from);
}
}
public GameServer(NetworkServer networkServer, GameServerMessageRouter <TPlayer> router)
{
ThreadChecker.AssertMainThread();
this.clientAcceptor = new GameServerClientAcceptor <TPlayer>()
{
listener = this
};
this.networkServer = networkServer;
this.networkServer.listener = this;
this._playerCollection = new PlayerCollection <int, TPlayer>();
this.pingController = new GameServerPingController <TPlayer>(this._playerCollection);
this.router = router;
this.router.Configure(this);
}
void IRemoteClientListener.RemoteClientDidConnect(int playerId, bool isLocalPlayer)
{
ThreadChecker.AssertReliableChannel();
var player = new TPlayer();
player.Configure(playerId, isLocalPlayer);
this._playerCollection.Add(playerId, player);
this.listener?.GameClientPlayerDidConnect(player);
if (player.isLocalPlayer)
{
this.localPlayer = player;
this.router.dispatcher.Enqueue(() => this.listener?.GameClientDidIdentifyLocalPlayer(player));
var endPoint = this.networkClient.localEndPoint;
var remote = this.networkClient.remoteEndPoint;
this.natIdentifierAckHelper.Start(new NatIdentifierRequestMessage(player.playerId, endPoint.address, endPoint.port), remote);
}
}
public void Update()
{
ThreadChecker.AssertMainThread();
this.pingController.Update();
}
public void Stop()
{
ThreadChecker.AssertMainThread();
this.networkServer.Stop();
}
public void Start(int port)
{
ThreadChecker.AssertMainThread();
this.networkServer.Start(new NetEndPoint(IPAddress.Any, port));
}
void INetworkServerListener.NetworkServerPlayerDidDisconnect(ReliableChannel channel)
{
ThreadChecker.AssertReliableChannel();
this.clientAcceptor.NetworkServerPlayerDidDisconnect(channel);
}
