@axpecter/lync 1.5.2 → 2.1.0

package/src/transport/Server.luau

@@ -1,362 +1,217 @@
 --!strict
 --!optimize 2
--- Server-side transport with batching, delta state, frame XOR.
+-- Server-side transport: per-player channels, broadcast, flush.
 
 local Players = game:GetService("Players")
-local RunService = game:GetService("RunService")
 
 local Baseline = require(script.Parent.Parent.internal.Baseline)
-local Bridge = require(script.Parent.Bridge)
+local Bridge = require(script.Parent.Parent.transport.Bridge)
 local Channel = require(script.Parent.Parent.internal.Channel)
-local Gate = require(script.Parent.Gate)
-local Middleware = require(script.Parent.Parent.internal.Middleware)
+local Gate = require(script.Parent.Parent.transport.Gate)
 local Pool = require(script.Parent.Parent.internal.Pool)
-local Reader = require(script.Parent.Reader)
+local Reader = require(script.Parent.Parent.transport.Reader)
 local Types = require(script.Parent.Parent.Types)
 
-type ChannelState = Types.ChannelState
-type Codec<T> = Types.Codec<T>
-
-local channelWriteBatch = Channel.writeBatch
-local channelWriteBatchRaw = Channel.writeBatchRaw
-local channelSetPacket = Channel.setCurrentPacket
-
 -- State ---------------------------------------------------------------
 
-type PlayerState = {
-    reliable: ChannelState,
-    unreliable: ChannelState,
-}
-
-local _players = {} :: { [Player]: PlayerState }
-local _prevRecv = {} :: { [Player]: buffer }
-local _isStarted = false
-local _broadScratch = Channel.create()
+local _reliableChannels: { [Player]: Types.ChannelState } = {}
+local _unreliableChannels: { [Player]: Types.ChannelState } = {}
+local _playerStats: { [Player]: Types.PlayerStats } = {}
+local _statsEnabled = false
 
 -- Private -------------------------------------------------------------
 
-local function onPlayerAdded(player: Player): ()
-    _players[player] = {
-        reliable = Pool.acquire(),
-        unreliable = Pool.acquire(),
-    }
-    Gate.onPlayerAdded(player)
-end
-
-local function onPlayerRemoving(player: Player): ()
-    local state = _players[player]
-    if not state then
-        return
+local function getReliable(player: Player): Types.ChannelState
+    local ch = _reliableChannels[player]
+    if not ch then
+        ch = Pool.acquire()
+        _reliableChannels[player] = ch
     end
-
-    Pool.release(state.reliable)
-    Pool.release(state.unreliable)
-    _players[player] = nil
-    _prevRecv[player] = nil
-
-    Gate.onPlayerRemoved(player)
-    Baseline.clearSource(player)
+    return ch
 end
 
-local function receive(player: Player, data: any, refs: any, applyXor: boolean): ()
-    local buf = Reader.decodeIncoming(data)
-    if not buf then
-        return
-    end
-
-    local raw: buffer
-    if applyXor then
-        raw = Channel.xorApply(buf, _prevRecv[player])
-        _prevRecv[player] = raw
-    else
-        raw = buf
-    end
-
-    local safeRefs: { Instance }? = if typeof(refs) == "table" then refs else nil
-    local ok, err = pcall(Reader.process, raw, safeRefs, player, 0)
-    if not ok then
-        warn(`[Lync] Read failed from {player.Name} ({player.UserId}): {err}`)
+local function getUnreliable(player: Player): Types.ChannelState
+    local ch = _unreliableChannels[player]
+    if not ch then
+        ch = Pool.acquire()
+        _unreliableChannels[player] = ch
     end
+    return ch
 end
 
-local function flushChannel(remote: any, ch: ChannelState, target: Player, applyXor: boolean): ()
-    if ch.cursor == 0 then
-        return
-    end
+local function flushPlayer(player: Player): ()
+    -- Reliable channel
+    local rCh = _reliableChannels[player]
+    if rCh and rCh.cursor > 0 then
+        local snapshot, refs, byteLen, refCount = Channel.sealAndDump(rCh)
 
