roblox-opencode 1.0.0

package/vendor/rbxutil/input/Mouse.luau

@@ -0,0 +1,278 @@
+-- Mouse
+-- Stephen Leitnick
+-- November 07, 2020
+
+local Signal = require(script.Parent.Parent.Signal)
+local Trove = require(script.Parent.Parent.Trove)
+
+local UserInputService = game:GetService("UserInputService")
+
+local RAY_DISTANCE = 1000
+
+--[=[
+	@class Mouse
+	@client
+
+	The Mouse class is part of the Input package.
+
+	```lua
+	local Mouse = require(packages.Input).Mouse
+	```
+]=]
+local Mouse = {}
+Mouse.__index = Mouse
+
+--[=[
+	@within Mouse
+	@prop LeftDown Signal<boolean>
+	@tag Event
+]=]
+--[=[
+	@within Mouse
+	@prop LeftUp Signal<boolean>
+	@tag Event
+]=]
+--[=[
+	@within Mouse
+	@prop RightDown Signal<boolean>
+	@tag Event
+]=]
+--[=[
+	@within Mouse
+	@prop RightUp Signal<boolean>
+	@tag Event
+]=]
+--[=[
+	@within Mouse
+	@prop MiddleDown Signal<boolean>
+	@tag Event
+]=]
+--[=[
+	@within Mouse
+	@prop MiddleUp Signal<boolean>
+	@tag Event
+]=]
+--[=[
+	@within Mouse
+	@prop Moved Signal<Vector2, boolean>
+	@tag Event
+	```lua
+	mouse.Moved:Connect(function(position, processed) ... end)
+	```
+]=]
+--[=[
+	@within Mouse
+	@prop Scrolled Signal<number, boolean>
+	@tag Event
+	```lua
+	mouse.Scrolled:Connect(function(scrollAmount, processed) ... end)
+	```
+]=]
+
+--[=[
+	@return Mouse
+
+	Constructs a new mouse input capturer.
+
+	```lua
+	local mouse = Mouse.new()
+	```
+]=]
+function Mouse.new()
+	local self = setmetatable({}, Mouse)
+
+	self._trove = Trove.new()
+
+	self.LeftDown = self._trove:Construct(Signal)
+	self.LeftUp = self._trove:Construct(Signal)
+	self.RightDown = self._trove:Construct(Signal)
+	self.RightUp = self._trove:Construct(Signal)
+	self.MiddleDown = self._trove:Construct(Signal)
+	self.MiddleUp = self._trove:Construct(Signal)
+	self.Scrolled = self._trove:Construct(Signal)
+	self.Moved = self._trove:Construct(Signal)
+
+	self._trove:Connect(UserInputService.InputBegan, function(input, processed)
+		if input.UserInputType == Enum.UserInputType.MouseButton1 then
+			self.LeftDown:Fire(processed)
+		elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
+			self.RightDown:Fire(processed)
+		elseif input.UserInputType == Enum.UserInputType.MouseButton3 then
+			self.MiddleDown:Fire(processed)
+		end
+	end)
+
+	self._trove:Connect(UserInputService.InputEnded, function(input, processed)
+		if input.UserInputType == Enum.UserInputType.MouseButton1 then
+			self.LeftUp:Fire(processed)
+		elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
+			self.RightUp:Fire(processed)
+		elseif input.UserInputType == Enum.UserInputType.MouseButton3 then
+			self.MiddleUp:Fire(processed)
+		end
+	end)
+
+	self._trove:Connect(UserInputService.InputChanged, function(input, processed)
+		if input.UserInputType == Enum.UserInputType.MouseMovement then
+			local position = input.Position
+			self.Moved:Fire(Vector2.new(position.X, position.Y), processed)
+		elseif input.UserInputType == Enum.UserInputType.MouseWheel then
+			self.Scrolled:Fire(input.Position.Z, processed)
+		end
+	end)
+
+	return self
+end
+
+--[=[
+	Checks if the left mouse button is down.
+]=]
+function Mouse:IsLeftDown(): boolean
+	return UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton1)
+end
+
+--[=[
+	Checks if the right mouse button is down.
+]=]
+function Mouse:IsRightDown(): boolean
+	return UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton2)
+end
+
+--[=[
+	Checks if the middle mouse button is down.
+]=]
+function Mouse:IsMiddleDown(): boolean
+	return UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton3)
+end
+
+--[=[
+	Gets the screen position of the mouse.
+]=]
+function Mouse:GetPosition(): Vector2
+	return UserInputService:GetMouseLocation()
+end
+
+--[=[
+	Gets the delta screen position of the mouse. In other words, the
+	distance the mouse has traveled away from its locked position in
+	a given frame (see note about mouse locking below).
+
+	:::info Only When Mouse Locked
+	Getting the mouse delta is only intended for when the mouse is locked. If the
+	mouse is _not_ locked, this will return a zero Vector2. The mouse can be locked
+	using the `mouse:Lock()` and `mouse:LockCenter()` method.
+	:::
+]=]
+function Mouse:GetDelta(): Vector2
+	return UserInputService:GetMouseDelta()
+end
+
+--[=[
+	Returns the viewport point ray for the mouse at the current mouse
+	position (or the override position if provided).
+]=]
+function Mouse:GetRay(overridePos: Vector2?): Ray
+	local mousePos = overridePos or UserInputService:GetMouseLocation()
+	local viewportMouseRay = workspace.CurrentCamera:ViewportPointToRay(mousePos.X, mousePos.Y)
+	return viewportMouseRay
+end
+
+--[=[
+	Performs a raycast operation out from the mouse position (or the
+	`overridePos` if provided) into world space. The ray will go
+	`distance` studs forward (or 1000 studs if not provided).
+
+	Returns the `RaycastResult` if something was hit, else returns `nil`.
+
+	Use `Raycast` if it is important to capture any objects that could be
+	hit along the projected ray. If objects can be ignored and only the
+	final position of the ray is needed, use `Project` instead.
+
+	```lua
+	local params = RaycastParams.new()
+	local result = mouse:Raycast(params)
+	if result then
+		print(result.Instance)
+	else
+		print("Mouse raycast did not hit anything")
+	end
+	```
+]=]
+function Mouse:Raycast(raycastParams: RaycastParams, distance: number?, overridePos: Vector2?): RaycastResult?
+	local viewportMouseRay = self:GetRay(overridePos)
+	local result = workspace:Raycast(
+		viewportMouseRay.Origin,
+		viewportMouseRay.Direction * (distance or RAY_DISTANCE),
+		raycastParams
+	)
+	return result
+end
+
+--[=[
+	Gets the 3D world position of the mouse when projected forward. This would be the
+	end-position of a raycast if nothing was hit. Similar to `Raycast`, optional
+	`distance` and `overridePos` arguments are allowed.
+	
+	Use `Project` if you want to get the 3D world position of the mouse at a given
+	distance but don't care about any objects that could be in the way. It is much
+	faster to project a position into 3D space than to do a full raycast operation.
+
+	```lua
+	local params = RaycastParams.new()
+	local distance = 200
+
+	local result = mouse:Raycast(params, distance)
+	if result then
+		-- Do something with result
+	else
+		-- Raycast failed, but still get the world position of the mouse:
+		local worldPosition = mouse:Project(distance)
+	end
+	```
+]=]
+function Mouse:Project(distance: number?, overridePos: Vector2?): Vector3
+	local viewportMouseRay = self:GetRay(overridePos)
+	return viewportMouseRay.Origin + (viewportMouseRay.Direction.Unit * (distance or RAY_DISTANCE))
+end
+
+--[=[
+	Locks the mouse in its current position on screen. Call `mouse:Unlock()`
+	to unlock the mouse.
+
+	:::caution Must explicitly unlock
+	Be sure to explicitly call `mouse:Unlock()` before cleaning up the mouse.
+	The `Destroy` method does _not_ unlock the mouse since there is no way
+	to guarantee who "owns" the mouse lock.
+	:::
+]=]
+function Mouse:Lock()
+	UserInputService.MouseBehavior = Enum.MouseBehavior.LockCurrentPosition
+end
+
+--[=[
+	Locks the mouse in the center of the screen. Call `mouse:Unlock()`
+	to unlock the mouse.
+
+	:::caution Must explicitly unlock
+	See cautionary in `Lock` method above.
+	:::
+]=]
+function Mouse:LockCenter()
+	UserInputService.MouseBehavior = Enum.MouseBehavior.LockCenter
+end
+
+--[=[
+	Unlocks the mouse.
+]=]
+function Mouse:Unlock()
+	UserInputService.MouseBehavior = Enum.MouseBehavior.Default
+end
+
+--[=[
+	Destroys the mouse.
+]=]
+function Mouse:Destroy()
+	self._trove:Destroy()
+end
+
+return Mouse

