cluaupp 0.1.0

package/runtime/Chrono/_impl/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/_impl/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/_impl/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/_impl/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

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

@@ -0,0 +1,264 @@
+const Types = require(script.Parent.Types)
+
+const IS_SERVER = game:GetService("RunService"):IsServer()
+const CHRONO_PRIMARY = "__CHRONO_PRIMARY"
+
+export type WarningLevels = "NONE" | "LOW" | "MEDIUM" | "HIGH"
+
+export type Configs =
+	"MIN_BUFFER"
+	| "MAX_BUFFER"
+	| "MAX_SNAPSHOT_COUNT"
+	| "CHECK_NEW_VERSION"
+	| "DEFAULT_NORMAL_TICK_DISTANCE"
+	| "DEFAULT_HALF_TICK_DISTANCE"
+	| "DEFAULT_MODEL_REPLICATION_MODE"
+	| "PLAYER_REPLICATION"
+	| "REPLICATE_DEATHS"
+	| "REPLICATE_CFRAME_SETTERS"
+	| "__VERSION"
+	| "MAX_TOTAL_BYTES_PER_FRAME_PER_PLAYER"
+	| "WARNING_SEVERITY"
+	| "GRID_UPDATE_INTERVAL"
+	| "GRID_MAX_UPDATE_TIME"
+
+export type SetConfig =
+	("MIN_BUFFER", number) -> ()
+	& ("MAX_BUFFER", number) -> ()
+	& ("DEFAULT_NORMAL_TICK_DISTANCE", number) -> ()
+	& ("DEFAULT_HALF_TICK_DISTANCE", number) -> ()
+	& ("MAX_SNAPSHOT_COUNT", number) -> ()
+	& ("CHECK_NEW_VERSION", boolean) -> ()
+	& ("DEFAULT_MODEL_REPLICATION_MODE", Types.MODEL_REPLICATION_MODE) -> ()
+	& ("PLAYER_REPLICATION", "AUTOMATIC" | "CUSTOM") -> ()
+	& ("REPLICATE_DEATHS", "NONE" | "PLAYER_ENTITIES" | "PLAYER_CHARACTERS") -> ()
+	& ("REPLICATE_CFRAME_SETTERS", "NONE" | "PLAYER_ENTITIES" | "PLAYER_CHARACTERS") -> ()
+	& ("MAX_TOTAL_BYTES_PER_FRAME_PER_PLAYER", number) -> ()
+	& ("WARNING_SEVERITY", WarningLevels) -> ()
+	& ("GRID_UPDATE_INTERVAL", number) -> ()
+	& ("GRID_MAX_UPDATE_TIME", number) -> ()
+local LOCKED = false
+const BASE_CONFIG = {
+	__VERSION = "v2.1.6",
+	CHECK_NEW_VERSION = true,
+	MAX_TOTAL_BYTES_PER_FRAME_PER_PLAYER = 300, -- Base line value
+	MIN_BUFFER = 0.09,
+	MAX_BUFFER = 0.5,
+
+	GRID_UPDATE_INTERVAL = 0.1,
+	GRID_MAX_UPDATE_TIME = 0.0005,
+
+	WARNING_SEVERITY = "MEDIUM", -- "NONE", "LOW", "MEDIUM", "HIGH"
+	DEFAULT_NORMAL_TICK_DISTANCE = 50,
+	DEFAULT_HALF_TICK_DISTANCE = 100, -- Anything beyond this distance will not be replicated
+
+	REPLICATE_DEATHS = "PLAYER_CHARACTERS",
+	--[[
+		- This requires PLAYER_REPLICATION to be set to AUTOMATIC
+		-NONE = No deaths are replicated
+		-PLAYER_ENTITIES = Only deaths where player has entity ownership are replicated to players
+		-PLAYER_CHARACTERS= Only replicate deaths for player characters
+	]]
+	REPLICATE_CFRAME_SETTERS = "PLAYER_ENTITIES",
+	--[[
+		- This requires PLAYER_REPLICATION to be set to AUTOMATIC
+		-NONE = No deaths are replicated
+		-PLAYER_ENTITIES = Only deaths where player has entity ownership are replicated to players
+		-PLAYER_CHARACTERS= Only replicate deaths for player characters
+	]]
+
+	PLAYER_REPLICATION = "AUTOMATIC",
+
+	--[[
+		- Custom
+			+ More control over how replication is handled
+			- More work to set up
+		- Automatic Will automatically register player models as entities
+			+ Easy to use
+			- Less control over replication
+
+	]]
+	DEFAULT_MODEL_REPLICATION_MODE = "NATIVE",
+	--[[
+		-NATIVE = Use Roblox's built in model replication.
+			+ Easy to use
+			- More bandwidth
+		-NATIVE_WITH_LOCK = Use Roblox's built in model replication, but disable server CFrame replication.
+			+ Less bandwidth than NATIVE as roblox's cframe replication is disabled.
+			- Server side roblox physics is disabled acting as if it was anchored.
+			+ Good for characters or client owned entities as physics will be client sided
+		-CUSTOM = Client and Server have separate cloned models.
+			+ Less bandwidth
+			- Have to write custom code to replicate stuff like animations
+	]]
+	MAX_SNAPSHOT_COUNT = 30,
+}
+const ENTITY_TYPES: { [string]: Types.EntityConfig } = {
+	DEFAULT = {
+		NAME = "DEFAULT",
+		TICK_RATE = 1 / 20,
+		BUFFER = 0.1, --if buffer is 0 or nil for server side entities then it will use an dynamic buffer
+	},
+	WITH_ROT = {
+		NAME = "WITH_ROT",
+		TICK_RATE = 1 / 20,
+		BUFFER = 0.1,
+		FULL_ROTATION = true,
+	},
+	PLAYER = {
+		NAME = "PLAYER",
+		MODEL_REPLICATION_MODE = "NATIVE",
+		BUFFER = 0, -- handled dynamically for players
+		HALF_TICK_DISTANCE = math.huge, -- Keep players replicated at all distances to mimic roblox's default behavior
+		TICK_RATE = 1 / 20,
+		ASSEMBLY_ROOT_PART_CHECK = true,
+	},
+}
+const ENTITY_MODELS = {}
+const MODEL_BROAD_PHASES = {}
+
+--[=[
+	Registers an entity type configuration.
+	Can only be called before the config is locked.
+
+	@param name The name of the entity type.
+	@param config The configuration for the entity type.
+]=]
+const function RegisterEntityType(name: string, config: Types.EntityConfigInput)
+	assert(not LOCKED, "Config is locked and cannot be modified after startup.")
+	ENTITY_TYPES[name] = config :: any
+end
+
+--[=[
+	Registers an entity model. This can be registered after the config is locked.
+	Server and client may have different models registered under the same name.
+
+	@param name The name of the entity model.
+	@param model The model or part to use for the entity.
+	@param broadPhase Optional broad phase vector or size for frustum culling on the client. If vector is zero then only do 1 check in the center instead of a box check.
+]=]
+const function RegisterEntityModel(name: string, model: Model | BasePart | false, broadPhase: vector | Vector3?)
+	if model ~= false and model:IsA("Model") and not model.PrimaryPart then
+		error(name .. " must have a PrimaryPart to be registered as an entity model.")
+	end
+	ENTITY_MODELS[name] = model
+	MODEL_BROAD_PHASES[name] = broadPhase
+end
+
+const SetConfig = function(name, value)
+	assert(not LOCKED, "Config is locked and cannot be modified after startup.")
+	BASE_CONFIG[name] = value
+end :: SetConfig
+
+const function GetEntityType(name: string?): Types.EntityConfig
+	return name and ENTITY_TYPES[name] or ENTITY_TYPES["DEFAULT"]
+end
+
+const function GetEntityModel(name: string): Model | BasePart | false?
+	if ENTITY_MODELS[name] == nil then
+		warn(`Entity model {name} not found in Config.`)
+		return nil
+	end
+	return ENTITY_MODELS[name]
+end
+
+const function GetBroadPhase(name: string): vector?
+	return MODEL_BROAD_PHASES[name] :: any
+end
+
+const function GetConfig(name: Configs)
+	return BASE_CONFIG[name]
+end
+
+const waiting = {}
+const function WaitForLock(fx: () -> ())
+	if LOCKED then
+		fx()
+	else
+		table.insert(waiting, fx)
+	end
+end
+
+const function SetWarningSeverity(level: WarningLevels)
+	if level ~= "NONE" and level ~= "LOW" and level ~= "MEDIUM" and level ~= "HIGH" then
+		error("Invalid warning level: " .. tostring(level))
+	end
+	BASE_CONFIG.WARNING_SEVERITY = level
+end
+
+const function Lock()
+	(require)(script.Parent.Warn).low("Config is now locked")
+
+	LOCKED = true
+	const DEFAULT_NORMAL_TICK_DISTANCE = BASE_CONFIG.DEFAULT_NORMAL_TICK_DISTANCE
+	const DEFAULT_HALF_TICK_DISTANCE = BASE_CONFIG.DEFAULT_HALF_TICK_DISTANCE
+	for i, v in ENTITY_TYPES do
+		const cloned = table.clone(v)
+		cloned.NAME = i
+		cloned.AUTO_UPDATE_POSITION = cloned.AUTO_UPDATE_POSITION ~= false
+		cloned.FULL_ROTATION = cloned.FULL_ROTATION or false
+		cloned.NORMAL_TICK_DISTANCE = cloned.NORMAL_TICK_DISTANCE or DEFAULT_NORMAL_TICK_DISTANCE
+		cloned.HALF_TICK_DISTANCE = cloned.HALF_TICK_DISTANCE or DEFAULT_HALF_TICK_DISTANCE
+		cloned.MODEL_REPLICATION_MODE = cloned.MODEL_REPLICATION_MODE
+			or BASE_CONFIG.DEFAULT_MODEL_REPLICATION_MODE :: any
+		if IS_SERVER then
+			cloned.TICKER = (require)(script.Parent.Ticker).new(cloned)
+		else
+			cloned.CLIENT_CLOCK = {} :: any
+			cloned.UpdateBuffer = function(self, buffer: number)
+				if not self.CLIENT_CLOCK or not next(self.CLIENT_CLOCK :: any) then
+					error("Config not initialized yet, cannot update buffer for entity type: " .. self.NAME)
+				end
+				self.BUFFER = buffer
+				if self.CLIENT_CLOCK.NORMAL then
+					self.CLIENT_CLOCK.NORMAL:UpdateBuffer(buffer)
+				end
+				if self.CLIENT_CLOCK.HALF then
+					self.CLIENT_CLOCK.HALF:UpdateBuffer(buffer)
+				end
+
+				-- Owned entities of this type use their own per-entity clock, so update those too.
+				-- Skip any entity that set an explicit per-entity override (_clockBuffer), which wins over the config.
+				const Holder = (require)(script.Parent.Holder)
+				const Entity = (require)(script.Parent.Entity)
+				for _, entity in Holder.idMap do
+					if entity.entityConfig == self then
+						Entity._UpdateClockBuffer(entity)
+					end
+				end
+			end
+		end
+
+		ENTITY_TYPES[i] = cloned
+	end
+	for _, fx in waiting do
+		fx()
+	end
+end
+
+return {
+	SetConfig = SetConfig,
+	RegisterEntityType = RegisterEntityType,
+	RegisterEntityModel = RegisterEntityModel,
+	FLAGS = {
+		["SERVER_VELOCITY_FIX"] = true, -- Fixes velocity calculation on the server when two packets are received next to each other
+		["VELOCITY_CALC_FIX"] = true, -- Fixes velocity calculation when dt is less then tickrate
+		["SNAPSHOT_INTERPOLATION_FIX"] = true, -- Fixes interpolation of snapshots when replication is stopped briefly and resumed rapidly which can cause slight jitter due to velocity.
+		["SET_CFRAME_FIX"] = true, -- Adds a teleport flag to packets
+		["FIX_TELEPORT_JITTER"] = true, -- Resolves jitter issue when clearing snapshots then settings cframe/teleporting can cause a bouncing effect. Uses a locking mechanism when getting the snapshot buffer to prevent old snapshots from being retrieved.
+	},
+
+	_EntityConfigs = ENTITY_TYPES,
+	_GetEntityType = GetEntityType, --// For internal use only
+	GetEntityType = GetEntityType,
+	_GetEntityModel = GetEntityModel,
+	_GetConfig = GetConfig,
+	_Lock = Lock,
+	_WaitForLock = WaitForLock,
+	_GetBroadPhase = GetBroadPhase,
+	_Base_Config = BASE_CONFIG, --//Modifying this after locking may not change behaviors of some config options.
+	SetModelPrimaryForChrono = function(model: Model, primaryName: string)
+		model:SetAttribute(CHRONO_PRIMARY, primaryName)
+	end,
+	SetWarningSeverity = SetWarningSeverity,
+}