-    local raw, refs = Channel.sealAndDump(ch)
+        -- XOR against previous frame
+        local xored = Channel.xorApply(snapshot, byteLen, rCh.prevDump, rCh.prevDumpLen)
+        rCh.prevDump = snapshot
+        rCh.prevDumpLen = byteLen
 
-    if applyXor then
-        local xored = Channel.xorApply(raw, ch.prevDump)
-        ch.prevDump = raw
-        remote:FireClient(target, xored, refs)
-    else
-        remote:FireClient(target, raw, refs)
-    end
+        Bridge.fireClient(player, xored, refs)
+        Channel.reset(rCh)
 
-    Channel.reset(ch)
-end
+        if _statsEnabled then
+            local ps = _playerStats[player]
+            if ps then
+                ps.bytesSent += byteLen
+            end
+        end
+    end
 
-local function flush(): ()
-    local reliable = Bridge.reliable
-    local unreliable = Bridge.unreliable
+    -- Unreliable channel (no XOR, no delta)
+    local uCh = _unreliableChannels[player]
+    if uCh and uCh.cursor > 0 then
+        local snapshot, refs, byteLen, _ = Channel.sealAndDump(uCh)
 
-    for player, state in _players do
-        local ok, err = pcall(flushChannel, reliable, state.reliable, player, true)
-        if not ok then
-            warn(`[Lync] Flush failed for {player.Name} ({player.UserId}): {err}`)
-            Channel.reset(state.reliable)
-        end
+        Bridge.fireClientUnreliable(player, snapshot, refs)
+        Channel.reset(uCh)
 
-        local ok2, err2 = pcall(flushChannel, unreliable, state.unreliable, player, false)
-        if not ok2 then
-            warn(`[Lync] Flush failed for {player.Name} ({player.UserId}): {err2}`)
-            Channel.reset(state.unreliable)
+        if _statsEnabled then
+            local ps = _playerStats[player]
+            if ps then
+                ps.bytesSent += byteLen
+            end
         end
     end
 end
 
--- Serialize data once into shared scratch, return raw bytes + refs snapshot.
-local function serializeBroadcast(
-    name: string,
-    codec: Codec<any>,
-    data: any
-): (number, { Instance }?)
-    local scratch = _broadScratch
-    scratch.cursor = 0
-    table.clear(scratch.refs)
-    channelSetPacket(name)
-    codec.write(scratch, data)
-
-    local snapRefs = if #scratch.refs > 0 then table.clone(scratch.refs) else nil
-    return scratch.cursor, snapRefs
-end
+-- Public --------------------------------------------------------------
 
--- Run middleware and serialize once. Returns nil if middleware dropped.
-local function prepareBroadcast(
-    name: string,
-    codec: Codec<any>,
-    data: any
-): (any, number, { Instance }?)
-    local final: any
-    if Middleware.hasSend then
-        final = Middleware.runSend(data, name, nil)
-        if final == nil then
-            return nil, 0, nil
-        end
-    else
-        final = data
-    end
+local Server = {}
 
-    local snapLen, snapRefs = serializeBroadcast(name, codec, final)
-    return final, snapLen, snapRefs
+function Server.getChannel(player: Player, isUnreliable: boolean): Types.ChannelState
+    return if isUnreliable then getUnreliable(player) else getReliable(player)
 end
 
--- Fan out to all connected players via _players map.
-local function broadcastToAll(
-    id: number,
-    name: string,
-    codec: Codec<any>,
-    data: any,
-    isUnreliable: boolean,
-    exceptSet: { [Player]: true }?
-): ()
-    local final, snapLen, snapRefs = prepareBroadcast(name, codec, data)
-    if final == nil and data ~= nil then
-        return
+function Server.flush(): ()
+    if Channel.hasTimestamps() then
+        Channel.updateTimestamp()
     end
 
