cluaupp 0.1.0

package/runtime/Chrono/_impl/Shared/Signal.luau

@@ -0,0 +1,219 @@
+--!nocheck
+--------------------------------------------------------------------------------
+--               Batched Yield-Safe Signal Implementation                     --
+-- This is a Signal class which has effectively identical behavior to a       --
+-- normal RBXScriptSignal, with the only difference being a couple extra      --
+-- stack frames at the bottom of the stack trace when an error is thrown.     --
+-- This implementation caches runner coroutines, so the ability to yield in   --
+-- the signal handlers comes at minimal extra cost over a naive signal        --
+-- implementation that either always or never spawns a thread.                --
+--                                                                            --
+-- API:                                                                       --
+--   local Signal = require(THIS MODULE)                                      --
+--   local sig = Signal.new()                                                 --
+--   local connection = sig:Connect(function(arg1, arg2, ...) ... end)        --
+--   sig:Fire(arg1, arg2, ...)                                                --
+--   connection:Disconnect()                                                  --
+--   sig:DisconnectAll()                                                      --
+--   local arg1, arg2, ... = sig:Wait()                                       --
+--                                                                            --
+-- Licence:                                                                   --
+--   Licenced under the MIT licence.                                          --
+--                                                                            --
+-- Authors:                                                                   --
+--   stravant - July 31st, 2021 - Created the file.                           --
+--------------------------------------------------------------------------------
+
+export type Signal<fx, T...> = {
+	Fire: (self: any, T...) -> (),
+	DisconnectAll: (self: any) -> (),
+	Event: Event<fx, T...>,
+}
+
+export type Connection = {
+	Disconnect: (self: any) -> (),
+	Connected: boolean,
+}
+
+export type Event<fx, T...> = {
+	Connect: (self: any, FN: fx) -> Connection,
+	Once: (self: any, FN: fx) -> Connection,
+	Wait: (self: any) -> T...,
+}
+
+-- The currently idle thread to run the next handler on
+local freeRunnerThread = nil
+
+-- Function which acquires the currently idle handler runner thread, runs the
+-- function fn on it, and then releases the thread, returning it to being the
+-- currently idle one.
+-- If there was a currently idle runner thread already, that's okay, that old
+-- one will just get thrown and eventually GCed.
+const function acquireRunnerThreadAndCallEventHandler(fn, ...)
+	const acquiredRunnerThread = freeRunnerThread
+	freeRunnerThread = nil
+	fn(...)
+	-- The handler finished running, this runner thread is free again.
+	freeRunnerThread = acquiredRunnerThread
+end
+
+-- Coroutine runner that we create coroutines of. The coroutine can be
+-- repeatedly resumed with functions to run followed by the argument to run
+-- them with.
+const function runEventHandlerInFreeThread()
+	-- Note: We cannot use the initial set of arguments passed to
+	-- runEventHandlerInFreeThread for a call to the handler, because those
+	-- arguments would stay on the stack for the duration of the thread's
+	-- existence, temporarily leaking references. Without access to raw bytecode
+	-- there's no way for us to clear the "..." references from the stack.
+	while true do
+		acquireRunnerThreadAndCallEventHandler(coroutine.yield())
+	end
+end
+
+-- Connection class
+const Connection = {}
+Connection.__index = Connection
+
+function Connection.new(signal, fn, defer)
+	return setmetatable({
+		_type_ = "Connection",
+		Connected = true,
+		_signal = signal,
+		_fn = fn,
+		_next = false,
+		_defer = defer or false,
+		_binCleanup = Connection.Disconnect,
+	}, Connection)
+end
+
+function Connection:Disconnect()
+	self.Connected = false
+
+	-- Unhook the node, but DON'T clear it. That way any fire calls that are
+	-- currently sitting on this node will be able to iterate forwards off of
+	-- it, but any subsequent fire calls will not hit it, and it will be GCed
+	-- when no more fire calls are sitting on it.
+	if self._signal._handlerListHead == self then
+		self._signal._handlerListHead = self._next
+	else
+		local prev = self._signal._handlerListHead
+		while prev and prev._next ~= self do
+			prev = prev._next
+		end
+		if prev then
+			prev._next = self._next
+		end
+	end
+end
+
+-- Make Connection strict
+setmetatable(Connection, {
+	__index = function(tb, key)
+		error(("Attempt to get Connection::%s (not a valid member)"):format(tostring(key)), 2)
+	end,
+	__newindex = function(tb, key, value)
+		error(("Attempt to set Connection::%s (not a valid member)"):format(tostring(key)), 2)
+	end,
+})
+
+const Event = {}
+Event.__index = Event
+
+function Event.new()
+	return setmetatable({
+		_type_ = "Event",
+		_handlerListHead = false,
+	}, Event)
+end
+
+function Event:Connect(fn, defer)
+	const connection = Connection.new(self, fn, defer)
+	if self._handlerListHead then
+		connection._next = self._handlerListHead
+		self._handlerListHead = connection
+	else
+		self._handlerListHead = connection
+	end
+	return connection
+end
+
+-- Implement Signal:Wait() in terms of a temporary connection using
+-- a Signal:Connect() which disconnects itself.
+function Event:Wait(defer)
+	const waitingCoroutine = coroutine.running()
+	local cn
+	cn = self:Connect(function(...)
+		cn:Disconnect()
+		task.spawn(waitingCoroutine, ...)
+	end, defer)
+	return coroutine.yield()
+end
+
+-- Implement Signal:Once() in terms of a connection which disconnects
+-- itself before running the handler.
+function Event:Once(fn, defer)
+	local cn
+	cn = self:Connect(function(...)
+		if cn.Connected then
+			cn:Disconnect()
+		end
+		fn(...)
+	end, defer)
+	return cn
+end
+
+-- Signal class
+const Signal = {}
+Signal.__index = Signal
+
+function Signal.new()
+	return setmetatable({
+		_type_ = "Signal",
+		Event = Event.new(),
+		_binCleanup = Signal.DisconnectAll,
+	}, Signal)
+end
+
+-- Disconnect all handlers. Since we use a linked list it suffices to clear the
+-- reference to the head handler.
+function Signal:DisconnectAll()
+	self.Event._handlerListHead = false
+end
+
+-- Signal:Fire(...) implemented by running the handler functions on the
+-- coRunnerThread, and any time the resulting thread yielded without returning
+-- to us, that means that it yielded to the Roblox scheduler and has been taken
+-- over by Roblox scheduling, meaning we have to make a new coroutine runner.
+function Signal:Fire(...)
+	local item = self.Event._handlerListHead
+	debug.profilebegin("Signal.Fire")
+	while item do
+		if item.Connected then
+			if item._defer then
+				task.defer(item._fn, ...)
+			else
+				if not freeRunnerThread then
+					freeRunnerThread = coroutine.create(runEventHandlerInFreeThread)
+					-- Get the freeRunnerThread to the first yield
+					coroutine.resume(freeRunnerThread)
+				end
+				task.spawn(freeRunnerThread, item._fn, ...)
+			end
+		end
+		item = item._next
+	end
+	debug.profileend()
+end
+
+-- Make signal strict
+setmetatable(Signal, {
+	__index = function(tb, key)
+		error(("Attempt to get Signal::%s (not a valid member)"):format(tostring(key)), 2)
+	end,
+	__newindex = function(tb, key, value)
+		error(("Attempt to set Signal::%s (not a valid member)"):format(tostring(key)), 2)
+	end,
+})
+
+return Signal

