private int AddChannel(NetworkDelivery type)
{
EP2PSend options = EP2PSend.k_EP2PSendReliableWithBuffering;
switch (type)
{
case NetworkDelivery.Unreliable:
options = EP2PSend.k_EP2PSendUnreliable;
break;
case NetworkDelivery.UnreliableSequenced:
options = EP2PSend.k_EP2PSendUnreliable;
break;
case NetworkDelivery.Reliable:
options = EP2PSend.k_EP2PSendReliableWithBuffering;
break;
case NetworkDelivery.ReliableSequenced:
options = EP2PSend.k_EP2PSendReliableWithBuffering;
break;
case NetworkDelivery.ReliableFragmentedSequenced:
options = EP2PSend.k_EP2PSendReliableWithBuffering;
break;
default:
options = EP2PSend.k_EP2PSendReliableWithBuffering;
break;
}
channelSendTypes.Add(channelCounter, options);
channelCounter++;
return(channelCounter - 1);
}
DeliveryMethod ConvertNetworkDelivery(NetworkDelivery type)
{
switch (type)
{
case NetworkDelivery.Unreliable:
{
return(DeliveryMethod.Unreliable);
}
case NetworkDelivery.UnreliableSequenced:
{
return(DeliveryMethod.Sequenced);
}
case NetworkDelivery.Reliable:
{
return(DeliveryMethod.ReliableUnordered);
}
case NetworkDelivery.ReliableSequenced:
{
return(DeliveryMethod.ReliableOrdered);
}
case NetworkDelivery.ReliableFragmentedSequenced:
{
return(DeliveryMethod.ReliableOrdered);
}
default:
{
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
}
public override void Send(ulong clientId, ArraySegment <byte> data, NetworkDelivery delivery)
{
EP2PSend sendType = NetworkDeliveryToEP2PSend(delivery);
if (clientId == ServerClientId)
{
#if UNITY_SERVER
SteamGameServerNetworking.SendP2PPacket(serverUser.SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#else
SteamNetworking.SendP2PPacket(serverUser.SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#endif
}
else
{
if (connectedUsers.ContainsKey(clientId))
{
#if UNITY_SERVER
SteamGameServerNetworking.SendP2PPacket(connectedUsers[clientId].SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#else
SteamNetworking.SendP2PPacket(connectedUsers[clientId].SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#endif
}
else
{
if (NetworkManager.Singleton.LogLevel <= LogLevel.Error)
{
NetworkLog.LogErrorServer(nameof(SteamNetworkingTransport) + " - Can't Send to client, client not connected, clientId: " + clientId);
}
}
}
}
private EP2PSend NetworkDeliveryToEP2PSend(NetworkDelivery type)
{
EP2PSend options = EP2PSend.k_EP2PSendReliableWithBuffering;
switch (type)
{
case NetworkDelivery.Unreliable:
options = EP2PSend.k_EP2PSendUnreliable;
break;
case NetworkDelivery.UnreliableSequenced:
options = EP2PSend.k_EP2PSendUnreliable;
break;
case NetworkDelivery.Reliable:
options = EP2PSend.k_EP2PSendReliableWithBuffering;
break;
case NetworkDelivery.ReliableSequenced:
options = EP2PSend.k_EP2PSendReliableWithBuffering;
break;
case NetworkDelivery.ReliableFragmentedSequenced:
options = EP2PSend.k_EP2PSendReliableWithBuffering;
break;
default:
options = EP2PSend.k_EP2PSendReliableWithBuffering;
break;
}
return(options);
}
public override void Send(ulong clientId, ArraySegment <byte> data, NetworkDelivery delivery)
{
GetRufflesConnectionDetails(clientId, out ulong connectionId);
byte channelId = channelNameToId[delivery];
connections[connectionId].Send(data, channelId, false, 0);
}
public override void Send(ulong clientId, ArraySegment <byte> data, NetworkDelivery qos)
{
if (!m_Peers.ContainsKey(clientId))
{
return;
}
m_Peers[clientId].Send(data.Array, data.Offset, data.Count, ConvertNetworkDelivery(qos));
}
public override void Send(ulong clientId, ArraySegment <byte> data, NetworkDelivery delivery)
{
Packet packet = default;
packet.Create(data.Array, data.Offset, data.Count, NetworkDeliveryToPacketFlag(delivery));
GetEnetConnectionDetails(clientId, out uint peerId);
connectedEnetPeers[peerId].Send(0, ref packet);
}
public PacketFlags NetworkDeliveryToPacketFlag(NetworkDelivery delivery)
{
return(delivery switch
{
NetworkDelivery.Unreliable => PacketFlags.Unsequenced,
NetworkDelivery.Reliable => PacketFlags.Reliable, // ENET csharp Does not support ReliableUnsequenced. https://github.com/MidLevel/MLAPI.Transports/pull/5#issuecomment-498311723
NetworkDelivery.ReliableSequenced => PacketFlags.Reliable,
NetworkDelivery.ReliableFragmentedSequenced => PacketFlags.Reliable,
NetworkDelivery.UnreliableSequenced => PacketFlags.None, // unreliable sequenced according to docs here https://github.com/nxrighthere/ENet-CSharp
_ => throw new ArgumentOutOfRangeException(nameof(delivery), delivery, null)
});
public override void Send(ulong clientId, ArraySegment <byte> data, NetworkDelivery delivery)
{
if (clientId == ServerClientId)
{
WebSocketClient.Send(data);
}
else
{
WebSocketServerConnectionBehavior.Send(clientId, data);
}
}
private SendType NetworkDeliveryToSendType(NetworkDelivery delivery)
{
return(delivery switch
{
NetworkDelivery.Reliable => SendType.Reliable,
NetworkDelivery.ReliableFragmentedSequenced => SendType.Reliable,
NetworkDelivery.ReliableSequenced => SendType.Reliable,
NetworkDelivery.Unreliable => SendType.Unreliable,
NetworkDelivery.UnreliableSequenced => SendType.Unreliable,
_ => SendType.Reliable
});
public int AddMLAPIChannel(NetworkDelivery type, ConnectionConfig config)
{
switch (type)
{
case NetworkDelivery.Unreliable:
return(config.AddChannel(QosType.Unreliable));
case NetworkDelivery.Reliable:
return(config.AddChannel(QosType.Reliable));
case NetworkDelivery.ReliableSequenced:
return(config.AddChannel(QosType.ReliableSequenced));
case NetworkDelivery.ReliableFragmentedSequenced:
return(config.AddChannel(QosType.ReliableFragmentedSequenced));
case NetworkDelivery.UnreliableSequenced:
return(config.AddChannel(QosType.UnreliableSequenced));
}
return(0);
}
private ChannelType ConvertChannelType(NetworkDelivery type)
{
switch (type)
{
case NetworkDelivery.Reliable:
return(ChannelType.Reliable);
case NetworkDelivery.ReliableFragmentedSequenced:
return(ChannelType.ReliableSequencedFragmented);
case NetworkDelivery.ReliableSequenced:
return(ChannelType.ReliableSequenced);
case NetworkDelivery.Unreliable:
return(ChannelType.Unreliable);
case NetworkDelivery.UnreliableSequenced:
return(ChannelType.UnreliableOrdered);
}
return(ChannelType.Reliable);
}
public PacketReliability ConvertNetworkDelivery(NetworkDelivery delivery)
{
switch (delivery)
{
case NetworkDelivery.Unreliable:
return(PacketReliability.UnreliableUnordered);
case NetworkDelivery.UnreliableSequenced:
return(PacketReliability.ReliableOrdered);
case NetworkDelivery.Reliable:
return(PacketReliability.ReliableUnordered);
case NetworkDelivery.ReliableSequenced:
return(PacketReliability.ReliableOrdered);
case NetworkDelivery.ReliableFragmentedSequenced:
return(PacketReliability.ReliableOrdered);
default:
return(PacketReliability.ReliableOrdered);
}
}
public EnetDelivery MLAPINetworkDeliveryToPacketFlag(NetworkDelivery type)
{
switch (type)
{
case NetworkDelivery.Unreliable:
{
return(EnetDelivery.Unreliable);
}
case NetworkDelivery.Reliable:
{
// ENET Does not support ReliableUnsequenced.
// https://github.com/MidLevel/MLAPI.Transports/pull/5#issuecomment-498311723
return(EnetDelivery.ReliableSequenced);
}
case NetworkDelivery.ReliableSequenced:
{
return(EnetDelivery.ReliableSequenced);
}
case NetworkDelivery.ReliableFragmentedSequenced:
{
return(EnetDelivery.ReliableSequenced);
}
case NetworkDelivery.UnreliableSequenced:
{
return(EnetDelivery.UnreliableSequenced);
}
default:
{
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
}
public bool ConnectToSimulator()
{
return(NetworkDelivery.ConnectToSimulator());
}
public TransportChannel(NetworkChannel channel, NetworkDelivery delivery)
{
Channel = channel;
Delivery = delivery;
}
public override void Send(ulong clientId, ArraySegment <byte> data, NetworkDelivery delivery)
{
throw new NotImplementedException();
}
