cluaupp 0.1.0

package/runtime/Chrono/Server/Receiver.luau

@@ -0,0 +1,287 @@
+const RunService = game:GetService("RunService")
+const Players = game:GetService("Players")
+const Receiver = {}
+
+const MiddleMans = {}
+local SortedMiddleMans = {}
+const Shared = script.Parent.Parent.Shared
+const Ticker = require(Shared.Ticker)
+const InterpolationMath = require(Shared.InterpolationMath)
+const Warn = require(Shared.Warn)
+const ServerClock = require(script.Parent.ServerClock)
+const Types = require(Shared.Types)
+const Holder = require(Shared.Holder)
+const Entity = require(Shared.Entity)
+const Config = require(Shared.Config)
+const ClockUnwrap = require(Shared.ClockUnwrap)
+const Stats = require(Shared.Stats).SERVER
+
+const ClientClockWrap: ClockUnwrap.Store = {}
+local BASE_MAX_TOTAL_BYTES_PER_FRAME_PER_PLAYER = 300
+
+Config._WaitForLock(function()
+	BASE_MAX_TOTAL_BYTES_PER_FRAME_PER_PLAYER = Config._GetConfig("MAX_TOTAL_BYTES_PER_FRAME_PER_PLAYER")
+end)
+
+local BytesReceived = 0
+
+const UnreliableEvent = Shared.Remotes.Replicate
+const SafeReplicateEvent = Shared.Remotes.SafeReplicate
+
+const FULL_BYTES = 4 * 3 + 2 * 3
+const YAW_BYTES = 4 * 3 + 2
+const BASE_TELEPORT_TIME_THRESHOLD = 0.5
+
+const function FireMiddleMans(player: Player, entity: Types.Entity, cframe: CFrame, arriveTime: number): boolean
+	if #SortedMiddleMans == 0 then
+		return false
+	end
+	debug.profilebegin("FireMiddleMans")
+	for _, mmData: any in SortedMiddleMans do
+		const block = mmData.func(player, entity, cframe, arriveTime)
+		if block then
+			return true
+		end
+	end
+	debug.profileend()
+	return false
+end
+const function UnmapRotation(x: number): number
+	return (x / 65535) * (2 * math.pi) - math.pi
+end
+const function DeserializeFull(b: buffer, index: number): CFrame
+	const x = buffer.readf32(b, index)
+	index += 4
+	const y = buffer.readf32(b, index)
+	index += 4
+	const z = buffer.readf32(b, index)
+	index += 4
+	const rx = UnmapRotation(buffer.readu16(b, index))
+	index += 2
+	const ry = UnmapRotation(buffer.readu16(b, index))
+	index += 2
+	const rz = UnmapRotation(buffer.readu16(b, index))
+	index += 2
+	return CFrame.new(x, y, z) * CFrame.fromOrientation(rx, ry, rz)
+end
+
+const function DeserializeYaw(b: buffer, index: number): CFrame
+	const x = buffer.readf32(b, index)
+	index += 4
+	const y = buffer.readf32(b, index)
+	index += 4
+	const z = buffer.readf32(b, index)
+	index += 4
+	const ry = UnmapRotation(buffer.readu16(b, index))
+	index += 2
+	return CFrame.new(x, y, z) * CFrame.fromOrientation(0, ry, 0)
+end
+
+const function DeserializeEntityPacket(b: buffer, index: number): (number, CFrame, number, boolean)
+	const id = buffer.readu16(b, index)
+	index += 2
+	const packed = buffer.readu8(b, index)
+	index += 1
+	const isFull = bit32.band(packed, 1) == 1
+	const isTeleport = bit32.band(packed, 4) == 4
+
+	local cframe: CFrame
+	if isFull then
+		cframe = DeserializeFull(b, index)
+		index += FULL_BYTES
+	else
+		cframe = DeserializeYaw(b, index)
+		index += YAW_BYTES
+	end
+
+	return id, cframe, index, isTeleport
+end
+
+const function CalculateMaxThroughputForPlayer(player: Player): number
+	local numberOfEntities = 0
+	for _ in Holder._clientOwned[player] or {} do
+		numberOfEntities += 1
+	end
+	return BASE_MAX_TOTAL_BYTES_PER_FRAME_PER_PLAYER + numberOfEntities * (FULL_BYTES + 3)
+end
+
+const function HandleEntity(
+	player: Player,
+	id: number,
+	serverClock: number,
+	clientClock: number,
+	cframe: CFrame,
+	copyB: buffer,
+	isTeleport: boolean
+)
+	const entity = Holder.GetEntityFromId(id)
+	if not entity or entity.networkOwner ~= player then
+		return
+	end
+
+	const teleportTime = entity._teleport
+	const ping = math.max(player:GetNetworkPing(), 0) + 0.05
+
+	const withinTeleportThreshold = teleportTime and os.clock() - teleportTime < (BASE_TELEPORT_TIME_THRESHOLD + ping)
+	if isTeleport then
+		if withinTeleportThreshold then
+			entity._teleport = nil
+		else
+			const packed = buffer.readu8(copyB, 2)
+			buffer.writeu8(copyB, 2, bit32.band(packed, bit32.bnot(4)))
+		end
+	elseif withinTeleportThreshold then
+		return
+	end
+
+	if entity.lastClientClock and clientClock < entity.lastClientClock then
+		return
+	end
+
+	debug.profilebegin("HandleEntity.FireMiddleMans")
+	if FireMiddleMans(player, entity, cframe, serverClock) then
+		debug.profileend()
+		return
+	end
+	debug.profileend()
+	local velocity = nil
+	if Config.FLAGS.SERVER_VELOCITY_FIX and entity.snapshot then
+		const latest = entity.snapshot:GetLatest()
+		const lastClientClock = entity.lastClientClock or clientClock
+		local tickrate = entity.entityConfig.TICK_RATE
+		if entity.isHalfTicked then
+			tickrate = tickrate * 2
+		end
+		if latest then
+			velocity = InterpolationMath.CalculateVelocity(
+				latest.value.Position,
+				lastClientClock,
+				cframe.Position,
+				clientClock,
+				tickrate
+			)
+		end
+	end
+	if Entity.Push(entity, serverClock, cframe, velocity) then
+		entity.arriveFrame = Ticker.GetGlobalTick()
+
+		entity.lastClientClock = clientClock
+		entity.cframeBuffer = copyB
+		if entity.modelReplicationMode == "NATIVE" and not entity._lockedCFReplication then
+			return
+		end
+		Entity._SetPartCFrame(entity, cframe)
+	end
+end
+
+const TotalBytes = {}
+const function OnReceive(player: Player, data: buffer)
+	if not data then
+		return
+	end
+	TotalBytes[player] = (TotalBytes[player] or 0) + buffer.len(data)
+	BytesReceived += buffer.len(data)
+	const maxBytes = CalculateMaxThroughputForPlayer(player)
+	if TotalBytes[player] > maxBytes then
+		Warn.medium("Player", player.Name, "exceeded max bytes per frame:", TotalBytes[player], "max:", maxBytes)
+		return
+	end
+	debug.profilebegin("Receiver.OnReceive")
+	local index = 0
+	const clientClock = ClockUnwrap.unwrapFor(ClientClockWrap, player, buffer.readu32(data, index))
+	index += 4
+	const serverClock = os.clock()
+	const dataLength = buffer.len(data)
+
+	ServerClock.Store(player, clientClock)
+
+	while index < dataLength do
+		const id, cframe, newIndex, isTeleport = DeserializeEntityPacket(data, index)
+		const copy = buffer.create(newIndex - index)
+		buffer.copy(copy, 0, data, index, newIndex - index)
+		index = newIndex
+		HandleEntity(player, id, serverClock, clientClock, cframe, copy, isTeleport)
+	end
+	debug.profileend()
+end
+
+--[=[
+	Registers a middle man function that can intercept incoming entity updates.
+
+	@param name The unique name of the middle man
+	@param priority The priority of the middle man ( higher priority runs first )
+	@param func The function to call. Should return true to block the update, else allow it.
+]=]
+function Receiver.RegisterMiddleMan(
+	name: string,
+	priority: number,
+	func: (
+		player: Player,
+		entity: Types.Entity,
+		cframe: CFrame,
+		arriveTime: number
+	) -> boolean
+)
+	MiddleMans[name] = { priority = priority, func = func }
+	SortedMiddleMans = {}
+	for mm, data in MiddleMans do
+		table.insert(SortedMiddleMans, data)
+	end
+	table.sort(SortedMiddleMans, function(a, b)
+		return a.priority > b.priority
+	end)
+end
+
+--[=[
+	Unregisters a middle man function.
+	@param name The unique name of the middle man
+]=]
+function Receiver.UnregisterMiddleMan(name: string)
+	MiddleMans[name] = nil
+	SortedMiddleMans = {}
+	for mm, data in MiddleMans do
+		table.insert(SortedMiddleMans, data)
+	end
+	table.sort(SortedMiddleMans, function(a, b)
+		return a.priority > b.priority
+	end)
+end
+
+if RunService:IsServer() then
+	local lastByteCheckTime = 0
+	RunService.Heartbeat:Connect(function(a0: number)
+		table.clear(TotalBytes)
+
+		if os.clock() - lastByteCheckTime > 1 then
+			Stats.BYTES_RECEIVED_PER_SEC = BytesReceived
+			BytesReceived = 0
+			lastByteCheckTime = os.clock()
+		end
+	end)
+	UnreliableEvent.OnServerEvent:Connect(OnReceive)
+	SafeReplicateEvent.OnServerEvent:Connect(OnReceive)
+
+	Shared.Remotes.ClientHeartbeat.OnServerEvent:Connect(function(player: Player, seconds: number)
+		if type(seconds) ~= "number" then
+			return
+		end
+		const clientClock = ClockUnwrap.seatFullFor(ClientClockWrap, player, seconds)
+		ServerClock.Store(player, clientClock)
+	end)
+
+	Players.PlayerRemoving:Connect(function(player)
+		ClientClockWrap[player] = nil
+	end)
+end
+
+function Receiver._GetClientClockRaws(): { { player: Player, raw: number, offset: number } }
+	const out = {}
+	for player, state in ClientClockWrap do
+		if state.lastRaw then
+			table.insert(out, { player = player, raw = state.lastRaw, offset = state.offset })
+		end
+	end
+	return out
+end
+
+return Receiver

