cluaupp 0.1.0

package/runtime/Chrono/Client/Sender.luau

@@ -0,0 +1,205 @@
+const Players = game:GetService("Players")
+const LocalPlayer = Players.LocalPlayer
+
+const Shared = script.Parent.Parent.Shared
+const Holder = require(Shared.Holder)
+const Types = require(Shared.Types)
+const Entity = require(Shared.Entity)
+const ClockUnwrap = require(Shared.ClockUnwrap)
+const UnreliableEvent = Shared.Remotes.Replicate
+const SafeReplicateEvent = Shared.Remotes.SafeReplicate
+
+const ClientOwned = Holder._clientOwned
+if not ClientOwned[LocalPlayer] then
+	ClientOwned[LocalPlayer] = {}
+end
+const PlayerEntities = ClientOwned[LocalPlayer]
+
+const FULL_BYTES = 4 * 3 + 2 * 3 + 3
+const YAW_BYTES = 4 * 3 + 2 + 3
+const MAX_BUFFER_SIZE = 900
+
+const BUFFER = buffer.create(MAX_BUFFER_SIZE + 50)
+local INDEX = 0
+
+const TAU = math.pi * 2
+
+local clock = 0
+local hasTeleport = false
+
+const function MapRotation(u16: number): number
+	return math.round((u16 + math.pi) / (TAU / 65535))
+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 function SerializeFull(b: buffer, cframe: CFrame, index: number)
+	const x, y, z = cframe.X, cframe.Y, cframe.Z
+	const rx, ry, rz = cframe: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, cframe: CFrame, index: number)
+	const x, y, z = cframe.X, cframe.Y, cframe.Z
+	const _, ry, _ = cframe: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 Flush()
+	if INDEX == 0 then
+		return
+	end
+
+	const copy = buffer.create(INDEX + 4)
+	buffer.writeu32(copy, 0, ClockUnwrap.quantize(clock))
+	buffer.copy(copy, 4, BUFFER, 0, INDEX)
+	if hasTeleport then
+		SafeReplicateEvent:FireServer(copy)
+	else
+		UnreliableEvent:FireServer(copy)
+	end
+
+	INDEX = 0
+end
+
+const function WriteEntity(id: number, cf: CFrame, fullCFrame: boolean?, halfTicked: boolean?, teleport: boolean?)
+	const length = if fullCFrame then FULL_BYTES else YAW_BYTES
+
+	if INDEX + length > MAX_BUFFER_SIZE then
+		Flush()
+	end
+
+	buffer.writeu16(BUFFER, INDEX, id)
+	INDEX += 2
+	local packed = if fullCFrame then 1 else 0
+
+	if halfTicked then
+		packed += 2
+	end
+
+	if teleport then
+		packed += 4
+	end
+
+	buffer.writeu8(BUFFER, INDEX, packed)
+	INDEX += 1
+
+	if fullCFrame then
+		INDEX = SerializeFull(BUFFER, cf, INDEX)
+	else
+		INDEX = SerializeYaw(BUFFER, cf, INDEX)
+	end
+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
+
+--//This is to catch an edge case where the primarypart hasn't been replicated
+const function CheckLocker(entity: Types.Entity)
+	if entity._cfLockFailed then
+		if entity._lockedCFReplication and entity.isContextOwner and not entity._player then
+			const part = Entity._GetPart(entity)
+			if part then
+				Entity._LockPartPhysicsReplication(part)
+				entity._cfLockFailed = nil
+			end
+		else
+			entity._cfLockFailed = nil
+		end
+	end
+end
+
+const function CheckEntity(entity: Types.Entity)
+	if entity.destroyed or entity.paused then
+		return
+	end
+
+	const config = entity.entityConfig
+	local tickRate = config.TICK_RATE
+
+	if entity.isHalfTicked then
+		tickRate = tickRate * 2
+	elseif entity.isHalfTicked == nil then
+		return
+	end
+
+	const now = clock
+	const lastTime = entity.lastReplicatedTime or 0
+	const difference = now - lastTime
+
+	if difference < tickRate then
+		return
+	end
+	CheckLocker(entity)
+	FireEvent(entity, "Ticked", difference)
+	const primaryPart = Entity.GetPrimaryPart(entity)
+
+	if entity.autoUpdatePosition and primaryPart then
+		Entity.Push(entity, now, primaryPart.CFrame)
+	end
+
+	const currentCFrame = entity.latestCFrame
+	const lastCFrame = entity.lastCheckedCFrame
+	if currentCFrame and CFrameChanged(lastCFrame, currentCFrame) then
+		entity.lastReplicatedTime = now
+		const fullCFrame = config.FULL_ROTATION
+		entity.lastCheckedCFrame = currentCFrame
+		hasTeleport = hasTeleport or entity._teleport
+		WriteEntity(entity.id, currentCFrame, fullCFrame, entity.isHalfTicked, entity._teleport)
+		entity._teleport = nil
+	end
+end
+
+const function Update()
+	clock = os.clock()
+	for entity in PlayerEntities do
+		CheckEntity(entity)
+	end
+
+	Flush()
+	hasTeleport = false
+end
+
+return {
+	Update = Update,
+}

