cluaupp 0.1.0

package/runtime/Chrono/_impl/Shared/Ticker.luau

@@ -0,0 +1,112 @@
+const RunService = game:GetService("RunService")
+const Ticker = {}
+
+--//TODO: this should be in server since client don't use it, maybe move later
+
+const function popSwap(t, item, index)
+	const lastIndex = #t
+	if index ~= lastIndex then
+		const lastItem = t[lastIndex]
+		t[index] = lastItem
+		lastItem._tickerIndex = index
+	end
+	t[lastIndex] = nil
+end
+
+const Types = require(script.Parent.Types)
+const Warn = require(script.Parent.Warn)
+type Entity = Types.Entity
+type Ticker = Types.Ticker
+
+local GlobalTick = 0
+
+function Ticker._IncrementGlobalTick()
+	GlobalTick += 1
+end
+
+function Ticker.GetGlobalTick()
+	return GlobalTick
+end
+
+function Ticker.new(config: Types.EntityConfig): Ticker
+	const ticker = {
+		tickedHalf = false,
+		tickHalfRate = config.TICK_RATE * 2,
+		tickRate = config.TICK_RATE,
+		lastTicked = 0,
+		tickedFrame = 0,
+		objects = {},
+		callbacks = {},
+		config = config,
+		dt = 0,
+		halfdt = 0,
+	}
+	return ticker
+end
+
+function Ticker.AddCallback(ticker: Ticker, callback: (ticker: Ticker, dt: number) -> ())
+	table.insert(ticker.callbacks, callback)
+end
+
+function Ticker.RemoveCallback(ticker: Ticker, callback: (ticker: Ticker, dt: number) -> ())
+	const index = table.find(ticker.callbacks, callback)
+	if index then
+		table.remove(ticker.callbacks, index)
+	end
+end
+
+function Ticker.Add(ticker: Ticker, object: Entity)
+	table.insert(ticker.objects, object)
+	object._ticker = ticker
+	object._tickerIndex = #ticker.objects
+end
+
+function Ticker.Remove(ticker: Ticker, object: Entity)
+	const index = object._tickerIndex
+	if not index then
+		Warn.low("Ticker.remove called on object not in ticker", object.id)
+		return
+	end
+
+	popSwap(ticker.objects :: any, object, index)
+
+	object._ticker = nil
+	object._tickerIndex = nil
+end
+
+function Ticker.move(object: Entity, newTicker: Ticker)
+	const oldTicker = object._ticker
+	if oldTicker then
+		Ticker.Remove(oldTicker, object)
+	end
+	Ticker.Add(newTicker, object)
+end
+
+function Ticker.CheckUpdate(ticker: Ticker): boolean
+	const difference = os.clock() - ticker.lastTicked
+
+	if difference >= ticker.tickRate then
+		ticker.lastTicked = os.clock()
+		ticker.tickedFrame = GlobalTick
+		ticker.tickedHalf = not ticker.tickedHalf
+
+		if ticker.tickedHalf then
+			ticker.halfdt = difference + ticker.dt
+		else
+			ticker.halfdt = difference
+		end
+
+		ticker.dt = difference
+		if #ticker.callbacks > 0 then
+			for _, callback in ticker.callbacks do
+				callback(ticker, difference)
+			end
+		end
+
+		return true
+	end
+
+	return false
+end
+
+return Ticker

package/runtime/Chrono/_impl/Shared/Types.luau

