215 lines
7.4 KiB
C#
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;
|
|
}
|