Gamepad-Eingabe

Roblox akzeptiert Eingaben von USB-Spielcontrollern wie Xbox und PlayStation-Controllern.Da Gamepads in verschiedenen Variationen erhältlich sind, musst du zusätzliche Einrichtungen befolgen, um zu überprüfen, dass die Gamepad-Eingaben eines Spieler:inin deiner Erlebnisverwendbar sind.

Um Gamepad-Eingänge einzurichten, kannst du ContextActionService oder UserInputService verwenden, um verbundene Gamepads für das Gerät eines Spieler:inzu erkennen , unterstützte Eingänge zu überprüfen, die mit Roblox kompatibel sind, Eingabe zu empfangen und mehr.

Wenn du Gamepad-Eingänge bindest, siehe gewöhnliche Steuerungsschemata, um ein konsistentes Gamepad-Erlebnis für Spieler zu schaffen.Nachdem die Eingänge festlegenwurden, kannst du das Erlebnis des Spieler:inverbessern, indem du haptisches Feedback auf unterstützten Controllern einschließt.

Spielpads erkennen

Du kannst erkennen, ob das Gerät eines Spieler:inderzeit ein Gamepad aktiv verwendet, mit der EigenschaftenUserInputService.GamepadEnabled.

Gamepad erkennen
local UserInputService = game:GetService("UserInputService")

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

Du kannst mit UserInputService.GamepadConnected und UserInputService.GamepadDisconnected Veranstaltungen verbundene Gamepads überprüfen.Diese Ereignisse werden ausgelöst, wenn ein Gerät jeweils verbunden oder getrennt wird, und beide Ereignisse senden eine Enum.UserInputType an die verbundene Funktion, die anzeigt, welches Spielpad das Ereignis verursacht hat.In den meisten Fällen ist das verbundene Gamepad Gamepad1 .

Verbindung und Trennung überprüfen
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)

Du kannst auch abfragen, ob ein bestimmter Controller mit der Methode UserInputService:GetGamepadConnected() verbunden ist.Dies nimmt ein Enum.UserInputType als Argument und akzeptiert nur Werte von Gamepad1 durch Gamepad8.

Abfrage spezifische Gamepad-Verbindung
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

Unterstützte Eingänge überprüfen

Da Spielkonsolen unterschiedliche Eingabesätze haben können, solltest du überprüfen, welche Eingaben mit UserInputService:GetSupportedGamepadKeyCodes() unterstützt werden.Diese Methode nimmt ein Enum.UserInputType als Argument und gibt eine Tabelle mit einer Liste aller verfügbaren Eingänge für den angegebenen Controller zurück.

Unterstützte Eingänge überprüfen
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

Eingabe empfangen

ContextActionService ist nützlich für die Bindung von Steuerelementen an beide Gamepads und andere Eingabequellen wie Maus- und Tastaturoberflächen oder mobile Touchscreen-Buttons oder für die Bindung mehrerer Funktionen an einen einzigen Knopf-Eingang auf jedem Gerät.Zum Beispiel bindet das folgende Codebeispiel eine OpenSpellBook -Aktion an die Taste des Gamepads ButtonR2 und die Taste der Tastatur B.

Kontextaktionsservice Bind-Aktion
local ContextActionService = game:GetService("ContextActionService")

local function openSpellBook(actionName, inputState, inputObject)
	if inputState == Enum.UserInputState.Begin then
		-- Offenes Zauberbuch
	end
end

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

Funktionen, die an ContextActionService gebunden sind, werden auf alle Eingangszustände feuern ( Begin , Change und End ), es wird daher empfohlen, die UserInputState wie in der Zeile 4 zu überprüfen, um sicherzustellen, dass die gewünschte Aktion nur auf dem Gamepad-Eingangszustand erfolgt, den Sie beabsichtigen.

Alternativ kannst du UserInputService verwenden, um Steuerelemente direkt von einem Gamepad zu binden.Wenn du Gamepad-Ereignisse durch diesen Service erkennst, verwende das InputBegan-Ereignis, um zu erkennen, wann die Taste zum ersten Mal gedrückt wurde, und das InputEnded-Ereignis, um zu erkennen, wann die Taste freigegeben wird.In der Handlungsfunktion zeigt die Eigenschaft InputObject.UserInputType, welches Gamepad das Ereignis abgefeuert hat, und InputObject.KeyCode zeigt den spezifischen Knopf oder Stick an, der es abgefeuert hat.

Button-Eingabe-Service Knopfdruckerkennung
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)

Gamepad-Zustand

Du kannst den aktuellen Zustand aller Schaltflächen und Stäbe auf einem Gamepad mit der Methode UserInputService:GetGamepadState() erkennen.Dies ist nützlich, wenn du die aktuellen Gamepad-Eingänge überprüfen musst, wenn ein deutliches Ereignis in deiner Erlebnisauftritt, z. B. überprüfen, ob bestimmte Tasten gedrückt werden, wenn ein Charakter ein Objekt berührt.

Zustand von Gamepad-Eingängen überprüfen
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")

