Files
systemrevivalserver/Services/World/WorldHandler.cs
T

88 lines
3.2 KiB
C#

// Server.Services.World/WorldHandler.cs
using Server.Networking;
using Server.Networking.Handling;
using Server.Networking.Messages;
using Server.Services.Auth;
namespace Server.Services.World;
public sealed class WorldHandler : IClientMessageHandler
{
private readonly ILogger<WorldHandler> _log;
private readonly IWorldService _world;
private readonly ISessionRegistry _sessions;
private readonly IZoneLeaseService _lease;
private readonly IMessageSerializer _ser;
private readonly HandlerContext _ctx;
public WorldHandler(
ILogger<WorldHandler> log,
IWorldService world,
ISessionRegistry sessions,
IZoneLeaseService lease,
IMessageSerializer ser)
{
_log = log; _world = world; _sessions = sessions; _lease = lease; _ser = ser;
_ctx = new HandlerContext(ser);
}
public IReadOnlyCollection<int> SupportedOpCodes => new[]
{
OpCodes.WORLD_SPAWN_REQUEST,
OpCodes.WORLD_INPUT
};
public async Task HandleAsync(int opCode, IConnection connection, ReadOnlyMemory<byte> payload, CancellationToken ct)
{
// Expect: TryGet(connId, out accountId, out token)
if (!_sessions.TryGet(connection.Id, out var accountId, out var token))
{
await _ctx.ReplyObjectAsync(connection, OpCodes.ERROR, new { error = "auth_required" }, ct);
return;
}
// Expect: TryGetCharacter(connId, out characterId) ← add this to ISessionRegistry if missing
if (!_sessions.TryGetCharacter(connection.Id, out var charId))
{
await _ctx.ReplyObjectAsync(connection, OpCodes.ERROR, new { error = "character_required" }, ct);
return;
}
switch (opCode)
{
case OpCodes.WORLD_SPAWN_REQUEST:
{
var req = _ser.Deserialize<WorldSpawnRequest>(payload);
if (!_lease.IsOwner((ulong)req.ZoneId))
{
await _ctx.ReplyObjectAsync(connection, OpCodes.ERROR, new { error = "not_owner_zone" }, ct);
return;
}
var result = await _world.SpawnAsync(accountId, charId, ct);
var ok = result.ok; var error = result.error; var self = result.self; var neighbors = result.neighbors;
if (!ok)
{
await _ctx.ReplyObjectAsync(connection, OpCodes.ERROR, new { error = error ?? "spawn_failed" }, ct);
return;
}
await _ctx.ReplyObjectAsync(connection, OpCodes.WORLD_SPAWN, self, ct);
foreach (var n in neighbors)
await _ctx.ReplyObjectAsync(connection, OpCodes.WORLD_SPAWN, n, ct);
break;
}
case OpCodes.WORLD_INPUT:
{
var req = _ser.Deserialize<WorldInput>(payload);
if (!_lease.IsOwner((ulong)req.ZoneId)) return; // ignore for MVP
_world.EnqueueInput((ulong)req.ZoneId, charId, req.Dx, req.Dy, req.Facing, req.ClientSeq);
break;
}
}
}
}