-    local scratchBuff = _broadScratch.buff
-    for player, state in _players do
-        if exceptSet and exceptSet[player] then
-            continue
-        end
-        local ch = if isUnreliable then state.unreliable else state.reliable
-        channelWriteBatchRaw(ch, id, scratchBuff, snapLen, snapRefs)
-    end
-end
-
--- Fan out to a specific player list.
-local function broadcastToList(
-    players: { Player },
-    id: number,
-    name: string,
-    codec: Codec<any>,
-    data: any,
-    isUnreliable: boolean
-): ()
-    local final, snapLen, snapRefs = prepareBroadcast(name, codec, data)
-    if final == nil and data ~= nil then
-        return
+    for player in _reliableChannels do
+        flushPlayer(player)
     end
 
-    local scratchBuff = _broadScratch.buff
-    for _, player in players do
-        local state = _players[player]
-        if not state then
-            continue
+    for player in _unreliableChannels do
+        if not _reliableChannels[player] then
+            flushPlayer(player)
         end
-        local ch = if isUnreliable then state.unreliable else state.reliable
-        channelWriteBatchRaw(ch, id, scratchBuff, snapLen, snapRefs)
     end
 end
 
--- Fan out to a group set { [Player]: true }.
-local function broadcastToSet(
-    set: { [Player]: true },
-    id: number,
-    name: string,
-    codec: Codec<any>,
-    data: any,
-    isUnreliable: boolean
-): ()
-    local final, snapLen, snapRefs = prepareBroadcast(name, codec, data)
-    if final == nil and data ~= nil then
-        return
-    end
-
-    local scratchBuff = _broadScratch.buff
-    for player in set do
-        local state = _players[player]
-        if not state then
-            continue
-        end
-        local ch = if isUnreliable then state.unreliable else state.reliable
-        channelWriteBatchRaw(ch, id, scratchBuff, snapLen, snapRefs)
-    end
+function Server.flushPlayer(player: Player): ()
+    flushPlayer(player)
 end
 
--- Public --------------------------------------------------------------
+function Server.start(): ()
+    local container = Instance.new("Folder")
+    container.Name = "LyncRemotes"
+    container.Parent = game:GetService("ReplicatedStorage")
 
-local Server = {}
+    Bridge.setup(container)
 
-function Server.start(): ()
-    if _isStarted then
-        return
-    end
-    _isStarted = true
+    local reliable = Bridge.reliable()
+    local unreliable = Bridge.unreliable()
 
-    Bridge.setup()
+    -- Incoming reliable
+    reliable.OnServerEvent:Connect(function(player: Player, data: any, refs: any?)
+        local incoming = Reader.decodeIncoming(data)
+        if not incoming then
+            return
+        end
 
-    Players.PlayerAdded:Connect(onPlayerAdded)
-    Players.PlayerRemoving:Connect(onPlayerRemoving)
-    for _, player in Players:GetPlayers() do
-        onPlayerAdded(player)
-    end
+        local incomingLen = buffer.len(incoming)
 
-    Bridge.reliable.OnServerEvent:Connect(function(player: Player, data: any, refs: any): ()
-        receive(player, data, refs, true)
-    end)
-    Bridge.unreliable.OnServerEvent:Connect(function(player: Player, data: any, refs: any): ()
-        receive(player, data, refs, false)
-    end)
-    RunService.Heartbeat:Connect(flush)
-end
+        -- Bandwidth check
+        if not Gate.checkBandwidth(player, incomingLen) then
+            return
+        end
 
-function Server.writeTo(
-    player: Player,
-    id: number,
-    name: string,
-    codec: Codec<any>,
-    data: any,
-    isUnreliable: boolean
-): ()
-    local state = _players[player]
-    if not state then
-        return
-    end
+        -- XOR decode against player's previous outbound (client→server has no XOR)
+        local ok, err = pcall(Reader.process, incoming, incomingLen, refs :: any, player, true)
+        if not ok then
+            warn(`[Lync] Server: read error from {player.Name}: {err}`)
+        end
+
+        if _statsEnabled then
+            local ps = _playerStats[player]
+            if ps then
+                ps.bytesReceived += incomingLen
+            end
+        end
+    end)
 