package/runtime/Chrono/_impl/Shared/Snapshots.luau

@@ -0,0 +1,218 @@
+--!native
+
+const Types = require(script.Parent.Types)
+
+type SnapshotData<Value, Velocity> = Types.SnapshotData<Value, Velocity>
+
+type Snapshot<Value, Velocity> = Types.Snapshot<Value, Velocity>
+
+const Config = require(script.Parent.Config)
+const Warn = require(script.Parent.Warn)
+
+local MAX_LENGTH
+
+Config._WaitForLock(function()
+	MAX_LENGTH = Config._GetConfig("MAX_SNAPSHOT_COUNT")
+end)
+
+const function GetBufferIndex(head: number, relativeIndex: number): number
+	return (head + relativeIndex - 2) % MAX_LENGTH + 1
+end
+
+const function BinarySearchInsertionPoint<Value, Velocity>(self: Snapshot<Value, Velocity>, timeStamp: number): number
+	const count = self.count
+	if count == 0 then
+		return 1
+	end
+
+	local left = 1
+	local right = count
+	const cache = self.cache
+	const head = self.head
+
+	while left <= right do
+		const mid = (left + right) // 2
+		const bufferIndex = GetBufferIndex(head, mid)
+		const midTime = cache[bufferIndex].t
+
+		if midTime < timeStamp then
+			left = mid + 1
+		else
+			right = mid - 1
+		end
+	end
+
+	return left
+end
+
+const function ShiftElementsRight<Value, Velocity>(self: Snapshot<Value, Velocity>, startPos: number, endPos: number)
+	const cache = self.cache
+	const head = self.head
+
+	for i = endPos, startPos, -1 do
+		const fromIndex = GetBufferIndex(head, i)
+		const toIndex = GetBufferIndex(head, i + 1)
+		cache[toIndex] = cache[fromIndex]
+	end
+end
+
+const function GetLatest<Value, Velocity>(self: Snapshot<Value, Velocity>): SnapshotData<Value, Velocity>?
+	if self.count == 0 then
+		return nil
+	end
+
+	const lastIndex = GetBufferIndex(self.head, self.count)
+	return self.cache[lastIndex]
+end
+
+const function Push<Value, Velocity>(self: Snapshot<Value, Velocity>, timeStamp: number, value: Value, velocity: Velocity)
+	const newData = { t = timeStamp, value = value, velocity = velocity }
+
+	if self.count == 0 then
+		self.cache[self.head] = newData
+		self.count = 1
+		return
+	end
+
+	const insertionPos = BinarySearchInsertionPoint(self, timeStamp)
+
+	if insertionPos > self.count then
+		if self.count < MAX_LENGTH then
+			const newIndex = GetBufferIndex(self.head, self.count + 1)
+			self.cache[newIndex] = newData
+			self.count += 1
+		else
+			const newIndex = self.head
+			self.cache[newIndex] = newData
+			self.head = self.head % MAX_LENGTH + 1
+		end
+	else
+		if self.count < MAX_LENGTH then
+			ShiftElementsRight(self, insertionPos, self.count)
+			const insertIndex = GetBufferIndex(self.head, insertionPos)
+			self.cache[insertIndex] = newData
+			self.count += 1
+		else
+			for i = 1, insertionPos - 1 do
+				const fromIndex = GetBufferIndex(self.head, i + 1)
+				const toIndex = GetBufferIndex(self.head, i)
+				self.cache[toIndex] = self.cache[fromIndex]
+			end
+			const insertIndex = GetBufferIndex(self.head, insertionPos)
+			self.cache[insertIndex] = newData
+		end
+	end
+end
+
+const function PushWithCheck<Value, Velocity>(
+	self: Snapshot<Value, Velocity>,
+	timeStamp: number,
+	value: Value,
+	velocity: Velocity,
+	tickrate: number
+)
+	const latestData = GetLatest(self)
+	if latestData and timeStamp - latestData.t > tickrate * 3 and Config.FLAGS.SNAPSHOT_INTERPOLATION_FIX then
+		Push(self, timeStamp - tickrate, latestData.value, vector.zero, true)
+	end
+	Push(self, timeStamp, value, velocity)
+end
+
+const function GetAt<Value, Velocity>(self: Snapshot<Value, Velocity>, at: number, bypassLock: boolean?): Value?
+	const count = self.count
+	if count == 0 then
+		return nil
+	end
+
+	if count == 1 then
+		const index = GetBufferIndex(self.head, 1)
+		return self.cache[index].value
+	end
+
+	if at < 0 then
+		const latest = GetLatest(self)
+		return latest and latest.value or nil
+	end
+
+	const cache = self.cache
+	const head = self.head
+	const lerpFunction = self.Lerp
+	const lockedTime = self.lockedTime
+
+	if at < lockedTime and not bypassLock then
+		at = lockedTime
+	end
+
+	const insertionPos = BinarySearchInsertionPoint(self, at)
+
+	const beforePos = insertionPos - 1
+	const afterPos = insertionPos
+
+	local beforeData: SnapshotData<Value, Velocity>?
+	local afterData: SnapshotData<Value, Velocity>?
+
+	if beforePos >= 1 and beforePos <= count then
+		const beforeIndex = GetBufferIndex(head, beforePos)
+		beforeData = cache[beforeIndex]
+	end
+
+	if afterPos >= 1 and afterPos <= count then
+		const afterIndex = GetBufferIndex(head, afterPos)
+		afterData = cache[afterIndex]
+	end
+
+	if beforeData and afterData then
+		const dt = afterData.t - beforeData.t
+		if dt == 0 then
+			return beforeData.value
+		end
+		const alpha = (at - beforeData.t) / dt
+
+		const p0, p1 = (beforeData.value :: any).Position, (afterData.value :: any).Position
+		const v0, v1 = beforeData.velocity, afterData.velocity
+
+		const position = lerpFunction(p0, p1, v0, v1, alpha, dt)
+		const cf = (beforeData.value :: any):Lerp(afterData.value, alpha)
+
+		return CFrame.new(position) * cf.Rotation
+	elseif beforeData then
+		Warn.low("Tried to fetch a time that was ahead of snapshot storage!")
+		return beforeData.value
+	elseif afterData then
+		Warn.low("Tried to fetch a time that was behind snapshot storage!")
+		return afterData.value
+	end
+
+	return nil
+end
+
+const function Clear<Value, Velocity>(self: Snapshot<Value, Velocity>)
+	self.head = 1
+	self.count = 0
+	self.lockedTime = 0
+end
+
+const function New<Value, Velocity>(
+	lerpFunction: (Vector3, Vector3, Velocity, Velocity, number, number) -> Vector3
+): Snapshot<Value, Velocity>
+	const cache = table.create(MAX_LENGTH)
+	for i = 1, MAX_LENGTH do
+		cache[i] = { t = 0, value = (nil :: any) :: Value, velocity = (nil :: any) :: Velocity }
+	end
+
+	return {
+		cache = cache,
+		head = 1,
+		count = 0,
+		lockedTime = 0,
+		Lerp = lerpFunction,
+
+		Push = Push,
+		PushWithCheck = PushWithCheck,
+		GetLatest = GetLatest,
+		GetAt = GetAt,
+		Clear = Clear,
+	}
+end
+
+return New

