private void OnClientConnected(object sender, TcpClient newClient)
{
PacketTransport transport = TransportFactoryCreateTransport(newClient);
ServerSession session = new ServerSession(transport);
session.ProcessPacketAction = OnProcessPacket;
session.Start();
}
/// <summary>
/// Construtor padrão para uma nova sessão sobre o transporte informado.
/// </summary>
/// <param name="transport">Transporte de comunicação de pacotes.</param>
public ServerSession(PacketTransport transport)
{
this.m_Transport = transport;
this.m_Rpcs = new Dictionary <int, IRpc>();
this.m_PacketQueue = new PacketQueue();
m_PacketQueue.DisconnectedAction = OnDisconnected;
m_PacketQueue.PacketReceivedAction = OnPacketReceived;
}
/// <summary>
/// Retorna o transporte para a conexão atual.
/// Se ainda não estiver conectado, tenta conectar no servidor.
/// O estado desconctado é um estado terminal.
/// Retorna uma excessão caso não consiga conectar no servidor.
/// </summary>
/// <param name="forceConnect">Força uma reconexão mesmo que esteja desconectado.</param>
/// <returns>O transporte atualmente conectado.</returns>
protected IPacketTransport InternalGetTransport(bool forceConnect)
{
if (m_State == ChannelState.Connected)
{
return(m_transport);
}
lock (m_transportInitializeLock)
{
if (m_State == ChannelState.Connected)
{
return(m_transport);
}
if (!forceConnect)
{
if (m_State != ChannelState.NotConnected)
{
SocketException sex = new SocketException((int)SocketError.NotConnected);
throw sex;
}
}
m_State = ChannelState.Connecting;
TcpClient client = new TcpClient();
IPacketTransport transport = null;
try
{
client.Connect(m_remoteHostName, m_remotePort);
// TODO: Channel: implement multiple transport options
transport = new PacketTransport(client);
transport.SetReceiveAction(OnPacketReceived);
transport.SetDisconnectAction(OnDisconnected);
transport.Start();
m_transport = transport;
m_State = ChannelState.Connected;
return(m_transport);
}
catch (Exception)
{
m_State = ChannelState.NotConnected;
client?.Close();
transport?.Dispose();
throw;
}
}
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
Console.WriteLine(peer.Id + " Sent data");
ServerClient client;
if (Clients.TryGetValue(peer.Id, out client))
{
PacketTransport.Receive(peer, client, reader.RawData, reader.Position);
}
}
public void SendToAuthenticated <T>(T packet) where T : IPacketStruct
{
foreach (KeyValuePair <int, ServerClient> pair in Clients)
{
ServerClient client = pair.Value;
if (client.State == ServerClient.ClientState.Authenticated)
{
PacketTransport.SendPacket(client.Peer, packet);
}
}
}
/// <summary>
/// Finaliza a sessão, encerrando todas as RPCs pendentes e liberando os recursos alocados.
/// </summary>
private void InternalClose()
{
m_Transport?.Dispose();
m_Transport = null;
var rpcs = m_Rpcs;
m_Rpcs = null;
if (rpcs != null)
{
foreach (var rpc in rpcs.Values.ToArray())
{
rpc.Cancel();
rpc.Dispose();
}
rpcs.Clear();
}
}
public void SendPacket<T>(T packet) where T : IPacketStruct
{
PacketTransport.SendPacket(Peer, packet);
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
//Console.WriteLine("Received Data");
PacketTransport.Receive(peer, this, reader.RawData, reader.Position);
}
public void SendEvent(PacketType packetType)
{
PacketTransport.SendEvent(netClient.FirstPeer, packetType);
}
public void SendPacket <T>(T packet) where T : IPacketStruct
{
PacketTransport.SendPacket(netClient.FirstPeer, packet);
}
