cluaupp 0.1.0

package/runtime/Chrono/Server/Sender.luau

@@ -0,0 +1,306 @@
+const RunService = game:GetService("RunService")
+
+const Ticker = require(script.Parent.Parent.Shared.Ticker)
+const Entity = require(script.Parent.Parent.Shared.Entity)
+const EntityGrid = require(script.Parent.EntityGrid)
+const Types = require(script.Parent.Parent.Shared.Types)
+const Shared = script.Parent.Parent.Shared
+const ModelHelper = require(Shared.ModelHelper)
+const ClockUnwrap = require(Shared.ClockUnwrap)
+const Stats = require(Shared.Stats).SERVER
+
+const FULL_BYTES = 4 * 3 + 2 * 3 + 2
+const YAW_BYTES = 4 * 3 + 2 + 2
+const MAX_BUFFER_SIZE = 900
+
+local BytesSentPerSec = 0
+local PacketsSentPerSec = 0
+
+const BUFFER = buffer.create(MAX_BUFFER_SIZE + 51)
+
+type BufferHolder = { [Types.Ticker]: { buffer } }
+const UnreliableEvent = Shared.Remotes.Replicate
+const ReliableEvent = Shared.Remotes.ReplicateFull
+
+const function WriteTickerHeader(b: buffer, index: number, ticker: Types.Ticker, isHalf: boolean?): number
+	const lastTicked = ticker.lastTicked
+	const sendFull = ticker.config.FULL_ROTATION
+
+	buffer.writeu32(b, index, ClockUnwrap.quantize(lastTicked)) -- changed to u32 fixed-point precision
+	index += 4
+
+	local packed = if isHalf then 1 else 0
+	if sendFull then
+		packed += 2
+	end
+
+	buffer.writeu8(b, index, packed)
+	index += 1
+
+	return index
+end
+
+const function Flush(player, index: number, id)
+	const copy = buffer.create(index)
+	buffer.copy(copy, 0, BUFFER, 0, index)
+
+	UnreliableEvent:FireClient(player, id, copy)
+	BytesSentPerSec += index
+	PacketsSentPerSec += 1
+end
+
+const function FlushClientOwned(player, buffersT: { [number]: { buffer } })
+	local index = 0
+
+	for time, buffers in buffersT do
+		const quantized = ClockUnwrap.quantize(time)
+		buffer.writeu32(BUFFER, index, quantized)
+		index += 4
+		local indexToWriteLength = index
+		index += 1
+
+		local length = 0
+		for _, buf in buffers do
+			const sizeOffset = buffer.len(buf)
+
+			if index + sizeOffset > MAX_BUFFER_SIZE then
+				buffer.writeu8(BUFFER, indexToWriteLength, length)
+				Flush(player, index, "O")
+				index = 0
+				buffer.writeu32(BUFFER, index, quantized)
+				index += 4
+				indexToWriteLength = index
+				index += 1
+				length = 0
+			end
+
+			buffer.copy(BUFFER, index, buf, 0, sizeOffset)
+			length += 1
+			index += sizeOffset
+		end
+
+		buffer.writeu8(BUFFER, indexToWriteLength, length)
+	end
+
+	if index > 0 then
+		Flush(player, index, "O")
+	end
+end
+
+const function FlushEntities(player, buffers: BufferHolder, isHalf: boolean?)
+	local index = 0
+	const BUFFER = BUFFER
+	for ticker, bufferT in buffers do
+		const sizeOffset = ticker.config.FULL_ROTATION and FULL_BYTES or YAW_BYTES
+		index = WriteTickerHeader(BUFFER, index, ticker, isHalf)
+		local indexToWriteLength = index
+		index += 1
+
+		local length = 0
+		for _, buf in bufferT do
+			if index + sizeOffset > MAX_BUFFER_SIZE then
+				buffer.writeu8(BUFFER, indexToWriteLength, length)
+				Flush(player, index, "X")
+				index = WriteTickerHeader(BUFFER, 0, ticker, isHalf)
+				indexToWriteLength = index
+				index += 1
+				length = 0
+			end
+
+			length += 1
+			buffer.copy(BUFFER, index, buf, 0, sizeOffset)
+			index += sizeOffset
+		end
+
+		buffer.writeu8(BUFFER, indexToWriteLength, length)
+	end
+
+	if index > 0 then
+		Flush(player, index, "X")
+	end
+end
+
+--//honestly tables should beeeee fine for nowww, could buffer it later if reallllly needed
+const function GetEntityFullData(player: Player, entity: Types.Entity): Types.EntityReceivePacket?
+	if entity.destroyed then
+		return nil
+	end
+	const modelData, metaData = ModelHelper.ReadyModelFromRep(entity, player)
+
+	local configName: string? = entity.entityConfig.NAME
+	if configName == "DEFAULT" then
+		configName = nil
+	end
+
+	local cframe = entity.latestCFrame or CFrame.identity
+	local time = entity.lastClientClock or 0
+
+	if entity.isContextOwner then
+		const primaryPart = Entity.GetPrimaryPart(entity)
+		if primaryPart then
+			cframe = primaryPart.CFrame
+		end
+
+		time = os.clock()
+	end
+
+	return {
+		id = entity.id,
+		_player = entity._player,
+		networkOwner = entity.networkOwner,
+		cframe = cframe,
+		time = time,
+		config = configName,
+
+		model = modelData,
+		_modelMetaData = metaData,
+
+		paused = entity.paused,
+		isHalfTicked = entity.isHalfTicked,
+		_data = entity._data,
+		_lockedCFReplication = entity._lockedCFReplication,
+
+		mountParentId = entity.mountParentId,
+		mountOffset = entity.mountOffset,
+		broadPhase = entity.broadPhase :: any,
+	}
+end
+
+local playerReplicateTotal = 0
+local playerReplicateCount = 0
+const function ReplicatePlayer(player: Player)
+	const holder = EntityGrid.GetEntityHolder(player)
+	if not holder then
+		return
+	end
+	debug.profilebegin("ReplicatePlayer")
+	const replicatedOLD = holder.REPLICATED -- Leftovers will be removed
+	const replicated = table.clone(replicatedOLD)
+	holder.REPLICATED = replicated
+
+	const holderEntityAdded = holder.EntityAdded
+	const holderEntityRemoving = holder.EntityRemoving
+	const normal = holder.NORMAL
+	const half = holder.HALF
+
+	const toSendFull = {}
+	const toRemove = {}
+	const clientOwned = {}
+	const entityChanges = {}
+
+	const normalBuffers: BufferHolder = {}
+	const halfBuffers: BufferHolder = {}
+	const frameTimeNow = Ticker.GetGlobalTick()
+
+	const function HandleClientEntities(entity: Types.Entity)
+		if entity.arriveFrame ~= frameTimeNow then -- (time will be the same during the same frame)
+			return
+		end
+		if entity.networkOwner == player then
+			return
+		end
+		const clientTime = entity.lastClientClock or 0
+		if not clientOwned[clientTime] then
+			clientOwned[clientTime] = {}
+		end
+
+		table.insert(clientOwned[clientTime], entity.cframeBuffer :: buffer)
+	end
+
+	const function Handle(entity: Types.Entity, isNormal: boolean)
+		if entity.destroyed then
+			return
+		end
+		replicated[entity] = true
+		if not replicatedOLD[entity] then
+			holderEntityAdded:Fire(entity)
+			table.insert(toSendFull, GetEntityFullData(player, entity))
+			return
+		end
+		if entity._changes then
+			table.insert(entityChanges, entity._changes)
+		end
+		replicatedOLD[entity] = nil
+		if entity.paused then
+			return
+		end
+
+		const isServerOwned = entity.isContextOwner
+		if not isServerOwned then
+			HandleClientEntities(entity)
+			return
+		end
+
+		const ticker = entity._ticker
+		if not (ticker and ticker.tickedFrame == frameTimeNow and entity.cframeBuffer) then
+			return
+		end
+
+		const isHalf = entity.isHalfTicked or not isNormal
+
+		if isHalf and not ticker.tickedHalf then
+			return
+		end
+
+		const buffers = if isHalf then halfBuffers else normalBuffers
+		local bufferTable = buffers[ticker]
+		if not bufferTable then
+			bufferTable = {}
+			buffers[ticker] = bufferTable
+		end
+		table.insert(bufferTable, entity.cframeBuffer)
+	end
+	const startTime = os.clock()
+	for _, entity in normal do
+		Handle(entity, true)
+	end
+	for _, entity in half do
+		Handle(entity, false)
+	end
+
+	for entity, _ in replicatedOLD do
+		replicated[entity] = nil
+		holderEntityRemoving:Fire(entity)
+		table.insert(toRemove, entity._lastId or entity.id)
+	end
+
+	FlushClientOwned(player, clientOwned)
+	FlushEntities(player, normalBuffers)
+	FlushEntities(player, halfBuffers, true)
+
+	if #toRemove > 0 or #toSendFull > 0 or #entityChanges > 0 then
+		-- print(
+		-- 	"Sending reliable packet to",
+		-- 	player.Name,
+		-- 	"toSendFull:",
+		-- 	#toSendFull,
+		-- 	"toRemove:",
+		-- 	#toRemove,
+		-- 	"entityChanges:",
+		-- 	#entityChanges
+		-- )
+		ReliableEvent:FireClient(player, toSendFull, toRemove, entityChanges)
+	end
+	debug.profileend()
+	const endTime = os.clock()
+	playerReplicateTotal += endTime - startTime
+	playerReplicateCount += 1
+end
+
+local lastStatTime = os.clock()
+RunService.Heartbeat:Connect(function()
+	Stats.REPLICATE_PLAYER_TIME_MS = playerReplicateTotal / math.max(playerReplicateCount, 1) * 1000
+	if os.clock() - lastStatTime > 1 then
+		Stats.BYTES_SENT_PER_SEC = BytesSentPerSec
+		Stats.PACKETS_SENT_PER_SEC = PacketsSentPerSec
+		BytesSentPerSec = 0
+		PacketsSentPerSec = 0
+		lastStatTime = os.clock()
+		playerReplicateTotal = 0
+		playerReplicateCount = 0
+	end
+end)
+
+return {
+	ReplicatePlayer = ReplicatePlayer,
+}