package/runtime/Chrono/_impl/Shared/Stats.luau

@@ -0,0 +1,204 @@
+const Players = game:GetService("Players")
+const RunService = game:GetService("RunService")
+
+const Config = require(script.Parent.Config)
+const Entity = require(script.Parent.Entity)
+const Holder = require(script.Parent.Holder)
+const Types = require(script.Parent.Types)
+
+const ShowEntityLocations = true
+const HasDebuggerOpened = {}
+const Stats = {
+	REPLICATE_PERMISSIONS = {
+		--[123456789] = true,
+	} :: { [number]: boolean },
+
+	--// Client
+	CLIENT = {
+		_PAUSE = false,
+		TOTAL_ENTITIES_CULLED = 0,
+		ENTITIES_MOVED_THIS_FRAME = 0,
+		TOTAL_CLIENT_ENTITIES_CHECKED_THIS_FRAME = 0,
+		TOTAL_CLIENT_ENTITIES = 0,
+		AVG_INTERPOLATION_TIME_MS = 0,
+
+		BYTES_RECEIVED_PER_SEC = 0,
+		NEW_ENTITIES_PER_SEC = 0,
+		ENTITY_CHANGES_PER_SEC = 0,
+		ENTITY_REMOVALS_PER_SEC = 0,
+
+		CLIENT_ENTITIES = {} :: { [number]: Types.ClientEntitiesStats },
+	},
+	--// Server
+	SERVER = {
+		_SHOULD_REPLICATE = false,
+		AVG_TICKER_TIME_MS = 0,
+		ENTITY_GRID_UPDATE_TIME_MS = 0,
+		GRID_UPDATE_SECTIONS = 0,
+		NUMBER_OF_ENTITIES = 0,
+		NON_TICKED = 0,
+		ENTITIES_FULL_TICKED = 0,
+		ENTITIES_HALF_TICKED = 0,
+
+		REPLICATE_PLAYER_TIME_MS = 0,
+		BYTES_RECEIVED_PER_SEC = 0,
+		BYTES_SENT_PER_SEC = 0,
+		PACKETS_SENT_PER_SEC = 0,
+
+		SERVER_ENTITIES = {} :: { [number]: Types.ServerEntitiesStats },
+		GRID_STATS = {} :: { [string]: { HALF: { number }, NORMAL: { number } } },
+	},
+}
+
+const function processID(id: number, replicate)
+	script:SetAttribute(tostring(id), replicate)
+end
+
+function Stats.HasPermissionToReplicate(userId: number | Player)
+	if typeof(userId) == "Instance" and userId:IsA("Player") then
+		userId = userId.UserId
+	end
+	return script:GetAttribute(tostring(userId)) == true
+end
+
+function Stats.ReplicateStatsForPlayer(userId: number | Player)
+	if RunService:IsClient() then
+		warn("Stats.ReplicateStatsForPlayer should only be called on the server.")
+		return
+	end
+	if typeof(userId) == "Instance" and userId:IsA("Player") then
+		userId = userId.UserId
+	end
+	Stats.REPLICATE_PERMISSIONS[userId] = true
+	processID(userId, true)
+end
+
+function Stats.StopReplicatingStatsForPlayer(userId: number | Player)
+	if RunService:IsClient() then
+		warn("Stats.StopReplicatingStatsForPlayer should only be called on the server.")
+		return
+	end
+	if typeof(userId) == "Instance" and userId:IsA("Player") then
+		userId = userId.UserId
+	end
+	Stats.REPLICATE_PERMISSIONS[userId] = nil
+	processID(userId, false)
+end
+
+for i, v in Stats.REPLICATE_PERMISSIONS do
+	processID(i, v)
+end
+
+const function updateStat(type: string, name: string, value: any)
+	if name == "WARNING_SEVERITY" then
+		Config.SetWarningSeverity(value)
+	end
+	if type == "FFLAG" then
+		Config.FLAGS[name] = value
+	end
+end
+
+const StatsRemoteHeaders = {
+	REPLICATE_SERVER_STATS = "REPLICATE_SERVER_STATS",
+	UPDATE_STAT = "UPDATE_STAT",
+	DEBUGGER_OPENED = "DEBUGGER_OPENED",
+	CLIENT_STATS_ACTION = "CLIENT_STATS_ACTION",
+}
+
+if RunService:IsServer() then
+	const statsRemote = Instance.new("RemoteEvent", script)
+	statsRemote.Name = "Stats"
+
+	RunService.Heartbeat:Connect(function()
+		local should = false
+		if next(Stats.REPLICATE_PERMISSIONS) then
+			for i, v in Players:GetPlayers() do
+				if Stats.REPLICATE_PERMISSIONS[v.UserId] and HasDebuggerOpened[v.UserId] then
+					should = true
+					statsRemote:FireClient(v, StatsRemoteHeaders.REPLICATE_SERVER_STATS, Stats.SERVER)
+				end
+			end
+		end
+
+		Stats.SERVER._SHOULD_REPLICATE = should
+	end)
+
+	statsRemote.OnServerEvent:Connect(function(plr: Player, header: string, ...)
+		if header == StatsRemoteHeaders.DEBUGGER_OPENED then
+			const opened = ...
+			HasDebuggerOpened[plr.UserId] = opened
+			return
+		end
+
+		if Stats.REPLICATE_PERMISSIONS and not Stats.REPLICATE_PERMISSIONS[plr.UserId] then
+			return
+		end
+
+		if header == StatsRemoteHeaders.UPDATE_STAT then
+			const type, name, value = ...
+			updateStat(type, name, value)
+			statsRemote:FireAllClients(StatsRemoteHeaders.UPDATE_STAT, type, name, value)
+		elseif header == StatsRemoteHeaders.CLIENT_STATS_ACTION then
+			const actionType, id = ...
+			const entity = Holder.GetEntityFromId(id)
+			if not entity then
+				return
+			end
+			if actionType == "CHANGE_NATIVE" then
+				const mode = Entity.GetModelReplicationType(entity)
+				if mode == "NATIVE" then
+					Entity.LockNativeServerCFrameReplication(entity)
+				elseif mode == "NATIVE_WITH_LOCK" then
+					Entity.UnlockNativeServerCFrameReplication(entity)
+				end
+			elseif actionType == "TOGGLE_PAUSE" then
+				if entity.paused then
+					Entity.ResumeReplication(entity)
+				else
+					Entity.PauseReplication(entity)
+				end
+			elseif actionType == "CHANGE_CONFIG" then
+				const configName = select(3, ...)
+				Entity.SetConfig(entity, configName)
+			end
+		end
+	end)
+else
+	const statsRemote = script:WaitForChild("Stats") :: RemoteEvent
+
+	const function handleServerEvent(header: string, ...)
+		if header == StatsRemoteHeaders.REPLICATE_SERVER_STATS then
+			const serverStats = ...
+			if Stats.CLIENT._PAUSE then
+				return
+			end
+			for statName, value in serverStats do
+				Stats.SERVER[statName] = value
+			end
+		elseif header == StatsRemoteHeaders.UPDATE_STAT then
+			const type, name, value = ...
+			updateStat(type, name, value)
+		end
+	end
+
+	statsRemote.OnClientEvent:Connect(handleServerEvent)
+
+	Stats._openedDebugger = function()
+		Stats.SERVER._SHOULD_REPLICATE = true
+		statsRemote:FireServer(StatsRemoteHeaders.DEBUGGER_OPENED, true)
+	end
+	Stats._closedDebugger = function()
+		Stats.SERVER._SHOULD_REPLICATE = false
+		statsRemote:FireServer(StatsRemoteHeaders.DEBUGGER_OPENED, false)
+	end
+
+	Stats._updateStat = function(type: string, name: string, value: any)
+		statsRemote:FireServer(StatsRemoteHeaders.UPDATE_STAT, type, name, value)
+	end
+
+	Stats._fireClientStatsEvent = function(...)
+		statsRemote:FireServer(StatsRemoteHeaders.CLIENT_STATS_ACTION, ...)
+	end
+end
+
+return Stats