Working on world movement

This commit is contained in:
dingo
2026-02-15 13:00:06 -05:00
parent 6008c17a0b
commit 87650dbe47
+74 -15
View File
@@ -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<WorldHandler> _log;
@@ -29,6 +30,7 @@ public sealed class WorldHandler : IClientMessageHandler
private readonly ConcurrentDictionary<Guid, SessionState> _players = new();
private readonly ConcurrentDictionary<ulong, long> _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<int> 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<SessionState> 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; }
}