cluaupp 1.0.0 → 1.4.0

package/runtime/Chrono/Server/Sender.luau

@@ -1,306 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,137 +0,0 @@
---!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

@@ -1,31 +0,0 @@
-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

@@ -1,70 +0,0 @@
---!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