cluaupp 1.0.0 → 1.4.0

package/runtime/Chrono/Client/Receiver.luau

@@ -1,395 +0,0 @@
-const RunService = game:GetService("RunService")
-const Players = game:GetService("Players")
-const Shared = script.Parent.Parent.Shared
-
-const Warn = require(Shared.Warn)
-const Entity = require(Shared.Entity)
-const Events = require(Shared.Events)
-const Holder = require(Shared.Holder)
-const ModelHelper = require(Shared.ModelHelper)
-const Types = require(Shared.Types)
-const ClockUnwrap = require(Shared.ClockUnwrap)
-const Stats = require(Shared.Stats).CLIENT
-const ClientClock = require(script.Parent.ClientClock)
-
-local BytesReceived = 0
-local NewPerSec = 0
-local RemovedPerSec = 0
-local ChangesPerSec = 0
-
-const SetTickMode = Entity._SetTickMode
-
-const UnreliableEvent = Shared.Remotes.Replicate
-const ReliableEvent = Shared.Remotes.ReplicateFull
-const HeartbeatRemote = Shared.Remotes.Heartbeat
-const ClientClockRelayRemote = Shared.Remotes.ClientClockRelay
-
-const ServerWrap = ClockUnwrap.new()
-const ClientOwnedWrap: ClockUnwrap.Store = {}
-
-const TickerHeaderBytes = 4 + 1
-const FULL_BYTES = 4 * 3 + 2 * 3
-const YAW_BYTES = 4 * 3 + 2
-
-const TAU = 2 * math.pi
-
-const function UnmapRotation(u16: number): number
-	return (u16 / 65535) * TAU - math.pi
-end
-
-const function ReadTickerHeader(b: buffer, index: number): (number, boolean, boolean)
-	const lastTicked = ClockUnwrap.unwrap(ServerWrap, buffer.readu32(b, index))
-	const packed = buffer.readu8(b, index + 4)
-
-	const isHalfTickRate = bit32.band(packed, 1) == 1
-	const isFull = bit32.band(packed, 2) == 2
-
-	return lastTicked, isFull, isHalfTickRate
-end
-
-const function DeserializeFull(b: buffer, index: number): CFrame
-	const x = buffer.readf32(b, index)
-	index += 4
-	const y = buffer.readf32(b, index)
-	index += 4
-	const z = buffer.readf32(b, index)
-	index += 4
-
-	const rx = UnmapRotation(buffer.readu16(b, index))
-	index += 2
-	const ry = UnmapRotation(buffer.readu16(b, index))
-	index += 2
-	const rz = UnmapRotation(buffer.readu16(b, index))
-	index += 2
-
-	return CFrame.new(x, y, z) * CFrame.fromOrientation(rx, ry, rz)
-end
-
-const function DeserializeYaw(b: buffer, index: number): CFrame
-	const x = buffer.readf32(b, index)
-	index += 4
-	const y = buffer.readf32(b, index)
-	index += 4
-	const z = buffer.readf32(b, index)
-	index += 4
-
-	const ry = UnmapRotation(buffer.readu16(b, index))
-	index += 2
-
-	return CFrame.new(x, y, z) * CFrame.fromOrientation(0, ry, 0)
-end
-
-const function HandleRemoved(id: number)
-	const entity = Holder.GetEntityFromId(id)
-	if entity then
-		Entity.Destroy(entity)
-		return
-	end
-	Warn.high("Tried to remove non existent entity with id", id)
-end
-
-const function SetMountId(entity: Types.Entity, mountParentId: number?)
-	entity.mountParentId = mountParentId
-	Events._Signals.EntityMountChanged:Fire(entity, mountParentId)
-end
-
-const function SetMountOffset(entity: Types.Entity, mountOffset: CFrame?)
-	entity.mountOffset = mountOffset or CFrame.identity
-end
-
-const ValueChanges = {
-	networkOwner = Entity["设置网络主控玩家"],
-	isHalfTicked = SetTickMode,
-	_data = Entity.SetData,
-	entityConfig = Entity.SetConfig,
-	autoUpdatePos = Entity.SetAutoUpdatePos,
-	mountParentId = SetMountId,
-	mountOffset = SetMountOffset,
-	broadPhase = Entity.SetBroadPhase,
-}
-
-const function HandleChanges(changes: { id: number, data: { { any } } })
-	const entity = Holder.GetEntityFromId(changes.id)
-	if not entity then
-		return
-	end
-	local hasMetadata
-	local modelData
-	for _, pair in changes.data do
-		const key = pair[1]
-		const value = pair[2]
-
-		const handler = ValueChanges[key]
-		if handler then
-			handler(entity, value)
-		elseif key == "latestCFrame" then
-			Entity.SetCFrame(entity, value)
-		elseif key == "_modelMetaData" then
-			hasMetadata = value
-		elseif key == "model" then
-			modelData = value
-		elseif key == "_player" then
-			if value then
-				Holder.SetAsCharacter(value, entity)
-			else
-				Holder.RemovePlayerCharacter(entity)
-			end
-		elseif key == "paused" then
-			if value then
-				Entity.PauseReplication(entity)
-			else
-				Entity.ResumeReplication(entity)
-			end
-		elseif key == "_lockedCFReplication" then
-			entity._lockedCFReplication = value
-			if not value then
-				const part = Entity._GetPart(entity)
-				if part then
-					Entity._UnlockPartPhysicsReplication(part)
-				end
-			else
-				Entity.SyncOwnerShip(entity)
-			end
-		else
-			Warn.high("Unhandled entity change key:", key)
-		end
-	end
-
-	if modelData ~= nil then
-		const model, modelType = ModelHelper.CreateModelFromData(modelData)
-		Entity.SetModel(entity, model, modelType :: any)
-		entity._modelMetaData = hasMetadata
-	end
-end
-
-const function HandleNewEntity(data: Types.EntityReceivePacket)
-	const model, modelType = ModelHelper.CreateModelFromData(data.model)
-	const entity = Entity._new(data.config, model, modelType, data.cframe)
-
-	entity.id = data.id
-	entity._player = data._player
-	entity._modelMetaData = data._modelMetaData
-	entity.paused = data.paused or false
-	entity.isHalfTicked = data.isHalfTicked
-	entity._data = data._data
-	entity.mountParentId = data.mountParentId
-	entity.mountOffset = data.mountOffset or CFrame.identity
-	entity.broadPhase = data.broadPhase or entity.broadPhase
-	entity._lockedCFReplication = data._lockedCFReplication or false
-
-	Entity.Push(entity, data.time, data.cframe)
-
-	Entity["设置网络主控玩家"](entity, data.networkOwner)
-	SetTickMode(entity, data.isHalfTicked)
-	Holder.RegisterEntity(entity)
-end
-
-const function PushCFrameFor(
-	id: number,
-	clientOwned: boolean,
-	cframe: CFrame,
-	time: number,
-	isHalfTick: boolean,
-	teleport: boolean?
-): boolean
-	const entity = Holder.GetEntityFromId(id)
-	if not entity then
-		Warn.high("Received update for non existent entity with id", id)
-		return false
-	end
-
-	const withinTeleportThreshold = entity._teleport and os.clock() - entity._teleport < 0.5
-	if withinTeleportThreshold then
-		if teleport then
-			entity._teleport = nil
-		else
-			return false
-		end
-	end
-
-	if clientOwned then
-		const renderCache = entity._clientClock
-		if renderCache then
-			if isHalfTick then
-				renderCache:SetTickRate(renderCache._baseTickRate * 2)
-			else
-				renderCache:SetTickRate(renderCache._baseTickRate)
-			end
-			renderCache:OnSnapShot(time)
-		end
-	else
-		const renderCaches = entity.entityConfig.CLIENT_CLOCK
-		if renderCaches then
-			const renderCache = isHalfTick and renderCaches.HALF or renderCaches.NORMAL
-			if renderCache then
-				renderCache:OnSnapShot(time)
-			end
-		end
-	end
-
-	if entity.isHalfTicked ~= isHalfTick then
-		SetTickMode(entity, isHalfTick)
-	end
-	entity.isHalfTicked = isHalfTick
-
-	Entity.Push(entity, time, cframe)
-	return true
-end
-
-const function HandleClientOwned(b: buffer)
-	BytesReceived += buffer.len(b)
-	const bLen = buffer.len(b)
-	local index = 0
-
-	while index < bLen do
-		const rawTime = buffer.readu32(b, index)
-		index += 4
-		const length = buffer.readu8(b, index)
-		index += 1
-		for i = 1, length do
-			const id = buffer.readu16(b, index)
-			index += 2
-			const packed = buffer.readu8(b, index)
-			index += 1
-			const isFull = bit32.band(packed, 1) == 1
-			const isHalfTickRate = bit32.band(packed, 2) == 2
-			const teleport = bit32.band(packed, 4) == 4
-			local cf: CFrame
-			if isFull then
-				cf = DeserializeFull(b, index)
-				index += FULL_BYTES
-			else
-				cf = DeserializeYaw(b, index)
-				index += YAW_BYTES
-			end
-			const entity = Holder.GetEntityFromId(id)
-			if not entity then
-				Warn.medium("Received update for non existent entity with id", id)
-				continue
-			end
-			-- Unwrap in the source player's frame (delta-based, offset-0). Shares state with
-			-- this player's other entity packets + the clock relay.
-			const time = ClockUnwrap.unwrapFor(ClientOwnedWrap, entity.networkOwner or "__unknown", rawTime)
-			PushCFrameFor(id, true, cf, time, isHalfTickRate, teleport)
-		end
-	end
-end
-
-const function HandleServerOwned(b: buffer)
-	const bLen = buffer.len(b)
-	BytesReceived += bLen
-	local index = 0
-	while index < bLen do
-		const lastTicked, isFull, isHalfTickRate = ReadTickerHeader(b, index)
-		index += TickerHeaderBytes
-		const length = buffer.readu8(b, index)
-		index += 1
-		for i = 1, length do
-			const id = buffer.readu16(b, index)
-			index += 2
-			local cframe
-			if isFull then
-				cframe = DeserializeFull(b, index)
-				index += FULL_BYTES
-			else
-				cframe = DeserializeYaw(b, index)
-				index += YAW_BYTES
-			end
-			PushCFrameFor(id, false, cframe, lastTicked, isHalfTickRate)
-		end
-	end
-end
-
-const function HandleUnreliable(id: string, data: buffer)
-	if id == "X" then -- Server Owned
-		HandleServerOwned(data)
-	elseif id == "O" then -- Client Owned
-		HandleClientOwned(data)
-	else
-		Warn.high("Unknown unreliable replicate id", id)
-	end
-end
-
-const function HandleReliable(newEntities: {}, removedEntities: { number }, entityChanges: { any })
-	--RunService.PreAnimation:Wait() -- was encountering an issues where instances were not replicated prob was streaming endabled?
-	if removedEntities then
-		for _, id in removedEntities do
-			HandleRemoved(id)
-		end
-		RemovedPerSec += #removedEntities
-	end
-
-	if newEntities then
-		for _, data: any in newEntities do
-			HandleNewEntity(data)
-		end
-		NewPerSec += #newEntities
-	end
-
-	if entityChanges then
-		for _, changeData in entityChanges do
-			HandleChanges(changeData)
-		end
-		ChangesPerSec += #entityChanges
-	end
-end
-
-UnreliableEvent.OnClientEvent:Connect(HandleUnreliable)
-ReliableEvent.OnClientEvent:Connect(HandleReliable)
-
-HeartbeatRemote.OnClientEvent:Connect(function(time: number)
-	-- Reduce the full-precision server time into the same offset-0 frame as the buffered
-	-- server-owned headers, otherwise the two feeds would disagree and freeze the clock.
-	const unwrapped = ClockUnwrap.unwrap(ServerWrap, ClockUnwrap.quantize(time))
-	for clock in ClientClock.serverOwnedClocks do
-		-- Refresh, not OnSnapShot: keep the clock fresh without feeding the heartbeat
-		-- cadence into the interpolation buffer's jitter estimate.
-		clock:Refresh(unwrapped)
-	end
-end)
-
--- Client-clock relay: reseats each source to the server's authoritative wrap offset so every
--- receiver agrees on the source's epoch regardless of join time. max() avoids regressing a wrap
--- this client already witnessed between relays.
-ClientClockRelayRemote.OnClientEvent:Connect(function(list: { { player: Player, raw: number, offset: number } })
-	if type(list) ~= "table" then
-		return
-	end
-	for _, entry in list do
-		const player = entry.player
-		const raw = entry.raw
-		const offset = entry.offset
-		if player and type(raw) == "number" and type(offset) == "number" then
-			local state = ClientOwnedWrap[player]
-			if not state then
-				state = ClockUnwrap.new()
-				ClientOwnedWrap[player] = state
-			end
-			state.lastRaw = raw
-			state.offset = math.max(state.offset, offset)
-		end
-	end
-end)
-
-Players.PlayerRemoving:Connect(function(player)
-	ClientOwnedWrap[player] = nil
-end)
-
-local lastByteCheckTime = 0
-RunService.Heartbeat:Connect(function()
-	if os.clock() - lastByteCheckTime > 1 then
-		if not Stats._PAUSE then
-			Stats.BYTES_RECEIVED_PER_SEC = BytesReceived
-			Stats.NEW_ENTITIES_PER_SEC = NewPerSec
-			Stats.ENTITY_CHANGES_PER_SEC = ChangesPerSec
-			Stats.ENTITY_REMOVALS_PER_SEC = RemovedPerSec
-		end
-		NewPerSec = 0
-		RemovedPerSec = 0
-		ChangesPerSec = 0
-		BytesReceived = 0
-		lastByteCheckTime = os.clock()
-	end
-end)
-
-return nil

