Entrada del gamepad

*Este contenido se traduce usando la IA (Beta) y puede contener errores. Para ver esta página en inglés, haz clic en aquí.

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:

EntradaCasos de uso comunes
ButtonAAcepta solicitudes del jugador o selecciones de interfaz de usuario. Alternativamente se utiliza para acciones principales como el salto.
ButtonBCancelar las solicitudes del jugador o las selecciones de la interfaz gráfica de usuario. Alternativamente se usa para acciones secundarias como esquivar, rodar o correr.
Thumbstick1Generalmente asociado con el movimiento de personajes.
Thumbstick2Generalmente asociado con el movimiento de la cámara.
ButtonL2 , ButtonR2Generalmente se usa para acciones primarias, como disparar.
ButtonL1 , ButtonR1 , ButtonX , ButtonYAcciones secundarias como recargar, apuntar o acceder a un inventario o minimapa.

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
Tamaño o ubicaciónDescripción
LargeMotor más grande, útil para el ruido genérico.
SmallMotor más pequeño, útil para ráfagas más sutiles como resbalones de neumáticos, choque eléctrico, etc.
LeftTriggerDebajo del desencadenadorizquierdo.
RightTriggerDebajo del desencadenadorderecho.
LeftHandEn el lado izquierdo del Control (ES_MX).
RightHandEn el lado derecho del Control (ES_MX).

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.

Emulate Device Controllers button indicated in Test tab View of the generic controller in the Controller Emulator.

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.