cluaupp 1.0.0 → 1.4.0

package/runtime/Chrono/Client/Sender.luau

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

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

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

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