@@ -0,0 +1,247 @@
+export type SnapshotData<Value = CFrame, Velocity = Vector3> = {
+	t: number,
+	value: Value,
+	velocity: Velocity,
+}
+
+--// FX is the function template for the events.
+export type Signal<fx, T...> = {
+	Fire: (self: any, T...) -> (),
+	DisconnectAll: (self: any) -> (),
+	Event: Event<fx, T...>,
+}
+
+export type ClientEntitiesStats = {
+	id: number,
+	entity: Entity,
+	networkOwner: Player?,
+	isCharacter: boolean,
+	config: string,
+	lastReceivedTime: number?,
+	lastReplicatedTime: number?,
+
+	averageLatency: number?,
+	targetTime: number?,
+	deviation: number?,
+	bufferedTime: number?,
+	currentPosition: Vector3?,
+	snapshots: {
+		t: number,
+		value: CFrame,
+	},
+}
+
+export type ServerEntitiesStats = {
+	id: number,
+	isPaused: boolean,
+	networkOwner: Player?,
+	isCharacter: boolean,
+	config: string,
+	tickRate: number?,
+	lastTicked: number?,
+	lastPosition: Vector3,
+	modelType: string?,
+}
+export type Connection = {
+	Disconnect: (self: any) -> (),
+	Connected: boolean,
+	_binCleanup: () -> (),
+}
+
+export type Event<fx, T...> = {
+	Connect: (self: any, FN: fx, defer: boolean?) -> Connection,
+	Once: (self: any, FN: fx, defer: boolean?) -> Connection,
+	Wait: (self: any, defer: boolean?) -> T...,
+	_binCleanup: () -> (),
+}
+
+export type Snapshot<Value, Velocity> = {
+	cache: { SnapshotData<Value, Velocity> },
+	head: number,
+	count: number,
+	lockedTime: number,
+	Lerp: (p0: Vector3, p1: Vector3, v0: Velocity, v1: Velocity, t: number, dt: number) -> Vector3,
+
+	Push: (self: Snapshot<Value, Velocity>, t: number, value: Value, velocity: Velocity) -> (),
+	PushWithCheck: (
+		self: Snapshot<Value, Velocity>,
+		t: number,
+		value: Value,
+		velocity: Velocity,
+		tickrate: number
+	) -> (),
+
+	GetLatest: (self: Snapshot<Value, Velocity>) -> SnapshotData<Value, Velocity>?,
+	GetAt: (self: Snapshot<Value, Velocity>, t: number, bypassLock: boolean?) -> Value?,
+	Clear: (self: Snapshot<Value, Velocity>) -> (),
+}
+
+export type PlayerEntityHolder = {
+	PLAYER: Player,
+	HALF: { Entity },
+	NORMAL: { Entity },
+	_TEMP_HALF: { Entity },
+	_TEMP_NORMAL: { Entity },
+	REPLICATED: { [Entity]: true },
+	EntityAdded: Signal<(Entity) -> (), Entity>,
+	EntityRemoving: Signal<(Entity) -> (), Entity>,
+}
+
+export type MODEL_REPLICATION_MODE = "NATIVE" | "NATIVE_WITH_LOCK" | "CUSTOM"
+export type EntityConfig = {
+	NAME: string,
+	TICKER: Ticker?,
+	CLIENT_CLOCK: {
+		NORMAL: ClientClock?,
+		HALF: ClientClock?,
+	}?,
+
+	BUFFER: number,
+	TICK_RATE: number,
+	FULL_ROTATION: boolean?, -- defaults to false
+	AUTO_UPDATE_POSITION: boolean?, -- defaults to true
+	STORE_SNAPSHOTS: boolean?, -- defaults to false
+	MODEL_REPLICATION_MODE: MODEL_REPLICATION_MODE?,
+	NORMAL_TICK_DISTANCE: number?,
+	HALF_TICK_DISTANCE: number?,
+	CUSTOM_INTERPOLATION: boolean?,
+	ASSEMBLY_ROOT_PART_CHECK: boolean?,
+	ATTACH_MODEL_META_DATA: boolean?, -- defaults to true
+	UpdateBuffer: (self: EntityConfig, buffer: number) -> ()?,
+}
+
+export type EntityConfigInput = {
+	BUFFER: number,
+	TICK_RATE: number,
+	FULL_ROTATION: boolean?,
+	AUTO_UPDATE_POSITION: boolean?, -- If false have to manually call Entity.push
+	STORE_SNAPSHOTS: boolean?, -- Should snapshots be stored on the server. Excludes client owned
+	MODEL_REPLICATION_MODE: MODEL_REPLICATION_MODE?,
+	ASSEMBLY_ROOT_PART_CHECK: boolean?, -- If true, will check if the primary part is the root part of the model or inside the model.
+
+	NORMAL_TICK_DISTANCE: number?,
+	HALF_TICK_DISTANCE: number?,
+	CUSTOM_INTERPOLATION: boolean?,
+	ATTACH_MODEL_META_DATA: boolean?, -- if explicitly false then chrono will not attach meta data. See shared/ModelHelper
+	-- Might consider giving a config level replication rules instead of just entity
+}
+
+export type Ticker = {
+	tickedHalf: boolean,
+	tickRate: number,
+	tickHalfRate: number,
+	lastTicked: number,
+	tickedFrame: number,
+	objects: { Entity },
+	callbacks: { (ticker: Ticker, dt: number) -> () },
+	config: EntityConfig,
+	dt: number,
+	halfdt: number,
+}
+
+export type InterpolationBuffer = {
+	init: boolean,
+	averageLatency: number,
+	deviation: number,
+	lastLatency: number,
+	clientClock: ClientClock,
+}
+
+export type ClientClock = {
+	name: string,
+	lastClockAt: number?,
+	lastClockDuration: number,
+	renderAt: number?,
+	tickRate: number,
+	_baseTickRate: number,
+	_owner: Player?,
+	buffer: InterpolationBuffer?,
+	bufferConst: number?,
+
+	Clear: (self: ClientClock) -> (),
+	GetTargetRenderTime: (self: ClientClock) -> number,
+	GetEstimatedServerTime: (self: ClientClock) -> number,
+	OnSnapShot: (self: ClientClock, currentTime: number) -> (),
+	Refresh: (self: ClientClock, currentTime: number) -> boolean,
+	SetTickRate: (self: ClientClock, tickRate: number) -> (),
+	UpdateBuffer: (self: ClientClock, time: number?) -> (),
+	Destroy: (self: ClientClock) -> (),
+}
+
+export type ReplicationRule = {}
+
+export type EntityReceivePacket = {
+	id: number,
+	_player: Player?,
+	networkOwner: Player?,
+	time: number,
+	cframe: CFrame,
+	config: string?,
+	model: string | Model | BasePart?,
+	paused: boolean?,
+	isHalfTicked: boolean?,
+	_data: any,
+	mountParentId: number?,
+	mountOffset: CFrame?,
+	broadPhase: vector?,
+	_modelMetaData: string?,
+	_lockedCFReplication: boolean?,
+}
+
+export type Entity = {
+	--Client
+	-- this is for non server owned
+	_clockBuffer: number?,
+	_clientClock: ClientClock?,
+	_modelMetaData: string?,
+	broadPhase: vector?,
+	interpolation: boolean,
+	_outofBroadPhaseTick: number?,
+	_teleport: number?,
+	--Server
+	autoUpdatePosition: boolean,
+	replicationRules: { ReplicationRule }?,
+	_ticker: Ticker?,
+	_tickerIndex: number?,
+
+	--NetworkOwner
+	isContextOwner: boolean,
+	networkOwner: Player?,
+	_player: Player?,
+	_cfLockFailed: boolean?,
+
+	snapshot: Snapshot<CFrame, Vector3>?,
+	latestCFrame: CFrame?,
+	latestTime: number?,
+
+	isHalfTicked: boolean?,
+	id: number,
+	entityConfig: EntityConfig, -- defaults to DEFAULT config
+	modelString: string?,
+	model: Model | BasePart?,
+	paused: boolean,
+
+	modelReplicationMode: "NATIVE" | "CUSTOM"?,
+
+	lastCheckedCFrame: CFrame?,
+
+	lastReplicatedTime: number?,
+	arriveFrame: number?, -- This is only for client owned on the server
+	lastClientClock: number?,
+
+	cframeBuffer: buffer?,
+	registered: boolean,
+	destroyed: boolean,
+
+	_lockedCFReplication: boolean?,
+	_data: any,
+	_changes: { { string | any } }?,
+	_events: { [string]: Signal<any, any> }?,
+	_lastId: number?,
+	_chronoPrimary: string?,
+
+	mountParentId: number?,
+	mountOffset: CFrame?,
+}
+
+return nil

