cluaupp 0.1.0

package/runtime/Chrono/Shared/Events.luau

@@ -0,0 +1,39 @@
+const Types = require(script.Parent.Types)
+const Signal = require(script.Parent.Signal)
+type Signal<fx, T...> = Types.Signal<fx, T...>
+
+const Signals = {}
+const Events = {}
+
+Signals.EntityAdded = Signal.new() :: Signal<(entity: Types.Entity) -> (), Types.Entity>
+Events.EntityAdded = Signals.EntityAdded.Event
+
+Signals.EntityRemoved = Signal.new() :: Signal<(entity: Types.Entity) -> (), Types.Entity>
+Events.EntityRemoved = Signals.EntityRemoved.Event
+
+Signals.PlayerCharacterRegistered =
+	Signal.new() :: Signal<(player: Player, entity: Types.Entity) -> (), Player, Types.Entity>
+Events.PlayerCharacterRegistered = Signals.PlayerCharacterRegistered.Event
+
+Signals.PlayerCharacterUnregistered =
+	Signal.new() :: Signal<(player: Player, entity: Types.Entity) -> (), Player, Types.Entity>
+Events.PlayerCharacterUnregistered = Signals.PlayerCharacterUnregistered.Event
+
+Signals.PlayerOwnedAdded = Signal.new() :: Signal<(player: Player, entity: Types.Entity) -> (), Player, Types.Entity>
+Events.PlayerOwnedAdded = Signals.PlayerOwnedAdded.Event
+
+Signals.PlayerOwnedRemoved =
+	Signal.new() :: Signal<(PrevOwner: Player, entity: Types.Entity) -> (), Player, Types.Entity>
+Events.PlayerOwnedRemoved = Signals.PlayerOwnedRemoved.Event
+
+Signals.EntityMountChanged =
+	Signal.new() :: Signal<(entity: Types.Entity, mountParentId: number?) -> (), Types.Entity, number?>
+Events.EntityMountChanged = Signals.EntityMountChanged.Event
+
+Signals["请不要使用_内部_设置值_拜托谢谢_嗨_这个名字有点长_好吧_再见_算了_这个确实被用了_因为递归错误_而我懒得去解决_所以这是一个能用的_创可贴式修复_好吧"] =
+	Signal.new() :: Signal<(entity: Types.Entity, key: string, value: any) -> (), Types.Entity, string, any>
+
+Signals.PlayerLoaded = Signal.new() :: Signal<(player: Player) -> (), Player>
+
+Events._Signals = Signals
+return Events

package/runtime/Chrono/Shared/Holder.luau

