vinzenz/servicepoint-tanks
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

tanks can spawn and get rendered

Browse source
This commit is contained in:
Vinzenz Schroeter 2024-04-07 13:02:49 +02:00
parent 151cad4cee
commit a3bd582b2e
20 changed files with 286 additions and 108 deletions
Download patch file Download diff file Expand all files Collapse all files

8
TanksServer/Services/GameTickService.cs
View file

@ -2,7 +2,7 @@ using Microsoft.Extensions.Hosting;
namespace TanksServer.Services;
internal sealed class GameTickService(IEnumerable<ITickStep> steps) : IHostedService
internal sealed class GameTickService(IEnumerable<ITickStep> steps) : IHostedService, IDisposable
{
private readonly CancellationTokenSource _cancellation = new();
private readonly List<ITickStep> _steps = steps.ToList();
@ -29,6 +29,12 @@ internal sealed class GameTickService(IEnumerable<ITickStep> steps) : IHostedSer
await _cancellation.CancelAsync();
if (_run != null) await _run;
}
public void Dispose()
{
_cancellation.Dispose();
_run?.Dispose();
}
}
public interface ITickStep

56
TanksServer/Services/MapDrawer.cs
View file

@ -1,56 +0,0 @@
namespace TanksServer.Services;
internal class MapDrawer(MapService map):ITickStep
{
private const uint GameFieldPixelCount = MapService.PixelsPerRow * MapService.PixelsPerColumn;
private void DrawInto(DisplayPixelBuffer buf)
{
for (var tileY = 0; tileY < MapService.TilesPerColumn; tileY++)
for (var tileX = 0; tileX < MapService.TilesPerRow; tileX++)
{
if (!map.IsCurrentlyWall(tileX, tileY))
continue;
var absoluteTilePixelY = tileY * MapService.TileSize;
for (var pixelInTileY = 0; pixelInTileY < MapService.TileSize; pixelInTileY++)
{
var absoluteRowStartPixelIndex = (absoluteTilePixelY + pixelInTileY) * MapService.PixelsPerRow
+ tileX * MapService.TileSize;
for (var pixelInTileX = 0; pixelInTileX < MapService.TileSize; pixelInTileX++)
buf.Pixels[absoluteRowStartPixelIndex + pixelInTileX] = pixelInTileX % 2 == pixelInTileY % 2;
}
}
}
private DisplayPixelBuffer CreateGameFieldPixelBuffer()
{
var data = new byte[10 + GameFieldPixelCount / 8];
var result = new DisplayPixelBuffer(data)
{
Magic1 = 0,
Magic2 = 19,
X = 0,
Y = 0,
WidthInTiles = MapService.TilesPerRow,
HeightInPixels = MapService.PixelsPerColumn
};
return result;
}
private DisplayPixelBuffer? _lastFrame;
public DisplayPixelBuffer LastFrame
{
get => _lastFrame ?? throw new InvalidOperationException("first frame not yet drawn");
private set => _lastFrame = value;
}
public Task TickAsync()
{
var buffer = CreateGameFieldPixelBuffer();
DrawInto(buffer);
LastFrame = buffer;
return Task.CompletedTask;
}
}

8
TanksServer/Services/MapService.cs
View file

@ -1,6 +1,8 @@
using TanksServer.Models;
namespace TanksServer.Services;
internal class MapService
internal sealed class MapService
{
public const int TilesPerRow = 44;
public const int TilesPerColumn = 20;
@ -35,8 +37,8 @@ internal class MapService
private char this[int tileX, int tileY] => _map[tileX + tileY * TilesPerRow];
public bool IsCurrentlyWall(int tileX, int tileY)
public bool IsCurrentlyWall(TilePosition position)
{
return this[tileX, tileY] == '#';
return this[position.X, position.Y] == '#';
}
}

112
TanksServer/Services/PixelDrawer.cs Normal file
View file

