Files
systemrevivalserver/Game/World/WorldInputParser.cs
T
2026-02-16 08:56:15 -05:00

215 lines
7.4 KiB
C#

using System.Text;
using System.Text.Json;
namespace GameServer.World;
public static class WorldInputParser
{
private static readonly JsonSerializerOptions JsonOpts = new() { PropertyNameCaseInsensitive = true };
public sealed class InputReq
{
public uint Seq { get; set; }
public float MoveX { get; set; }
public float MoveY { get; set; }
public bool IsRunning { get; set; }
public string? Facing { get; set; }
public bool IsMovingProvided { get; set; }
public bool IsMoving { get; set; }
public bool HasTargetPosition { get; set; }
public bool UseTargetPosition { get; set; }
public bool NativeDirectional { get; set; }
public float TargetX { get; set; }
public float TargetY { get; set; }
}
public sealed class SpawnReq
{
public int? RegionId { get; set; }
public int? ZoneX { get; set; }
public int? ZoneY { get; set; }
public int? ChunkX { get; set; }
public int? ChunkY { get; set; }
}
public static T? Parse<T>(ReadOnlyMemory<byte> payload)
{
try
{
if (payload.IsEmpty) return default;
var s = Encoding.UTF8.GetString(payload.Span);
if (string.IsNullOrWhiteSpace(s)) return default;
return JsonSerializer.Deserialize<T>(s, JsonOpts);
}
catch { return default; }
}
public static InputReq? ParseWorldInput(ReadOnlyMemory<byte> payload, float currentX, float currentY)
{
if (payload.IsEmpty) return null;
try
{
using var doc = JsonDocument.Parse(Encoding.UTF8.GetString(payload.Span));
var root = doc.RootElement;
if (root.ValueKind != JsonValueKind.Object) return null;
var source = root;
if (TryGetProperty(root, "input", out var nested) && nested.ValueKind == JsonValueKind.Object)
source = nested;
float moveX = 0f;
float moveY = 0f;
var hasMoveX = TryGetFloat(source, out moveX, "moveX", "dx", "inputX", "horizontal");
var hasMoveY = TryGetFloat(source, out moveY, "moveY", "dy", "inputY", "vertical");
var hasRawX = TryGetFloat(source, out var rawX, "x");
var hasRawY = TryGetFloat(source, out var rawY, "y");
if (!hasMoveX && hasRawX && IsDirectionalValue(rawX))
{
moveX = rawX;
hasMoveX = true;
}
if (!hasMoveY && hasRawY && IsDirectionalValue(rawY))
{
moveY = rawY;
hasMoveY = true;
}
var hasAbsTarget = false;
var useAbsTarget = false;
var absTargetX = 0f;
var absTargetY = 0f;
var hadNativeDirectional = hasMoveX || hasMoveY;
var hasTargetX = TryGetFloat(source, out var parsedTargetX, "targetX", "worldTargetX");
var hasTargetY = TryGetFloat(source, out var parsedTargetY, "targetY", "worldTargetY");
if (hasTargetX && hasTargetY)
{
hasAbsTarget = true;
absTargetX = parsedTargetX;
absTargetY = parsedTargetY;
var dx = absTargetX - currentX;
var dy = absTargetY - currentY;
var len = MathF.Sqrt((dx * dx) + (dy * dy));
var directionalIsNeutral = (!hasMoveX && !hasMoveY) ||
(MathF.Abs(moveX) <= 0.01f && MathF.Abs(moveY) <= 0.01f);
if (directionalIsNeutral && len > 0.5f)
{
useAbsTarget = true;
moveX = dx / len;
moveY = dy / len;
hasMoveX = true;
hasMoveY = true;
}
}
if (!hasMoveX && !hasMoveY)
return null;
TryGetUInt(source, out var seq, "seq", "clientSeq", "inputSeq");
TryGetBool(source, out var isRunning, "isRunning", "running", "sprint");
var hasIsMoving = TryGetBool(source, out var isMoving, "isMoving", "moving");
TryGetString(source, out var facing, "facing", "dir", "direction");
return new InputReq
{
Seq = seq,
MoveX = moveX,
MoveY = moveY,
IsRunning = isRunning,
Facing = facing,
IsMovingProvided = hasIsMoving,
IsMoving = isMoving,
HasTargetPosition = hasAbsTarget,
UseTargetPosition = useAbsTarget,
NativeDirectional = hadNativeDirectional,
TargetX = absTargetX,
TargetY = absTargetY
};
}
catch
{
return null;
}
}
internal static bool TryGetProperty(JsonElement source, string name, out JsonElement value)
{
foreach (var p in source.EnumerateObject())
{
if (string.Equals(p.Name, name, StringComparison.OrdinalIgnoreCase))
{
value = p.Value;
return true;
}
}
value = default;
return false;
}
internal static bool TryGetFloat(JsonElement source, out float value, params string[] names)
{
foreach (var n in names)
{
if (!TryGetProperty(source, n, out var e)) continue;
if (e.ValueKind == JsonValueKind.Number && e.TryGetSingle(out value)) return true;
if (e.ValueKind == JsonValueKind.String && float.TryParse(e.GetString(), out value)) return true;
}
value = 0f;
return false;
}
internal static bool TryGetUInt(JsonElement source, out uint value, params string[] names)
{
foreach (var n in names)
{
if (!TryGetProperty(source, n, out var e)) continue;
if (e.ValueKind == JsonValueKind.Number && e.TryGetUInt32(out value)) return true;
if (e.ValueKind == JsonValueKind.String && uint.TryParse(e.GetString(), out value)) return true;
}
value = 0;
return false;
}
internal static bool TryGetBool(JsonElement source, out bool value, params string[] names)
{
foreach (var n in names)
{
if (!TryGetProperty(source, n, out var e)) continue;
if (e.ValueKind == JsonValueKind.True || e.ValueKind == JsonValueKind.False)
{
value = e.GetBoolean();
return true;
}
if (e.ValueKind == JsonValueKind.Number && e.TryGetInt32(out var num))
{
value = num != 0;
return true;
}
if (e.ValueKind == JsonValueKind.String && bool.TryParse(e.GetString(), out value))
return true;
}
value = false;
return false;
}
internal static bool TryGetString(JsonElement source, out string? value, params string[] names)
{
foreach (var n in names)
{
if (!TryGetProperty(source, n, out var e)) continue;
if (e.ValueKind == JsonValueKind.String)
{
value = e.GetString();
return true;
}
}
value = null;
return false;
}
internal static bool IsDirectionalValue(float value)
=> float.IsFinite(value) && value >= -1.05f && value <= 1.05f;
}