Entrée du gamepad

Roblox accepte l'entrée de manettes de jeu USB telles que la Xbox et les contrôleurs de PlayStation.Comme les manettes de jeu existent sous différentes variantes, vous devez suivre une configuration supplémentaire pour vérifier que les entrées du gamepad d'un joueur sont utilisables dans votre expérience.

Pour configurer les entrées du gamepad, vous pouvez utiliser ou pour détecter les gamepads connectés pour l'appareil d'un joueur , vérifier les entrées prises en charge compatibles avec Roblox , recevoir une entrée et plus encore.

Lors de la liaison des entrées du gamepad, voir schémas de contrôle communs pour créer une expérience de jeu cohérente pour les joueurs.Une fois les entrées configurer, vous pouvez améliorer l'expérience du joueur en incluant un retour haptique sur les contrôleurs pris en charge.

Détecter les gamepads

Vous pouvez détecter si l'appareil d'un joueur a actuellement une manette de jeu active en utilisant la propriété UserInputService.GamepadEnabled.

Détection de manette de jeu
local UserInputService = game:GetService("UserInputService")

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

Vous pouvez vérifier les manettes de jeu connectées via UserInputService.GamepadConnected et UserInputService.GamepadDisconnected événements.Ces événements se déclenchent lorsqu'un appareil est connecté ou déconnecté respectivement, et les deux événements passent un Enum.UserInputType à la fonction connectée indiquant quel gamepad a causé l'événement.Dans la plupart des cas, la manette de jeu connectée est Gamepad1 .

Vérification de la connexion et de la déconnexion
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)

Vous pouvez également demander si un contrôleur spécifique est connecté à l'aide de la méthode UserInputService:GetGamepadConnected().Cela prend un Enum.UserInputType comme argument et n'accepte que des valeurs de Gamepad1 à travers Gamepad8 .

Connexion spécifique de manette de jeu à la requête
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

Vérifier les entrées soutenues

Comme les manettes de jeu peuvent avoir différents ensembles d'entrées, vous devez vérifier quelles entrées sont prises en charge avec UserInputService:GetSupportedGamepadKeyCodes() .Cette méthode prend un Enum.UserInputType comme argument et renvoie une table avec une liste de toutes les entrées disponibles pour le contrôleur spécifié.

Vérification des entrées soutenues
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

Recevoir une entrée

ContextActionService est utile pour lier les contrôles à la fois aux manettes de jeu et à d'autres sources d'entrée telles que les entrées souris et clavier ou les boutons tactiles mobiles, ou pour lier plusieurs fonctions à une seule entrée de bouton sur n'importe quel appareil.Par exemple, l'exemple de code suivant lie une action OpenSpellBook à la touche ButtonR2 du gamepad et la touche B cléclavier.

Action de liage du service ContextActionService
local ContextActionService = game:GetService("ContextActionService")

local function openSpellBook(actionName, inputState, inputObject)
	if inputState == Enum.UserInputState.Begin then
		-- Livre d'invocation ouvert
	end
end

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

Alternativement, vous pouvez utiliser UserInputService pour lier les contrôles directement à partir d'une manette de jeu.Lors de la détection d'événements de manette de jeu via ce service, utilisez l'événement InputBegan pour détecter quand le bouton a été initialement pressé et InputEnded pour détecter quand le bouton est libéré.Dans la fonction de manipulation, la propriété InputObject.UserInputType indique le gamepad qui a déclenché l'événement et InputObject.KeyCode indique le bouton ou le joystick spécifique qui l'a déclenché.

Détection de la pression du bouton 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)

État du gamepad

Vous pouvez détecter l'état actuel de tous les boutons et bâtons sur une manette de jeu avec la méthode UserInputService:GetGamepadState().Cela est utile si vous devez vérifier les entrées de manette de jeu actuelles lorsqu'un événement distinct se produit dans votre expérience, comme vérifier si des boutons spécifiques sont appuyés lorsque un personnage touche un objet.

Vérification de l'état des entrées de manette de jeu
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")

-- Lorsque le pied gauche entre en contact avec quelque chose, vérifiez l'état de la sortie du gamepad
leftFoot.Touched:Connect(function(hit)
	local state = UserInputService:GetGamepadState(Enum.UserInputType.Gamepad1)
	for _, input in state do

		-- Si le bouton R2 est actuellement maintenu, imprimez un message
		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)

Activer la pression

Vous pouvez détecter la pression exercée sur les déclencheurs du gamepad en vérifiant la valeur Position.Z de l'entrée déclencheur.

Tester la pression déclencheur
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)

Schémas de contrôle communs

Les manettes de jeu se présentent sous différentes formes et tailles.Comme pour toute méthode d'entrée de joueur, il est préférable de créer une certaine cohérence à travers différents jeux et expériences.

Les suivantes sont des liens d'entrée communs qui aideront les joueurs à se sentir immédiatement familiers et à l'aise avec les contrôlesdu gamepad :

Réponse commentaires

De nombreux contrôleurs de manette de jeu ont des moteurs intégrés pour fournir un retour haptique.L'ajout de vibrations et de rumble peut grandement améliorer l'expérience d'un joueur et fournir des commentaires subtils au-delà des visuels ou de l'audio.Vous pouvez utiliser le HapticService pour vérifier le support de vibration avant d'allumer les moteurs.

assistancede vibration

Pas tous les contrôleurs ont des moteurs, il est donc important de vérifier le support avant d'essayer d'utiliser les moteurs haptiques.Pour demander si un contrôleur donné a un assistancede vibration, appelez HapticService:IsVibrationSupported() .

Vérifier le support de vibration
local HapticService = game:GetService("HapticService")

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

Certains contrôleurs ont plusieurs moteurs pour différentes échelles de vibration.Une fois que vous avez vérifié si une manette de jeu prend en charge la vibration, vous devriez également vérifier si elle prend en charge les moteurs que vous prévoyez d'utiliser via HapticService:IsMotorSupported() .

Vérifier les moteurs pris en charge
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

Activer les moteurs

Une fois que vous avez confirmé que la manette de jeu d'un joueur prend en charge la vibration, vous pouvez allumer un moteur spécifique avec HapticService:SetMotor() .Cette méthode prend le gamepad et l'amplitude de la vibration comme arguments.L'amplitude peut être n'importe quelle valeur entre 0 et 1.

Activation du moteur
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

Émulation de contrôleur

L'émulateur de contrôleur vous permet d'émuler avec précision l'entrée du gamepad directement dans Studio. Le contrôleur par défaut est une manette de jeu générique, mais vous pouvez sélectionner des alternatives pour les appareils PlayStation, Xbox et Quest dans le menu sélecteur supérieur gauche.

Pendant les tests de jeu, vous pouvez contrôler l'expérience avec le contrôleur virtuel en utilisant votre souris.

Vous pouvez également cliquer sur Éditer les mappages dans le coin supérieur droit pour afficher et modifier les mappages de clé pour le contrôleur virtuel, par exemple E à ButtonL2 ou 9 à ButtonA .Ces mises en correspondance sont sauvegardées comme d'autres paramètres de Studio (par contrôleur, par utilisateur, par ordinateur) et sont traduites en événements de manette dans la fenêtre émulateur et dans la fenêtre de vision 3D.