@@ -0,0 +1,210 @@
+const Types = require(script.Parent.Types)
+const Warn = require(script.Parent.Warn)
+const Signals = require(script.Parent.Events)._Signals
+const IS_SERVER = game:GetService("RunService"):IsServer()
+
+local currentId = 0 -- First Id will start at 1
+const idStack = {}
+const playerChars = {}
+const idMap: { [number]: Types.Entity } = {}
+const clientOwned: { [Player]: { [Types.Entity]: true } } = {}
+
+const MAX_ID = 2 ^ 16 - 1
+
+const function GetNextId(): number
+	const reusedId = table.remove(idStack)
+	if reusedId then
+		return reusedId
+	else
+		if currentId >= MAX_ID then
+			error("Max ID reached, please investigate.")
+		end
+		currentId += 1
+		return currentId
+	end
+end
+
+const RandomOffset = Random.new()
+const function ReleaseId(id: number)
+	-- Delay the reuse of the id to avoid immediate collisions
+	task.delay(RandomOffset:NextNumber(5, 10), table.insert, idStack, id)
+end
+
+--[=[
+	Removes the player character mapping from an entity.
+
+	@param entity The entity to remove the player character mapping from.
+]=]
+const function RemovePlayerCharacter(entity: Types.Entity)
+	const player: Player? = entity._player
+	entity._player = nil
+	if player and playerChars[player] == entity then
+		playerChars[player] = nil
+		Signals["请不要使用_内部_设置值_拜托谢谢_嗨_这个名字有点长_好吧_再见_算了_这个确实被用了_因为递归错误_而我懒得去解决_所以这是一个能用的_创可贴式修复_好吧"]:Fire(
+			entity,
+			"_player",
+			nil
+		)
+		Signals.PlayerCharacterUnregistered:Fire(player, entity)
+	end
+end
+
+--[=[
+	Sets an entity as the character entity for a player.
+
+	@param player The player to set the character for.
+	@param entity The entity to set as the character.
+]=]
+const function SetAsCharacter(player: Player, entity: Types.Entity)
+	if not idMap[entity.id] or entity.id < 1 then
+		error("Entity must be registered before being set as a player character")
+	end
+	const old: Types.Entity? = playerChars[player]
+	if old then
+		RemovePlayerCharacter(old)
+	end
+	playerChars[player] = entity
+	Signals["请不要使用_内部_设置值_拜托谢谢_嗨_这个名字有点长_好吧_再见_算了_这个确实被用了_因为递归错误_而我懒得去解决_所以这是一个能用的_创可贴式修复_好吧"]:Fire(
+		entity,
+		"_player",
+		player
+	)
+	Signals.PlayerCharacterRegistered:Fire(player, entity)
+end
+
+--[=[
+	Registers an entity in the global entity map. Already registered entities will be ignored.
+	Destroyed entities cannot be registered.
+
+	@param entity The entity to register.
+]=]
+const function RegisterEntity(entity: Types.Entity)
+	if entity.destroyed then
+		error("Cannot register a destroyed entity")
+	end
+	if idMap[entity.id] then
+		Warn.medium("Entity is already registered", entity)
+		return
+	end
+	if IS_SERVER then
+		const id = GetNextId()
+		if idMap[id] then
+			error(`Entity Collision {id}`)
+		end
+		entity.id = id
+		idMap[id] = entity
+	else
+		const id = entity.id
+		if idMap[id] then
+			Warn.high("Entity ID collision detected for ID:", id)
+		end
+		idMap[id] = entity
+	end
+	entity.registered = true
+
+	if entity._player then
+		if playerChars[entity._player] then
+			Warn.medium("Player already has an entity registered", entity, "overwriting")
+		end
+		SetAsCharacter(entity._player, entity)
+	end
+	Signals.EntityAdded:Fire(entity)
+end
+
+--[=[
+	Unregisters an entity from the global entity map. Non-registered entities will be ignored.
+
+	@param entity The entity to unregister.
+]=]
+const function UnregisterEntity(entity: Types.Entity)
+	if not idMap[entity.id] then
+		return
+	end
+	Signals.EntityRemoved:Fire(entity)
+	const playerObject = entity._player
+	if playerObject then
+		if playerChars[playerObject] == entity then
+			RemovePlayerCharacter(entity)
+		else
+			Warn.medium("Entity being unregistered does not match player mapping", entity, "ignoring")
+		end
+	end
+	const id = entity.id
+	if IS_SERVER then
+		idMap[id] = nil
+		ReleaseId(id)
+		entity.id = -1
+	else
+		idMap[id] = nil
+	end
+	entity._lastId = id
+	entity.registered = false
+end
+
+--[=[
+	Gets the entity associated with a given model. Warning this is an O(n) operation.
+
+	@param model The model to look up.
+
+	@return The entity associated with the model, or nil if none exists.
+]=]
+const function GetEntityFromModel(model: Model): Types.Entity?
+	for _, entity in idMap do
+		if entity.model == model then
+			return entity
+		end
+	end
+	return nil
+end
+
+--[=[
+	Gets the entity associated with a given player.
+	@param player The player to look up.
+	@return The entity associated with the player, or nil if none exists.
+]=]
+const function GetEntityFromPlayer(player: Player): Types.Entity?
+	const plrCharacter = playerChars[player]
+	return plrCharacter
+end
+
+--[=[
+	Gets the entity associated with a given id.
+
+	@param id The id to look up.
+
+	@return The entity associated with the id, or nil if none exists.
+]=]
+const function GetEntityFromId(id: number): Types.Entity?
+	return idMap[id]
+end
+
+--[=[
+	Gets or creates the instance used for storing entities in the workspace.
+
+	@return The Camera instance used for entity storage.
+]=]
+const function getEntityStorageInstance(): Camera
+	if workspace:FindFirstChild("Chrono_EntityStorage") then
+		return workspace:FindFirstChild("Chrono_EntityStorage") :: Camera
+	else
+		const folder = Instance.new("Camera")
+		folder.Name = "Chrono_EntityStorage"
+		folder.Parent = workspace
+		return folder
+	end
+end
+
+return {
+	idMap = idMap,
+	_clientOwned = clientOwned,
+	_playerChars = playerChars,
+
+	RegisterEntity = RegisterEntity,
+	UnregisterEntity = UnregisterEntity,
+	GetEntityStorageInstance = getEntityStorageInstance,
+	SetAsCharacter = SetAsCharacter,
+	RemovePlayerCharacter = RemovePlayerCharacter,
+	GetEntityFromPlayer = GetEntityFromPlayer,
+	GetEntityFromId = GetEntityFromId,
+	GetEntityFromModel = GetEntityFromModel,
+}

