@axpecter/lync 2.0.0 → 2.1.0

package/src/transport/Client.luau

@@ -1,206 +1,95 @@
 --!strict
 --!optimize 2
--- Client-side transport with batching, frame XOR on reliable.
+-- Client-side transport: single channel pair, flush.
 
-local RunService = game:GetService("RunService")
-
-local Bridge = require(script.Parent.Bridge)
+local Bridge = require(script.Parent.Parent.transport.Bridge)
 local Channel = require(script.Parent.Parent.internal.Channel)
-local Middleware = require(script.Parent.Parent.internal.Middleware)
-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>
-type Registration = Types.Registration
-
 -- State ---------------------------------------------------------------
 
-local NOT_STARTED = "[Lync] Client not started. Call Lync.start() before sending"
-
-local _reliable = nil :: ChannelState?
-local _unreliable = nil :: ChannelState?
-local _prevRecv = nil :: buffer?
-local _isStarted = false
-
--- Flush control
-local _flushRate = 60
-local _flushInterval = 1 / 60
-local _useAccumulator = false
-local _flushAccum = 0
-local _flushedThisFrame = false
+local _reliable: Types.ChannelState = Channel.create()
+local _unreliable: Types.ChannelState = Channel.create()
+local _prevIncoming: buffer? = nil
+local _prevIncomingLen = 0
 
--- Timestamp
-local _frameCounter: number = 0
-
--- Private -------------------------------------------------------------
-
-local function receive(data: any, refs: any, applyXor: boolean): ()
-    local buf = Reader.decodeIncoming(data)
-    if not buf then
-        return
-    end
+-- Public --------------------------------------------------------------
 
-    local raw: buffer
-    if applyXor then
-        raw = Channel.xorApply(buf, _prevRecv)
-        _prevRecv = raw
-    else
-        raw = buf
-    end
+local Client = {}
 
-    local safeRefs: { Instance }? = if typeof(refs) == "table" then refs else nil
-    local ok, err = pcall(Reader.process, raw, safeRefs, nil, 0)
-    if not ok then
-        warn(`[Lync] Read failed: {err}`)
-    end
+function Client.getChannel(isUnreliable: boolean): Types.ChannelState
+    return if isUnreliable then _unreliable else _reliable
 end
 
-local function flushChannel(remote: any, ch: ChannelState, applyXor: boolean): ()
-    if ch.cursor == 0 then
-        return
+function Client.flush(): ()
+    if Channel.hasTimestamps() then
+        Channel.updateTimestamp()
     end
 
-    local raw, refs = Channel.sealAndDump(ch)
-
-    if applyXor then
-        local xored = Channel.xorApply(raw, ch.prevDump)
-        ch.prevDump = raw
-        remote:FireServer(xored, refs)
-    else
-        remote:FireServer(raw, refs)
+    -- Reliable
+    if _reliable.cursor > 0 then
+        local snapshot, refs, byteLen, _ = Channel.sealAndDump(_reliable)
+        Bridge.fireServer(snapshot, refs)
+        Channel.reset(_reliable)
     end
 
-    Channel.reset(ch)
-end
-
-local function flush(): ()
-    if Channel.hasTimestamps() then
-        _frameCounter = (_frameCounter + 1) % 256
-        Channel.updateTimestamp(_frameCounter, 0, os.clock())
+    -- Unreliable
+    if _unreliable.cursor > 0 then
+        local snapshot, refs, byteLen, _ = Channel.sealAndDump(_unreliable)
+        Bridge.fireServerUnreliable(snapshot, refs)
+        Channel.reset(_unreliable)
     end
-
-    flushChannel(Bridge.reliable, _reliable :: ChannelState, true)
-    flushChannel(Bridge.unreliable, _unreliable :: ChannelState, false)
 end
 
--- Public --------------------------------------------------------------
-
-local Client = {}
-
 function Client.start(): ()
-    if _isStarted then
-        return
-    end
-    _isStarted = true
+    local container = game:GetService("ReplicatedStorage"):WaitForChild("LyncRemotes")
+    Bridge.setup(container)
 
-    Bridge.setup()
+    local reliable = Bridge.reliable()
+    local unreliable = Bridge.unreliable()
 