package/runtime/Chrono/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Parihsz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/runtime/Chrono/Server/EntityGrid.luau

@@ -0,0 +1,299 @@
+--!native
+const Players = game:GetService("Players")
+
+const RunService = game:GetService("RunService")
+
+const Events = require(script.Parent.Parent.Shared.Events)
+const Config = require(script.Parent.Parent.Shared.Config)
+const ReplicationRules = require(script.Parent.Parent.Shared.ReplicationRules)
+const Stats = require(script.Parent.Parent.Shared.Stats)
+--[[
+	We just need to track entities with players near them
+
+	Track how far an entity is from a player
+	Fast query to get entities near a player
+	Far away entities could be checked less frequently
+
+	Ideas:
+	   1. give each player their own hashgird that stores other npcs
+	      - expensive so no
+	   2. idk-
+
+	cause when we do like um
+	for i,entity in queryEntitiesNear(location,100) -- this range is constant
+
+	but for far away entities we have to query again
+
+	maybe have two grids, one for close and one for far?
+	actually maybe just do
+   player:{
+		closeEntities = {},
+		farEntities = {},
+   }
+	changed to
+	player:{
+		normalEntities = {},
+		halfTick = {},
+		lowTick = {},
+   }
+]]
+for id, entity in { "ALL_ENTITIES" } do
+	--[[
+	--we could now give entities a proxy of how far they are for removal
+	--we could do
+		EntityConfig: {
+			Normal: 100,
+			HalfTick: 200,
+			LowTick: 300,
+			--don't need a removal one since we can just not replicate it
+		}
+	--loop thru players and get range
+	--insert into the players close and far table
+
+
+	-- Changed it so the ticker system keeps track of it now
+	]]
+end
+--[[
+	-- the old has grid had a system where it was
+	local UPDATE_INTERVAL = 2
+	so there really wasn't a point to query again until it updated
+	but ig we still need to check for when an npc was removed from proxy
+	could create another table to store removed entities
+
+]]
+
+const Shared = script.Parent.Parent.Shared
+const Types = require(Shared.Types)
+const Holder = require(Shared.Holder)
+const Ticker = require(Shared.Ticker)
+const Entity = require(Shared.Entity)
+const Signal = require(Shared.Signal)
+
+const SetTickMode = Entity._SetTickMode
+
+type Entity = Types.Entity
+
+local UPDATE_INTERVAL = 0.1
+local MAX_TIME_PER_UPDATE = 0.0005
+
+local lastUpdate = 0
+
+local FULL_TICKED = 0
+local HALF_TICKED = 0
+local UN_TICKED = 0
+
+type PlayerEntityHolder = Types.PlayerEntityHolder
+
+const entities = Holder.idMap
+const playerTablePositionPair: { [PlayerEntityHolder]: vector } = {}
+const playerToHolder: { [Player]: PlayerEntityHolder } = {}
+
+const function Check(entity: Entity)
+	const part = Entity.GetPrimaryPart(entity)
+	const cframe = part and part.CFrame or entity.latestCFrame
+	if not cframe or entity.destroyed then
+		return
+	end
+	if entity.id < 1 then
+		warn(entity, " has invalid id, cannot check for proximity")
+		return
+	end
+	const position: vector = cframe.Position :: any
+	const entityConfig = entity.entityConfig
+	local hasNormalTickers = false
+	local hasHalfTickers = false
+	const halfTickDistance = entityConfig.HALF_TICK_DISTANCE or math.huge
+	const normalTickDistance = entityConfig.NORMAL_TICK_DISTANCE or math.huge
+	const networkOwner = entity.networkOwner
+	const ownedHolder = networkOwner and playerToHolder[networkOwner]
+
+	const isLocked = entity._lockedCFReplication
+	const isNotNative = isLocked or entity.modelReplicationMode ~= "NATIVE"
+	for holder, playerPos in playerTablePositionPair do
+		const viewer = holder.PLAYER
+		const allowed = ReplicationRules.Allows(entity, viewer)
+		if not allowed then
+			continue
+		end
+
+		const distance = vector.magnitude(position - playerPos)
+
+		if distance > halfTickDistance and isNotNative then
+			if holder == ownedHolder then
+				table.insert(holder._TEMP_NORMAL, entity)
+			end
+			continue
+		end
+
+		if distance <= normalTickDistance then
+			hasNormalTickers = true
+			table.insert(holder._TEMP_NORMAL, entity)
+		else
+			hasHalfTickers = true
+			table.insert(holder._TEMP_HALF, entity)
+		end
+	end
+
+	const configTicker = entityConfig.TICKER
+	if not configTicker then
+		return
+	end
+
+	const currentTicker = entity._ticker
+	if hasHalfTickers and not hasNormalTickers then
+		if entity.isHalfTicked == false then
+			--warn("Entity is now half ticked", entity.id)
+		end
+		SetTickMode(entity, true)
+		HALF_TICKED += 1
+	elseif hasNormalTickers then
+		if entity.isHalfTicked then
+			--warn("Entity is normal ticked", entity.id)
+		end
+		SetTickMode(entity, false)
+		FULL_TICKED += 1
+	else
+		UN_TICKED += 1
+	end
+	if (hasNormalTickers or hasHalfTickers) and entity._ticker ~= configTicker then
+		Ticker.move(entity, configTicker)
+		--warn("Adding entity to ticker", entity.id)
+	elseif not (hasNormalTickers or hasHalfTickers) and currentTicker then
+		SetTickMode(entity, nil)
+		--warn("Removing entity from ticker", entity.id,currentTicker)
+		Ticker.Remove(currentTicker, entity)
+	end
+end
+
+local yielded: thread? = nil
+local totalTime = 0
+const function DoLoop()
+	totalTime = 0
+	FULL_TICKED = 0
+	HALF_TICKED = 0
+	UN_TICKED = 0
+	for holder, _ in playerTablePositionPair do
+		table.clear(holder._TEMP_HALF)
+		table.clear(holder._TEMP_NORMAL)
+	end
+	debug.profilebegin("EntityGrid.Update")
+	local count = 0
+	local start = os.clock()
+	local sections = 1
+	for _, entity in entities do
+		debug.profilebegin(`Check One`)
+		Check(entity)
+		count += 1
+		debug.profileend()
+		if os.clock() - start > MAX_TIME_PER_UPDATE then
+			sections += 1
+			debug.profileend()
+			totalTime += os.clock() - start
+			yielded = coroutine.running()
+			coroutine.yield()
+			yielded = nil
+			start = os.clock()
+			debug.profilebegin("EntityGrid.ResumeUpdate")
+		end
+	end
+	debug.profileend()
+	totalTime += os.clock() - start
+	Stats.SERVER.GRID_UPDATE_SECTIONS = sections
+	Stats.SERVER.ENTITY_GRID_UPDATE_TIME_MS = totalTime * 1000
+	Stats.SERVER.NUMBER_OF_ENTITIES = count
+	Stats.SERVER.ENTITIES_FULL_TICKED = FULL_TICKED
+	Stats.SERVER.ENTITIES_HALF_TICKED = HALF_TICKED
+	Stats.SERVER.NON_TICKED = UN_TICKED
+
+	local debugPlayers = {}
+
+	for _, holder in playerToHolder do
+		const tempNormal = holder._TEMP_NORMAL
+		const tempHalf = holder._TEMP_HALF
+		table.clear(holder.HALF)
+		table.clear(holder.NORMAL)
+		debugPlayers[holder.PLAYER.Name] = {
+			HALF = {},
+			NORMAL = {},
+		}
+		for _, entity in tempNormal do
+			table.insert(debugPlayers[holder.PLAYER.Name].NORMAL, entity.id)
+			table.insert(holder.NORMAL, entity)
+		end
+		for _, entity in tempHalf do
+			table.insert(debugPlayers[holder.PLAYER.Name].HALF, entity.id)
+			table.insert(holder.HALF, entity)
+		end
+	end
+	Stats.SERVER.GRID_STATS = debugPlayers
+end
+
+-- this might be able to be optimized more later
+const function Update()
+	if yielded then
+		task.spawn(yielded)
+		return
+	end
+	if os.clock() - lastUpdate < UPDATE_INTERVAL then
+		return
+	end
+	UPDATE_INTERVAL = Config._GetConfig("GRID_UPDATE_INTERVAL") or UPDATE_INTERVAL
+	MAX_TIME_PER_UPDATE = Config._GetConfig("GRID_MAX_UPDATE_TIME") or MAX_TIME_PER_UPDATE
+
+	lastUpdate = os.clock()
+	task.spawn(DoLoop)
+end
+
+const function UpdatePlayerPosition(player: Player, position: vector)
+	const holder = playerToHolder[player]
+	if not holder then
+		return
+	end
+	playerTablePositionPair[holder] = position
+end
+
+const function GetEntityHolder(Player: Player): PlayerEntityHolder?
+	return playerToHolder[Player]
+end
+
+const function PlayerAdded(player: Player)
+	if playerToHolder[player] then
+		return
+	end
+	const t = {
+		PLAYER = player,
+		HALF = {},
+		NORMAL = {},
+		REPLICATED = {},
+		_TEMP_HALF = {},
+		_TEMP_NORMAL = {},
+		EntityAdded = Signal.new(),
+		EntityRemoving = Signal.new(),
+	}
+	playerToHolder[player] = t
+	playerTablePositionPair[t] = vector.zero
+
+	Events._Signals.PlayerLoaded:Fire(player)
+end
+if RunService:IsServer() then
+	Shared.Remotes.ClientLoaded.OnServerEvent:Connect(PlayerAdded)
+
+	Players.PlayerRemoving:Connect(function(player: Player)
+		const holder = playerToHolder[player]
+		if not holder then
+			return
+		end
+		holder.EntityAdded:DisconnectAll()
+		holder.EntityRemoving:DisconnectAll()
+		playerTablePositionPair[holder] = nil
+		playerToHolder[player] = nil
+	end)
+end
+-- Players.PlayerAdded:Connect(PlayerAdded)
+
+return {
+	Update = Update,
+	UpdatePlayerPosition = UpdatePlayerPosition,
+	GetEntityHolder = GetEntityHolder,
+}