@ -0,0 +1,112 @@
using System.Diagnostics;
using System.Net.Mime;
using Microsoft.Extensions.Logging;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using TanksServer.Helpers;
using TanksServer.Models;
namespace TanksServer.Services;
internal sealed class PixelDrawer : ITickStep
{
private const uint GameFieldPixelCount = MapService.PixelsPerRow * MapService.PixelsPerColumn;
private DisplayPixelBuffer? _lastFrame;
private readonly MapService _map;
private readonly TankManager _tanks;
private readonly bool[] _tankSprite;
private readonly int _tankSpriteWidth;
public PixelDrawer(MapService map, TankManager tanks, ILogger<PixelDrawer> logger)
{
_map = map;
_tanks = tanks;
using var tankImage = Image.Load<Rgba32>("assets/tank.png");
_tankSprite = new bool[tankImage.Height * tankImage.Width];
var whitePixel = new Rgba32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
var i = 0;
for (var y = 0; y < tankImage.Height; y++)
for (var x = 0; x < tankImage.Width; x++, i++)
{
_tankSprite[i] = tankImage[x, y] == whitePixel;
}
_tankSpriteWidth = tankImage.Width;
}
public DisplayPixelBuffer LastFrame
{
get => _lastFrame ?? throw new InvalidOperationException("first frame not yet drawn");
private set => _lastFrame = value;
}
public Task TickAsync()
{
var buffer = CreateGameFieldPixelBuffer();
DrawMap(buffer);
DrawTanks(buffer);
LastFrame = buffer;
return Task.CompletedTask;
}
private void DrawMap(DisplayPixelBuffer buf)
{
for (var tileY = 0; tileY < MapService.TilesPerColumn; tileY++)
for (var tileX = 0; tileX < MapService.TilesPerRow; tileX++)
{
var tile = new TilePosition(tileX, tileY);
if (!_map.IsCurrentlyWall(tile))
continue;
var absoluteTilePixelY = tileY * MapService.TileSize;
for (var pixelInTileY = 0; pixelInTileY < MapService.TileSize; pixelInTileY++)
{
var absoluteRowStartPixelIndex = (absoluteTilePixelY + pixelInTileY) * MapService.PixelsPerRow
+ tileX * MapService.TileSize;
for (var pixelInTileX = 0; pixelInTileX < MapService.TileSize; pixelInTileX++)
buf.Pixels[absoluteRowStartPixelIndex + pixelInTileX] = pixelInTileX % 2 == pixelInTileY % 2;
}
}
}
private void DrawTanks(DisplayPixelBuffer buf)
{
foreach (var tank in _tanks)
{
for (var dy = 0; dy < MapService.TileSize; dy++)
{
var rowStartIndex = (tank.Position.Y + dy) * MapService.PixelsPerRow;
for (var dx = 0; dx < MapService.TileSize; dx++)
{
var i = rowStartIndex + tank.Position.X + dx;
buf.Pixels[i] = TankSpriteAt(dx, dy, tank.Rotation);
}
}
}
}
private bool TankSpriteAt(int dx, int dy, int tankRotation)
{
var x = tankRotation % 4 * (MapService.TileSize + 1);
var y = tankRotation / 4 * (MapService.TileSize + 1);
return _tankSprite[(y + dy) * _tankSpriteWidth + x + dx];
}
private static DisplayPixelBuffer CreateGameFieldPixelBuffer()
{
var data = new byte[10 + GameFieldPixelCount / 8];
var result = new DisplayPixelBuffer(data)
{
Magic1 = 0,
Magic2 = 19,
X = 0,
Y = 0,
WidthInTiles = MapService.TilesPerRow,
HeightInPixels = MapService.PixelsPerColumn
};
return result;
}
}

14
TanksServer/Services/ServicePointDisplay.cs
View file

@ -3,13 +3,21 @@ using Microsoft.Extensions.Options;
namespace TanksServer.Services;
internal sealed class ServicePointDisplay(IOptions<ServicePointDisplayConfiguration> options)
internal sealed class ServicePointDisplay(
IOptions<ServicePointDisplayConfiguration> options,
PixelDrawer drawer
) : ITickStep, IDisposable
{
private readonly UdpClient _udpClient = new(options.Value.Hostname, options.Value.Port);
public ValueTask<int> Send(DisplayPixelBuffer buffer)
public Task TickAsync()
{
return _udpClient.SendAsync(buffer.Data);
return _udpClient.SendAsync(drawer.LastFrame.Data).AsTask();
}
public void Dispose()
{
_udpClient.Dispose();
}
}

51
TanksServer/Services/SpawnQueue.cs Normal file
View file

@ -0,0 +1,51 @@
using System.Collections.Concurrent;
using TanksServer.Models;
namespace TanksServer.Services;
internal sealed class SpawnQueue(TankManager tanks, MapService map) : ITickStep
{
private readonly ConcurrentQueue<Player> _playersToSpawn = new();
public Task TickAsync()
{
while (_playersToSpawn.TryDequeue(out var player))
{
var tank = new Tank(player, ChooseSpawnPosition())
{
Rotation = Random.Shared.Next(0, 16)
};
tanks.Add(tank);
}
return Task.CompletedTask;
}
private PixelPosition ChooseSpawnPosition()
{
List<TilePosition> candidates = new();
for (var x = 0; x < MapService.TilesPerRow; x++)
for (var y = 0; y < MapService.TilesPerColumn; y++)
{
var tile = new TilePosition(x, y);
if (map.IsCurrentlyWall(tile))
continue;
// TODO: check tanks
candidates.Add(tile);
}
var chosenTile = candidates[Random.Shared.Next(candidates.Count)];
return new PixelPosition(
chosenTile.X * MapService.TileSize,
chosenTile.Y * MapService.TileSize
);
}
public void SpawnTankForPlayer(Player player)
{
_playersToSpawn.Enqueue(player);
}
}

20
TanksServer/Services/TankManager.cs Normal file
View file

@ -0,0 +1,20 @@
using System.Collections;
using System.Collections.Concurrent;
using Microsoft.Extensions.Logging;
using TanksServer.Models;
namespace TanksServer.Services;
internal sealed class TankManager(ILogger<TankManager> logger) : IEnumerable<Tank>
{
private readonly ConcurrentBag<Tank> _tanks = new();
public void Add(Tank tank)
{
logger.LogInformation("Tank added");
_tanks.Add(tank);
}
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
public IEnumerator<Tank> GetEnumerator() => _tanks.GetEnumerator();
}