roblox-opencode 1.0.0

package/vendor/rbxutil/spring/init.luau

@@ -0,0 +1,97 @@
+--!strict
+
+--[=[
+	@class Spring
+
+	Simulates a critically damped spring. This is mostly just a wrapper around
+	[`TweenService:SmoothDamp()`](https://create.roblox.com/docs/reference/engine/classes/TweenService#SmoothDamp).
+]=]
+
+local TweenService = game:GetService("TweenService")
+
+local Spring = {}
+Spring.__index = Spring
+
+export type Spring<T> = typeof(setmetatable(
+	{} :: {
+		Current: T,
+		Target: T,
+		Velocity: T,
+		SmoothTime: number,
+		MaxSpeed: number,
+	},
+	Spring
+))
+
+--[=[
+	Creates a new spring.
+
+	The type `T` can be a `number`, `Vector2`, `Vector3`, or `CFrame`.
+
+	@param initial T -- Initial value
+	@param smoothTime number -- Approximate time it takes to reach target
+	@param maxSpeed number -- Maximum speed (defaults to infinity)
+]=]
+function Spring.new<T>(initial: T, smoothTime: number, maxSpeed: number?): Spring<T>
+	local self = setmetatable({
+		Current = initial,
+		Target = initial,
+		Velocity = if typeof(initial) == "CFrame" then CFrame.identity else (initial :: any) * 0,
+		SmoothTime = smoothTime,
+		MaxSpeed = if maxSpeed ~= nil then maxSpeed else math.huge,
+	}, Spring)
+
+	return self
+end
+
+--[=[
+	@within Spring
+	@method Update
+
+	Updates the spring. This method should be called continuously, even if the target value hasn't changed.
+
+	```lua
+	local newValue = spring:Update(dt)
+	```
+
+	@param deltaTime number
+	@return T
+]=]
+function Spring.Update<T>(self: Spring<T>, dt: number): T
+	self.Current, self.Velocity =
+		TweenService:SmoothDamp(self.Current, self.Target, self.Velocity, self.SmoothTime, self.MaxSpeed, dt)
+
+	return self.Current
+end
+
+--[=[
+	@within Spring
+	@method Impulse
+
+	Impulses the spring.
+
+	```lua
+	spring:Impulse(rng:NextUnitVector() * 10)
+	```
+
+	@param velocity T
+]=]
+function Spring.Impulse<T>(self: Spring<T>, velocity: T)
+	self.Velocity += velocity :: any
+end
+
+--[=[
+	@within Spring
+	@method Reset
+
+	Resets the spring to the given value.
+
+	@param value T
+]=]
+function Spring.Reset<T>(self: Spring<T>, value: T)
+	self.Current = value
+	self.Target = value
+	self.Velocity = if typeof(self.Current) == "CFrame" then CFrame.identity else (self.Current :: any) * 0
+end
+
+return Spring

package/vendor/rbxutil/spring/package.json

@@ -0,0 +1,17 @@
+{
+	"name": "@rbxutil/spring",
+	"version": "1.0.0",
+	"main": "init.luau",
+	"repository": "github:Sleitnick/RbxUtil",
+	"license": "MIT",
+	"types": "index.d.ts",
+	"files": [
+		"./*",
+		"!*.toml",
+		"!*.json",
+		"!*.test.luau"
+	],
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/vendor/rbxutil/spring/wally.toml

@@ -0,0 +1,8 @@
+[package]
+name = "sleitnick/spring"
+description = "Critically damped spring"
+version = "1.0.0"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"

package/vendor/rbxutil/stream/index.d.ts

@@ -0,0 +1,88 @@
+interface Stream {}
+
+interface stream {
+	/** Creates a stream. */
+	create: (size: number) => Stream;
+
+	/** Creates a stream from an existing buffer. */
+	frombuffer: (buf: buffer) => Stream;
+
+	/** Creates a stream from a buffer created with the given string. */
+	fromstring: (str: string) => Stream;
+
+	readu8: (s: Stream) => number;
+	readi8: (s: Stream) => number;
+	readu16: (s: Stream) => number;
+	readi16: (s: Stream) => number;
+	readu32: (s: Stream) => number;
+	readi32: (s: Stream) => number;
+	readf32: (s: Stream) => number;
+	readf64: (s: Stream) => number;
+	readstring: (s: Stream, count: number) => string;
+	readlstring: (s: Stream) => string;
+	readvectorf32: (s: Stream) => vector;
+	readvectoru32: (s: Stream) => vector;
+	readvectori32: (s: Stream) => vector;
+	readvectoru16: (s: Stream) => vector;
+	readvectori16: (s: Stream) => vector;
+	readvectoru8: (s: Stream) => vector;
+	readvectori8: (s: Stream) => vector;
+
+	writeu8: (s: Stream, n: number) => void;
+	writei8: (s: Stream, n: number) => void;
+	writeu16: (s: Stream, n: number) => void;
+	writei16: (s: Stream, n: number) => void;
+	writeu32: (s: Stream, n: number) => void;
+	writei32: (s: Stream, n: number) => void;
+	writef32: (s: Stream, n: number) => void;
+	writef64: (s: Stream, n: number) => void;
+	writestring: (s: Stream, str: string, count?: number) => void;
+	writelstring: (s: Stream, str: string, count?: number) => void;
+	writevectorf32: (s: Stream, v: vector) => void;
+	writevectoru32: (s: Stream, v: vector) => void;
+	writevectori32: (s: Stream, v: vector) => void;
+	writevectoru16: (s: Stream, v: vector) => void;
+	writevectori16: (s: Stream, v: vector) => void;
+	writevectoru8: (s: Stream, v: vector) => void;
+	writevectori8: (s: Stream, v: vector) => void;
+
+	/** Get the length of the backing buffer. */
+	len: (s: Stream) => number;
+
+	/** Get the cursor position. */
+	pos: (s: Stream) => number;
+
+	/** Copy `count` bytes from `source` into `target`. */
+	copy: (target: Stream, source: Stream, count: number) => void;
+
+	/** Copy `count` bytes from the `source` stream into the `target` buffer. */
+	copytobuffer: (target: buffer, targetOffset: number, source: Stream, count: number) => void;
+	
+	/** Copy `count` bytes from the `source` buffer into the `target` stream. */
+	copyfrombuffer: (target: Stream, source: buffer, sourceOffset: number | undefined, count: number) => void;
+
+	/** Set the cursor relative to the beginning of the buffer. */
+	seek: (s: Stream, offset: number) => void;
+
+	/** Set the cursor backward relative to the end of the buffer. */
+	seekend: (s: Stream, offset: number) => void;
+
+	/** Offset the cursor forward from its current position. */
+	seekforward: (s: Stream, offset: number) => void;
+
+	/** Offset the cursor backward from its current position. */
+	seekbackward: (s: Stream, offset: number) => void;
+
+	/** Gets the string of the backing buffer. */
+	tostring: (s: Stream) => string;
+
+	/** Get the backing buffer. */
+	buffer: (s: Stream) => buffer;
+
+	/** Returns `true` if the cursor is at the end of the stream. */
+	atend: (s: Stream) => boolean;
+}
+
+declare const stream: stream;
+
+export = stream;