separate folders per functionality
This commit is contained in:
Vinzenz Schroeter
parent
7f00160780
commit
0ca6a91a7e
33 changed files with 60 additions and 113 deletions
6
TanksServer/Interactivity/AppSerializerContext.cs
Normal file
6
TanksServer/Interactivity/AppSerializerContext.cs
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
using System.Text.Json.Serialization;
|
||||
|
||||
namespace TanksServer.Interactivity;
|
||||
|
||||
[JsonSerializable(typeof(Player))]
|
||||
internal sealed partial class AppSerializerContext: JsonSerializerContext;
|
||||
89
TanksServer/Interactivity/ByteChannelWebSocket.cs
Normal file
89
TanksServer/Interactivity/ByteChannelWebSocket.cs
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
using System.Diagnostics;
|
||||
using System.Net.WebSockets;
|
||||
using System.Threading.Channels;
|
||||
|
||||
namespace TanksServer.Interactivity;
|
||||
|
||||
/// <summary>
|
||||
/// Hacky class for easier semantics
|
||||
/// </summary>
|
||||
internal sealed class ByteChannelWebSocket : Channel<byte[]>
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly WebSocket _socket;
|
||||
private readonly Task _backgroundDone;
|
||||
private readonly byte[] _buffer;
|
||||
|
||||
private readonly Channel<byte[]> _outgoing = Channel.CreateUnbounded<byte[]>();
|
||||
private readonly Channel<byte[]> _incoming = Channel.CreateUnbounded<byte[]>();
|
||||
|
||||
public ByteChannelWebSocket(WebSocket socket, ILogger logger, int messageSize)
|
||||
{
|
||||
_socket = socket;
|
||||
_logger = logger;
|
||||
_buffer = new byte[messageSize];
|
||||
_backgroundDone = Task.WhenAll(ReadLoopAsync(), WriteLoopAsync());
|
||||
|
||||
Reader = _incoming.Reader;
|
||||
Writer = _outgoing.Writer;
|
||||
}
|
||||
|
||||
private async Task ReadLoopAsync()
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
if (_socket.State is not (WebSocketState.Open or WebSocketState.CloseSent))
|
||||
break;
|
||||
|
||||
var response = await _socket.ReceiveAsync(_buffer, CancellationToken.None);
|
||||
if (response.MessageType == WebSocketMessageType.Close)
|
||||
{
|
||||
if (_socket.State == WebSocketState.CloseReceived)
|
||||
await _socket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, string.Empty,
|
||||
CancellationToken.None);
|
||||
break;
|
||||
}
|
||||
|
||||
if (response.Count != _buffer.Length)
|
||||
{
|
||||
await _socket.CloseAsync(
|
||||
WebSocketCloseStatus.InvalidPayloadData,
|
||||
"response has unexpected size",
|
||||
CancellationToken.None);
|
||||
break;
|
||||
}
|
||||
|
||||
await _incoming.Writer.WriteAsync(_buffer.ToArray());
|
||||
}
|
||||
|
||||
if (_socket.State != WebSocketState.Closed)
|
||||
Debugger.Break();
|
||||
|
||||
_incoming.Writer.Complete();
|
||||
}
|
||||
|
||||
private async Task WriteLoopAsync()
|
||||
{
|
||||
await foreach (var data in _outgoing.Reader.ReadAllAsync())
|
||||
{
|
||||
_logger.LogTrace("sending {} bytes of data", data.Length);
|
||||
try
|
||||
{
|
||||
await _socket.SendAsync(data, WebSocketMessageType.Binary, true, CancellationToken.None);
|
||||
}
|
||||
catch (WebSocketException wsEx)
|
||||
{
|
||||
_logger.LogDebug(wsEx, "send failed");
|
||||
}
|
||||
}
|
||||
|
||||
await _socket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
|
||||
}
|
||||
|
||||
public async Task CloseAsync()
|
||||
{
|
||||
_logger.LogDebug("closing socket");
|
||||
_outgoing.Writer.Complete();
|
||||
await _backgroundDone;
|
||||
}
|
||||
}
|
||||
109
TanksServer/Interactivity/ClientScreenServer.cs
Normal file
109
TanksServer/Interactivity/ClientScreenServer.cs
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
using System.Diagnostics;
|
||||
using System.Net.WebSockets;
|
||||
using System.Threading.Channels;
|
||||
using Microsoft.Extensions.Hosting;
|
||||
using TanksServer.ServicePointDisplay;
|
||||
|
||||
namespace TanksServer.Interactivity;
|
||||
|
||||
internal sealed class ClientScreenServer(
|
||||
ILogger<ClientScreenServer> logger,
|
||||
ILoggerFactory loggerFactory
|
||||
) : IHostedLifecycleService
|
||||
{
|
||||
private readonly ConcurrentDictionary<ClientScreenServerConnection, byte> _connections = new();
|
||||
private bool _closing;
|
||||
|
||||
public Task HandleClient(WebSocket socket)
|
||||
{
|
||||
if (_closing)
|
||||
{
|
||||
logger.LogWarning("ignoring request because connections are closing");
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
logger.LogDebug("HandleClient");
|
||||
var connection =
|
||||
new ClientScreenServerConnection(socket, loggerFactory.CreateLogger<ClientScreenServerConnection>(), this);
|
||||
var added = _connections.TryAdd(connection, 0);
|
||||
Debug.Assert(added);
|
||||
return connection.Done;
|
||||
}
|
||||
|
||||
public Task StoppingAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
logger.LogInformation("closing connections");
|
||||
_closing = true;
|
||||
return Task.WhenAll(_connections.Keys.Select(c => c.CloseAsync()));
|
||||
}
|
||||
|
||||
public Task StartAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
||||
public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
||||
public Task StartedAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
||||
public Task StartingAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
||||
public Task StoppedAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
||||
|
||||
private void Remove(ClientScreenServerConnection connection) => _connections.TryRemove(connection, out _);
|
||||
|
||||
public IEnumerable<ClientScreenServerConnection> GetConnections() => _connections.Keys;
|
||||
|
||||
internal sealed class ClientScreenServerConnection: IDisposable
|
||||
{
|
||||
private readonly ByteChannelWebSocket _channel;
|
||||
private readonly SemaphoreSlim _wantedFrames = new(1);
|
||||
private readonly ClientScreenServer _server;
|
||||
private readonly ILogger<ClientScreenServerConnection> _logger;
|
||||
|
||||
public ClientScreenServerConnection(WebSocket webSocket,
|
||||
ILogger<ClientScreenServerConnection> logger,
|
||||
ClientScreenServer server)
|
||||
{
|
||||
_server = server;
|
||||
_logger = logger;
|
||||
_channel = new(webSocket, logger, 0);
|
||||
Done = ReceiveAsync();
|
||||
}
|
||||
|
||||
public async Task SendAsync(PixelDisplayBufferView buf)
|
||||
{
|
||||
if (!await _wantedFrames.WaitAsync(TimeSpan.Zero))
|
||||
{
|
||||
_logger.LogTrace("client does not want a frame yet");
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogTrace("sending");
|
||||
try
|
||||
{
|
||||
await _channel.Writer.WriteAsync(buf.Data);
|
||||
}
|
||||
catch (ChannelClosedException)
|
||||
{
|
||||
_logger.LogWarning("send failed, channel is closed");
|
||||
}
|
||||
}
|
||||
|
||||
private async Task ReceiveAsync()
|
||||
{
|
||||
await foreach (var _ in _channel.Reader.ReadAllAsync())
|
||||
_wantedFrames.Release();
|
||||
|
||||
_logger.LogTrace("done receiving");
|
||||
_server.Remove(this);
|
||||
}
|
||||
|
||||
public Task CloseAsync()
|
||||
{
|
||||
_logger.LogDebug("closing connection");
|
||||
return _channel.CloseAsync();
|
||||
}
|
||||
|
||||
public Task Done { get; }
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_wantedFrames.Dispose();
|
||||
Done.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
113
TanksServer/Interactivity/ControlsServer.cs
Normal file
113
TanksServer/Interactivity/ControlsServer.cs
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
using System.Net.WebSockets;
|
||||
using Microsoft.Extensions.Hosting;
|
||||
|
||||
namespace TanksServer.Interactivity;
|
||||
|
||||
internal sealed class ControlsServer(ILogger<ControlsServer> logger, ILoggerFactory loggerFactory)
|
||||
: IHostedLifecycleService
|
||||
{
|
||||
private readonly List<ControlsServerConnection> _connections = [];
|
||||
|
||||
public Task HandleClient(WebSocket ws, Player player)
|
||||
{
|
||||
logger.LogDebug("control client connected {}", player.Id);
|
||||
var clientLogger = loggerFactory.CreateLogger<ControlsServerConnection>();
|
||||
var sock = new ControlsServerConnection(ws, clientLogger, this, player);
|
||||
_connections.Add(sock);
|
||||
return sock.Done;
|
||||
}
|
||||
|
||||
public Task StoppingAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
return Task.WhenAll(_connections.Select(c => c.CloseAsync()));
|
||||
}
|
||||
|
||||
public Task StartAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
||||
public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
||||
public Task StartedAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
||||
public Task StartingAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
||||
public Task StoppedAsync(CancellationToken cancellationToken) => Task.CompletedTask;
|
||||
|
||||
private void Remove(ControlsServerConnection connection)
|
||||
{
|
||||
_connections.Remove(connection);
|
||||
}
|
||||
|
||||
private sealed class ControlsServerConnection
|
||||
{
|
||||
private readonly ByteChannelWebSocket _binaryWebSocket;
|
||||
private readonly ILogger<ControlsServerConnection> _logger;
|
||||
private readonly ControlsServer _server;
|
||||
private readonly Player _player;
|
||||
|
||||
public ControlsServerConnection(WebSocket socket, ILogger<ControlsServerConnection> logger,
|
||||
ControlsServer server, Player player)
|
||||
{
|
||||
_logger = logger;
|
||||
_server = server;
|
||||
_player = player;
|
||||
_binaryWebSocket = new(socket, logger, 2);
|
||||
Done = ReceiveAsync();
|
||||
}
|
||||
|
||||
public Task Done { get; }
|
||||
|
||||
private enum MessageType : byte
|
||||
{
|
||||
Enable = 0x01,
|
||||
Disable = 0x02,
|
||||
}
|
||||
|
||||
private enum InputType : byte
|
||||
{
|
||||
Forward = 0x01,
|
||||
Backward = 0x02,
|
||||
Left = 0x03,
|
||||
Right = 0x04,
|
||||
Shoot = 0x05
|
||||
}
|
||||
|
||||
private async Task ReceiveAsync()
|
||||
{
|
||||
await foreach (var buffer in _binaryWebSocket.Reader.ReadAllAsync())
|
||||
{
|
||||
var type = (MessageType)buffer[0];
|
||||
var control = (InputType)buffer[1];
|
||||
|
||||
_logger.LogTrace("player input {} {} {}", _player.Id, type, control);
|
||||
|
||||
var isEnable = type switch
|
||||
{
|
||||
MessageType.Enable => true,
|
||||
MessageType.Disable => false,
|
||||
_ => throw new ArgumentException("invalid message type")
|
||||
};
|
||||
|
||||
switch (control)
|
||||
{
|
||||
case InputType.Forward:
|
||||
_player.Controls.Forward = isEnable;
|
||||
break;
|
||||
case InputType.Backward:
|
||||
_player.Controls.Backward = isEnable;
|
||||
break;
|
||||
case InputType.Left:
|
||||
_player.Controls.TurnLeft = isEnable;
|
||||
break;
|
||||
case InputType.Right:
|
||||
_player.Controls.TurnRight = isEnable;
|
||||
break;
|
||||
case InputType.Shoot:
|
||||
_player.Controls.Shoot = isEnable;
|
||||
break;
|
||||
default:
|
||||
throw new ArgumentException("invalid control type");
|
||||
}
|
||||
}
|
||||
|
||||
_server.Remove(this);
|
||||
}
|
||||
|
||||
public Task CloseAsync() => _binaryWebSocket.CloseAsync();
|
||||
}
|
||||
}
|
||||
39
TanksServer/Interactivity/PlayerServer.cs
Normal file
39
TanksServer/Interactivity/PlayerServer.cs
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
using System.Diagnostics.CodeAnalysis;
|
||||
using TanksServer.GameLogic;
|
||||
|
||||
namespace TanksServer.Interactivity;
|
||||
|
||||
internal sealed class PlayerServer(ILogger<PlayerServer> logger, SpawnQueueProvider spawnQueueProvider)
|
||||
{
|
||||
private readonly ConcurrentDictionary<string, Player> _players = new();
|
||||
|
||||
public Player GetOrAdd(string name)
|
||||
{
|
||||
var player = _players.GetOrAdd(name, AddAndSpawn);
|
||||
logger.LogInformation("player {} (re)joined", player.Id);
|
||||
return player;
|
||||
}
|
||||
|
||||
public bool TryGet(Guid? playerId, [MaybeNullWhen(false)] out Player foundPlayer)
|
||||
{
|
||||
foreach (var player in _players.Values)
|
||||
{
|
||||
if (player.Id != playerId)
|
||||
continue;
|
||||
foundPlayer = player;
|
||||
return true;
|
||||
}
|
||||
|
||||
foundPlayer = null;
|
||||
return false;
|
||||
}
|
||||
|
||||
public IEnumerable<Player> GetAll() => _players.Values;
|
||||
|
||||
private Player AddAndSpawn(string name)
|
||||
{
|
||||
var player = new Player(name);
|
||||
spawnQueueProvider.Queue.Enqueue(player);
|
||||
return player;
|
||||
}
|
||||
}
|
||||
18
TanksServer/Interactivity/SendToClientScreen.cs
Normal file
18
TanksServer/Interactivity/SendToClientScreen.cs
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
using TanksServer.GameLogic;
|
||||
using TanksServer.Graphics;
|
||||
|
||||
namespace TanksServer.Interactivity;
|
||||
|
||||
internal sealed class SendToClientScreen(
|
||||
ClientScreenServer clientScreenServer,
|
||||
LastFinishedFrameProvider lastFinishedFrameProvider
|
||||
) : ITickStep
|
||||
{
|
||||
public Task TickAsync()
|
||||
{
|
||||
var tasks = clientScreenServer
|
||||
.GetConnections()
|
||||
.Select(c => c.SendAsync(lastFinishedFrameProvider.LastFrame));
|
||||
return Task.WhenAll(tasks);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue