413 lines
13 KiB
C#
413 lines
13 KiB
C#
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);
|
|
}
|
|
}
|