package/runtime/Chrono/_impl/Shared/Warn.luau

@@ -0,0 +1,33 @@
+const Config = require(script.Parent.Config)
+
+type level = Config.WarningLevels
+
+const function checkLevel(level: level): boolean
+	const levels: { [level]: number } = {
+		NONE = 0,
+		LOW = 1,
+		MEDIUM = 2,
+		HIGH = 3,
+	}
+	const currentLevel = levels[Config._GetConfig("WARNING_SEVERITY") :: level] or 0
+	if currentLevel == 0 then
+		return false
+	end
+	const checkAgainst = levels[level] or 0
+	return currentLevel <= checkAgainst
+end
+
+return (
+	setmetatable({}, {
+		__index = function(_, level: level)
+			if not checkLevel(level:upper()) then
+				return function() end
+			end
+			return warn
+		end,
+	}) :: any
+) :: {
+	low: (...any) -> (),
+	medium: (...any) -> (),
+	high: (...any) -> (),
+}

package/runtime/Chrono/_impl/Shared/_CUSTOM_MODEL_REP/init.model.json

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

package/runtime/Chrono/_impl/init.luau

@@ -0,0 +1,96 @@
+const RunService = game:GetService("RunService")
+
+const IS_SERVER = RunService:IsServer()
+const Config = require(script.Shared.Config)
+const HTTPS = game:GetService("HttpService")
+const Stats = require(script.Shared.Stats)
+const Player = require(script.Server.Player)
+const Receiver = require(script.Server.Receiver)
+const ServerClock = require(script.Server.ServerClock)
+const Entity = require(script.Shared.Entity)
+const Events = require(script.Shared.Events)
+const Holder = require(script.Shared.Holder)
+const ReplicationRules = require(script.Shared.ReplicationRules)
+const Snapshots = require(script.Shared.Snapshots)
+const Types = require(script.Shared.Types)
+const EntityGrid = require(script.Server.EntityGrid)
+
+export type SnapshotData<Value, Velocity> = Types.SnapshotData<Value, Velocity>
+export type Signal<fx, T...> = Types.Signal<fx, T...>
+export type ClientEntitiesStats = Types.ClientEntitiesStats
+export type ServerEntitiesStats = Types.ServerEntitiesStats
+export type Connection = Types.Connection
+export type Event<fx, T...> = Types.Event<fx, T...>
+export type Snapshot<Value, Velocity> = Types.Snapshot<Value, Velocity>
+export type MODEL_REPLICATION_MODE = Types.MODEL_REPLICATION_MODE
+export type EntityConfig = Types.EntityConfig
+export type EntityConfigInput = Types.EntityConfigInput
+export type Ticker = Types.Ticker
+export type InterpolationBuffer = Types.InterpolationBuffer
+export type ClientClock = Types.ClientClock
+export type ReplicationRule = Types.ReplicationRule
+export type EntityReceivePacket = Types.EntityReceivePacket
+export type Entity = Types.Entity
+export type PlayerEntityHolder = Types.PlayerEntityHolder
+
+const function CheckVersion()
+	task.spawn(function()
+		pcall(function()
+			const url = "https://api.github.com/repos/Parihsz/Chrono/releases/latest"
+			const success, result = pcall(function()
+				return HTTPS:GetAsync(url)
+			end)
+			if not success then
+				return
+			end
+			const data = HTTPS:JSONDecode(result)
+			const latestVersion = data.tag_name
+			const currentVersion = Config._GetConfig("__VERSION")
+			if latestVersion ~= currentVersion then
+				warn(
+					("Chrono: A new version is available! You are using version %s, but the latest version is %s."):format(
+						currentVersion,
+						latestVersion
+					)
+				)
+			end
+		end)
+	end)
+end
+local STARTED = false
+return {
+	Start = function(config: ModuleScript?)
+		if STARTED then
+			warn("Chrono: Already Started. Ignoring subsequent calls.")
+			return
+		end
+		STARTED = true
+		if config then
+			(require)(config)
+		end
+		if IS_SERVER then
+			require(script.Server.Replicate)
+		else
+			require(script.Client.Replicate)
+		end
+		Config._Lock()
+		if IS_SERVER and Config._GetConfig("CHECK_NEW_VERSION") then
+			CheckVersion()
+		end
+		const currentVersion = Config._GetConfig("__VERSION")
+		print(`Chrono {currentVersion} Started.`)
+	end,
+
+	Holder = Holder,
+	Entity = Entity,
+	Stats = Stats,
+	Config = Config,
+	ReplicationRules = ReplicationRules,
+	Events = Events,
+	Snapshots = Snapshots,
+
+	ServerClock = ServerClock,
+	Player = Player,
+	ServerReceiver = Receiver,
+	EntityGrid = EntityGrid,
+}

