Entrada del gamepad

Roblox acepta la entrada de gamepads USB como los controladores de Xbox y PlayStation.Dado que los gamepads vienen en diferentes variedades, debes seguir un procedimiento adicional para verificar que las entradas del gamepad de un jugador sean utilizables en tu experiencia.

Para configurar las entradas del gamepad, puedes usar ContextActionService o UserInputService para detectar gamepads conectados para el dispositivo de un jugador , verificar las entradas compatibles con Roblox que son compatibles con Roblox, recibir entrada y más.

Al vincular las entradas del gamepad, vea esquemas de control comunes para crear una experiencia de gamepad consistente para los jugadores.Una vez que se hayan establecerlas entradas, puedes mejorar la experiencia del jugador incluyendo retroalimentación háptica en los controles admitidos.

Detectar mandos de juego

Puedes detectar si el dispositivo de un jugador tiene actualmente un gamepad activo usando la propiedad UserInputService.GamepadEnabled.

Detectando gamepad
local UserInputService = game:GetService("UserInputService")

if UserInputService.GamepadEnabled then
	print("Player has gamepad enabled...")
end

Puedes verificar los gamepads conectados a través de UserInputService.GamepadConnected y UserInputService.GamepadDisconnected eventos.Estos eventos se disparan cuando un dispositivo se conecta o se desconecta respectivamente, y ambos eventos pasan un Enum.UserInputType a la función conectada que indica qué gamepad causó el evento.En la mayoría de los casos, el gamepad conectado es Gamepad1 .

Comprobación de conexión y desconexión
local UserInputService = game:GetService("UserInputService")

UserInputService.GamepadConnected:Connect(function(gamepad)
	print("User has connected controller: " .. tostring(gamepad))
end)

UserInputService.GamepadDisconnected:Connect(function(gamepad)
	print("User has disconnected controller: " .. tostring(gamepad))
end)

También puedes consultar si un controlador específico está conectado usando el método UserInputService:GetGamepadConnected().Esto toma un Enum.UserInputType como argumento y solo acepta valores de Gamepad1 a través de Gamepad8 .

Conexión específica de gamepad de consulta
local UserInputService = game:GetService("UserInputService")

if UserInputService:GetGamepadConnected(Enum.UserInputType.Gamepad1) then
	print("Gamepad1 is connected")
elseif UserInputService:GetGamepadConnected(Enum.UserInputType.Gamepad2) then
	print("Gamepad2 is connected")
end

Verificar entradas admitidas

Dado que los gamepads pueden tener diferentes conjuntos de entradas, deberías verificar qué entradas son compatibles con UserInputService:GetSupportedGamepadKeyCodes() .Este método toma un Enum.UserInputType como argumento y devuelve una tabla con una lista de todos los inputs disponibles para el Control (ES_MX)especificado.

Verificando entradas admitidas
local UserInputService = game:GetService("UserInputService")

local availableInputs = UserInputService:GetSupportedGamepadKeyCodes(Enum.UserInputType.Gamepad2)

print("This controller supports the following controls:")
for _, control in availableInputs do
	print(control)
end

Recibir entrada

ContextActionService es útil para vincular controles a ambos gamepads y otras fuentes de entrada, como ratón y teclado entradas o toques móviles en la pantalla táctil, o para vincular múltiples funciones a una sola entrada de botón en cualquier dispositivo.Por ejemplo, el siguiente ejemplo de código vincula una acción OpenSpellBook a el botón del controlador para juegoButtonR2 y la clavedel teclado B.

Acción de vinculación del servicio ContextAction
local ContextActionService = game:GetService("ContextActionService")

local function openSpellBook(actionName, inputState, inputObject)
	if inputState == Enum.UserInputState.Begin then
		-- Libro de hechizos abierto
	end
end

ContextActionService:BindAction("OpenSpellBook", openSpellBook, false, Enum.KeyCode.ButtonR2, Enum.KeyCode.B)

Alternativamente, puedes usar UserInputService para vincular controles directamente desde un controlador para juego.Al detectar eventos de controlador a través de este servicio, utilice el evento InputBegan para detectar cuando se presionó inicialmente el botón y InputEnded para detectar cuando se libera el botón.En la función de manejo, la propiedad InputObject.UserInputType indica qué gamepad disparó el evento y InputObject.KeyCode indica el botón o palanca específico que lo disparó.

Detección de presión de botón de UserInputService
local UserInputService = game:GetService("UserInputService")

UserInputService.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.Gamepad1 then
		if input.KeyCode == Enum.KeyCode.ButtonA then
			print("Button A pressed on Gamepad1")
		end
	end
end)

Estado del gamepad

Puedes detectar el estado actual de todos los botones y palancas en un gamepad con el método UserInputService:GetGamepadState().Esto es útil si necesitas verificar las entradas del controlador actual cuando ocurre un evento distinto en tu experiencia, como verificar si se presionan botones específicos cuando un personaje toca un objeto.

Comprobación del estado de las entradas de gamepad
local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")

local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local leftFoot = character:WaitForChild("LeftFoot")