-    _reliable = Channel.create()
-    _unreliable = Channel.create()
-
-    Bridge.reliable.OnClientEvent:Connect(function(data: any, refs: any): ()
-        receive(data, refs, true)
-    end)
-    Bridge.unreliable.OnClientEvent:Connect(function(data: any, refs: any): ()
-        receive(data, refs, false)
-    end)
-
-    if _useAccumulator then
-        RunService.Heartbeat:Connect(function(dt: number)
-            if _flushedThisFrame then
-                _flushedThisFrame = false
-                return
-            end
-            _flushAccum += dt
-            if _flushAccum < _flushInterval then
-                return
-            end
-            _flushAccum -= _flushInterval
-            flush()
-        end)
-    else
-        RunService.Heartbeat:Connect(function()
-            if _flushedThisFrame then
-                _flushedThisFrame = false
-                return
-            end
-            flush()
-        end)
-    end
-end
-
-function Client.write(reg: Registration, data: any, isUnreliable: boolean): ()
-    if not _isStarted then
-        error(NOT_STARTED)
-    end
-
-    local final: any
-    if Middleware.hasSend then
-        final = Middleware.runSend(data, reg.name, nil)
-        if final == nil then
+    -- Incoming reliable (XOR encoded)
+    reliable.OnClientEvent:Connect(function(data: any, refs: any?)
+        local incoming = Reader.decodeIncoming(data)
+        if not incoming then
             return
         end
-    else
-        final = data
-    end
 
-    local ch = if isUnreliable then _unreliable :: ChannelState else _reliable :: ChannelState
-    if Channel.statsEnabled() then
-        local before = ch.cursor
-        Channel.writeBatch(ch, reg, final)
-        reg.bytesSent += ch.cursor - before
-        reg.fires += 1
-    else
-        Channel.writeBatch(ch, reg, final)
-    end
-end
-
-function Client.writeQuery(
-    id: number,
-    name: string,
-    correlationId: number,
-    codec: Codec<any>,
-    data: any
-): ()
-    if not _isStarted then
-        error(NOT_STARTED)
-    end
+        local incomingLen = buffer.len(incoming)
 
-    local final: any
-    if Middleware.hasSend then
-        final = Middleware.runSend(data, name, nil)
-        if final == nil then
-            return
+        -- XOR decode against previous frame
+        local decoded: buffer
+        if _prevIncoming then
+            decoded = Channel.xorApply(incoming, incomingLen, _prevIncoming, _prevIncomingLen)
+        else
+            decoded = incoming
         end
-    else
-        final = data
-    end
 
-    Channel.writeQuery(_reliable :: ChannelState, id, name, correlationId, codec, final)
-end
+        -- Store decoded (not XOR'd) for next frame's XOR base
+        _prevIncoming = decoded
+        _prevIncomingLen = incomingLen
 
-function Client.writeQueryNil(id: number, name: string, correlationId: number): ()
-    if not _isStarted then
-        error(NOT_STARTED)
-    end
-    Channel.writeQuery(_reliable :: ChannelState, id, name, correlationId, nil, nil)
-end
+        local ok, err = pcall(Reader.process, decoded, incomingLen, refs :: any, nil, false)
+        if not ok then
+            warn(`[Lync] Client: read error: {err}`)
+        end
+    end)
 
-function Client.flush(): ()
-    _flushAccum = 0
-    _flushedThisFrame = true
-    flush()
-end
+    -- Incoming unreliable (no XOR)
+    unreliable.OnClientEvent:Connect(function(data: any, refs: any?)
+        local incoming = Reader.decodeIncoming(data)
+        if not incoming then
+            return
+        end
 
-function Client.setFlushRate(hz: number): ()
-    _flushRate = math.clamp(hz, 1, 60)
-    _flushInterval = 1 / _flushRate
-    _useAccumulator = _flushRate < 60
-end
+        local incomingLen = buffer.len(incoming)
 
-function Client.getFlushRate(): number
-    return _flushRate
+        local ok, err = pcall(Reader.process, incoming, incomingLen, refs :: any, nil, false)
+        if not ok then
+            warn(`[Lync] Client: read error (unreliable): {err}`)
+        end
+    end)
 end
 
 return table.freeze(Client)