package/vendor/rbxutil/input/PreferredInput.luau

@@ -0,0 +1,91 @@
+--!strict
+
+--[=[
+	@class PreferredInput
+	@client
+
+	A helper library for observing the preferred user input of the
+	player. This is useful for determining what input schemes
+	to use during gameplay. A player might switch from using
+	a mouse to a gamepad mid-game, and it is important for the
+	game to respond to this change.
+
+	The PreferredInput library is part of the Input package.
+
+	```lua
+	local PreferredInput = require(packages.Input).PreferredInput
+	```
+]=]
+--[=[
+	@within PreferredInput
+	@function observe
+	@param handler (preferred: Enum.PreferredInput) -> (() -> ())?
+	@return () -> ()
+
+	Observes the preferred input. In other words, the handler function will
+	be fired immediately, as well as any time the preferred input changes.
+
+	The returned function can be called to disconnect the observer.
+
+	```lua
+	local disconnect = PreferredInput.observe(function(preferred)
+		-- Fires immediately & any time the preferred input changes
+		print(preferred)
+
+		return function()
+			-- Preferred input has changed
+		end
+	end)
+
+	-- If/when desired, observer can be stopped by calling the returned function:
+	disconnect()
+	```
+]=]
+--[=[
+	@within PreferredInput
+	@function get
+	@return Enum.PreferredInput
+
+	Gets the preferred input. This is equivalent to
+	[`UserInputService.PreferredInput`](https://create.roblox.com/docs/reference/engine/classes/UserInputService#PreferredInput).
+]=]
+
+local UserInputService = game:GetService("UserInputService")
+
+local PreferredInput = {}
+
+function PreferredInput.observe(callback: (preferred: Enum.PreferredInput) -> (() -> ())?)
+	local cleanup: (() -> ())? = nil
+	local id = 0
+
+	local function onPreferredInputChanged()
+		id += 1
+		local observeId = id
+
+		local cleanupFn = callback(UserInputService.PreferredInput)
+		if typeof(cleanupFn) == "function" then
+			if id == observeId then
+				cleanup = cleanupFn
+			else
+				task.spawn(cleanupFn)
+			end
+		end
+	end
+
+	task.spawn(onPreferredInputChanged)
+	local conn = UserInputService:GetPropertyChangedSignal("PreferredInput"):Connect(onPreferredInputChanged)
+
+	return function()
+		conn:Disconnect()
+		if typeof(cleanup) == "function" then
+			task.spawn(cleanup)
+			cleanup = nil
+		end
+	end
+end
+
+function PreferredInput.get()
+	return UserInputService.PreferredInput
+end
+
+return PreferredInput

package/vendor/rbxutil/input/Touch.luau

@@ -0,0 +1,120 @@
+-- Touch
+-- Stephen Leitnick
+-- March 14, 2021
+
+local Trove = require(script.Parent.Parent.Trove)
+local Signal = require(script.Parent.Parent.Signal)
+
+local UserInputService = game:GetService("UserInputService")
+
+--[=[
+	@class Touch
+	@client
+
+	The Touch class is part of the Input package.
+
+	```lua
+	local Touch = require(packages.Input).Touch
+	```
+]=]
+local Touch = {}
+Touch.__index = Touch
+
+--[=[
+	@within Touch
+	@prop TouchTap Signal<(touchPositions: {Vector2}, processed: boolean)>
+	@tag Event
+	Proxy for [UserInputService.TouchTap](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchTap).
+]=]
+--[=[
+	@within Touch
+	@prop TouchTapInWorld Signal<(position: Vector2, processed: boolean)>
+	@tag Event
+	Proxy for [UserInputService.TouchTapInWorld](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchTapInWorld).
+]=]
+--[=[
+	@within Touch
+	@prop TouchMoved Signal<(touch: InputObject, processed: boolean)>
+	@tag Event
+	Proxy for [UserInputService.TouchMoved](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchMoved).
+]=]
+--[=[
+	@within Touch
+	@prop TouchLongPress Signal<(touchPositions: {Vector2}, state: Enum.UserInputState, processed: boolean)>
+	@tag Event
+	Proxy for [UserInputService.TouchLongPress](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchLongPress).
+]=]
+--[=[
+	@within Touch
+	@prop TouchPan Signal<(touchPositions: {Vector2}, totalTranslation: Vector2, velocity: Vector2, state: Enum.UserInputState, processed: boolean)>
+	@tag Event
+	Proxy for [UserInputService.TouchPan](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchPan).
+]=]
+--[=[
+	@within Touch
+	@prop TouchPinch Signal<(touchPositions: {Vector2}, scale: number, velocity: Vector2, state: Enum.UserInputState, processed: boolean)>
+	@tag Event
+	Proxy for [UserInputService.TouchPinch](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchPinch).
+]=]
+--[=[
+	@within Touch
+	@prop TouchRotate Signal<(touchPositions: {Vector2}, rotation: number, velocity: number, state: Enum.UserInputState, processed: boolean)>
+	@tag Event
+	Proxy for [UserInputService.TouchRotate](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchRotate).
+]=]
+--[=[
+	@within Touch
+	@prop TouchSwipe Signal<(swipeDirection: Enum.SwipeDirection, numberOfTouches: number, processed: boolean)>
+	@tag Event
+	Proxy for [UserInputService.TouchSwipe](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchSwipe).
+]=]
+--[=[
+	@within Touch
+	@prop TouchStarted Signal<(touch: InputObject, processed: boolean)>
+	@tag Event
+	Proxy for [UserInputService.TouchStarted](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchStarted).
+]=]
+--[=[
+	@within Touch
+	@prop TouchEnded Signal<(touch: InputObject, processed: boolean)>
+	@tag Event
+	Proxy for [UserInputService.TouchEnded](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchEnded).
+]=]
+
+--[=[
+	Constructs a new Touch input capturer.
+]=]
+function Touch.new()
+	local self = setmetatable({}, Touch)
+
+	self._trove = Trove.new()
+
+	self.TouchTap = self._trove:Construct(Signal.Wrap, UserInputService.TouchTap)
+	self.TouchTapInWorld = self._trove:Construct(Signal.Wrap, UserInputService.TouchTapInWorld)
+	self.TouchMoved = self._trove:Construct(Signal.Wrap, UserInputService.TouchMoved)
+	self.TouchLongPress = self._trove:Construct(Signal.Wrap, UserInputService.TouchLongPress)
+	self.TouchPan = self._trove:Construct(Signal.Wrap, UserInputService.TouchPan)
+	self.TouchPinch = self._trove:Construct(Signal.Wrap, UserInputService.TouchPinch)
+	self.TouchRotate = self._trove:Construct(Signal.Wrap, UserInputService.TouchRotate)
+	self.TouchSwipe = self._trove:Construct(Signal.Wrap, UserInputService.TouchSwipe)
+	self.TouchStarted = self._trove:Construct(Signal.Wrap, UserInputService.TouchStarted)
+	self.TouchEnded = self._trove:Construct(Signal.Wrap, UserInputService.TouchEnded)
+
+	return self
+end
+
+--[=[
+	Returns the value of [`UserInputService.TouchEnabled`](https://developer.roblox.com/en-us/api-reference/property/UserInputService/TouchEnabled).
+]=]
+function Touch:IsTouchEnabled(): boolean
+	return UserInputService.TouchEnabled
+end
+
+--[=[
+	Destroys the Touch input capturer.
+]=]
+function Touch:Destroy()
+	self._trove:Destroy()
+end
+
+return Touch

package/vendor/rbxutil/input/init.luau

@@ -0,0 +1,33 @@
+-- Input
+-- Stephen Leitnick
+-- October 10, 2021
+
+--[=[
+	@class Input
+
+	The Input package provides access to various user input classes.
+
+	- [PreferredInput](/api/PreferredInput)
+	- [Mouse](/api/Mouse)
+	- [Keyboard](/api/Keyboard)
+	- [Touch](/api/Touch)
+	- [Gamepad](/api/Gamepad)
+
+	Reference the desired input modules via the Input package to get started:
+
+	```lua
+	local PreferredInput = require(Packages.Input).PreferredInput
+	local Mouse = require(Packages.Input).Mouse
+	local Keyboard = require(Packages.Input).Keyboard
+	local Touch = require(Packages.Input).Touch
+	local Gamepad = require(Packages.Input).Gamepad
+	```
+]=]
+
+return {
+	PreferredInput = require(script.PreferredInput),
+	Mouse = require(script.Mouse),
+	Keyboard = require(script.Keyboard),
+	Touch = require(script.Touch),
+	Gamepad = require(script.Gamepad),
+}

package/vendor/rbxutil/input/wally.toml

@@ -0,0 +1,12 @@
+[package]
+name = "sleitnick/input"
+description = "Basic input classes"
+version = "3.0.0"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"
+
+[dependencies]
+Signal = "sleitnick/signal@2"
+Trove = "sleitnick/trove@1"

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

@@ -0,0 +1,15 @@
+type PredicateFn = (module: ModuleScript) => boolean;
+type Modules = { [key: string]: unknown };
+
+declare namespace Loader {
+	interface Constructor {
+		LoadChildren: (parent: Instance, predicate?: PredicateFn) => Modules;
+		LoadDescendants: (parent: Instance, predicate?: PredicateFn) => Modules;
+		MatchesName: (matchName: string) => (module: ModuleScript) => boolean;
+		SpawnAll: (loadedModules: Modules, methodName: string) => void;
+	}
+}
+
+declare const Loader: Loader.Constructor;
+
+export = Loader;

package/vendor/rbxutil/loader/init.luau

@@ -0,0 +1,137 @@
+--[=[
+	@class Loader
+
+	The Loader module will require all children or descendant ModuleScripts. There are also
+	some utility functions included, which assist with loading and starting modules in
+	single-script environments.
+
+	For example, here is a loader that loads all ModuleScripts under a folder that end with
+	the name Service, and then calls all of their OnStart methods:
+	```lua
+	local MyModules = ReplicatedStorage.MyModules
+	Loader.SpawnAll(
+		Loader.LoadDescendants(MyModules, Loader.MatchesName("Service$")),
+		"OnStart"
+	)
+	```
+]=]
+local Loader = {}
+
+--[=[
+	@within Loader
+	@type PredicateFn (module: ModuleScript) -> boolean
+	Predicate function type.
+]=]
+type PredicateFn = (module: ModuleScript) -> boolean
+
+--[=[
+	Requires all children ModuleScripts.
+
+	If a `predicate` function is provided, then the module will only
+	be loaded if the predicate returns `true` for the the given
+	ModuleScript.
+
+	```lua
+	-- Load all ModuleScripts directly under MyModules:
+	Loader.LoadChildren(ReplicatedStorage.MyModules)
+
+	-- Load all ModuleScripts directly under MyModules if they have names ending in 'Service':
+	Loader.LoadChildren(ReplicatedStorage.MyModules, function(moduleScript)
+		return moduleScript.Name:match("Service$") ~= nil
+	end)
+	```
+]=]
+function Loader.LoadChildren(parent: Instance, predicate: PredicateFn?): { [string]: any }
+	local modules: { [string]: any } = {}
+	for _, child in parent:GetChildren() do
+		if child:IsA("ModuleScript") then
+			if predicate and not predicate(child) then
+				continue
+			end
+			local m = require(child)
+			modules[child.Name] = m
+		end
+	end
+	return modules
+end
+
+--[=[
+	Requires all descendant ModuleScripts.
+
+	If a `predicate` function is provided, then the module will only
+	be loaded if the predicate returns `true` for the the given
+	ModuleScript.
+
+	```lua
+	-- Load all ModuleScripts under MyModules:
+	Loader.LoadDescendants(ReplicatedStorage.MyModules)
+
+	-- Load all ModuleScripts under MyModules if they have names ending in 'Service':
+	Loader.LoadDescendants(ReplicatedStorage.MyModules, function(moduleScript)
+		return moduleScript.Name:match("Service$") ~= nil
+	end)
+]=]
+function Loader.LoadDescendants(parent: Instance, predicate: PredicateFn?): { [string]: any }
+	local modules: { [string]: any } = {}
+	for _, descendant in parent:GetDescendants() do
+		if descendant:IsA("ModuleScript") then
+			if predicate and not predicate(descendant) then
+				continue
+			end
+			local m = require(descendant)
+			modules[descendant.Name] = m
+		end
+	end
+	return modules
+end
+
+--[=[
+	A commonly-used predicate in the `LoadChildren` and `LoadDescendants`
+	functions is one to match names. Therefore, the `MatchesName` utility
+	function provides a quick way to create such predicates.
+
+	```lua
+	Loader.LoadDescendants(ReplicatedStorage.MyModules, Loader.MatchesName("Service$"))
+	```
+]=]
+function Loader.MatchesName(matchName: string): (module: ModuleScript) -> boolean
+	return function(moduleScript: ModuleScript): boolean
+		return moduleScript.Name:match(matchName) ~= nil
+	end
+end
+
+--[=[
+	Utility function for spawning a specific method in all given modules.
+	If a module does not contain the specified method, it is simply
+	skipped. Methods are called with `task.spawn` internally.
+
+	For example, if the modules are expected to have an `OnStart()` method,
+	then `SpawnAll()` could be used to start all of them directly after
+	they have been loaded:
+
+	```lua
+	local MyModules = ReplicatedStorage.MyModules
+
+	-- Load all modules under MyModules and then call their OnStart methods:
+	Loader.SpawnAll(Loader.LoadDescendants(MyModules), "OnStart")
+
+	-- Same as above, but only loads modules with names that end with Service:
+	Loader.SpawnAll(
+		Loader.LoadDescendants(MyModules, Loader.MatchesName("Service$")),
+		"OnStart"
+	)
+	```
+]=]
+function Loader.SpawnAll(loadedModules: { [string]: any }, methodName: string)
+	for name, mod in loadedModules do
+		local method = mod[methodName]
+		if type(method) == "function" then
+			task.spawn(function()
+				debug.setmemorycategory(name)
+				method(mod)
+			end)
+		end
+	end
+end
+
+return Loader

package/vendor/rbxutil/loader/wally.toml

@@ -0,0 +1,8 @@
+[package]
+name = "sleitnick/loader"
+description = "Requires all modules within a given instance"
+version = "2.0.0"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"