cluaupp 1.0.0 → 1.4.0

package/runtime/Chrono/Shared/Signal.luau

@@ -1,219 +0,0 @@
---!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/Shared/Snapshots.luau

@@ -1,218 +0,0 @@
---!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/Shared/Stats.luau

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