cluaupp 1.0.0 → 1.4.0

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

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

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

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

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

package/runtime/Chrono/_impl/init.luau

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

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

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

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

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

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

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

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