package/runtime/Chrono/Client/Replicate.luau

@@ -1,333 +0,0 @@
-const Shared = script.Parent.Parent.Shared
-
-const RunService = game:GetService("RunService")
-
-const Ticker = require(Shared.Ticker)
-const Warn = require(Shared.Warn)
-const StatsALL = require(script.Parent.Parent.Shared.Stats)
-const ApplyMounts = require(script.Parent.Parent.Shared.ApplyMounts)
-const RenderCache = require(script.Parent.ClientClock)
-const ModelResolver = require(script.Parent.ModelResolver)
-const Entity = require(Shared.Entity)
-const Holder = require(Shared.Holder)
-const Config = require(Shared.Config)
-const Types = require(Shared.Types)
-const Sender = require(script.Parent.Sender)
-const Stats = require(Shared.Stats).CLIENT
-
-const CLIENT_CLOCK_SYNC_RATE = 15 -- should be fine having lower then server
-require(script.Parent.Player)
-require(script.Parent.Receiver)
-
-const idMap = Holder.idMap
-
-local FrustumLookVector = vector.create(0, 0, -1)
-local FrustumRightVector = vector.create(1, 0, 0)
-local FrustumUpVector = vector.create(0, 1, 0)
-local FrustumPosition = vector.create(0, 0, 0)
-local TanHorizontal = 0
-local TanVertical = 0
-
-const function PrepareFrustumCheck()
-	const cframe: CFrame = workspace.CurrentCamera.CFrame
-	FrustumLookVector = cframe.LookVector :: any
-	FrustumRightVector = cframe.RightVector :: any
-	FrustumUpVector = cframe.UpVector :: any
-
-	FrustumPosition = cframe.Position :: any
-
-	const cam = workspace.CurrentCamera
-	const halfFov = math.rad(cam.FieldOfView / 2)
-	const aspectRatio = cam.ViewportSize.X / cam.ViewportSize.Y
-	TanHorizontal = math.tan(halfFov) * aspectRatio
-	TanVertical = math.tan(halfFov)
-end
-
-const function CheckPointInFrustum(pos: vector)
-	const diff = pos - FrustumPosition
-
-	const magnitude = vector.magnitude(diff)
-
-	if magnitude == 0 then
-		return true
-	end
-
-	const forwardDis = vector.dot(diff, FrustumLookVector)
-
-	const forwardDot = forwardDis / magnitude
-	if forwardDot < 0 then
-		return false
-	end
-	if forwardDis < 1 then
-		return true
-	end
-	const unit = diff / magnitude
-	const rightDot = vector.dot(unit, FrustumRightVector)
-
-	if math.abs(rightDot) > forwardDot * TanHorizontal then
-		return false
-	end
-
-	const upDot = vector.dot(unit, FrustumUpVector)
-	if math.abs(upDot) > forwardDot * TanVertical then
-		return false
-	end
-	return true
-end
-
-const function CheckBroadPhaseInFrustum(center: vector, size: vector)
-	if size == vector.zero then
-		return CheckPointInFrustum(center)
-	end
-	const halfSize = size * 0.5
-	const halfX = halfSize.x
-	const halfY = halfSize.y
-	const halfZ = halfSize.z
-	const negX = -halfX
-	const negY = -halfY
-	const negZ = -halfZ
-
-	return CheckPointInFrustum(center + vector.create(halfX, halfY, halfZ))
-		or CheckPointInFrustum(center + vector.create(negX, halfY, halfZ))
-		or CheckPointInFrustum(center + vector.create(halfX, negY, halfZ))
-		or CheckPointInFrustum(center + vector.create(negX, negY, halfZ))
-		or CheckPointInFrustum(center + vector.create(halfX, halfY, negZ))
-		or CheckPointInFrustum(center + vector.create(negX, halfY, negZ))
-		or CheckPointInFrustum(center + vector.create(halfX, negY, negZ))
-		or CheckPointInFrustum(center + vector.create(negX, negY, negZ))
-end
-const Ticks = 4
-local OutOfBroadPhaseTick = 0
-local CurrentTick = 0
-local TotalInterpolationTime = 0
-local AmtInterpolations = 0
-
-local CheckedThisFrame = 0
-local TotalCulled = 0
-local MovedThisFrame = 0
-
-const function Interpolate(entity: Types.Entity)
-	const config = entity.entityConfig
-	if not entity.interpolation or config.CUSTOM_INTERPOLATION then
-		return
-	end
-	const primaryPart = Entity.GetPrimaryPart(entity)
-
-	if not primaryPart then
-		return
-	end
-
-	if entity.isContextOwner then
-		return
-	end
-
-	if config.ASSEMBLY_ROOT_PART_CHECK then
-		if primaryPart.AssemblyRootPart ~= primaryPart then
-			Warn.low(
-				"Primary part for entity "
-					.. entity.id
-					.. " is not the assembly root part. Skipping interpolation for this entity."
-			)
-			return
-		end
-	end
-
-	const currentEntityTick = entity._outofBroadPhaseTick
-	if currentEntityTick and currentEntityTick ~= CurrentTick then
-		return
-	end
-
-	const snapshot = entity.snapshot
-	if not snapshot then
-		Warn.medium("No snapshot for entity", entity)
-		return
-	end
-	CheckedThisFrame += 1
-	debug.profilebegin("Get Render CFrame")
-	const targetTime = Entity.GetTargetRenderTime(entity)
-	const targetCFrame = snapshot:GetAt(targetTime)
-	debug.profileend()
-	if not targetCFrame then
-		return
-	end
-	const broadPhase: vector? = entity.broadPhase
-
-	if broadPhase then
-		const toCheck = targetCFrame :: any
-		const lastCheckedCFrame = entity.lastCheckedCFrame
-		debug.profilebegin("Prepare Frustum")
-		const passed = CheckBroadPhaseInFrustum(toCheck.Position, broadPhase)
-		debug.profileend()
-		if not passed then
-			if lastCheckedCFrame and lastCheckedCFrame.Position ~= toCheck.Position then
-				debug.profilebegin("Check Last CFrame")
-				const passLast = CheckBroadPhaseInFrustum(lastCheckedCFrame.Position :: any, broadPhase)
-				debug.profileend()
-				if not passLast then
-					TotalCulled += 1
-					return
-				end
-			else
-				if not lastCheckedCFrame then
-					entity.lastCheckedCFrame = toCheck
-				end
-				if not entity._outofBroadPhaseTick then
-					entity._outofBroadPhaseTick = OutOfBroadPhaseTick
-					OutOfBroadPhaseTick += 1
-					if OutOfBroadPhaseTick % Ticks == 0 then
-						OutOfBroadPhaseTick = 0
-					end
-				end
-				TotalCulled += 1
-				return
-			end
-		end
-		entity.lastCheckedCFrame = nil
-		entity._outofBroadPhaseTick = nil
-	end
-	debug.profilebegin("Set CFrame")
-	if targetCFrame == targetCFrame then
-		primaryPart.CFrame = targetCFrame
-	end
-	MovedThisFrame += 1
-	debug.profileend()
-end
-
-const function updateEntityStats()
-	if not StatsALL.SERVER._SHOULD_REPLICATE or Stats._PAUSE then
-		return
-	end
-	const entities = {}
-	for _, entity in idMap do
-		const id = entity.id
-		const config = entity.entityConfig
-		const configName = config and config.NAME or "DEFAULT"
-		const networkOwner = entity.networkOwner
-		const isCharacter = entity._player ~= nil
-
-		const lastRecvTime = entity.latestTime or 0
-		const lastReplicatedTime = entity.lastReplicatedTime or 0
-
-		local renderCache = entity._clientClock
-
-		if not renderCache then
-			const RenderCaches = entity.entityConfig.CLIENT_CLOCK
-			if RenderCaches then
-				renderCache = entity.isHalfTicked and RenderCaches.HALF or RenderCaches.NORMAL
-			end
-		end
-
-		local targetRender = 0
-		local averageLatency = 0
-		local deviation = 0
-		local bufferedTime = 0
-
-		if renderCache then
-			targetRender = renderCache:GetTargetRenderTime()
-			const interpolationBuff = renderCache.buffer
-			if interpolationBuff then
-				averageLatency = interpolationBuff.averageLatency
-				deviation = interpolationBuff.deviation
-			end
-			bufferedTime = RenderCache._getBuffer(renderCache)
-		end
-		const primaryPart = Entity.GetPrimaryPart(entity)
-		const snapshot = entity.snapshot
-		const currentPosition = primaryPart and primaryPart.Position
-		const snapshots = {}
-		if snapshot then
-			for _, snap in snapshot.cache do
-				table.insert(snapshots, { t = snap.t, value = snap.value, velocity = snap.velocity })
-			end
-			table.sort(snapshots, function(a, b)
-				return a.t > b.t
-			end)
-		end
-		const data = {
-			id = id,
-			entity = entity,
-			networkOwner = networkOwner,
-			isCharacter = isCharacter,
-			config = configName,
-			lastReceivedTime = lastRecvTime,
-			lastReplicatedTime = lastReplicatedTime,
-			targetTime = targetRender,
-			averageLatency = averageLatency,
-			deviation = deviation,
-			bufferedTime = bufferedTime,
-			currentPosition = currentPosition,
-			snapshots = snapshots,
-		}
-		table.insert(entities, data)
-	end
-	Stats.CLIENT_ENTITIES = entities
-end
-Config._WaitForLock(function()
-	RunService.Heartbeat:Connect(function(deltaTime: number)
-		CurrentTick += 1
-		if CurrentTick % Ticks == 0 then -- Runs every 4 frames at 60hz this is 15hz
-			Stats.TOTAL_ENTITIES_CULLED = TotalCulled
-			TotalCulled = 0
-			CurrentTick = 0
-		end
-		RenderCache.UpdateAll(deltaTime)
-		debug.profilebegin("Prepare Frustum Check")
-		PrepareFrustumCheck()
-		debug.profileend()
-		local total = 0
-		const startTime = os.clock()
-		debug.profilebegin("Interpolate Entities")
-		for _, entity in idMap do
-			ModelResolver(entity)
-			if entity.destroyed or entity.paused then
-				continue
-			end
-			if entity.mountParentId then
-				continue
-			end
-			total += 1
-			Interpolate(entity)
-		end
-		debug.profileend()
-		const endTime = os.clock()
-		debug.profilebegin("Update Entity Stats")
-		updateEntityStats()
-		debug.profileend()
-		TotalInterpolationTime += (endTime - startTime)
-		AmtInterpolations += 1
-
-		ApplyMounts()
-		if not Stats._PAUSE then
-			Stats.TOTAL_CLIENT_ENTITIES_CHECKED_THIS_FRAME = total
-			Stats.ENTITIES_MOVED_THIS_FRAME = MovedThisFrame
-			Stats.TOTAL_CLIENT_ENTITIES = total
-			Stats.AVG_INTERPOLATION_TIME_MS = (TotalInterpolationTime / AmtInterpolations) * 1000
-		end
-		MovedThisFrame = 0
-		CheckedThisFrame = 0
-		if AmtInterpolations > 60 then
-			TotalInterpolationTime = 0
-			AmtInterpolations = 0
-		end
-		Sender.Update()
-		Ticker._IncrementGlobalTick()
-	end)
-	-- Client clock heartbeat: sends the FULL os.clock so the server can seat this client's wrap
-	-- epoch directly (remotes serialize numbers as f64 anyway, so it's the same bytes as a u32).
-	-- Keeps the server's view fresh + correct even for a still (macro/auto-click) player that
-	-- sends no entity packets. See ClockUnwrap.
-	const ClientHeartbeatRemote = Shared.Remotes.ClientHeartbeat
-	ClientHeartbeatRemote:FireServer(os.clock()) -- seed on join
-	local clientHeartbeatAcc = 0
-	RunService.Heartbeat:Connect(function(dt: number)
-		clientHeartbeatAcc += dt
-		if clientHeartbeatAcc >= CLIENT_CLOCK_SYNC_RATE then
-			clientHeartbeatAcc = 0
-			ClientHeartbeatRemote:FireServer(os.clock())
-		end
-	end)
-
-	Shared.Remotes.ClientLoaded:FireServer()
-end)
-
-return nil