-- Cuando el pie izquierdo entra en contacto con algo, compruebe el estado de la entrada del gamepad
leftFoot.Touched:Connect(function(hit)
	local state = UserInputService:GetGamepadState(Enum.UserInputType.Gamepad1)
	for _, input in state do

		-- Si el botón R2 se mantiene actualmente, imprima un mensaje
		if input.KeyCode == Enum.KeyCode.ButtonR2 and input.UserInputState == Enum.UserInputState.Begin then
			print("Character's left foot touched something while holding right trigger")
		end
	end
end)

Presión de activación

Puedes detectar cuánta presión se está colocando en los gatillos del gamepad comprobando el valor Position.Z de la entrada del desencadenador.

Presión de activación de prueba
local UserInputService = game:GetService("UserInputService")

UserInputService.InputChanged:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.Gamepad1 then
		if input.KeyCode == Enum.KeyCode.ButtonL2 then
			print("Pressure on left trigger has changed:", input.Position.Z)
		elseif input.KeyCode == Enum.KeyCode.ButtonR2 then
			print("Pressure on right trigger has changed:", input.Position.Z)
		end
	end
end)

Esquemas de control comunes

Los gamepads vienen en una variedad de formas y tamaños.Al igual que con cualquier método de entrada de jugadores, es mejor crear cierta coherencia en diferentes juegos y experiencias.

A continuación se muestran las siguientes vinculaciones de entrada comunes que ayudarán a los jugadores a sentirse familiarizados y cómodos con los controles del gamepad de inmediato:

Comentarios opinión

Muchos controladores de consola tienen motores integrados para proporcionar opiniónháptica.Añadir vibraciones y ruidos puede mejorar enormemente la experiencia de un jugador y proporcionar comentarios sutiles más allá de las imágenes o el sonido, audio.Puedes usar el HapticService para verificar el soporte de vibración antes de encender los motores.

Soporte de vibración

No todos los controladores tienen motores, por lo que es importante verificar el soporte antes de intentar usar los motores hápticos.Para consultar si un controlador determinado tiene Soportede vibración, llame a HapticService:IsVibrationSupported() .

Compruebe el soporte de vibración
local HapticService = game:GetService("HapticService")

local gamepad = Enum.UserInputType.Gamepad1
local isVibrationSupported = HapticService:IsVibrationSupported(gamepad)

Algunos controladores tienen motores múltiples para diferentes escalas de vibración.Una vez que hayas comprobado si un gamepad admite vibración, también deberías comprobar si admite los motores que pretendes usar a través de HapticService:IsMotorSupported() .

Compruebe los motores admitidos
local HapticService = game:GetService("HapticService")

local gamepad = Enum.UserInputType.Gamepad1
local isVibrationSupported = HapticService:IsVibrationSupported(gamepad)

if isVibrationSupported then
	local largeMotor = HapticService:IsMotorSupported(gamepad, Enum.VibrationMotor.Large)
	local smallMotor = HapticService:IsMotorSupported(gamepad, Enum.VibrationMotor.Small)
	local leftTriggerMotor = HapticService:IsMotorSupported(gamepad, Enum.VibrationMotor.LeftTrigger)
	local rightTriggerMotor = HapticService:IsMotorSupported(gamepad, Enum.VibrationMotor.RightTrigger)
	local leftHandMotor = HapticService:IsMotorSupported(gamepad, Enum.VibrationMotor.LeftHand)
	local rightHandMotor = HapticService:IsMotorSupported(gamepad, Enum.VibrationMotor.RightHand)
end

Activar motores

Una vez que hayas confirmado que el gamepad de un jugador admite vibración, puedes encender un motor específico con HapticService:SetMotor() .Este método toma el gamepad y la amplitud de la vibración como argumentos.La amplitud puede ser cualquier valor entre 0 y 1.

Activando el motor
local HapticService = game:GetService("HapticService")

local gamepad = Enum.UserInputType.Gamepad1
local isVibrationSupported = HapticService:IsVibrationSupported(gamepad)

if isVibrationSupported then
	local largeMotor = HapticService:IsMotorSupported(gamepad, Enum.VibrationMotor.Large)
	if largeMotor then
		HapticService:SetMotor(gamepad, Enum.VibrationMotor.Large, 0.5)
	end
end

Emulación de controlador

El Emulador de controlador te permite emular con precisión la entrada del gamepad directamente en Studio.El controlador predeterminado es un controlador para juegogenérico, pero puedes seleccionar alternativas para dispositivos de PlayStation, Xbox y Quest en el menú desplegable de la parte superior izquierda.

Durante las pruebas de juego, puedes controlar la experiencia con el controlador virtual usando tu ratón.

También puedes hacer clic en Editar mapas en la esquina superior derecha para ver y editar mapas de teclas para el Control (ES_MX)virtual, por ejemplo E a ButtonL2 o 9 a ButtonA .Estos mapas se guardan como otros ajustes de Studio (por Control (ES_MX), por usuario, por ordenador) y se traducen a eventos de gamepad en la ventana del emulador y en el ventanilla3D.