package/runtime/Chrono/Server/Player.luau

@@ -0,0 +1,141 @@
+--!native
+const Players = game:GetService("Players")
+
+const RunService = game:GetService("RunService")
+
+const Warn = require(script.Parent.Parent.Shared.Warn)
+const Config = require(script.Parent.Parent.Shared.Config)
+const Entity = require(script.Parent.Parent.Shared.Entity)
+const Holder = require(script.Parent.Parent.Shared.Holder)
+const Types = require(script.Parent.Parent.Shared.Types)
+
+const playerEntities = Holder._playerChars
+
+const function RegisterPlayer(
+	player: Player,
+	character: Model,
+	configuration: {
+		config: string?,
+		modelRepMode: Types.MODEL_REPLICATION_MODE?,
+	}
+): Types.Entity
+	const entity = playerEntities[player]
+
+	if entity then
+		Entity.Destroy(entity)
+	end
+
+	const config = configuration.config or "PLAYER"
+	local modelRepMode: Types.MODEL_REPLICATION_MODE? = configuration.modelRepMode
+	const configData = Config._EntityConfigs[config] or {} :: any
+	modelRepMode = modelRepMode or configData.MODEL_REPLICATION_MODE
+	character.Archivable = true
+
+	const humanoid = character:FindFirstChildWhichIsA("Humanoid")
+	const hrp = character:FindFirstChild("HumanoidRootPart")
+	if humanoid and hrp then
+		const rigType = humanoid.RigType
+		if rigType == Enum.HumanoidRigType.R6 and character.PrimaryPart == character:FindFirstChild("Head") then
+			Config.SetModelPrimaryForChrono(character, "HumanoidRootPart")
+		end
+	end
+
+	const newEntity = Entity.new(config, character, modelRepMode :: any)
+
+	Holder.SetAsCharacter(player, newEntity)
+	Entity.SetNetworkOwner(newEntity, player)
+
+	-- task.delay(7, function()
+	-- 	Entity.SetModel(newEntity, character, "NATIVE", true)
+	-- 	task.wait(5)
+	-- 	Entity.SetModel(newEntity, character, "CUSTOM", true)
+	-- end)
+
+	return newEntity
+end
+
+const function UnregisterPlayer(player: Player)
+	const entity = playerEntities[player]
+	if entity then
+		Entity.Destroy(entity)
+	end
+end
+
+const function OnCharacterAdded(character: Model, player: Player)
+	task.wait(0.1)
+	RegisterPlayer(player, character, {
+		config = "PLAYER",
+	})
+end
+
+const function OnPlayerAdded(player: Player)
+	const connection = player.CharacterAdded:Connect(function(character: Model)
+		OnCharacterAdded(character, player)
+	end)
+	if player.Character then
+		OnCharacterAdded(player.Character, player)
+	end
+	local connection2
+	connection2 = player.AncestryChanged:Connect(function()
+		if not player:IsDescendantOf(game) then
+			connection:Disconnect()
+			connection2:Disconnect()
+		end
+	end)
+end
+
+Config._WaitForLock(function()
+	if not RunService:IsServer() then
+		return
+	end
+	if Config._GetConfig("PLAYER_REPLICATION") ~= "AUTOMATIC" then
+		Warn.low("automatic player replication is disabled")
+		return
+	end
+	const deathRemote = script.Parent.Parent.Shared.Remotes.Death
+	const ReplicateMode: "NONE" | "PLAYER_ENTITIES" | "PLAYER_CHARACTERS" = Config._GetConfig("REPLICATE_DEATHS")
+	deathRemote.OnServerEvent:Connect(function(plr, id)
+		if ReplicateMode == "NONE" then
+			return
+		end
+		const entity = Holder.GetEntityFromId(id)
+		if not entity then
+			return
+		end
+
+		if entity.networkOwner ~= plr then
+			return
+		end
+		if ReplicateMode == "PLAYER_CHARACTERS" and not entity._player then
+			return
+		end
+
+		const model = entity.model
+		if model then
+			const humanoid: Humanoid? = model:FindFirstChildWhichIsA("Humanoid")
+			task.wait()
+			if humanoid and humanoid:GetState() ~= Enum.HumanoidStateType.Dead then
+				humanoid.Health = 0
+				task.delay(0, function()
+					if humanoid:GetState() ~= Enum.HumanoidStateType.Dead then
+						humanoid.Health = 0
+						humanoid.Health = 10
+						humanoid.Health = 0
+					end
+				end)
+			end
+		end
+		deathRemote:FireAllClients(id)
+	end)
+	Players.PlayerAdded:Connect(OnPlayerAdded)
+	Players.PlayerRemoving:Connect(UnregisterPlayer)
+
+	for _, player in Players:GetPlayers() do
+		OnPlayerAdded(player)
+	end
+end)
+
+return {
+	RegisterPlayer = RegisterPlayer,
+	UnregisterPlayer = UnregisterPlayer,
+}