372 lines
15 KiB
C#
372 lines
15 KiB
C#
using LobbyServerDto;
|
|
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace Lobbies
|
|
{
|
|
public class LobbyClient : IDisposable
|
|
{
|
|
TcpLobbbyClient tcpClient = new TcpLobbbyClient();
|
|
private readonly ConcurrentQueue<LobbyClientEvent> events = new ConcurrentQueue<LobbyClientEvent>();
|
|
BufferRental bufferRental = new BufferRental(4096);
|
|
|
|
AutoResetEvent waitForExternalIp = new AutoResetEvent(false);
|
|
|
|
private Dictionary<Guid, LobbyInfo> lobbyInformation = new Dictionary<Guid, LobbyInfo>();
|
|
private string? host;
|
|
private int port;
|
|
private int connectionId;
|
|
|
|
public string? externalIp;
|
|
public int externalPort;
|
|
|
|
public void Connect(string host, int port, CancellationToken cancellationToken)
|
|
{
|
|
this.host = host;
|
|
this.port = port;
|
|
|
|
try
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
using var cts = cancellationToken.Register(() =>
|
|
{
|
|
tcpClient.Stop();
|
|
});
|
|
|
|
tcpClient.DataReceived -= TcpClient_DataReceived;
|
|
tcpClient.DataReceived += TcpClient_DataReceived;
|
|
|
|
tcpClient.Disconnected -= TcpClient_Disconnected;
|
|
tcpClient.Disconnected += TcpClient_Disconnected;
|
|
|
|
_ = Task.Run(() => tcpClient.Connect(host, port));
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
public IEnumerable<LobbyClientEvent> ReadEvents(int maxEvents)
|
|
{
|
|
if (events.Count > 0)
|
|
{
|
|
maxEvents = Math.Min(maxEvents, events.Count);
|
|
|
|
while (maxEvents > 0)
|
|
{
|
|
if(events.TryDequeue(out var _event))
|
|
{
|
|
yield return _event;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void HostLobby(Guid gameId, string name, int gameMode, int maxPlayerCount, string? password, string? ip, int port)
|
|
{
|
|
byte[]? hash = null, salt = null;
|
|
|
|
if(!string.IsNullOrEmpty(password))
|
|
{
|
|
(hash, salt) = PasswordHash.Hash(password);
|
|
}
|
|
|
|
var lobbyCreate = new LobbyCreate()
|
|
{
|
|
GameId = gameId,
|
|
Name = name,
|
|
GameMode = gameMode,
|
|
MaxPlayerCount = maxPlayerCount,
|
|
PlayerCount = 0,
|
|
PasswordHash = hash,
|
|
PasswordSalt = salt,
|
|
HostIp = ip,
|
|
HostPort = port
|
|
};
|
|
|
|
byte[] messageData = bufferRental.Rent();
|
|
var len = lobbyCreate.Serialize(messageData);
|
|
_ = Task.Run(async () => { await tcpClient.Send(messageData, 0, len); bufferRental.Return(messageData); });
|
|
}
|
|
|
|
public void RequestLobbyHostInfo(Guid lobbyId, string? password)
|
|
{
|
|
byte[]? passwordHash = null;
|
|
if(!string.IsNullOrEmpty(password) && lobbyInformation.ContainsKey(lobbyId) && lobbyInformation[lobbyId].PasswordSalt != null)
|
|
passwordHash = PasswordHash.Hash(password, lobbyInformation[lobbyId].PasswordSalt!);
|
|
|
|
var lobbyCreate = new LobbyRequestHostInfo()
|
|
{
|
|
LobbyId = lobbyId,
|
|
PasswordHash = passwordHash,
|
|
};
|
|
|
|
byte[] messageData = bufferRental.Rent();
|
|
var len = lobbyCreate.Serialize(messageData);
|
|
_ = Task.Run(async () => { await tcpClient.Send(messageData, 0, len); bufferRental.Return(messageData); });
|
|
}
|
|
|
|
|
|
public delegate void SendUdpMessageCallback(IPEndPoint remoteEndpoint, byte[] messageBuffer, int messageLength);
|
|
public void RequestLobbyNatPunch(Guid lobbyId, string? password, SendUdpMessageCallback sendUdpCallback)
|
|
{
|
|
byte[]? passwordHash = null;
|
|
if (!string.IsNullOrEmpty(password) && lobbyInformation.ContainsKey(lobbyId) && lobbyInformation[lobbyId].PasswordSalt != null)
|
|
passwordHash = PasswordHash.Hash(password, lobbyInformation[lobbyId].PasswordSalt!);
|
|
|
|
Task.Run(() =>
|
|
{
|
|
QueryExternalIpAndPort(sendUdpCallback);
|
|
var lobbyRequestNatPunch = new LobbyRequestNatPunch()
|
|
{
|
|
LobbyId = lobbyId,
|
|
PasswordHash = passwordHash,
|
|
ClientIp = externalIp,
|
|
ClientPort = externalPort
|
|
};
|
|
|
|
byte[] messageData = bufferRental.Rent();
|
|
var len = lobbyRequestNatPunch.Serialize(messageData);
|
|
_ = Task.Run(async () => { await tcpClient.Send(messageData, 0, len); bufferRental.Return(messageData); });
|
|
});
|
|
}
|
|
|
|
public void UpdateLobby(string name, int gameMode, int maxPlayerCount, int playerCount, string? password, string? ip, int port)
|
|
{
|
|
byte[]? hash = null, salt = null;
|
|
|
|
if (!string.IsNullOrEmpty(password))
|
|
{
|
|
(hash, salt) = PasswordHash.Hash(password);
|
|
}
|
|
|
|
var lobbyUpdate = new LobbyUpdate()
|
|
{
|
|
Name = name,
|
|
GameMode = gameMode,
|
|
MaxPlayerCount = maxPlayerCount,
|
|
PlayerCount = playerCount,
|
|
PasswordHash = hash,
|
|
PasswordSalt = salt,
|
|
HostIp = ip,
|
|
HostPort = port
|
|
};
|
|
|
|
byte[] messageData = bufferRental.Rent();
|
|
var len = lobbyUpdate.Serialize(messageData);
|
|
_ = Task.Run(async () => { await tcpClient.Send(messageData, 0, len); bufferRental.Return(messageData); });
|
|
}
|
|
|
|
public void CloseLobby()
|
|
{
|
|
var lobbyDelete = new LobbyDelete()
|
|
{
|
|
|
|
};
|
|
|
|
byte[] messageData = bufferRental.Rent();
|
|
var len = lobbyDelete.Serialize(messageData);
|
|
_ = Task.Run(async () => { await tcpClient.Send(messageData, 0, len); bufferRental.Return(messageData); });
|
|
}
|
|
|
|
public void ObserveLobbies(Guid gameId)
|
|
{
|
|
var lobbiesObserve = new LobbiesObserve() { GameId = gameId };
|
|
|
|
byte[] messageData = bufferRental.Rent();
|
|
var len = lobbiesObserve.Serialize(messageData);
|
|
_ = Task.Run(async () => { await tcpClient.Send(messageData, 0, len); bufferRental.Return(messageData); });
|
|
}
|
|
|
|
public void StopObservingLobbies()
|
|
{
|
|
var lobbiesStopObserve = new LobbiesStopObserve() { };
|
|
|
|
byte[] messageData = bufferRental.Rent();
|
|
var len = lobbiesStopObserve.Serialize(messageData);
|
|
_ = Task.Run(async () => { await tcpClient.Send(messageData, 0, len); bufferRental.Return(messageData); });
|
|
}
|
|
|
|
public void NotifyLobbyNatPunchDone(int natPunchId, string externalIp, int externalPort)
|
|
{
|
|
var lobbyNatPunchDone = new LobbyNatPunchDone() { NatPunchId = natPunchId, ExternalIp = externalIp, ExternalPort = externalPort };
|
|
|
|
byte[] messageData = bufferRental.Rent();
|
|
var len = lobbyNatPunchDone.Serialize(messageData);
|
|
_ = Task.Run(async () => { await tcpClient.Send(messageData, 0, len); bufferRental.Return(messageData); });
|
|
}
|
|
|
|
public static IPAddress[] GetIPsByName(string hostName, bool ip4Wanted, bool ip6Wanted)
|
|
{
|
|
// Check if the hostname is already an IPAddress
|
|
IPAddress? outIpAddress;
|
|
if (IPAddress.TryParse(hostName, out outIpAddress) == true)
|
|
return new IPAddress[] { outIpAddress };
|
|
//<----------
|
|
|
|
IPAddress[] addresslist = Dns.GetHostAddresses(hostName);
|
|
|
|
if (addresslist == null || addresslist.Length == 0)
|
|
return new IPAddress[0];
|
|
//<----------
|
|
|
|
if (ip4Wanted && ip6Wanted)
|
|
return addresslist;
|
|
//<----------
|
|
|
|
if (ip4Wanted)
|
|
return addresslist.Where(o => o.AddressFamily == AddressFamily.InterNetwork).ToArray();
|
|
//<----------
|
|
|
|
if (ip6Wanted)
|
|
return addresslist.Where(o => o.AddressFamily == AddressFamily.InterNetworkV6).ToArray();
|
|
//<----------
|
|
|
|
return new IPAddress[0];
|
|
}
|
|
|
|
public void QueryExternalIpAndPort(SendUdpMessageCallback sendUdpCallback)
|
|
{
|
|
byte[] messageData = bufferRental.Rent();
|
|
|
|
try
|
|
{
|
|
waitForExternalIp.Reset();
|
|
var queryExternalPortAndIp = new QueryExternalPortAndIp() { LobbyClientId = connectionId };
|
|
var len = queryExternalPortAndIp.Serialize(messageData);
|
|
var ip = GetIPsByName(host!, true, false).First();
|
|
|
|
do
|
|
{
|
|
sendUdpCallback(new IPEndPoint(ip, port), messageData, len);
|
|
}
|
|
while (!waitForExternalIp.WaitOne(100));
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
finally
|
|
{
|
|
bufferRental.Return(messageData);
|
|
}
|
|
}
|
|
|
|
public void Stop()
|
|
{
|
|
waitForExternalIp.Set();
|
|
tcpClient.Stop();
|
|
}
|
|
|
|
private void TcpClient_Disconnected(bool clean, string error)
|
|
{
|
|
if(!clean)
|
|
events.Enqueue(new LobbyClientEvent { EventType = LobbyClientEventTypes.Failed, EventData = new LobbyClientDisconnectReason { WasError = true, ErrorMessage = error } });
|
|
else
|
|
events.Enqueue(new LobbyClientEvent { EventType = LobbyClientEventTypes.Disconnected, EventData = new LobbyClientDisconnectReason { WasError = false, ErrorMessage = string.Empty } });
|
|
}
|
|
|
|
private void TcpClient_DataReceived(int dataLength, Memory<byte> data)
|
|
{
|
|
try
|
|
{
|
|
if (dataLength > 0)
|
|
{
|
|
switch (LobbyMessageIdentifier.ReadLobbyMessageIdentifier(data.Span))
|
|
{
|
|
case LobbyClientConnectionInfo.TypeId:
|
|
{
|
|
var lobbyClientConnectionInfo = LobbyClientConnectionInfo.Deserialize(data.Span);
|
|
if (lobbyClientConnectionInfo != null)
|
|
{
|
|
connectionId = lobbyClientConnectionInfo.Id;
|
|
events.Enqueue(new LobbyClientEvent { EventType = LobbyClientEventTypes.Connected, EventData = null });
|
|
}
|
|
}
|
|
break;
|
|
case LobbyInfo.TypeId:
|
|
{
|
|
var lobbyInfo = LobbyInfo.Deserialize(data.Span);
|
|
if (lobbyInfo != null)
|
|
{
|
|
lobbyInformation[lobbyInfo.Id] = lobbyInfo;
|
|
events.Enqueue(new LobbyClientEvent { EventType = LobbyClientEventTypes.LobbyUpdate, EventData = lobbyInfo });
|
|
}
|
|
}
|
|
break;
|
|
case LobbyDelete.TypeId:
|
|
{
|
|
var lobbyDelete = LobbyDelete.Deserialize(data.Span);
|
|
if (lobbyDelete != null)
|
|
{
|
|
lobbyInformation.Remove(lobbyDelete.Id);
|
|
events.Enqueue(new LobbyClientEvent { EventType = LobbyClientEventTypes.LobbyDelete, EventData = lobbyDelete });
|
|
}
|
|
}
|
|
break;
|
|
case LobbyHostInfo.TypeId:
|
|
{
|
|
var lobbyHostInfo = LobbyHostInfo.Deserialize(data.Span);
|
|
if (lobbyHostInfo != null)
|
|
{
|
|
events.Enqueue(new LobbyClientEvent { EventType = LobbyClientEventTypes.LobbyHostInfo, EventData = lobbyHostInfo });
|
|
}
|
|
}
|
|
break;
|
|
case LobbyRequestNatPunch.TypeId:
|
|
{
|
|
var lobbyRequestNatPunch = LobbyRequestNatPunch.Deserialize(data.Span);
|
|
if (lobbyRequestNatPunch != null)
|
|
{
|
|
events.Enqueue(new LobbyClientEvent { EventType = LobbyClientEventTypes.LobbyRequestNatPunch, EventData = lobbyRequestNatPunch });
|
|
}
|
|
}
|
|
break;
|
|
case LobbyNatPunchDone.TypeId:
|
|
{
|
|
var lobbyNatPunchDone = LobbyNatPunchDone.Deserialize(data.Span);
|
|
if (lobbyNatPunchDone != null)
|
|
{
|
|
events.Enqueue(new LobbyClientEvent { EventType = LobbyClientEventTypes.LobbyNatPunchDone, EventData = lobbyNatPunchDone });
|
|
}
|
|
}
|
|
break;
|
|
case SeenExternalIpAndPort.TypeId:
|
|
{
|
|
var seenExternalIpAndPort = SeenExternalIpAndPort.Deserialize(data.Span);
|
|
if (seenExternalIpAndPort != null)
|
|
{
|
|
externalIp = seenExternalIpAndPort.Ip;
|
|
externalPort = seenExternalIpAndPort.Port;
|
|
waitForExternalIp.Set();
|
|
|
|
events.Enqueue(new LobbyClientEvent { EventType = LobbyClientEventTypes.ExternalIpAndPort, EventData = seenExternalIpAndPort });
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
waitForExternalIp.Dispose();
|
|
tcpClient.Dispose();
|
|
}
|
|
|
|
}
|
|
}
|