-    local final: any
-    if Middleware.hasSend then
-        final = Middleware.runSend(data, name, player)
-        if final == nil then
+    -- Incoming unreliable
+    unreliable.OnServerEvent:Connect(function(player: Player, data: any, refs: any?)
+        local incoming = Reader.decodeIncoming(data)
+        if not incoming then
             return
         end
-    else
-        final = data
-    end
 
-    local ch = if isUnreliable then state.unreliable else state.reliable
-    channelWriteBatch(ch, id, name, codec, final)
-end
+        local incomingLen = buffer.len(incoming)
 
-function Server.writeToAll(
-    id: number,
-    name: string,
-    codec: Codec<any>,
-    data: any,
-    isUnreliable: boolean
-): ()
-    broadcastToAll(id, name, codec, data, isUnreliable, nil)
-end
+        local ok, err = pcall(Reader.process, incoming, incomingLen, refs :: any, player, true)
+        if not ok then
+            warn(`[Lync] Server: read error (unreliable) from {player.Name}: {err}`)
+        end
 
-function Server.writeToList(
-    players: { Player },
-    id: number,
-    name: string,
-    codec: Codec<any>,
-    data: any,
-    isUnreliable: boolean
-): ()
-    broadcastToList(players, id, name, codec, data, isUnreliable)
-end
+        if _statsEnabled then
+            local ps = _playerStats[player]
+            if ps then
+                ps.bytesReceived += incomingLen
+            end
+        end
+    end)
 
-function Server.writeToAllExcept(
-    exceptSet: { [Player]: true },
-    id: number,
-    name: string,
-    codec: Codec<any>,
-    data: any,
-    isUnreliable: boolean
-): ()
-    broadcastToAll(id, name, codec, data, isUnreliable, exceptSet)
-end
+    -- Player lifecycle
+    Players.PlayerAdded:Connect(function(player: Player)
+        if _statsEnabled then
+            _playerStats[player] = { bytesSent = 0, bytesReceived = 0 }
+        end
+    end)
 
-function Server.writeToSet(
-    set: { [Player]: true },
-    id: number,
-    name: string,
-    codec: Codec<any>,
-    data: any,
-    isUnreliable: boolean
-): ()
-    broadcastToSet(set, id, name, codec, data, isUnreliable)
-end
+    Players.PlayerRemoving:Connect(function(player: Player)
+        local rCh = _reliableChannels[player]
+        if rCh then
+            _reliableChannels[player] = nil
+            Pool.release(rCh)
+        end
 
--- Shared for both query requests and responses(identical wire format).
-function Server.writeQuery(
-    player: Player,
-    id: number,
-    name: string,
-    correlationId: number,
-    codec: Codec<any>,
-    data: any
-): ()
-    local state = _players[player]
-    if not state then
-        return
-    end
+        local uCh = _unreliableChannels[player]
+        if uCh then
+            _unreliableChannels[player] = nil
+            Pool.release(uCh)
+        end
 
-    local final: any
-    if Middleware.hasSend then
-        final = Middleware.runSend(data, name, player)
-        if final == nil then
-            return
+        _playerStats[player] = nil
+        Gate.clearPlayer(player)
+        Baseline.clearPlayer(player)
+    end)
+
+    -- Initialize stats for existing players
+    if _statsEnabled then
+        for _, player in Players:GetPlayers() do
+            _playerStats[player] = { bytesSent = 0, bytesReceived = 0 }
         end
-    else
-        final = data
     end
+end
 
-    Channel.writeQuery(state.reliable, id, name, correlationId, codec, final)
+function Server.enableStats(): ()
+    _statsEnabled = true
 end
 
-function Server.writeQueryNil(player: Player, id: number, name: string, correlationId: number): ()
-    local state = _players[player]
-    if not state then
-        return
-    end
+function Server.getPlayerStats(player: Player): Types.PlayerStats?
+    return _playerStats[player]
+end
 
-    Channel.writeQuery(state.reliable, id, name, correlationId, nil, nil)
+function Server.resetStats(): ()
+    for player, ps in _playerStats do
+        ps.bytesSent = 0
+        ps.bytesReceived = 0
+    end
 end
 
 return table.freeze(Server)