package/runtime/Chrono/init.luau

@@ -0,0 +1,14 @@
+--!strict
+-- Cluaupp Chrono — typed border over Parihsz/Chrono (_impl).
+
+local Impl = require(script._impl)
+
+export type SnapshotData<Value, Velocity> = Impl.SnapshotData<Value, Velocity>
+export type Signal<fx, T...> = Impl.Signal<fx, T...>
+export type Connection = Impl.Connection
+export type Event<fx, T...> = Impl.Event<fx, T...>
+export type Snapshot<Value, Velocity> = Impl.Snapshot<Value, Velocity>
+export type Entity = Impl.Entity
+export type Chrono = typeof(Impl)
+
+return Impl

package/runtime/Cmdr/BuiltInCommands/Admin/announce.luau

@@ -0,0 +1,21 @@
+const ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+const BuiltInGuards = ReplicatedStorage.CmdrClient.Shared.BuiltInGuards
+const NonEmptyString = require(BuiltInGuards.NonEmptyString) :: (number) -> (any) -> string?
+
+return {
+	Name = "announce",
+	Aliases = { "m" },
+	Description = "Makes a server-wide announcement.",
+	Group = "DefaultAdmin",
+	Args = {
+		{
+			Type = "string",
+			Name = "Text",
+			Description = "The announcement text.",
+		},
+	},
+	Guards = {
+		NonEmptyString(1),
+	},
+}