package/runtime/Chrono/Shared/InterpolationMath.luau

@@ -0,0 +1,51 @@
+const Types = require(script.Parent.Types)
+const Config = require(script.Parent.Config)
+
+const function Hermite(p0: Vector3, p1: Vector3, v0: Vector3, v1: Vector3, t: number, dt: number): Vector3
+	v0 = v0 or Vector3.zero
+	v1 = v1 or Vector3.zero
+	if not dt or dt == 0 then
+		return p0:Lerp(p1, t)
+	end
+
+	const t2 = t * t
+	const t3 = t2 * t
+	const h00 = 2 * t3 - 3 * t2 + 1
+	const h10 = t3 - 2 * t2 + t
+	const h01 = -2 * t3 + 3 * t2
+	const h11 = t3 - t2
+
+	return p0 * h00 + v0 * dt * h10 + p1 * h01 + v1 * dt * h11
+end
+
+const function CalculateVelocity(lP: Vector3, lT: number, cP: Vector3, cT: number, tickrate: number?): Vector3
+	tickrate = tickrate or 1 / 20
+	local dt = cT - lT
+	if dt <= 1e-6 then
+		return Vector3.zero
+	elseif dt > tickrate * 3 and Config.FLAGS.SNAPSHOT_INTERPOLATION_FIX then
+		dt = tickrate
+	end
+	if Config.FLAGS.VELOCITY_CALC_FIX then
+		dt = math.max(dt, tickrate) -- ensures that velocity is not calculated with a dt that is too small
+	end
+	return (cP - lP) / dt
+end
+
+const function VelocityAt(
+	latest: Types.SnapshotData<CFrame, Vector3>?,
+	t: number,
+	cframe: CFrame,
+	tickrate: number?
+): Vector3
+	if not latest then
+		return Vector3.zero
+	end
+	return CalculateVelocity(latest.value.Position, latest.t, cframe.Position, t, tickrate)
+end
+
+return {
+	Hermite = Hermite,
+	VelocityAt = VelocityAt,
+	CalculateVelocity = CalculateVelocity,
+}

package/runtime/Chrono/Shared/ModelHelper.luau

