From 87650dbe47bce4c3f55ae6081debe5b1950bd205 Mon Sep 17 00:00:00 2001 From: dingo Date: Sun, 15 Feb 2026 13:00:06 -0500 Subject: [PATCH] Working on world movement --- Game/World/WorldHandler.cs | 89 +++++++++++++++++++++++++++++++------- 1 file changed, 74 insertions(+), 15 deletions(-) diff --git a/Game/World/WorldHandler.cs b/Game/World/WorldHandler.cs index 7301562..9eb5bee 100644 --- a/Game/World/WorldHandler.cs +++ b/Game/World/WorldHandler.cs @@ -20,6 +20,7 @@ public sealed class WorldHandler : IClientMessageHandler private const float MoveRun = 180f; private const float TickStepSec = 0.10f; private static readonly TimeSpan NeutralInputGrace = TimeSpan.FromMilliseconds(180); + private static readonly TimeSpan DirectionalPriorityGrace = TimeSpan.FromMilliseconds(450); private const long PortalCooldownTicks = 8; // 0.8s at 10hz private readonly ILogger _log; @@ -29,6 +30,7 @@ public sealed class WorldHandler : IClientMessageHandler private readonly ConcurrentDictionary _players = new(); private readonly ConcurrentDictionary _portalCooldownByCharacter = new(); private readonly JsonSerializerOptions _json = new() { PropertyNameCaseInsensitive = true }; + private readonly bool _debugInput; private Task? _tickTask; private CancellationTokenSource? _tickCts; @@ -45,6 +47,10 @@ public sealed class WorldHandler : IClientMessageHandler _sessions = sessions; _ser = ser; _scopeFactory = scopeFactory; + _debugInput = string.Equals( + Environment.GetEnvironmentVariable("WORLD_INPUT_DEBUG"), + "true", + StringComparison.OrdinalIgnoreCase); } public IReadOnlyCollection SupportedOpCodes => new[] @@ -213,7 +219,13 @@ public sealed class WorldHandler : IClientMessageHandler var hasMovement = MathF.Abs(dx) > 0.001f || MathF.Abs(dy) > 0.001f; var now = DateTime.UtcNow; - if (req.UseTargetPosition) + if (req.NativeDirectional && hasMovement) + { + s.PreferDirectionalUntil = now + DirectionalPriorityGrace; + s.HasPendingTarget = false; + } + + if (req.UseTargetPosition && now >= s.PreferDirectionalUntil) { s.HasPendingTarget = true; s.PendingTargetX = req.TargetX; @@ -253,6 +265,14 @@ public sealed class WorldHandler : IClientMessageHandler s.PendingFacing = req.Facing; } s.PendingSeq = req.Seq; + + if (_debugInput) + { + _log.LogInformation( + "WORLD_INPUT conn={Conn} seq={Seq} nativeDir={NativeDir} useTarget={UseTarget} hasTarget={HasTarget} move=({MoveX:F3},{MoveY:F3}) target=({TargetX:F2},{TargetY:F2}) pendingTarget={PendingTarget} pendingMove=({PendingX:F3},{PendingY:F3}) pos=({PosX:F2},{PosY:F2})", + conn.Id, req.Seq, req.NativeDirectional, req.UseTargetPosition, req.HasTargetPosition, + req.MoveX, req.MoveY, req.TargetX, req.TargetY, s.HasPendingTarget, s.PendingMoveX, s.PendingMoveY, s.X, s.Y); + } return Task.CompletedTask; } @@ -303,16 +323,24 @@ public sealed class WorldHandler : IClientMessageHandler private async Task ApplyPendingInputAsync(GameDbContext db, WorldRegion region, SessionState s, CancellationToken ct) { + var beforeX = s.X; + var beforeY = s.Y; float dx; float dy; + var targetMode = s.HasPendingTarget; + var targetX = s.PendingTargetX; + var targetY = s.PendingTargetY; + var stepScale = 1f; + if (s.HasPendingTarget) { - var tx = s.PendingTargetX - s.X; - var ty = s.PendingTargetY - s.Y; + var tx = targetX - s.X; + var ty = targetY - s.Y; var targetDist = MathF.Sqrt((tx * tx) + (ty * ty)); if (targetDist <= 1f) { s.HasPendingTarget = false; + targetMode = false; dx = s.PendingMoveX; dy = s.PendingMoveY; } @@ -320,6 +348,12 @@ public sealed class WorldHandler : IClientMessageHandler { dx = tx / targetDist; dy = ty / targetDist; + var speedForScale = s.PendingIsRunning ? MoveRun : MoveWalk; + var maxTickStep = speedForScale * TickStepSec; + if (maxTickStep > 0.001f) + { + stepScale = MathF.Min(1f, targetDist / maxTickStep); + } } } else @@ -338,8 +372,9 @@ public sealed class WorldHandler : IClientMessageHandler } var speed = s.PendingIsRunning ? MoveRun : MoveWalk; - var nextX = s.X + (dx * speed * TickStepSec); - var nextY = s.Y + (dy * speed * TickStepSec); + var effectiveSpeed = speed * stepScale; + var nextX = s.X + (dx * effectiveSpeed * TickStepSec); + var nextY = s.Y + (dy * effectiveSpeed * TickStepSec); var moving = MathF.Abs(dx) > 0.001f || MathF.Abs(dy) > 0.001f; if (moving) @@ -348,15 +383,33 @@ public sealed class WorldHandler : IClientMessageHandler if (await WalkableAsync(db, region, s.X, nextY, s.IsVip, ct)) s.Y = nextY; else s.Errors.Add("blocked_non_walkable"); } + if (targetMode && s.HasPendingTarget) + { + var rx = targetX - s.X; + var ry = targetY - s.Y; + var remaining = MathF.Sqrt((rx * rx) + (ry * ry)); + if (remaining <= 1f) + { + s.HasPendingTarget = false; + } + } + var (zx, zy, cx, cy) = ToChunkPos(region, s.X, s.Y); s.ZoneX = zx; s.ZoneY = zy; s.ChunkX = cx; s.ChunkY = cy; - s.VelX = moving ? dx * speed : 0f; - s.VelY = moving ? dy * speed : 0f; - s.Speed = moving ? speed : 0f; + s.VelX = moving ? dx * effectiveSpeed : 0f; + s.VelY = moving ? dy * effectiveSpeed : 0f; + s.Speed = moving ? effectiveSpeed : 0f; s.IsMoving = moving; s.Facing = Facing(s.PendingFacing, dx, dy, s.Facing); s.Seq = s.PendingSeq; await TryTriggerPortalAsync(db, region, s, ct); + + if (_debugInput) + { + _log.LogInformation( + "WORLD_TICK seq={Seq} targetMode={TargetMode} hasPendingTarget={HasPendingTarget} input=({InputX:F3},{InputY:F3}) effSpeed={Speed:F1} vel=({VelX:F1},{VelY:F1}) pos=({BeforeX:F2},{BeforeY:F2})->({AfterX:F2},{AfterY:F2})", + s.Seq, targetMode, s.HasPendingTarget, dx, dy, s.Speed, s.VelX, s.VelY, beforeX, beforeY, s.X, s.Y); + } } private IEnumerable VisiblePlayers(SessionState self) @@ -688,19 +741,22 @@ public sealed class WorldHandler : IClientMessageHandler hasMoveY = true; } - // Compatibility: clients that send absolute target x/y (dungeon-style). - // Prefer absolute target when directional input is missing OR effectively zero. + // Compatibility: allow absolute target movement only when target fields are explicit. + // Plain x/y frequently carry client render position and must not drive world movement. var hasAbsTarget = false; var useAbsTarget = false; var absTargetX = 0f; var absTargetY = 0f; - if (hasRawX && hasRawY && (!IsDirectionalValue(rawX) || !IsDirectionalValue(rawY))) + 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 = rawX; - absTargetY = rawY; - var dx = rawX - currentX; - var dy = rawY - currentY; + 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); @@ -735,6 +791,7 @@ public sealed class WorldHandler : IClientMessageHandler IsMoving = isMoving, HasTargetPosition = hasAbsTarget, UseTargetPosition = useAbsTarget, + NativeDirectional = hadNativeDirectional, TargetX = absTargetX, TargetY = absTargetY }; @@ -901,6 +958,7 @@ public sealed class WorldHandler : IClientMessageHandler public string? PendingFacing { get; set; } public uint PendingSeq { get; set; } public DateTime LastNonNeutralInputAt { get; set; } = DateTime.UtcNow; + public DateTime PreferDirectionalUntil { get; set; } = DateTime.MinValue; public bool HasPendingTarget { get; set; } public float PendingTargetX { get; set; } public float PendingTargetY { get; set; } @@ -929,6 +987,7 @@ public sealed class WorldHandler : IClientMessageHandler 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; } }