package/runtime/Chrono/Server/ServerClock.luau

@@ -0,0 +1,50 @@
+const Players = game:GetService("Players")
+const ServerClockData = {} :: { [Player]: {
+	clockOffset: number,
+	oneWayDelay: number,
+} }
+
+const function Store(player: Player, clientClockTime: number, clientServerTimeNow: number?)
+	local data = ServerClockData[player]
+	if not data then
+		data = { clockOffset = 0, oneWayDelay = 0.05 }
+		ServerClockData[player] = data
+	end
+
+	if clientServerTimeNow then
+		const latency = workspace:GetServerTimeNow() - clientServerTimeNow
+		if latency > 0 and latency <= player:GetNetworkPing() + 0.05 then
+			data.oneWayDelay = latency
+		end
+	end
+
+	const ping = math.max(player:GetNetworkPing(), 0) + 0.05 -- network ping was 0 for some reason
+	const measuredClockOffset = os.clock() - clientClockTime - math.clamp(data.oneWayDelay, 0, ping)
+
+	data.clockOffset = data.clockOffset + 0.2 * (measuredClockOffset - data.clockOffset)
+end
+
+const function ConvertTo(player: Player, clock: number, environment: "Server" | "Client")
+	const data = ServerClockData[player]
+	if not data then
+		return clock
+	end
+
+	if environment == "Server" then
+		return clock + data.clockOffset
+	else
+		return clock - data.clockOffset
+	end
+end
+
+const function Remove(player: Player)
+	ServerClockData[player] = nil
+end
+
+Players.PlayerRemoving:Connect(Remove)
+
+return {
+	Store = Store,
+	ConvertTo = ConvertTo,
+	Remove = Remove,
+}

