A production-ready, server-authoritative multiplayer game server running at 60 ticks per second, supporting 100+ concurrent game rooms with sub-50ms latency.
A complete real-time multiplayer game server built with .NET 10
Physics simulation running at 60 ticks per second with smooth shape movement, boundary collision detection, and dynamic speed/direction changes.
All game logic runs server-side with client position validation. Anti-cheat measures ensure fair gameplay for all players.
Optimized for low latency with thread-safe operations, efficient algorithms, and minimal memory allocations.
Designed to handle multiple concurrent game rooms with horizontal scaling support and graceful degradation under load.
Production-ready features for a multiplayer game server
Precise timing with high-precision stopwatch, maintaining exactly 16.67ms per frame. Automatic frame rate monitoring and performance logging.
Real-time bidirectional communication with automatic fallback to SSE/Long Polling. Binary MessagePack serialization for optimal performance.
Thread-safe room creation, joining, and lifecycle management. Support for 2-8 players per room with unique room codes.
Velocity-based movement with boundary bouncing, random speed changes (100-400 px/s), and dynamic direction changes every 0.5-2 seconds.
Server-side distance calculation with configurable tolerance (15px). Grace period for fair game starts. Anti-cheat position validation.
Automatic player elimination when finger lifts or distance exceeds threshold. Real-time rankings and winner determination.
Layered architecture with clear separation of concerns
SignalR Hub - Entry point for all client requests, handles connection lifecycle, routes messages to services
GameRoomManager - Central registry of all active rooms, thread-safe operations with ConcurrentDictionary
Background Service - Runs continuously at 60 Hz, updates all active games, broadcasts shape positions
Shape Movement, Player Validation, Elimination Logic - Pure business logic, testable and maintainable
Touch position updates (60/sec)
Receives & validates input
Updates shape, validates players
Shape updates to all clients
Modern .NET ecosystem with performance-focused libraries
Optimized for low latency and high throughput
Clean, maintainable, and testable code structure
// Game Loop Service - 60 Hz Background Service
protected override async Task ExecuteAsync(
CancellationToken stoppingToken)
{
var stopwatch = Stopwatch.StartNew();
const double targetFrameTime = 1000.0 / 60.0; // 16.67ms
while (!stoppingToken.IsCancellationRequested)
{
var frameStart = stopwatch.ElapsedMilliseconds;
// Process all active game rooms
var activeRooms = _roomManager.GetActiveRooms();
foreach (var room in activeRooms)
{
// Update shape position
_shapeService.UpdatePosition(room.Shape, deltaTime);
// Validate players
var eliminated = _validationService
.ValidatePlayers(room);
// Broadcast updates
await _hubContext.Clients
.Group(room.RoomCode)
.OnShapeUpdate(shapeUpdate);
}
// Maintain 60 FPS
var frameTime = stopwatch.ElapsedMilliseconds - frameStart;
var sleepTime = (int)(targetFrameTime - frameTime);
if (sleepTime > 0)
await Task.Delay(sleepTime, stoppingToken);
}
}// Player Validation Service
public List<Player> ValidatePlayers(GameRoom room)
{
var eliminated = new List<Player>();
foreach (var player in room.AlivePlayers)
{
// Skip grace period
if (room.IsInGracePeriod) continue;
// Calculate distance
var distance = CalculateDistance(
player.TouchX, player.TouchY,
room.Shape.Position.X,
room.Shape.Position.Y
);
// Check threshold (radius + tolerance)
var threshold = room.Shape.Radius + 15;
if (distance > threshold)
{
eliminated.Add(player);
}
}
return eliminated;
}// Shape Movement Service
public void UpdatePosition(Shape shape, double deltaTime)
{
// Update position based on velocity
shape.Position.X += shape.Velocity.X * deltaTime;
shape.Position.Y += shape.Velocity.Y * deltaTime;
// Boundary collision
if (shape.Position.X - shape.Radius < 0)
{
shape.Position.X = shape.Radius;
shape.Velocity.X = -shape.Velocity.X;
}
// Random speed/direction changes
if (ShouldChangeSpeed(shape))
ChangeSpeed(shape);
if (ShouldChangeDirection(shape))
ChangeDirection(shape);
}