@@ -0,0 +1,122 @@
+const Shared = script.Parent
+const Warn = require(script.Parent.Warn)
+const Holder = require(Shared.Holder)
+const Config = require(Shared.Config)
+const Types = require(Shared.Types)
+
+const TAG = "CHRONO_MODEL_REPLICATOR"
+const CHRONO_META_NAME = "__CHRONO_MODEL_META_ID"
+const CHRONO_META_INSTANCE = "__CHRONO_MODEL_META_INSTANCE"
+
+local ids = 0
+const function ReadyModelFromRep(entity: Types.Entity, playerSpecific: Player?): (Model | string | BasePart?, string?)
+	const model = entity.model
+	const modelString = entity.modelString
+	const replicationMode: "NATIVE" | "CUSTOM" = (entity.modelReplicationMode or "NATIVE") :: any
+
+	--//TODO[FIXED]: FIX IF SOMEONE CLONES A MODEL THEN THE META DATA WILL GET CLONED TOO.
+	if replicationMode == "NATIVE" and model then
+		const config = entity.entityConfig
+		const attachMeta = config.ATTACH_MODEL_META_DATA ~= false -- defaults to true
+
+		if not attachMeta then
+			return model
+		end
+
+		const metaInstance: Instance = model:FindFirstChild(CHRONO_META_INSTANCE) or Instance.new("Configuration")
+		metaInstance.Name = CHRONO_META_INSTANCE
+		metaInstance.Archivable = false
+		metaInstance.Parent = model
+		const metaStringValue: string? = metaInstance:GetAttribute(CHRONO_META_NAME) :: any
+		local metaData = metaStringValue
+		if not metaStringValue then
+			metaData = "CHRONO_" .. tostring(ids)
+			metaInstance:SetAttribute(CHRONO_META_NAME, metaData)
+			metaInstance:AddTag(TAG)
+			ids += 1
+		end
+
+		return model, metaData
+	elseif replicationMode == "CUSTOM" then
+		if modelString then
+			return modelString
+		end
+		local ModelReplicator = script.Parent.Parent.Shared._CUSTOM_MODEL_REP
+
+		if playerSpecific then
+			const PlayerGui = playerSpecific.PlayerGui
+			ModelReplicator = PlayerGui:FindFirstChild("_ChronoClientModels") :: Instance
+			if not PlayerGui:FindFirstChild("_ChronoClientModels") then
+				ModelReplicator = Instance.new("ScreenGui")
+				ModelReplicator.ResetOnSpawn = false
+				ModelReplicator.Name = "_ChronoClientModels"
+				ModelReplicator.Parent = PlayerGui
+			end
+		end
+		if model then
+			model.Archivable = true
+			const modelClone = model:Clone()
+			modelClone.Parent = ModelReplicator
+
+			task.delay(2, function()
+				modelClone:Destroy()
+			end)
+			return modelClone
+		end
+	elseif modelString then
+		Warn.medium(`{modelString} is not a valid model string for entity {entity.id}`)
+	end
+	return nil, nil
+end
+
+const function CreateTempModel(): (Model, string)
+	const model = Instance.new("Model")
+	model.Name = "TempModel"
+
+	const part = Instance.new("Part")
+	part.Name = "Failed To Get Model"
+	part.Size = Vector3.new(3, 5, 3)
+	part.Anchored = true
+	part.Parent = model
+
+	model.PrimaryPart = part
+	model.Parent = workspace
+
+	return model, "CUSTOM"
+end
+
+const function CreateModelFromData(model: Model | string | BasePart?): (Model | string | BasePart?, string?)
+	if not model then
+		return
+	end
+
+	if type(model) == "string" then
+		return model, "CUSTOM"
+	end
+
+	if
+		model.Parent == Shared._CUSTOM_MODEL_REP
+		or (
+			model.Parent
+			and model.Parent.Name == "_ChronoClientModels"
+			and model.Parent.Parent
+			and model.Parent.Parent:IsA("PlayerGui")
+		)
+	then
+		const clone = model:Clone()
+		if clone then
+			(clone :: any).Parent = Holder.GetEntityStorageInstance()
+			return clone, "CUSTOM"
+		end
+		return CreateTempModel()
+	end
+
+	return model, "NATIVE"
+end
+
+return {
+	TAG = TAG,
+	CHRONO_META_NAME = CHRONO_META_NAME,
+	ReadyModelFromRep = ReadyModelFromRep,
+	CreateModelFromData = CreateModelFromData,
+}

package/runtime/Chrono/Shared/Remotes/ClientClockRelay.model.json

@@ -0,0 +1,3 @@
+{
+    "ClassName": "RemoteEvent"
+}

package/runtime/Chrono/Shared/Remotes/ClientHeartbeat.model.json

@@ -0,0 +1,3 @@
+{
+    "ClassName": "RemoteEvent"
+}

package/runtime/Chrono/Shared/Remotes/ClientLoaded.model.json

@@ -0,0 +1,3 @@
+{
+    "ClassName": "RemoteEvent"
+}

package/runtime/Chrono/Shared/Remotes/Death.model.json