package/runtime/Chrono/Shared/ApplyMounts.luau

@@ -0,0 +1,137 @@
+--!native
+
+const Entity = require(script.Parent.Entity)
+const Events = require(script.Parent.Events)
+const Holder = require(script.Parent.Holder)
+const Types = require(script.Parent.Types)
+
+local timestamp = 0
+const visited = {} :: { [Types.Entity]: number }
+const dp = {} :: { [Types.Entity]: number }
+const world = {} :: { [Types.Entity]: CFrame }
+
+const path = {} :: { Types.Entity }
+const mountedEntities = {} :: { [Types.Entity]: true }
+
+const function SetCFrame(entity: Types.Entity, cframe: CFrame)
+	const root = Entity._GetRootPart(entity)
+	if root then
+		root.CFrame = cframe
+		if entity.isContextOwner then
+			root.AssemblyAngularVelocity = Vector3.zero
+			root.AssemblyLinearVelocity = Vector3.zero
+		end
+	end
+end
+const function ResolveWorldCFrame(entity: Types.Entity): CFrame
+	const currentTime = timestamp
+	if dp[entity] == currentTime then
+		return world[entity]
+	end
+
+	local n = 0
+	local current = entity
+	local rootCFrame = CFrame.identity
+
+	while true do
+		if dp[current] == currentTime then
+			rootCFrame = world[current]
+			break
+		end
+
+		if visited[current] == currentTime then
+			--cycle detected
+			rootCFrame = Entity.GetAt(current, Entity.GetTargetRenderTime(current))
+				or current.latestCFrame
+				or CFrame.identity
+			dp[current] = currentTime
+			world[current] = rootCFrame
+			SetCFrame(current, rootCFrame)
+			break
+		end
+
+		visited[current] = currentTime
+
+		const parentId = current.mountParentId
+		if not parentId then
+			if current.isContextOwner then
+				const part = Entity.GetPrimaryPart(current)
+				rootCFrame = if part then part.CFrame else (current.latestCFrame or CFrame.identity)
+			else
+				rootCFrame = Entity.GetAt(current, Entity.GetTargetRenderTime(current))
+					or current.latestCFrame
+					or CFrame.identity
+			end
+			dp[current] = currentTime
+			world[current] = rootCFrame
+			break
+		end
+
+		const parent = Holder.GetEntityFromId(parentId)
+		if not parent or parent.destroyed then
+			rootCFrame = Entity.GetAt(current, Entity.GetTargetRenderTime(current))
+				or current.latestCFrame
+				or CFrame.identity
+			dp[current] = currentTime
+			world[current] = rootCFrame
+			SetCFrame(current, rootCFrame)
+			break
+		end
+
+		n += 1
+		path[n] = current
+		current = parent
+	end
+
+	local out = rootCFrame or CFrame.identity
+	for i = n, 1, -1 do
+		const child = path[i]
+		out = out * (child.mountOffset or CFrame.identity)
+		dp[child] = currentTime
+		world[child] = out
+		SetCFrame(child, out)
+		path[i] = nil
+	end
+
+	if dp[entity] ~= currentTime then
+		dp[entity] = currentTime
+		world[entity] = out
+		SetCFrame(entity, out)
+	end
+
+	return world[entity]
+end
+
+Events.EntityAdded:Connect(function(entity: Types.Entity)
+	if entity.mountParentId then
+		mountedEntities[entity] = true
+	end
+end, true)
+
+Events.EntityMountChanged:Connect(function(entity: Types.Entity, mountParentId: number?)
+	if mountParentId then
+		mountedEntities[entity] = true
+	else
+		mountedEntities[entity] = nil
+	end
+end, true)
+
+Events.EntityRemoved:Connect(function(entity: Types.Entity)
+	dp[entity] = nil
+	world[entity] = nil
+	mountedEntities[entity] = nil
+end, true)
+
+const function ApplyMounts()
+	debug.profilebegin("ApplyMounts")
+	for entity in mountedEntities do
+		if entity.destroyed or dp[entity] == timestamp then
+			continue
+		end
+		ResolveWorldCFrame(entity)
+	end
+	timestamp += 1
+	debug.profileend()
+end
+
+return ApplyMounts

