cluaupp 1.0.0 → 1.4.0

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

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

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