-- Wenn der linke Fuß mit etwas in Kontakt kommt, überprüfe den Gamepad-Eingabezustand
leftFoot.Touched:Connect(function(hit)
	local state = UserInputService:GetGamepadState(Enum.UserInputType.Gamepad1)
	for _, input in state do

		-- Wenn der ButtonR2 derzeit gehalten wird, drucke eine Nachricht aus
		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)

Druck auslösen

Du kannst erkennen, wie viel Druck auf Gamepad-Auslöser ausgeübt wird, indem du den Position.Z Wert des Eingabe-Auslösers überprüfst.

Test der Auslöseerdruck
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)

Gewöhnliche Kontrollschemata

Gamepads kommen in einer Vielzahl von Formen und Größen vor.Wie bei jeder Methode der Spieler输入, ist es am besten, einige Konsistenz über verschiedene Spiele und Erlebnisse zu schaffen.

Die folgenden sind häufige Eingabebindungen, die den Spielern helfen, sich sofort mit den Steuerungvertraut und komfortabel zu fühlen:

Eingabe	Gewöhnliche Anwendungsfälle
ButtonA	Akzeptiert Spieleraufforderungen oder GUI-Auswahl. Alternativ für primäre Aktionen wie Springen verwendet.
ButtonB	Storniert Spieler-Aufforderungen oder GUI-Auswahl. Alternativ für sekundäre Aktionen wie Ausweichen, Rollen oder Sprinten verwendet.
Thumbstick1	Im Allgemeinen mit der Bewegung des Charakters verbunden.
Thumbstick2	Im Allgemeinen mit der Kamerabewegung verbunden.
ButtonL2 , ButtonR2	Im Allgemeinen für primäre Aktionen verwendet, wie zum Beispiel Schießen.
ButtonL1 , ButtonR1 , ButtonX , ButtonY	Sekundäre Aktionen wie Nachladen, Zielen oder Zugriff auf ein Inventar oder Minikarte.

Haptisches Feedback

Viele Gamepad-Controller haben Motoren integriert, um haptisches Feedback zu liefern.Das Hinzufügen von Vibrationen und Geräuschen kann die Erfahrung eines Spieler:inerheblich verbessern und subtile Feedback jenseits von Bildern oder Audiodateienliefern.Sie können die HapticService verwenden, um die Vibrationsunterstützung zu überprüfen bevor die Motoren eingeschaltet werden.

Support

Nicht alle Controller haben Motoren, daher ist es wichtig, nach Unterstützung zu suchen, bevor du versuchst, haptische Motoren zu verwenden.Um zu überprüfen, ob ein bestimmter Controller Supporthat, rufen Sie HapticService:IsVibrationSupported() an.

Vibrationsunterstützung überprüfen
local HapticService = game:GetService("HapticService")

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

Einige Controller haben mehrere Motoren für verschiedene Vibrationsgrade.Sobald du überprüft hast, ob ein Gamepad Vibration unterstützt, solltest du auch überprüfen, ob es die Motoren unterstützt, die du durch HapticService:IsMotorSupported() verwenden möchtest.

Überprüfen Sie die unterstützten Motoren
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

Größe oder Standort	Beschreibung
Large	Größerer Motor, nützlich für allgemeine Vibration.
Small	Kleinerer Motor, nützlich für subtilere Vibrationen wie Reifenrutsche, elektrischer Schock usw.
LeftTrigger	Unter dem linken Auslöser.
RightTrigger	Unter dem rechten Auslöser.
LeftHand	Auf der linken Seite des Controllers.
RightHand	Auf der rechten Seite des Controllers.

Aktiviere Motoren

Sobald du bestätigt hast, dass das Spielpad eines Spieler:inVibration unterstützt, kannst du einen bestimmten Motor mit HapticService:SetMotor() einschalten.Diese Methode nimmt das Gamepad und die Amplitude der Vibration als Argumente.Die Amplitude kann ein Wert zwischen 0 und 1 sein.

Motor aktivieren
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

Controller-Emulation

Der Controller-Emulator lässt dich die Gamepad-Eingabe direkt in Studio genau emulieren.Der Standard-Controller ist ein generischer Gamepad, aber du kannst alternative für PlayStation, Xbox und Quest-Geräte aus dem oberen linken Auswahlmenü auswählen.

Emulate Device Controllers button indicated in Test tab

View of the generic controller in the Controller Emulator.

Während des Spieltests kannst du die Erfahrung mit dem virtuellen Controller mit deiner Maus steuern.

Du kannst auch auf Bearbeiten von Mappings in der oberen rechten Ecke klicken, um Schlüsselmappen für den virtuellen Controller anzuzeigen und zu bearbeiten, zum Beispiel E zu ButtonL2 oder 9 zu ButtonA.Diese Mappings werden wie andere Studio-Einstellungen gespeichert (pro Controller, pro Benutzer, pro Computer) und werden in beiden Emulator-Fenstern und im 3D-Ansichtsfenster in Spielepad-Ereignisse übersetzt.

Auf dieser Seite