package/runtime/Chrono/Shared/Bin.luau

@@ -0,0 +1,31 @@
+type BinItem = Instance | RBXScriptConnection | thread | () -> ...any | { _binCleanup: (...any) -> () }
+
+export type Add = <T>(Item: T & BinItem) -> T
+export type Clear = () -> ()
+
+return function(): (Add, Clear)
+	const Bin: { BinItem } = {}
+
+	return function<T>(Item: T & BinItem)
+		table.insert(Bin, Item :: any)
+
+		return Item
+	end :: any,
+		function()
+			for _, Item in Bin do
+				if typeof(Item) == "Instance" then
+					Item:Destroy()
+				elseif typeof(Item) == "RBXScriptConnection" then
+					Item:Disconnect()
+				elseif typeof(Item) == "function" then
+					task.spawn(Item)
+				elseif typeof(Item) == "thread" then
+					pcall(task.cancel, Item) -- must pcall or could error when passing its own thread in
+				elseif typeof(Item) == "table" and Item._binCleanup and type(Item._binCleanup) == "function" then
+					Item:_binCleanup()
+				end
+			end
+
+			table.clear(Bin)
+		end
+end

package/runtime/Chrono/Shared/ClockUnwrap.luau

@@ -0,0 +1,70 @@
+--!native
+
+const CLOCK_SCALE = 10000
+const TWO32 = 2 ^ 32
+const TWO31 = 2 ^ 31
+const CLOCK_WRAP = TWO32 / CLOCK_SCALE
+
+export type State = { lastRaw: number?, offset: number }
+export type Store = { [any]: State }
+
+const ClockUnwrap = {}
+ClockUnwrap.SCALE = CLOCK_SCALE
+ClockUnwrap.WRAP = CLOCK_WRAP
+
+function ClockUnwrap.quantize(seconds: number): number
+	return math.floor(seconds * CLOCK_SCALE) % TWO32
+end
+
+function ClockUnwrap.new(): State
+	return { lastRaw = nil, offset = 0 }
+end
+
+-- for u32
+function ClockUnwrap.unwrap(state: State, raw: number): number
+	raw %= TWO32
+	const lastRaw = state.lastRaw
+	if lastRaw then
+		const diff = (raw - lastRaw) % TWO32
+		if diff < TWO31 then
+			if raw < lastRaw then
+				state.offset += CLOCK_WRAP
+			end
+			state.lastRaw = raw
+		else
+			return (lastRaw + state.offset * CLOCK_SCALE - (TWO32 - diff)) / CLOCK_SCALE
+		end
+	else
+		state.lastRaw = raw
+	end
+	return raw / CLOCK_SCALE + state.offset
+end
+
+function ClockUnwrap.unwrapFor(store: Store, key: any, raw: number): number
+	local state = store[key]
+	if not state then
+		state = ClockUnwrap.new()
+		store[key] = state
+	end
+	return ClockUnwrap.unwrap(state, raw)
+end
+
+-- for f64 syncing
+function ClockUnwrap.seatFull(state: State, seconds: number): number
+	const scaled = math.floor(seconds * CLOCK_SCALE)
+	const raw = scaled % TWO32
+	state.lastRaw = raw
+	state.offset = (scaled - raw) / CLOCK_SCALE
+	return scaled / CLOCK_SCALE
+end
+
+function ClockUnwrap.seatFullFor(store: Store, key: any, seconds: number): number
+	local state = store[key]
+	if not state then
+		state = ClockUnwrap.new()
+		store[key] = state
+	end
+	return ClockUnwrap.seatFull(state, seconds)
+end
+
+return ClockUnwrap