package/runtime/Chrono/Server/Replicate.luau

@@ -0,0 +1,415 @@
+--!native
+const Players = game:GetService("Players")
+
+const RunService = game:GetService("RunService")
+
+const Shared = script.Parent.Parent.Shared
+
+const ApplyMounts = require(Shared.ApplyMounts)
+const Warn = require(Shared.Warn)
+const Bin = require(Shared.Bin)
+const Holder = require(Shared.Holder)
+const Events = require(Shared.Events)
+const Ticker = require(Shared.Ticker)
+const Config = require(Shared.Config)
+const Types = require(Shared.Types)
+const Entity = require(Shared.Entity)
+const EntityGrid = require(script.Parent.EntityGrid)
+const _Player = require(script.Parent.Player)
+const Sender = require(script.Parent.Sender)
+const _Receiver = require(script.Parent.Receiver)
+const Stats = require(Shared.Stats).SERVER
+
+const HeartbeatRemote = Shared.Remotes.Heartbeat
+const ClientClockRelayRemote = Shared.Remotes.ClientClockRelay
+
+const HEARTBEAT_RATE = 1 / 10
+local lastHeartbeat = 0
+
+const CLIENT_CLOCK_SYNC_RATE = 60
+local lastClientClockRelay = 0
+
+const tickers: { Types.Ticker } = {}
+
+Config._WaitForLock(function()
+	for _, entityConfig in Config._EntityConfigs do
+		if entityConfig.TICKER then
+			table.insert(tickers, entityConfig.TICKER)
+		else
+			Warn.high(entityConfig, "TICKERS not found on server config load")
+		end
+	end
+end)
+
+const function FireEvent(entity: Types.Entity, eventName: string, ...: any)
+	const events = entity._events
+	if not events then
+		return
+	end
+	const signal = events[eventName]
+	if signal then
+		signal:Fire(entity, ...)
+	end
+end
+
+const FULL_BYTES = 4 * 3 + 2 * 3 + 2
+const YAW_BYTES = 4 * 3 + 2 + 2
+
+const TAU = math.pi * 2
+
+const function MapRotation(x: number): number
+	return math.round((x + math.pi) / (TAU / 65535))
+end
+
+const function SerializeFull(b: buffer, cf: CFrame, index: number)
+	const x, y, z = cf.X, cf.Y, cf.Z
+	const rx, ry, rz = cf:ToOrientation()
+	buffer.writef32(b, index, x)
+	index += 4
+	buffer.writef32(b, index, y)
+	index += 4
+	buffer.writef32(b, index, z)
+	index += 4
+	buffer.writeu16(b, index, MapRotation(rx))
+	index += 2
+	buffer.writeu16(b, index, MapRotation(ry))
+	index += 2
+	buffer.writeu16(b, index, MapRotation(rz))
+	index += 2
+	return index
+end
+
+const function SerializeYaw(b: buffer, cf: CFrame, index: number)
+	const x, y, z = cf.X, cf.Y, cf.Z
+	const _, ry, _ = cf:ToOrientation()
+	buffer.writef32(b, index, x)
+	index += 4
+	buffer.writef32(b, index, y)
+	index += 4
+	buffer.writef32(b, index, z)
+	index += 4
+	buffer.writeu16(b, index, MapRotation(ry))
+	index += 2
+	return index
+end
+
+const function CFrameChanged(cframe1: CFrame?, cframe2: CFrame?): boolean
+	if cframe1 == cframe2 then
+		return false
+	end
+	if cframe1 == nil or cframe2 == nil then
+		return true
+	end
+	return cframe1:FuzzyEq(cframe2, 0.0001) == false
+end
+
+const function PushLatest(entity: Types.Entity, time: number)
+	if entity.autoUpdatePosition and entity.isContextOwner and entity.model then
+		const primaryPart = Entity.GetPrimaryPart(entity)
+		if not primaryPart then
+			Warn.low("Entity", entity, "has no primary part")
+			return
+		end
+		const cframe = primaryPart.CFrame
+		Entity.Push(entity, time, cframe)
+	end
+end
+
+const function CheckForChanges(entity: Types.Entity): CFrame?
+	const lastCFrame = entity.lastCheckedCFrame
+	const currentCFrame = entity.latestCFrame
+
+	if CFrameChanged(lastCFrame, currentCFrame) then
+		entity.lastCheckedCFrame = currentCFrame
+		return currentCFrame
+	end
+	return nil
+end
+
+const function CheckEntity(entity: Types.Entity, ticker: Types.Ticker, useFull: boolean, isHalfTick: boolean)
+	if entity.destroyed then
+		Ticker.Remove(ticker, entity)
+		return
+	end
+
+	if not entity.isContextOwner then
+		return
+	end
+
+	const entityIsHalf = entity.isHalfTicked
+	if (entityIsHalf and not isHalfTick) or entity.paused then
+		entity.cframeBuffer = nil
+		return
+	end
+	if entityIsHalf then
+		FireEvent(entity, "Ticked", ticker.halfdt)
+	else
+		FireEvent(entity, "Ticked", ticker.dt)
+	end
+
+	PushLatest(entity, ticker.lastTicked)
+	const changes = CheckForChanges(entity)
+
+	if changes then
+		if entity.id == 0 then
+			error("Entity Should not have and id of 0")
+		end
+		if useFull then
+			const b = buffer.create(FULL_BYTES)
+			buffer.writeu16(b, 0, entity.id)
+			SerializeFull(b, changes, 2)
+			entity.cframeBuffer = b
+		else
+			const b = buffer.create(YAW_BYTES)
+			buffer.writeu16(b, 0, entity.id)
+			SerializeYaw(b, changes, 2)
+			entity.cframeBuffer = b
+		end
+	else
+		entity.cframeBuffer = nil
+	end
+end
+
+const Changes: { Types.Entity } = {}
+
+--In the future we can optimize this so it uses buffers if really needed
+const function CheckEntityChanges()
+	for entity, changes in Entity._Changes do
+		const newChanges = { id = entity.id, data = {} }
+		for key, data in changes do
+			data = data or entity[key]
+			table.insert(newChanges.data, { key, data })
+		end
+		Entity._Changes[entity] = nil
+		entity._changes = newChanges
+		table.insert(Changes, entity)
+	end
+end
+
+local TotalTickerTime = 0
+local CountTicker = 0
+
+const function UpdateTickers()
+	debug.profilebegin("UpdateTickers")
+	const starts = os.clock()
+	for _, ticker in tickers do
+		if not next(ticker.objects) then
+			continue
+		end
+		debug.profilebegin(`{ticker.config.NAME}`)
+		if Ticker.CheckUpdate(ticker) then
+			--[[ Using the ticker's config instead can help protect if entity configs change mid-game since that
+                could potentially create a desync between the buffer serialization and deserialization
+            ]]
+			--// thought idk if we want to allow that (better to be safe ig for now)
+			const useFull = ticker.config.FULL_ROTATION == true
+			const isHalfTick = ticker.tickedHalf
+			for _, object in ticker.objects do
+				CheckEntity(object, ticker, useFull, isHalfTick)
+			end
+		end
+		debug.profileend()
+	end
+	debug.profileend()
+	const diff = os.clock() - starts
+	TotalTickerTime += diff
+	CountTicker += 1
+	Stats.AVG_TICKER_TIME_MS = (TotalTickerTime / CountTicker) * 1000
+	if CountTicker >= 60 then
+		TotalTickerTime = 0
+		CountTicker = 0
+	end
+end
+
+const function UpdatePlayerPositions()
+	for _, entity: Types.Entity in Holder._playerChars do
+		const player = entity.networkOwner
+		const primaryPart = Entity.GetPrimaryPart(entity)
+		const cframe = primaryPart and primaryPart.CFrame or entity.latestCFrame
+
+		if player and cframe then
+			EntityGrid.UpdatePlayerPosition(player, cframe.Position :: any)
+		end
+	end
+end
+
+const function updateEntityStats()
+	const hasOwned = Stats._SHOULD_REPLICATE
+	if not hasOwned then
+		Stats.SERVER_ENTITIES = {}
+		return
+	end
+	const entities: { Types.ServerEntitiesStats } = {}
+
+	for _, entity in Holder.idMap do
+		const networkOwner = entity.networkOwner
+		const isCharacter = entity._player ~= nil
+		const config = entity.entityConfig
+		const configName = config and config.NAME or "DEFAULT"
+		const configTickRate = 1 / config.TICK_RATE
+		const isHalfTicked = entity.isHalfTicked
+		local tickRate = configTickRate
+		const lastPosition = entity.latestCFrame and entity.latestCFrame.Position or nil
+		if isHalfTicked == true then
+			tickRate = tickRate / 2
+		elseif isHalfTicked == nil then
+			tickRate = 0
+		end
+		tickRate //= 1
+		if tickRate ~= tickRate or tickRate == math.huge then
+			tickRate = 0
+		end
+		const lastTicked = entity.latestTime
+		const data = {
+			isPaused = entity.paused,
+			id = entity.id,
+			networkOwner = networkOwner,
+			isCharacter = isCharacter,
+			config = configName,
+			tickRate = tickRate,
+			lastTicked = lastTicked,
+			lastPosition = lastPosition,
+			modelType = Entity.GetModelReplicationType(entity),
+		}
+		table.insert(entities, data)
+	end
+	Stats.SERVER_ENTITIES = entities
+end
+
+const function UpdateHeartbeat()
+	const now = os.clock()
+	if now - lastHeartbeat >= HEARTBEAT_RATE then
+		lastHeartbeat = now
+		for _, player in Players:GetPlayers() do
+			if not EntityGrid.GetEntityHolder(player) then
+				continue
+			end
+			HeartbeatRemote:FireClient(player, now)
+		end
+	end
+end
+
+const function UpdateClientClockRelay()
+	const now = os.clock()
+	if now - lastClientClockRelay < CLIENT_CLOCK_SYNC_RATE then
+		return
+	end
+	lastClientClockRelay = now
+
+	const raws = _Receiver._GetClientClockRaws()
+	if #raws == 0 then
+		return
+	end
+
+	ClientClockRelayRemote:FireAllClients(raws)
+end
+
+const function Update()
+	EntityGrid.Update()
+	UpdatePlayerPositions()
+	ApplyMounts()
+	UpdateTickers()
+	CheckEntityChanges()
+	UpdateHeartbeat()
+	UpdateClientClockRelay()
+
+	for _, player in Players:GetPlayers() do
+		Sender.ReplicatePlayer(player)
+	end
+	for _, entity in Changes do
+		entity._changes = nil
+	end
+	table.clear(Changes)
+	updateEntityStats()
+	Ticker._IncrementGlobalTick()
+end
+
+const function HandleEntity(plr, entity: Types.Entity)
+	const add, clear = Bin()
+
+	const function HandleModel(entity: Types.Entity)
+		if not entity.model then
+			return
+		end
+
+		const partToUse = Entity._GetRootPart(entity)
+
+		if not partToUse then
+			return
+		end
+
+		const function CFrameChanged()
+			const cframe = partToUse.CFrame
+			if entity.mountParentId then
+				entity.latestCFrame = cframe
+				return
+			end
+			if cframe == entity.latestCFrame then
+				return
+			end
+
+			Entity.SetCFrame(entity, cframe)
+		end
+
+		add(partToUse:GetPropertyChangedSignal("CFrame"):Connect(CFrameChanged))
+	end
+	const add2, clear2 = Bin()
+	add2(Entity.GetEvent(entity, "ModelChanged"):Connect(function()
+		clear()
+		HandleModel(entity)
+	end))
+	add2(Entity.GetEvent(entity, "LockChanged"):Connect(function()
+		clear()
+		HandleModel(entity)
+	end))
+	local destroyEvent
+	const event = Entity.GetEvent(entity, "NetworkOwnerChanged"):Once(function()
+		clear()
+		clear2()
+		destroyEvent:Disconnect()
+	end)
+
+	destroyEvent = Entity.GetEvent(entity, "Destroying"):Once(function()
+		clear()
+		clear2()
+		event:Disconnect()
+	end)
+
+	HandleModel(entity)
+end
+
+const function HandleCFrameSetters()
+	const mode: "NONE" | "PLAYER_ENTITIES" | "PLAYER_CHARACTERS" = Config._GetConfig("REPLICATE_CFRAME_SETTERS")
+	if mode == "NONE" then
+		return
+	end
+	if mode == "PLAYER_ENTITIES" then
+		Events.PlayerOwnedAdded:Connect(HandleEntity, true)
+	else
+		Events.PlayerCharacterRegistered:Connect(HandleEntity, true)
+	end
+
+	for _, entity in Holder.idMap do
+		if mode == "PLAYER_ENTITIES" and entity.networkOwner then
+			HandleEntity(entity.networkOwner, entity)
+		elseif mode == "PLAYER_CHARACTERS" and entity._player then
+			HandleEntity(entity._player, entity)
+		end
+	end
+end
+
+const function PlayerAdded(plr: Player)
+	const raws = _Receiver._GetClientClockRaws()
+	ClientClockRelayRemote:FireAllClients(raws)
+end
+
+Config._WaitForLock(function()
+	if not RunService:IsServer() then
+		return
+	end
+	HandleCFrameSetters()
+	Events._Signals.PlayerLoaded.Event:Connect(PlayerAdded)
+	RunService.PostSimulation:Connect(Update)
+end)
+
+return nil