104 lines
3.3 KiB
C#
104 lines
3.3 KiB
C#
using System.Buffers;
|
|
using System.Net.WebSockets;
|
|
using DisplayCommands;
|
|
using TanksServer.Graphics;
|
|
|
|
namespace TanksServer.Interactivity;
|
|
|
|
internal sealed class ClientScreenServerConnection : WebsocketServerConnection
|
|
{
|
|
private sealed record class Package(
|
|
IMemoryOwner<byte> PixelsOwner,
|
|
Memory<byte> Pixels,
|
|
IMemoryOwner<byte>? PlayerDataOwner,
|
|
Memory<byte>? PlayerData
|
|
);
|
|
|
|
private readonly MemoryPool<byte> _memoryPool = MemoryPool<byte>.Shared;
|
|
private readonly PlayerScreenData? _playerDataBuilder;
|
|
private readonly Player? _player;
|
|
private int _wantsFrameOnTick = 1;
|
|
private Package? _next;
|
|
|
|
public ClientScreenServerConnection(WebSocket webSocket,
|
|
ILogger<ClientScreenServerConnection> logger,
|
|
Player? player) : base(logger, new ByteChannelWebSocket(webSocket, logger, 0))
|
|
{
|
|
_player = player;
|
|
_player?.IncrementConnectionCount();
|
|
_playerDataBuilder = player == null
|
|
? null
|
|
: new PlayerScreenData(logger, player);
|
|
}
|
|
|
|
protected override ValueTask HandleMessageAsync(Memory<byte> _)
|
|
{
|
|
if (_wantsFrameOnTick != 0)
|
|
return ValueTask.CompletedTask;
|
|
|
|
var package = Interlocked.Exchange(ref _next, null);
|
|
if (package != null)
|
|
return SendAndDisposeAsync(package);
|
|
|
|
// the delay between one exchange and this set could be enough for another frame to complete
|
|
// this would mean the client simply drops a frame, so this should be fine
|
|
_wantsFrameOnTick = 1;
|
|
return ValueTask.CompletedTask;
|
|
}
|
|
|
|
public async ValueTask OnGameTickAsync(PixelGrid pixels, GamePixelGrid gamePixelGrid)
|
|
{
|
|
await Task.Yield();
|
|
|
|
var nextPixelsOwner = _memoryPool.Rent(pixels.Data.Length);
|
|
var nextPixels = nextPixelsOwner.Memory[..pixels.Data.Length];
|
|
pixels.Data.CopyTo(nextPixels);
|
|
|
|
IMemoryOwner<byte>? nextPlayerDataOwner = null;
|
|
Memory<byte>? nextPlayerData = null;
|
|
if (_playerDataBuilder != null)
|
|
{
|
|
var data = _playerDataBuilder.Build(gamePixelGrid);
|
|
nextPlayerDataOwner = _memoryPool.Rent(data.Length);
|
|
nextPlayerData = nextPlayerDataOwner.Memory[..data.Length];
|
|
data.CopyTo(nextPlayerData.Value);
|
|
}
|
|
|
|
var next = new Package(nextPixelsOwner, nextPixels, nextPlayerDataOwner, nextPlayerData);
|
|
if (Interlocked.Exchange(ref _wantsFrameOnTick, 0) != 0)
|
|
{
|
|
await SendAndDisposeAsync(next);
|
|
return;
|
|
}
|
|
|
|
var oldNext = Interlocked.Exchange(ref _next, next);
|
|
oldNext?.PixelsOwner.Dispose();
|
|
oldNext?.PlayerDataOwner?.Dispose();
|
|
}
|
|
|
|
public override ValueTask RemovedAsync()
|
|
{
|
|
_player?.DecrementConnectionCount();
|
|
return ValueTask.CompletedTask;
|
|
}
|
|
|
|
private async ValueTask SendAndDisposeAsync(Package package)
|
|
{
|
|
try
|
|
{
|
|
await Socket.SendBinaryAsync(package.Pixels, package.PlayerData == null);
|
|
if (package.PlayerData != null)
|
|
await Socket.SendBinaryAsync(package.PlayerData.Value);
|
|
}
|
|
catch (WebSocketException ex)
|
|
{
|
|
Logger.LogWarning(ex, "send failed");
|
|
}
|
|
finally
|
|
{
|
|
package.PixelsOwner.Dispose();
|
|
package.PlayerDataOwner?.Dispose();
|
|
}
|
|
}
|
|
}
|