Add Ehwrj clean-room live map

tools/Ehwrj.Tools.LocalApiStub/Ehwrj.Tools.LocalApiStub.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>Ehwrj.Tools.LocalApiStub</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../../src/Ehwrj.Core/Ehwrj.Core.csproj" />
+  </ItemGroup>
+</Project>

tools/Ehwrj.Tools.LocalApiStub/Program.cs

@@ -0,0 +1,412 @@
+using System.Globalization;
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using Ehwrj.Core.Services;
+
+namespace Ehwrj.Tools.LocalApiStub;
+
+internal static class Program
+{
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        WriteIndented = true
+    };
+
+    private static async Task<int> Main(string[] args)
+    {
+        var options = StubOptions.Parse(args);
+        if (options.ShowHelp)
+        {
+            StubOptions.PrintHelp();
+            return 0;
+        }
+
+        if (!LoopbackGuard.IsLoopbackHost(options.Host))
+        {
+            Console.Error.WriteLine("Only loopback hosts are allowed for the local API stub.");
+            return 1;
+        }
+
+        using var listener = new HttpListener();
+        var prefix = $"http://{options.Host}:{options.Port}/";
+        listener.Prefixes.Add(prefix);
+
+        using var shutdown = new CancellationTokenSource();
+        Console.CancelKeyPress += (_, eventArgs) =>
+        {
+            eventArgs.Cancel = true;
+            shutdown.Cancel();
+            listener.Stop();
+        };
+
+        try
+        {
+            listener.Start();
+        }
+        catch (HttpListenerException ex)
+        {
+            Console.Error.WriteLine($"Failed to listen on {prefix}: {ex.Message}");
+            return 1;
+        }
+
+        Console.WriteLine($"Ehwrj local API stub listening on {prefix}");
+        if (options.FixtureDirectory is not null)
+        {
+            Console.WriteLine($"Fixture replay: {Path.GetFullPath(options.FixtureDirectory)}");
+        }
+        Console.WriteLine("Endpoints: /map_info.json /map_obj.json /map.img /state /hudmsg /gamechat");
+        Console.WriteLine("Press Ctrl+C to stop.");
+
+        var startedAt = DateTimeOffset.UtcNow;
+        while (!shutdown.IsCancellationRequested)
+        {
+            HttpListenerContext context;
+            try
+            {
+                context = await listener.GetContextAsync().WaitAsync(shutdown.Token).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                break;
+            }
+            catch (HttpListenerException) when (shutdown.IsCancellationRequested)
+            {
+                break;
+            }
+
+            _ = Task.Run(() => HandleAsync(context, startedAt, options), shutdown.Token);
+        }
+
+        return 0;
+    }
+
+    private static async Task HandleAsync(HttpListenerContext context, DateTimeOffset startedAt, StubOptions options)
+    {
+        try
+        {
+            var path = context.Request.Url?.AbsolutePath ?? "/";
+            if (await TryWriteFixtureAsync(context, path, options.FixtureDirectory).ConfigureAwait(false))
+            {
+                return;
+            }
+
+            switch (path)
+            {
+                case "/map_info.json":
+                    await WriteJsonAsync(context, CreateMapInfo()).ConfigureAwait(false);
+                    break;
+                case "/map_obj.json":
+                    await WriteJsonAsync(context, CreateMapObjects((DateTimeOffset.UtcNow - startedAt).TotalSeconds)).ConfigureAwait(false);
+                    break;
+                case "/map.img":
+                    await WriteBytesAsync(context, "image/bmp", MapImageGenerator.CreateBmp(512, 512)).ConfigureAwait(false);
+                    break;
+                case "/state":
+                    await WriteJsonAsync(context, CreateState((DateTimeOffset.UtcNow - startedAt).TotalSeconds)).ConfigureAwait(false);
+                    break;
+                case "/hudmsg":
+                    await WriteJsonAsync(context, CreateHudMessages((DateTimeOffset.UtcNow - startedAt).TotalSeconds)).ConfigureAwait(false);
+                    break;
+                case "/gamechat":
+                    await WriteJsonAsync(context, CreateGameChat((DateTimeOffset.UtcNow - startedAt).TotalSeconds)).ConfigureAwait(false);
+                    break;
+                default:
+                    await WriteTextAsync(context, "Ehwrj local API stub\n").ConfigureAwait(false);
+                    break;
+            }
+        }
+        catch (Exception ex)
+        {
+            context.Response.StatusCode = 500;
+            await WriteTextAsync(context, ex.Message).ConfigureAwait(false);
+        }
+        finally
+        {
+            context.Response.Close();
+        }
+    }
+
+    private static object CreateMapInfo()
+    {
+        return new
+        {
+            grid_size = new[] { 1.0, 1.0 },
+            grid_steps = new[] { 0.1, 0.1 },
+            min_x = 0.0,
+            max_x = 1.0,
+            min_y = 0.0,
+            max_y = 1.0
+        };
+    }
+
+    private static object[] CreateMapObjects(double seconds)
+    {
+        var phase = seconds * 0.18;
+        var playerX = 0.5 + Math.Cos(phase) * 0.08;
+        var playerY = 0.5 + Math.Sin(phase) * 0.08;
+
+        return new object[]
+        {
+            new
+            {
+                id = "player",
+                name = "Player",
+                type = "player_aircraft",
+                team = "player",
+                icon = "fighter",
+                x = Round(playerX),
+                y = Round(playerY),
+                dx = Round(Math.Cos(phase)),
+                dy = Round(Math.Sin(phase))
+            },
+            new
+            {
+                id = "bandit-1",
+                name = "Bandit 1",
+                type = "aircraft",
+                team = "enemy",
+                icon = "fighter",
+                x = Round(0.5 + Math.Cos(phase + 1.8) * 0.22),
+                y = Round(0.5 + Math.Sin(phase + 1.8) * 0.18)
+            },
+            new
+            {
+                id = "bandit-2",
+                name = "Bandit 2",
+                type = "aircraft",
+                team = "enemy",
+                icon = "bomber",
+                x = Round(0.5 + Math.Cos(phase * 0.7 + 3.2) * 0.34),
+                y = Round(0.5 + Math.Sin(phase * 0.7 + 3.2) * 0.25)
+            },
+            new
+            {
+                id = "objective-a",
+                name = "A",
+                type = "capture_zone",
+                team = "ally",
+                icon = "zone",
+                x = 0.25,
+                y = 0.28
+            },
+            new
+            {
+                id = "objective-b",
+                name = "B",
+                type = "bombing_point",
+                team = "enemy",
+                icon = "zone",
+                x = 0.72,
+                y = 0.68
+            }
+        };
+    }
+
+    private static object CreateState(double seconds)
+    {
+        return new Dictionary<string, object>
+        {
+            ["TAS, km/h"] = Math.Round(720 + Math.Sin(seconds * 0.25) * 80, 1),
+            ["IAS, km/h"] = Math.Round(650 + Math.Sin(seconds * 0.22) * 65, 1),
+            ["Vy, m/s"] = Math.Round(Math.Sin(seconds * 0.34) * 38, 2),
+            ["H, m"] = Math.Round(2200 + Math.Sin(seconds * 0.11) * 420, 1)
+        };
+    }
+
+    private static object CreateHudMessages(double seconds)
+    {
+        var wave = (int)(seconds / 12) % 4;
+        return new
+        {
+            events = new object[]
+            {
+                new { text = wave == 0 ? "Enemy aircraft spotted" : "Maintain formation", enemy = wave == 0 },
+                new { text = "Objective B under attack", enemy = true }
+            }
+        };
+    }
+
+    private static object CreateGameChat(double seconds)
+    {
+        var wave = (int)(seconds / 15) % 3;
+        return new
+        {
+            items = new object[]
+            {
+                new { text = wave == 0 ? "Cover the bomber route" : "Regroup near A", enemy = false }
+            }
+        };
+    }
+
+    private static double Round(double value)
+    {
+        return Math.Round(Math.Clamp(value, 0.02, 0.98), 5);
+    }
+
+    private static Task WriteJsonAsync(HttpListenerContext context, object value)
+    {
+        var json = JsonSerializer.Serialize(value, JsonOptions);
+        return WriteBytesAsync(context, "application/json", Encoding.UTF8.GetBytes(json));
+    }
+
+    private static Task WriteTextAsync(HttpListenerContext context, string text)
+    {
+        return WriteBytesAsync(context, "text/plain; charset=utf-8", Encoding.UTF8.GetBytes(text));
+    }
+
+    private static async Task WriteBytesAsync(HttpListenerContext context, string contentType, byte[] bytes)
+    {
+        context.Response.ContentType = contentType;
+        context.Response.ContentLength64 = bytes.Length;
+        await context.Response.OutputStream.WriteAsync(bytes).ConfigureAwait(false);
+    }
+
+    private static async Task<bool> TryWriteFixtureAsync(HttpListenerContext context, string path, string? fixtureDirectory)
+    {
+        if (fixtureDirectory is null)
+        {
+            return false;
+        }
+
+        var fileName = path switch
+        {
+            "/map_info.json" => "map_info.json",
+            "/map_obj.json" => "map_obj.json",
+            "/map.img" => "map.img",
+            "/state" => "state.json",
+            "/hudmsg" => "hudmsg.json",
+            "/gamechat" => "gamechat.json",
+            _ => null
+        };
+
+        if (fileName is null)
+        {
+            return false;
+        }
+
+        var filePath = Path.Combine(fixtureDirectory, fileName);
+        if (!File.Exists(filePath))
+        {
+            return false;
+        }
+
+        var bytes = await File.ReadAllBytesAsync(filePath).ConfigureAwait(false);
+        var contentType = fileName.EndsWith(".json", StringComparison.OrdinalIgnoreCase)
+            ? "application/json"
+            : "image/bmp";
+        await WriteBytesAsync(context, contentType, bytes).ConfigureAwait(false);
+        return true;
+    }
+}
+
+internal sealed record StubOptions(string Host, int Port, string? FixtureDirectory, bool ShowHelp)
+{
+    public static StubOptions Parse(IReadOnlyList<string> args)
+    {
+        var host = "127.0.0.1";
+        var port = 8111;
+        string? fixtureDirectory = null;
+
+        for (var i = 0; i < args.Count; i++)
+        {
+            switch (args[i])
+            {
+                case "-h":
+                case "--help":
+                    return new StubOptions(host, port, fixtureDirectory, true);
+                case "--host" when i + 1 < args.Count:
+                    host = args[++i];
+                    break;
+                case "--port" when i + 1 < args.Count && int.TryParse(args[++i], NumberStyles.None, CultureInfo.InvariantCulture, out var parsed):
+                    port = parsed;
+                    break;
+                case "--fixture-dir" when i + 1 < args.Count:
+                    fixtureDirectory = args[++i];
+                    break;
+                default:
+                    Console.Error.WriteLine($"Ignoring unknown argument: {args[i]}");
+                    break;
+            }
+        }
+
+        return new StubOptions(host, port, fixtureDirectory, false);
+    }
+
+    public static void PrintHelp()
+    {
+        Console.WriteLine("""
+        Usage:
+          dotnet run --project tools/Ehwrj.Tools.LocalApiStub -- [--host 127.0.0.1] [--port 8111] [--fixture-dir captures/name]
+
+        Serves deterministic War Thunder-like local map, telemetry, and message endpoints for UI development.
+        When --fixture-dir is supplied, files captured by Ehwrj.Tools.Capture are replayed first.
+        """);
+    }
+}
+
+internal static class MapImageGenerator
+{
+    public static byte[] CreateBmp(int width, int height)
+    {
+        var stride = ((width * 3 + 3) / 4) * 4;
+        var pixelBytes = stride * height;
+        var fileSize = 54 + pixelBytes;
+        var bytes = new byte[fileSize];
+
+        bytes[0] = (byte)'B';
+        bytes[1] = (byte)'M';
+        WriteInt32(bytes, 2, fileSize);
+        WriteInt32(bytes, 10, 54);
+        WriteInt32(bytes, 14, 40);
+        WriteInt32(bytes, 18, width);
+        WriteInt32(bytes, 22, height);
+        WriteInt16(bytes, 26, 1);
+        WriteInt16(bytes, 28, 24);
+        WriteInt32(bytes, 34, pixelBytes);
+
+        for (var y = 0; y < height; y++)
+        {
+            var sourceY = height - 1 - y;
+            for (var x = 0; x < width; x++)
+            {
+                var nx = x / (double)Math.Max(1, width - 1);
+                var ny = sourceY / (double)Math.Max(1, height - 1);
+                var grid = x % 64 == 0 || sourceY % 64 == 0;
+                var water = Math.Sin(nx * 8.0) + Math.Cos(ny * 7.0) > 1.15;
+
+                var r = water ? (byte)28 : (byte)(42 + ny * 34);
+                var g = water ? (byte)78 : (byte)(74 + nx * 46);
+                var b = water ? (byte)98 : (byte)(58 + (1 - ny) * 34);
+
+                if (grid)
+                {
+                    r = (byte)Math.Min(255, r + 38);
+                    g = (byte)Math.Min(255, g + 38);
+                    b = (byte)Math.Min(255, b + 38);
+                }
+
+                var offset = 54 + y * stride + x * 3;
+                bytes[offset] = b;
+                bytes[offset + 1] = g;
+                bytes[offset + 2] = r;
+            }
+        }
+
+        return bytes;
+    }
+
+    private static void WriteInt16(byte[] bytes, int offset, short value)
+    {
+        bytes[offset] = (byte)value;
+        bytes[offset + 1] = (byte)(value >> 8);
+    }
+
+    private static void WriteInt32(byte[] bytes, int offset, int value)
+    {
+        bytes[offset] = (byte)value;
+        bytes[offset + 1] = (byte)(value >> 8);
+        bytes[offset + 2] = (byte)(value >> 16);
+        bytes[offset + 3] = (byte)(value >> 24);
+    }
+}