cluaupp 0.1.0

package/runtime/Chrono/_impl/Server/Replicate.luau

@@ -0,0 +1,415 @@
+--!native
+const Players = game:GetService("Players")
+
+const RunService = game:GetService("RunService")
+
+const Shared = script.Parent.Parent.Shared
+
+const ApplyMounts = require(Shared.ApplyMounts)
+const Warn = require(Shared.Warn)
+const Bin = require(Shared.Bin)
+const Holder = require(Shared.Holder)
+const Events = require(Shared.Events)
+const Ticker = require(Shared.Ticker)
+const Config = require(Shared.Config)
+const Types = require(Shared.Types)
+const Entity = require(Shared.Entity)
+const EntityGrid = require(script.Parent.EntityGrid)
+const _Player = require(script.Parent.Player)
+const Sender = require(script.Parent.Sender)
+const _Receiver = require(script.Parent.Receiver)
+const Stats = require(Shared.Stats).SERVER
+
+const HeartbeatRemote = Shared.Remotes.Heartbeat
+const ClientClockRelayRemote = Shared.Remotes.ClientClockRelay
+
+const HEARTBEAT_RATE = 1 / 10
+local lastHeartbeat = 0
+
+const CLIENT_CLOCK_SYNC_RATE = 60
+local lastClientClockRelay = 0
+
+const tickers: { Types.Ticker } = {}
+
+Config._WaitForLock(function()
+	for _, entityConfig in Config._EntityConfigs do
+		if entityConfig.TICKER then
+			table.insert(tickers, entityConfig.TICKER)
+		else
+			Warn.high(entityConfig, "TICKERS not found on server config load")
+		end
+	end
+end)
+
+const function FireEvent(entity: Types.Entity, eventName: string, ...: any)
+	const events = entity._events
+	if not events then
+		return
+	end
+	const signal = events[eventName]
+	if signal then
+		signal:Fire(entity, ...)
+	end
+end
+
+const FULL_BYTES = 4 * 3 + 2 * 3 + 2
+const YAW_BYTES = 4 * 3 + 2 + 2
+
+const TAU = math.pi * 2
+
+const function MapRotation(x: number): number
+	return math.round((x + math.pi) / (TAU / 65535))
+end
+
+const function SerializeFull(b: buffer, cf: CFrame, index: number)
+	const x, y, z = cf.X, cf.Y, cf.Z
+	const rx, ry, rz = cf:ToOrientation()
+	buffer.writef32(b, index, x)
+	index += 4
+	buffer.writef32(b, index, y)
+	index += 4
+	buffer.writef32(b, index, z)
+	index += 4
+	buffer.writeu16(b, index, MapRotation(rx))
+	index += 2
+	buffer.writeu16(b, index, MapRotation(ry))
+	index += 2
+	buffer.writeu16(b, index, MapRotation(rz))
+	index += 2
+	return index
+end
+
+const function SerializeYaw(b: buffer, cf: CFrame, index: number)
+	const x, y, z = cf.X, cf.Y, cf.Z
+	const _, ry, _ = cf:ToOrientation()
+	buffer.writef32(b, index, x)
+	index += 4
+	buffer.writef32(b, index, y)
+	index += 4
+	buffer.writef32(b, index, z)
+	index += 4
+	buffer.writeu16(b, index, MapRotation(ry))
+	index += 2
+	return index
+end
+
+const function CFrameChanged(cframe1: CFrame?, cframe2: CFrame?): boolean
+	if cframe1 == cframe2 then
+		return false
+	end
+	if cframe1 == nil or cframe2 == nil then
+		return true
+	end
+	return cframe1:FuzzyEq(cframe2, 0.0001) == false
+end
+
+const function PushLatest(entity: Types.Entity, time: number)
+	if entity.autoUpdatePosition and entity.isContextOwner and entity.model then
+		const primaryPart = Entity.GetPrimaryPart(entity)
+		if not primaryPart then
+			Warn.low("Entity", entity, "has no primary part")
+			return
+		end
+		const cframe = primaryPart.CFrame
+		Entity.Push(entity, time, cframe)
+	end
+end
+
+const function CheckForChanges(entity: Types.Entity): CFrame?
+	const lastCFrame = entity.lastCheckedCFrame
+	const currentCFrame = entity.latestCFrame
+
+	if CFrameChanged(lastCFrame, currentCFrame) then
+		entity.lastCheckedCFrame = currentCFrame
+		return currentCFrame
+	end
+	return nil
+end
+
+const function CheckEntity(entity: Types.Entity, ticker: Types.Ticker, useFull: boolean, isHalfTick: boolean)
+	if entity.destroyed then
+		Ticker.Remove(ticker, entity)
+		return
+	end
+
+	if not entity.isContextOwner then
+		return
+	end
+
+	const entityIsHalf = entity.isHalfTicked
+	if (entityIsHalf and not isHalfTick) or entity.paused then
+		entity.cframeBuffer = nil
+		return
+	end
+	if entityIsHalf then
+		FireEvent(entity, "Ticked", ticker.halfdt)
+	else
+		FireEvent(entity, "Ticked", ticker.dt)
+	end
+
+	PushLatest(entity, ticker.lastTicked)
+	const changes = CheckForChanges(entity)
+
+	if changes then
+		if entity.id == 0 then
+			error("Entity Should not have and id of 0")
+		end
+		if useFull then
+			const b = buffer.create(FULL_BYTES)
+			buffer.writeu16(b, 0, entity.id)
+			SerializeFull(b, changes, 2)
+			entity.cframeBuffer = b
+		else
+			const b = buffer.create(YAW_BYTES)
+			buffer.writeu16(b, 0, entity.id)
+			SerializeYaw(b, changes, 2)
+			entity.cframeBuffer = b
+		end
+	else
+		entity.cframeBuffer = nil
+	end
+end
+
+const Changes: { Types.Entity } = {}
+
+--In the future we can optimize this so it uses buffers if really needed
+const function CheckEntityChanges()
+	for entity, changes in Entity._Changes do
+		const newChanges = { id = entity.id, data = {} }
+		for key, data in changes do
+			data = data or entity[key]
+			table.insert(newChanges.data, { key, data })
+		end
+		Entity._Changes[entity] = nil
+		entity._changes = newChanges
+		table.insert(Changes, entity)
+	end
+end
+
+local TotalTickerTime = 0
+local CountTicker = 0
+
+const function UpdateTickers()
+	debug.profilebegin("UpdateTickers")
+	const starts = os.clock()
+	for _, ticker in tickers do
+		if not next(ticker.objects) then
+			continue
+		end
+		debug.profilebegin(`{ticker.config.NAME}`)
+		if Ticker.CheckUpdate(ticker) then
+			--[[ Using the ticker's config instead can help protect if entity configs change mid-game since that
+                could potentially create a desync between the buffer serialization and deserialization
+            ]]
+			--// thought idk if we want to allow that (better to be safe ig for now)
+			const useFull = ticker.config.FULL_ROTATION == true
+			const isHalfTick = ticker.tickedHalf
+			for _, object in ticker.objects do
+				CheckEntity(object, ticker, useFull, isHalfTick)
+			end
+		end
+		debug.profileend()
+	end
+	debug.profileend()
+	const diff = os.clock() - starts
+	TotalTickerTime += diff
+	CountTicker += 1
+	Stats.AVG_TICKER_TIME_MS = (TotalTickerTime / CountTicker) * 1000
+	if CountTicker >= 60 then
+		TotalTickerTime = 0
+		CountTicker = 0
+	end
+end
+
+const function UpdatePlayerPositions()
+	for _, entity: Types.Entity in Holder._playerChars do
+		const player = entity.networkOwner
+		const primaryPart = Entity.GetPrimaryPart(entity)
+		const cframe = primaryPart and primaryPart.CFrame or entity.latestCFrame
+
+		if player and cframe then
+			EntityGrid.UpdatePlayerPosition(player, cframe.Position :: any)
+		end
+	end
+end
+
+const function updateEntityStats()
+	const hasOwned = Stats._SHOULD_REPLICATE
+	if not hasOwned then
+		Stats.SERVER_ENTITIES = {}
+		return
+	end
+	const entities: { Types.ServerEntitiesStats } = {}
+
+	for _, entity in Holder.idMap do
+		const networkOwner = entity.networkOwner
+		const isCharacter = entity._player ~= nil
+		const config = entity.entityConfig
+		const configName = config and config.NAME or "DEFAULT"
+		const configTickRate = 1 / config.TICK_RATE
+		const isHalfTicked = entity.isHalfTicked
+		local tickRate = configTickRate
+		const lastPosition = entity.latestCFrame and entity.latestCFrame.Position or nil
+		if isHalfTicked == true then
+			tickRate = tickRate / 2
+		elseif isHalfTicked == nil then
+			tickRate = 0
+		end
+		tickRate //= 1
+		if tickRate ~= tickRate or tickRate == math.huge then
+			tickRate = 0
+		end
+		const lastTicked = entity.latestTime
+		const data = {
+			isPaused = entity.paused,
+			id = entity.id,
+			networkOwner = networkOwner,
+			isCharacter = isCharacter,
+			config = configName,
+			tickRate = tickRate,
+			lastTicked = lastTicked,
+			lastPosition = lastPosition,
+			modelType = Entity.GetModelReplicationType(entity),
+		}
+		table.insert(entities, data)
+	end
+	Stats.SERVER_ENTITIES = entities
+end
+
+const function UpdateHeartbeat()
+	const now = os.clock()
+	if now - lastHeartbeat >= HEARTBEAT_RATE then
+		lastHeartbeat = now
+		for _, player in Players:GetPlayers() do
+			if not EntityGrid.GetEntityHolder(player) then
+				continue
+			end
+			HeartbeatRemote:FireClient(player, now)
+		end
+	end
+end
+
+const function UpdateClientClockRelay()
+	const now = os.clock()
+	if now - lastClientClockRelay < CLIENT_CLOCK_SYNC_RATE then
+		return
+	end
+	lastClientClockRelay = now
+
+	const raws = _Receiver._GetClientClockRaws()
+	if #raws == 0 then
+		return
+	end
+
+	ClientClockRelayRemote:FireAllClients(raws)
+end
+
+const function Update()
+	EntityGrid.Update()
+	UpdatePlayerPositions()
+	ApplyMounts()
+	UpdateTickers()
+	CheckEntityChanges()
+	UpdateHeartbeat()
+	UpdateClientClockRelay()
+
+	for _, player in Players:GetPlayers() do
+		Sender.ReplicatePlayer(player)
+	end
+	for _, entity in Changes do
+		entity._changes = nil
+	end
+	table.clear(Changes)
+	updateEntityStats()
+	Ticker._IncrementGlobalTick()
+end
+
+const function HandleEntity(plr, entity: Types.Entity)
+	const add, clear = Bin()
+
+	const function HandleModel(entity: Types.Entity)
+		if not entity.model then
+			return
+		end
+
+		const partToUse = Entity._GetRootPart(entity)
+
+		if not partToUse then
+			return
+		end
+
+		const function CFrameChanged()
+			const cframe = partToUse.CFrame
+			if entity.mountParentId then
+				entity.latestCFrame = cframe
+				return
+			end
+			if cframe == entity.latestCFrame then
+				return
+			end
+
+			Entity.SetCFrame(entity, cframe)
+		end
+
+		add(partToUse:GetPropertyChangedSignal("CFrame"):Connect(CFrameChanged))
+	end
+	const add2, clear2 = Bin()
+	add2(Entity.GetEvent(entity, "ModelChanged"):Connect(function()
+		clear()
+		HandleModel(entity)
+	end))
+	add2(Entity.GetEvent(entity, "LockChanged"):Connect(function()
+		clear()
+		HandleModel(entity)
+	end))
+	local destroyEvent
+	const event = Entity.GetEvent(entity, "NetworkOwnerChanged"):Once(function()
+		clear()
+		clear2()
+		destroyEvent:Disconnect()
+	end)
+
+	destroyEvent = Entity.GetEvent(entity, "Destroying"):Once(function()
+		clear()
+		clear2()
+		event:Disconnect()
+	end)
+
+	HandleModel(entity)
+end
+
+const function HandleCFrameSetters()
+	const mode: "NONE" | "PLAYER_ENTITIES" | "PLAYER_CHARACTERS" = Config._GetConfig("REPLICATE_CFRAME_SETTERS")
+	if mode == "NONE" then
+		return
+	end
+	if mode == "PLAYER_ENTITIES" then
+		Events.PlayerOwnedAdded:Connect(HandleEntity, true)
+	else
+		Events.PlayerCharacterRegistered:Connect(HandleEntity, true)
+	end
+
+	for _, entity in Holder.idMap do
+		if mode == "PLAYER_ENTITIES" and entity.networkOwner then
+			HandleEntity(entity.networkOwner, entity)
+		elseif mode == "PLAYER_CHARACTERS" and entity._player then
+			HandleEntity(entity._player, entity)
+		end
+	end
+end
+
+const function PlayerAdded(plr: Player)
+	const raws = _Receiver._GetClientClockRaws()
+	ClientClockRelayRemote:FireAllClients(raws)
+end
+
+Config._WaitForLock(function()
+	if not RunService:IsServer() then
+		return
+	end
+	HandleCFrameSetters()
+	Events._Signals.PlayerLoaded.Event:Connect(PlayerAdded)
+	RunService.PostSimulation:Connect(Update)
+end)
+
+return nil

package/runtime/Chrono/_impl/Server/Sender.luau

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