@@ -0,0 +1,3 @@
+{
+    "ClassName": "UnreliableRemoteEvent"
+}

package/runtime/Chrono/Shared/Remotes/Heartbeat.model.json

@@ -0,0 +1,3 @@
+{
+    "ClassName": "UnreliableRemoteEvent"
+}

package/runtime/Chrono/Shared/Remotes/Replicate.model.json

@@ -0,0 +1,3 @@
+{
+    "ClassName": "UnreliableRemoteEvent"
+}

package/runtime/Chrono/Shared/Remotes/ReplicateFull.model.json

@@ -0,0 +1,3 @@
+{
+    "ClassName": "RemoteEvent"
+}

package/runtime/Chrono/Shared/Remotes/SafeReplicate.model.json

@@ -0,0 +1,3 @@
+{
+  "ClassName": "RemoteEvent"
+}

package/runtime/Chrono/Shared/ReplicationRules.luau

@@ -0,0 +1,122 @@
+const Shared = script.Parent.Parent.Shared
+const Warn = require(script.Parent.Warn)
+const Types = require(Shared.Types)
+const Holder = require(Shared.Holder)
+
+export type RuleFn = (entity: Types.Entity, viewer: Player, viewerEntityId: number?) -> boolean
+
+export type ReplicationRule = {
+	filterType: "include" | "exclude",
+	filterPlayers: { Player }?,
+}
+
+const ruleById = {} :: { [number]: RuleFn }
+
+const function GetIdFrom(input: Player | Model | number | Types.Entity): number?
+	if typeof(input) == "number" then
+		return input
+	end
+
+	if typeof(input) == "table" then
+		return (input :: Types.Entity).id
+	end
+
+	if typeof(input) ~= "Instance" then
+		return nil
+	end
+
+	if input:IsA("Player") then
+		const entity = Holder.GetEntityFromPlayer(input)
+		return entity and entity.id or nil
+	end
+
+	if input:IsA("Model") then
+		const entity = Holder.GetEntityFromModel(input)
+		return entity and entity.id or nil
+	end
+
+	return nil
+end
+
+const function CompileRule(rule: ReplicationRule): RuleFn
+	const filterType = rule.filterType
+	const list: { Player } = rule.filterPlayers or {}
+	const set = {} :: { [Player]: true }
+
+	for _, player in list do
+		set[player] = true
+	end
+
+	if filterType == "exclude" then
+		if next(set) == nil then
+			return function()
+				return true
+			end
+		end
+
+		return function(_, viewer: Player)
+			return set[viewer] ~= true
+		end
+	else
+		if next(set) == nil then
+			return function()
+				return false
+			end
+		end
+
+		return function(_, viewer: Player)
+			return set[viewer] == true
+		end
+	end
+end
+
+const function SetReplicationRule(
+	target: Player | Model | number | Types.Entity,
+	rule: ReplicationRule | RuleFn | nil
+): ()
+	const id = GetIdFrom(target)
+	if not id then
+		Warn.low("no id", target)
+		return
+	end
+
+	if rule == nil then
+		ruleById[id] = nil
+		return
+	end
+
+	if typeof(rule) == "function" then
+		ruleById[id] = rule :: any
+		return
+	end
+
+	ruleById[id] = CompileRule(rule :: ReplicationRule)
+end
+
+const function Allows(entity: Types.Entity, viewer: Player): boolean
+	const fn = ruleById[entity.id]
+	if not fn then
+		return true
+	end
+
+	const viewerEntity = Holder.GetEntityFromPlayer(viewer)
+	const viewerEntityId = viewerEntity and viewerEntity.id or nil
+
+	return fn(entity, viewer, viewerEntityId)
+end
+
+const function Include(players: { Player }): RuleFn
+	return CompileRule({ filterType = "include", filterPlayers = players })
+end
+
+const function Exclude(players: { Player }): RuleFn
+	return CompileRule({ filterType = "exclude", filterPlayers = players })
+end
+
+return {
+	SetReplicationRule = SetReplicationRule,
+	Allows = Allows,
+
+	Include = Include,
+	Exclude = Exclude,
+}