package/runtime/Cmdr/BuiltInCommands/Admin/announceServer.luau

@@ -0,0 +1,17 @@
+const TextService = game:GetService("TextService")
+
+return function(context: any, text: string): string
+	const filterSuccess, filteredText = pcall(function()
+		const filterResult =
+			TextService:FilterStringAsync(text, context.Executor.UserId, Enum.TextFilterContext.PublicChat)
+
+		return filterResult:GetNonChatStringForBroadcastAsync()
+	end)
+
+	if not filterSuccess then
+		return `Failed to filter announcement: {filteredText}`
+	end
+
+	context:BroadcastEvent("Message", filteredText, context.Executor)
+	return "Created announcement."
+end

package/runtime/Cmdr/BuiltInCommands/Admin/ban.luau

@@ -0,0 +1,59 @@
+const ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+const BuiltInGuards = ReplicatedStorage.CmdrClient.Shared.BuiltInGuards
+const MaxArrayLength = require(BuiltInGuards.MaxArrayLength) :: (number, number) -> (any) -> string?
+const MaxStringLength = require(BuiltInGuards.MaxStringLength) :: (number, number) -> (any) -> string?
+const NonEmptyString = require(BuiltInGuards.NonEmptyString) :: (number) -> (any) -> string?
+
+return {
+	Name = "ban",
+	Description = "Bans a player or set of players.",
+	Group = "DefaultAdmin",
+	Args = {
+		{
+			Type = "playerIds",
+			Name = "Players",
+			Description = "The players to ban (max 50).",
+		},
+		{
+			Type = "duration",
+			Name = "Duration",
+			Description = "How long the ban lasts (negative values indicate a permanent ban).",
+		},
+		{
+			Type = "string",
+			Name = "Public reason",
+			Description = "Ban message shown to the player.",
+		},
+		{
+			Type = "string",
+			Name = "Private reason",
+			Description = "Internal staff notes for ban history.",
+			Optional = true,
+		},
+		{
+			Type = "boolean",
+			Name = "Exclude alt accounts",
+			Description = "Skip banning their alternate accounts.",
+			Default = false,
+		},
+		{
+			Type = "boolean",
+			Name = "Apply to universe",
+			Description = "Ban from all places in this experience.",
+			Default = true,
+		},
+		{
+			Type = "boolean",
+			Name = "Apply device block",
+			Description = "Block their device from rejoining for 24 hours.",
+			Default = false,
+		},
+	},
+	Guards = {
+		MaxArrayLength(1, 50),
+		NonEmptyString(3),
+		MaxStringLength(3, 400),
+		MaxStringLength(4, 1000),
+	},
+}

