private void GetP2PPacket(IBasePacket packet, out byte[] data, out int dataLength, out int channel, out SendType send)
{
_buffer.Position = 0;
_buffer.LengthBytes = 0;
SocketMan.WritePacketHeader(_buffer, packet);
packet.Write(_buffer);
send = SendType.Unreliable;
switch (packet.Sc.DeliveryMethod)
{
case NetDeliveryMethod.ReliableSequenced:
case NetDeliveryMethod.ReliableOrdered:
case NetDeliveryMethod.ReliableUnordered:
send = SendType.Reliable;
break;
case NetDeliveryMethod.Unreliable:
case NetDeliveryMethod.UnreliableSequenced:
send = SendType.Unreliable;
break;
}
data = _buffer.Data;
dataLength = _buffer.LengthBytes;
//channel = packet.Sc.SequenceChannel;
channel = 1;
if (packet.Sc == SendCategory.FileTransfer)
{
send = SendType.Reliable;
channel = 2;
}
}
private void Listener_NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
_readBuffer.LengthBytes = reader.UserDataSize;
_readBuffer.Position = 0;
reader.GetBytes(_readBuffer.Data, reader.UserDataSize);
SocketMan.HandleIncomingData(_readBuffer);
reader.Recycle();
}
private void Listener_PeerDisconnectedEvent(NetPeer peer, DisconnectInfo disconnectInfo)
{
var pl = peer.Tag as ServerPlayer;
if (pl == null)
{
throw new Exception("ServerPlayer tag undefined on disconnect");
}
SocketMan.HandlePlayerDisconnected(pl.ClientIndex);
}
public override void Disconnect(string reason)
{
if (_connection == null)
{
return;
}
_connection.Close();
_connection._OnConnected = null;
_connection._OnDisconnected = null;
_connection._OnMessage = null;
_connection._OnConnectionChanged = null;
_connection = null;
SocketMan.SetSocketStatus(ClientSocketStatus.Disconnected, reason);
}
private void Listener_NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
var pl = peer.Tag as ServerPlayer;
if (pl == null)
{
Debug.LogError("ServerPlayer tag is undefined on receive event, disconnecting peer.");
peer.Disconnect();
return;
}
_readBuffer.LengthBytes = reader.UserDataSize;
_readBuffer.Position = 0;
reader.GetBytes(_readBuffer.Data, reader.UserDataSize);
SocketMan.HandleIncomingData2(pl.ClientIndex, _readBuffer);
reader.Recycle();
}
public override void Connect(string host, int port)
{
if (_connection != null)
{
Disconnect("Connecting to new host");
}
if (ulong.TryParse(host, out ulong steamid))
{
_connection = SteamNetworkingSockets.ConnectRelay <SteamConnectionManager>(steamid);
_connection._OnConnected = (connection) =>
{
SocketMan.HandleConnected();
};
_connection._OnDisconnected = (connection) =>
{
if ((int)connection.EndReason == 1999)
{
SocketMan.HandleDisconnected(DenyReason.MapChange.ToString());
}
else
{
SocketMan.HandleDisconnected(connection.State.ToString());
}
};
_connection._OnMessage = (data, size, msgNum, recvTime, channel) =>
{
_readBuffer.LengthBytes = size;
_readBuffer.Position = 0;
Marshal.Copy(data, _readBuffer.Data, 0, size);
SocketMan.HandleIncomingData(_readBuffer);
};
_connection._OnConnectionChanged = (info) =>
{
if (info.State == ConnectionState.ProblemDetectedLocally)
{
_connection?.Close();
SocketMan.SetSocketStatus(ClientSocketStatus.ProblemDetected);
}
};
}
}
private void _SendPacket(NetPeer peer, IBasePacket packet)
{
if (_server == null ||
!_server.IsRunning ||
peer == null ||
peer.ConnectionState != ConnectionState.Connected)
{
return;
}
_writeBuffer.Position = 0;
_writeBuffer.LengthBytes = 0;
SocketMan.WritePacketHeader(_writeBuffer, packet);
packet.Write(_writeBuffer);
var dm = DeliveryMethod.ReliableOrdered;
switch (packet.Sc.DeliveryMethod)
{
case Lidgren.Network.NetDeliveryMethod.ReliableOrdered:
dm = DeliveryMethod.ReliableOrdered;
break;
case Lidgren.Network.NetDeliveryMethod.ReliableSequenced:
dm = DeliveryMethod.ReliableSequenced;
break;
case Lidgren.Network.NetDeliveryMethod.ReliableUnordered:
dm = DeliveryMethod.ReliableUnordered;
break;
case Lidgren.Network.NetDeliveryMethod.Unreliable:
case Lidgren.Network.NetDeliveryMethod.UnreliableSequenced:
dm = DeliveryMethod.Unreliable;
break;
case Lidgren.Network.NetDeliveryMethod.Unknown:
dm = DeliveryMethod.Unreliable;
break;
}
peer.Send(_writeBuffer.Data, 0, _writeBuffer.LengthBytes, (byte)packet.Sc.SequenceChannel, dm);
}
public override void SendPacket(IBasePacket packet)
{
if (_client == null || !_client.IsRunning)
{
return;
}
_writeBuffer.Position = 0;
_writeBuffer.LengthBytes = 0;
SocketMan.WritePacketHeader(packet, _writeBuffer);
packet.Write(_writeBuffer);
var dm = DeliveryMethod.ReliableOrdered;
switch (packet.Sc.DeliveryMethod)
{
case Lidgren.Network.NetDeliveryMethod.ReliableOrdered:
dm = DeliveryMethod.ReliableOrdered;
break;
case Lidgren.Network.NetDeliveryMethod.ReliableSequenced:
dm = DeliveryMethod.ReliableSequenced;
break;
case Lidgren.Network.NetDeliveryMethod.ReliableUnordered:
dm = DeliveryMethod.ReliableUnordered;
break;
case Lidgren.Network.NetDeliveryMethod.Unreliable:
case Lidgren.Network.NetDeliveryMethod.UnreliableSequenced:
dm = DeliveryMethod.Unreliable;
break;
case Lidgren.Network.NetDeliveryMethod.Unknown:
dm = DeliveryMethod.Unreliable;
break;
}
_client.SendToAll(_writeBuffer.Data, 0, _writeBuffer.LengthBytes, (byte)packet.Sc.SequenceChannel, dm);
}
public override void StartSocket()
{
if (_socket != null)
{
StopSocket("Starting new socket");
}
_socket = SteamNetworkingSockets.CreateRelaySocket <SteamSocketInterface>();
_socket._OnConnected = (connection, connectionInfo) =>
{
var pl = SocketMan.CreatePlayer();
_steamidToClientIndex[connectionInfo.Identity.SteamId] = pl.ClientIndex;
};
_socket._OnConnecting = (connection, connectionInfo) =>
{
connection.Accept();
};
_socket._OnDisconnected = (connection, connectionInfo) =>
{
SocketMan.HandlePlayerDisconnected(GetClientIndex(connectionInfo.Identity.SteamId));
};
_socket._OnMessage = (connection, id, data, size, msgNum, recvTime, channel) =>
{
if (_recvBuffer.Data.Length < size)
{
_recvBuffer.Data = new byte[size];
}
_recvBuffer.Position = 0;
_recvBuffer.LengthBytes = size;
Marshal.Copy(data, _recvBuffer.Data, 0, size);
SocketMan.HandleIncomingData2(GetClientIndex((SteamId)id), _recvBuffer);
};
SetSocketStatus(ServerStatus.AcceptingConnections);
}
private void Listener_PeerConnectedEvent(NetPeer peer)
{
SocketMan.HandleConnected();
}
private void Listener_PeerDisconnectedEvent(NetPeer peer, DisconnectInfo disconnectInfo)
{
SocketMan.HandleDisconnected(disconnectInfo.Reason.ToString());
}
private void Listener_PeerConnectedEvent(NetPeer peer)
{
peer.Tag = SocketMan.CreatePlayer();
}
