tank movement (without collision)

TanksServer/Services/GameTickService.cs

@@ -20,7 +20,7 @@ internal sealed class GameTickService(IEnumerable<ITickStep> steps) : IHostedSer
         {
             foreach (var step in _steps)
                 await step.TickAsync();
-            await Task.Delay(1000);
+            await Task.Delay(1000/25);
         }
     }
 

TanksServer/Services/PixelDrawer.cs

@@ -75,14 +75,17 @@ internal sealed class PixelDrawer : ITickStep
     {
         foreach (var tank in _tanks)
         {
+            var pos = new PixelPosition((int)tank.Position.X, (int)tank.Position.Y);
+            var rotationVariant = (int)Math.Floor(tank.Rotation);
             for (var dy = 0; dy < MapService.TileSize; dy++)
             {
-                var rowStartIndex = (tank.Position.Y + dy) * MapService.PixelsPerRow;
+                var rowStartIndex = (pos.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);
+                    var i = rowStartIndex + pos.X + dx;
+                    if (TankSpriteAt(dx, dy, rotationVariant))
+                        buf.Pixels[i] = true;
                 }
             }
         }
@@ -91,8 +94,13 @@ internal sealed class PixelDrawer : ITickStep
     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];
+        var y = (int)Math.Floor(tankRotation / 4d) * (MapService.TileSize + 1);
+        var index = (y + dy) * _tankSpriteWidth + x + dx;
+
+        if (index < 0 || index > _tankSprite.Length)
+            Debugger.Break();
+
+        return _tankSprite[index];
     }
 
     private static DisplayPixelBuffer CreateGameFieldPixelBuffer()

TanksServer/Services/SpawnQueue.cs

@@ -21,7 +21,7 @@ internal sealed class SpawnQueue(TankManager tanks, MapService map) : ITickStep
         return Task.CompletedTask;
     }
 
-    private PixelPosition ChooseSpawnPosition()
+    private FloatPosition ChooseSpawnPosition()
     {
         List<TilePosition> candidates = new();
         
@@ -33,12 +33,12 @@ internal sealed class SpawnQueue(TankManager tanks, MapService map) : ITickStep
             if (map.IsCurrentlyWall(tile))
                 continue;
             
-            // TODO: check tanks
+            // TODO: check tanks and bullets
             candidates.Add(tile);
         }
 
         var chosenTile = candidates[Random.Shared.Next(candidates.Count)];
-        return new PixelPosition(
+        return new FloatPosition(
             chosenTile.X * MapService.TileSize,
             chosenTile.Y * MapService.TileSize
         );

TanksServer/Services/TankManager.cs

@@ -1,20 +1,70 @@
 using System.Collections;
 using System.Collections.Concurrent;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using TanksServer.Models;
 
 namespace TanksServer.Services;
 
-internal sealed class TankManager(ILogger<TankManager> logger) : IEnumerable<Tank>
+internal sealed class TankManager(ILogger<TankManager> logger, IOptions<TanksConfiguration> options)
+    : ITickStep, IEnumerable<Tank>
 {
     private readonly ConcurrentBag<Tank> _tanks = new();
+    private readonly TanksConfiguration _config = options.Value;
 
     public void Add(Tank tank)
     {
-        logger.LogInformation("Tank added");
+        logger.LogInformation("Tank added for player {}", tank.Owner.Id);
         _tanks.Add(tank);
     }
 
+    public Task TickAsync()
+    {
+        foreach (var tank in _tanks)
+        {
+            TryMoveTank(tank);
+        }
+
+        return Task.CompletedTask;
+    }
+
+    private bool TryMoveTank(Tank tank)
+    {
+        logger.LogTrace("moving tank for player {}", tank.Owner.Id);
+        var player = tank.Owner;
+
+        // move turret
+        if (player.Controls.TurnLeft) Rotate(tank, -_config.TurnSpeed);
+        if (player.Controls.TurnRight) Rotate(tank, +_config.TurnSpeed);
+
+        if (player.Controls is { Forward: false, Backward: false })
+            return false;
+
+        var direction = player.Controls.Forward ? 1 : -1;
+        var angle = tank.Rotation / 16d * 2d * Math.PI;
+        var newX = tank.Position.X + Math.Sin(angle) * direction * _config.MoveSpeed;
+        var newY = tank.Position.Y - Math.Cos(angle) * direction * _config.MoveSpeed;
+
+        return TryMove(tank, newX, newY)
+               || TryMove(tank, newX, tank.Position.Y)
+               || TryMove(tank, tank.Position.X, newY);
+    }
+
+    private static bool TryMove(Tank tank, double newX, double newY)
+    {
+        // TODO implement
+
+        tank.Position = new FloatPosition(newX, newY);
+        return true;
+    }
+
+    private void Rotate(Tank t, double speed)
+    {
+        var newRotation = (t.Rotation + speed + 16) % 16;
+        logger.LogTrace("rotating tank for {} from {} to {}", t.Owner.Id, t.Rotation, newRotation);
+        t.Rotation = newRotation;
+    }
+
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
     public IEnumerator<Tank> GetEnumerator() => _tanks.GetEnumerator();
 }