package/runtime/Cmdr/BuiltInCommands/Admin/banServer.luau

@@ -0,0 +1,30 @@
+const Players = game:GetService("Players")
+
+return function(
+	_,
+	playerIds: { number },
+	duration: number,
+	displayReason: string,
+	privateReason: string?,
+	excludeAltAccounts: boolean,
+	applyToUniverse: boolean,
+	applyDeviceBlock: boolean
+): string
+	const resolvedPrivateReason = if not privateReason or privateReason:match("^%s*$")
+		then displayReason
+		else privateReason
+
+	const resolvedDuration = if duration < 1 and duration ~= -1 then -1 else duration
+
+	const success, errorMessage = pcall(Players.BanAsync, Players, {
+		UserIds = playerIds,
+		Duration = resolvedDuration,
+		DisplayReason = displayReason,
+		PrivateReason = resolvedPrivateReason,
+		ExcludeAltAccounts = excludeAltAccounts,
+		ApplyToUniverse = applyToUniverse,
+		ApplyDeviceBlock = applyDeviceBlock,
+	})
+
+	return if success then `Banned {#playerIds} players.` else `BanAsync failed: {errorMessage}`
+end

package/runtime/Cmdr/BuiltInCommands/Admin/gotoPlace.luau

@@ -0,0 +1,35 @@
+const ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+const BuiltInGuards = ReplicatedStorage.CmdrClient.Shared.BuiltInGuards
+const NotEquals = require(BuiltInGuards.NotEquals) :: (number, any) -> (any) -> string?
+
+return {
+	Name = "goto-place",
+	Description = "Teleport to a Roblox place.",
+	Group = "DefaultAdmin",
+	AutoExec = {
+		'alias "follow-player|Join a player in another server." goto-place $1{players|Players|The players to teleport.} ${{get-player-place-instance $2{playerId|Target|The player you want to follow.}}}',
+		'alias "rejoin|Rejoin this place. You might end up in a different server." goto-place $1{players|Players|The players to teleport.} ${get-player-place-instance ${me} PlaceId}',
+	},
+	Args = {
+		{
+			Type = "players",
+			Name = "Players",
+			Description = "The players to teleport.",
+		},
+		{
+			Type = "positiveInteger",
+			Name = "Place ID",
+			Description = "The Place ID to teleport to.",
+		},
+		{
+			Type = "string",
+			Name = "JobId",
+			Description = "The JobId to teleport to.",
+			Optional = true,
+		},
+	},
+	Guards = {
+		NotEquals(3, "-"),
+	},
+}

package/runtime/Cmdr/BuiltInCommands/Admin/gotoPlaceServer.luau

@@ -0,0 +1,17 @@
+const TeleportService = game:GetService("TeleportService")
+
+return function(context: any, players: { Player }, placeId: number, jobId: string?): string
+	context:Reply("Commencing teleport...")
+
+	const success, errorMessage = pcall(function()
+		if jobId then
+			const options = Instance.new("TeleportOptions")
+			options.ServerInstanceId = jobId
+			TeleportService:TeleportAsync(placeId, players, options)
+		else
+			TeleportService:TeleportAsync(placeId, players)
+		end
+	end)
+
+	return if success then "Teleported." else `Teleport failed: {errorMessage}`
+end