GuiObject
*Ta zawartość została przetłumaczona przy użyciu narzędzi AI (w wersji beta) i może zawierać błędy. Aby wyświetlić tę stronę w języku angielskim, kliknij tutaj.
GuiObject jest abstrakcyjną klasą (podobną do BasePart ) dla obiektu interfejsu użytkownika 2D.Definiuje wszystkie właściwości związane z wyświetlaniem obiektu interfejsu graficznego użytkownika (GUI), takie jak Size i Position.Posiada także kilka przydatnych właściwości tylko do odczytu, takich jak AbsolutePosition , AbsoluteSize i AbsoluteRotation.
Aby manipulować układem obiektów GUI w specjalny sposób, możesz użyć struktury układu takiej jak lista/flex lub siatka i możesz je stylizować poza ich podstawowymi właściwościami za pomocą modyfikatorów wyglądu.
Chociaż można wykrywać zdarzenia przycisków myszy na dowolnym obiekcie GUI za pomocą InputBegan i InputEnded, tylko ImageButton i TextButton mają wygodne wydarzenia dedykowane, takie jak Activated , aby wykryć kliknięcie/naciśnięcie.
Podsumowanie
Właściwości
Określa, czy ten element interfejsu zanurza wejście.
Określa punkt pochodzenia GuiObject , względem jego absolutnego rozmiaru.
Określa, czy zmiana rozmiaru następuje w oparciu o treść dziecka.
Określa kolor tła GuiObject.
Określa przejrzystość tła i ramki GuiObject.
Określa kolor obramowania GuiObject.
Określa, w jaki sposób granica GuiObject jest rozmieszczona względem jej wymiarów.
Określa szerokość piksela obramowania GuiObject.
Określa, czy potomek GuiObjects poza granicami elementu GUI rodzica powinien się renderować.
Określa, czy mysz gracza jest aktywnie naciśnięta na GuiObject lub nie.
Określa, czy GuiButton można wejść w interakcję, czy nie, lub czy GuiState z GuiObject zmienia się lub nie.
Kontroluje kolejność sortowania GuiObject przy użyciu UIGridStyleLayout .
Ustawia GuiObject, które zostaną wybrane, gdy selektor gamepada zostanie przesunięty w dół.
Ustawia GuiObject, które zostaną wybrane, gdy selektor gamepada zostanie przesunięty w lewo.
Ustawia GuiObject, które zostaną wybrane, gdy selektor gamepada zostanie przesunięty w prawo.
Ustawia GuiObject, które zostaną wybrane, gdy selektor gamepada zostanie przesunięty w górę.
Określa pozycję piksela i skalarną pozycję GuiObject.
Określa liczbę stopni, w jakich GuiObject jest obrócony.
Określ, czy GuiObject może być wybrane przez gamepad.
Zastępuje domyślną ozdobę selekcji używaną do gamepadów.
Kolejność GuiObjects wybrana przez wybór interfejsu gamepada.
Określa rozmiar piksela i skali GuiObject .
Ustawia osie Size, na których GuiObject będzie oparty, w stosunku do rozmiaru jego rodzica.
Mieszana właściwość BackgroundTransparency i TextTransparency.
Określa, czy GuiObject i jego potomkowie zostaną wyrenderowane.
Określa kolejność, w której renderowanie GuiObject względem innych.
Opisuje rzeczywistą pozycję ekranu elementu GuiBase2d w pikselach.
Opisuje rzeczywitą rotację ekranu elementu GuiBase2d w stopniach.
Opisuje rzeczywistą rozdzielczość ekranu elementu GuiBase2d w pikselach.
Gdy ustawiono na true, lokalizacja zostanie zastosowana do tego GuiBase2d i jego potomków.
Odwołanie do LocalizationTable , które ma być użyte do zastosowania automatyzowanej lokalizacji do tego GuiBase2d i jego potomków.
Dostosowuje zachowanie wyboru pada w dół w grze.
Dostosowuje zachowanie wyboru gamepada w lewo.
Dostosowuje zachowanie wyboru gamepada w prawnym kierunku.
Dostosowuje zachowanie wyboru gamepada w kierunku góry.
Umożliwia dostosowanie ruchu wyboru gamepada.
Metody
- TweenPosition(endPosition : UDim2,easingDirection : Enum.EasingDirection,easingStyle : Enum.EasingStyle,time : number,override : boolean,callback : function):boolean
Płynnie przenosi interfejs użytkownika do nowego UDim2.
- TweenSize(endSize : UDim2,easingDirection : Enum.EasingDirection,easingStyle : Enum.EasingStyle,time : number,override : boolean,callback : function):boolean
- TweenSizeAndPosition(endSize : UDim2,endPosition : UDim2,easingDirection : Enum.EasingDirection,easingStyle : Enum.EasingStyle,time : number,override : boolean,callback : function):boolean
Płynnie przesuwa interfejs użytkownika do nowego rozmiaru i pozycji.
Zdarzenia
Wystrzeliwany, gdy użytkownik zaczyna interakcję za pomocą urządzenia interfejsu człowiek-komputer (przycisk myszy w dół, dotknięcie rozpoczęcia, przycisk klawiatury w dół itp.).
Wystrzeliwany, gdy użytkownik zmienia sposób interakcji za pomocą urządzenia interfejsu człowiek-komputer (przycisk myszy w dół, dotknięcie początku, przycisk klawiatury w dół itp.).
Wystrzeliwany, gdy użytkownik przestaje interakcjonować za pomocą urządzenia interfejsu człowiek-komputer (przycisk myszy w dół, dotknięcie początku, przycisk klawiatury w dół itp.).
Wystrzeliwuje, gdy użytkownik przesuwa mysz do elementu GUI.
Wystrzeliwuje, gdy użytkownik przesuwa mysz poza element interfejsu graficznego.
Wystrzeliwuje za każdym razem, gdy użytkownik przesuwa mysz, gdy znajduje się w środku elementu GUI.
Wystrzeliwuje, gdy użytkownik przewija koło myszy wstecz, gdy mysz znajduje się nad elementem GUI.
Wystrzeliwuje, gdy użytkownik przewija koło myszy w przód, gdy mysz znajduje się nad elementem GUI.
Wystrzeliwany, gdy GuiObject jest skupiany za pomocą wyboru Gamepad.
Wystrzelony, gdy wybór Gamepada przestaje skupiać się na GuiObject.
Wystrzeliwuje, gdy gracz zaczyna, kontynuuje i zatrzymuje długie naciśnięcie elementu interfejsu.
- TouchPan(touchPositions : Array,totalTranslation : Vector2,velocity : Vector2,state : Enum.UserInputState):RBXScriptSignal
Wystrzeliwuje, gdy gracz przesuwa palec po elementze interfejsu.
- TouchPinch(touchPositions : Array,scale : number,velocity : number,state : Enum.UserInputState):RBXScriptSignal
Wystrzeliwuje, gdy gracz wykonuje gest przesuwania lub ciągnięcia za pomocą dwóch palców na element UI.
- TouchRotate(touchPositions : Array,rotation : number,velocity : number,state : Enum.UserInputState):RBXScriptSignal
Wystrzeliwuje, gdy gracz wykonuje gest rotacji za pomocą dwóch palców na element UI.
Wypala się, gdy gracz wykonuje gest przesuwania na element interfejsu użytkownika.
Wystrzeliwuje, gdy gracz wykonuje gest dotknięcia na element interfejsu.
- SelectionChanged(amISelected : boolean,previousSelection : GuiObject,newSelection : GuiObject):RBXScriptSignal
Wybucha, gdy wybór gamepada przenosi się do, opuszcza lub zmienia w ramach połączonego GuiBase2d lub dowolnego potomka GuiObjects.
Właściwości
Active
Właściwość ta określa, czy będzie wysyłać wejście do przestrzeni 3D, takiej jak podstawowe modele z klasą .
Dla obiektów GuiButton ( ImageButton i TextButton ), ta właściwość określa, czy Activated pożary wystąpią ( AutoButtonColor nadal będą działać dla tych również).Wydarzenia InputBegan , InputChanged i InputEnded działają normalnie bez względu na wartość tej właściwości.
Przykłady kodu
This code sample demonstrates the usage of the Active property as a debounce for the Activated event.
-- Place this LocalScript within a TextButton (or ImageButton)
local textButton = script.Parent
textButton.Text = "Click me"
textButton.Active = true
local function onActivated()
-- This acts like a debounce
textButton.Active = false
-- Count backwards from 5
for i = 5, 1, -1 do
textButton.Text = "Time: " .. i
task.wait(1)
end
textButton.Text = "Click me"
textButton.Active = true
end
textButton.Activated:Connect(onActivated)
AnchorPoint
Właściwość ta określa punkt pochodzenia GuiObject , względem jego absolutnego rozmiaru.Punkt pochodzenia określa, skąd element jest umieszczony (poprzez GuiObject.Position ) i do którego rozszerza się renderowany GuiObject.Size.
Zobacz tutaj dla ilustrowanych diagramów i szczegółów.
Przykłady kodu
This code sample moves a UI element to different sides of the parent element. It starts at the top-left and ends at the bottom-right. Paste into a LocalScript in a Frame, within a ScreenGui.
local guiObject = script.Parent
while true do
-- Top-left
guiObject.AnchorPoint = Vector2.new(0, 0)
guiObject.Position = UDim2.new(0, 0, 0, 0)
task.wait(1)
-- Top
guiObject.AnchorPoint = Vector2.new(0.5, 0)
guiObject.Position = UDim2.new(0.5, 0, 0, 0)
task.wait(1)
-- Top-right
guiObject.AnchorPoint = Vector2.new(1, 0)
guiObject.Position = UDim2.new(1, 0, 0, 0)
task.wait(1)
-- Left
guiObject.AnchorPoint = Vector2.new(0, 0.5)
guiObject.Position = UDim2.new(0, 0, 0.5, 0)
task.wait(1)
-- Dead center
guiObject.AnchorPoint = Vector2.new(0.5, 0.5)
guiObject.Position = UDim2.new(0.5, 0, 0.5, 0)
task.wait(1)
-- Right
guiObject.AnchorPoint = Vector2.new(1, 0.5)
guiObject.Position = UDim2.new(1, 0, 0.5, 0)
task.wait(1)
-- Bottom-left
guiObject.AnchorPoint = Vector2.new(0, 1)
guiObject.Position = UDim2.new(0, 0, 1, 0)
task.wait(1)
-- Bottom
guiObject.AnchorPoint = Vector2.new(0.5, 1)
guiObject.Position = UDim2.new(0.5, 0, 1, 0)
task.wait(1)
-- Bottom-right
guiObject.AnchorPoint = Vector2.new(1, 1)
guiObject.Position = UDim2.new(1, 0, 1, 0)
task.wait(1)
end
AutomaticSize
Właściwość ta jest używana do automatycznego skalowania obiektów UI rodzica na podstawie rozmiaru jego potomków.Możesz użyć tej właściwości, aby dynamicznie dodać tekst i inne treści do obiektu interfejsu użytkownika podczas edycji lub czasu uruchamiania, a rozmiar dostosuje się do tych treści.
Gdy jest ustawiony na wartość > do czegokolwiek innego niż >, ten obiekt interfejsu może się zmienić w zależności od zawartości dziecka.
Aby uzyskać więcej informacji o tym, jak korzystać z tej właściwości i jak to działa, zobacz tutaj .
Przykłady kodu
The following script creates an automatically-sized parent frame with aUIListLayout, then it inserts several automatically-sized TextLabel objects. Note how the parent UIListLayout automatically resizes to fit its child content and the labels automatically resize to fit their text content. This script can be parented to a ScreenGui.
-- Array of text labels/fonts/sizes to output
local labelArray = {
{ text = "Lorem", font = Enum.Font.Creepster, size = 50 },
{ text = "ipsum", font = Enum.Font.IndieFlower, size = 35 },
{ text = "dolor", font = Enum.Font.Antique, size = 55 },
{ text = "sit", font = Enum.Font.SpecialElite, size = 65 },
{ text = "amet", font = Enum.Font.FredokaOne, size = 40 },
}
-- Create an automatically-sized parent frame
local parentFrame = Instance.new("Frame")
parentFrame.AutomaticSize = Enum.AutomaticSize.XY
parentFrame.BackgroundColor3 = Color3.fromRGB(90, 90, 90)
parentFrame.Size = UDim2.fromOffset(25, 100)
parentFrame.Position = UDim2.fromScale(0.1, 0.1)
parentFrame.Parent = script.Parent
-- Add a list layout
local listLayout = Instance.new("UIListLayout")
listLayout.Padding = UDim.new(0, 5)
listLayout.Parent = parentFrame
-- Set rounded corners and padding for visual aesthetics
local roundedCornerParent = Instance.new("UICorner")
roundedCornerParent.Parent = parentFrame
local uiPaddingParent = Instance.new("UIPadding")
uiPaddingParent.PaddingTop = UDim.new(0, 5)
uiPaddingParent.PaddingLeft = UDim.new(0, 5)
uiPaddingParent.PaddingRight = UDim.new(0, 5)
uiPaddingParent.PaddingBottom = UDim.new(0, 5)
uiPaddingParent.Parent = parentFrame
for i = 1, #labelArray do
-- Create an automatically-sized text label from array
local childLabel = Instance.new("TextLabel")
childLabel.AutomaticSize = Enum.AutomaticSize.XY
childLabel.Size = UDim2.fromOffset(75, 15)
childLabel.Text = labelArray[i]["text"]
childLabel.Font = labelArray[i]["font"]
childLabel.TextSize = labelArray[i]["size"]
childLabel.TextColor3 = Color3.new(1, 1, 1)
childLabel.Parent = parentFrame
-- Visual aesthetics
local roundedCorner = Instance.new("UICorner")
roundedCorner.Parent = childLabel
local uiPadding = Instance.new("UIPadding")
uiPadding.PaddingTop = UDim.new(0, 5)
uiPadding.PaddingLeft = UDim.new(0, 5)
uiPadding.PaddingRight = UDim.new(0, 5)
uiPadding.PaddingBottom = UDim.new(0, 5)
uiPadding.Parent = childLabel
task.wait(2)
end
BackgroundColor3
Właściwość ta określa kolor tła GuiObject (kolor wypełnienia).Jeśli twój element zawiera tekst, tak jak TextBox, TextButton lub TextLabel, upewnij się, że kolor tła kontrastuje z kolorem tekstu.
Inną właściwością, która określa właściwości wizualne tła, jest GuiObject.BackgroundTransparency ; jeśli jest ustawiona na 1, ani tło, ani granica nie zostaną wyrenderowane.
Zobacz też BorderColor3.
Przykłady kodu
This code sample causes a parent Frame to loop through all colors of the rainbow using Color3.fromHSV.
-- Put this code in a LocalScript in a Frame
local frame = script.Parent
while true do
for hue = 0, 255, 4 do
-- HSV = hue, saturation, value
-- If we loop from 0 to 1 repeatedly, we get a rainbow!
frame.BorderColor3 = Color3.fromHSV(hue / 256, 1, 1)
frame.BackgroundColor3 = Color3.fromHSV(hue / 256, 0.5, 0.8)
task.wait()
end
end
BackgroundTransparency
Właściwość ta określa przejrzystość tła i ramki GuiObject.Nie określa jednak przejrzystości tekstu, jeśli interfejs jest TextBox, TextButton lub TextLabel; przejrzystość tekstu jest określona TextBox.TextTransparency, TextButton.TextTransparency i TextLabel.TextTransparency odpowiednio.
Jeśli ta właściwość jest ustawiona na 1, tło ani granica nie zostaną wyrenderowane, a tło GUI będzie całkowicie przezroczyste.
BorderColor3
Określa kolor krawędzi GuiObject prostokątnej (również znanej jako kolor obwodu).Jest to odrębne od obiektu GuiObject.BackgroundColor3.Nie będziesz mógł zobaczyć granicy obiektu, jeśli jego właściwość GuiObject.BorderSizePixel jest ustawiona na 0.
Zauważ, że komponent UIStroke pozwala na bardziej zaawansowane efekty graniczne.
Przykłady kodu
This code sample causes the border of a parent GuiObject to highlight when the user hovers their mouse over the element.
-- Put me inside some GuiObject, preferrably an ImageButton/TextButton
local button = script.Parent
local function onEnter()
button.BorderSizePixel = 2
button.BorderColor3 = Color3.new(1, 1, 0) -- Yellow
end
local function onLeave()
button.BorderSizePixel = 1
button.BorderColor3 = Color3.new(0, 0, 0) -- Black
end
-- Connect events
button.MouseEnter:Connect(onEnter)
button.MouseLeave:Connect(onLeave)
-- Our default state is "not hovered"
onLeave()
BorderMode
Właściwość ta określa, w jaki sposób granica GuiObject jest rozmieszczana względem jej wymiarów za pomocą enum o tej samej nazwie, Enum.BorderMode .
Zauważ, że UIStroke może zastąpić tę właściwość i umożliwić bardziej zaawansowane efekty graniczne.
BorderSizePixel
Właściwość ta określa, jak szeroki jest render obramowania GuiObject w pikselach. Ustawienie jej na 0 wyłącza całkowicie obramowanie.
Zauważ, że UIStroke może zastąpić tę właściwość i umożliwić bardziej zaawansowane efekty graniczne.
Przykłady kodu
This code sample causes the border of a parent GuiObject to highlight when the user hovers their mouse over the element.
-- Put me inside some GuiObject, preferrably an ImageButton/TextButton
local button = script.Parent
local function onEnter()
button.BorderSizePixel = 2
button.BorderColor3 = Color3.new(1, 1, 0) -- Yellow
end
local function onLeave()
button.BorderSizePixel = 1
button.BorderColor3 = Color3.new(0, 0, 0) -- Black
end
-- Connect events
button.MouseEnter:Connect(onEnter)
button.MouseLeave:Connect(onLeave)
-- Our default state is "not hovered"
onLeave()
ClipsDescendants
Właściwość ta określa, czy GuiObject będzie przycinane (czynione niewidocznymi) jakiekolwiek części elementów GUI potomnego, które w przeciwnym razie wyrenderują się poza granice prostokąta.
Zauważ, że Rotation nie jest wspierane przez tę właściwość.Jeśli to lub jakikolwiek przodek GUI ma niezerowe , właściwość ta jest ignorowana, a elementy GUI potomków zostaną wyrenderowane niezależnie od wartości tej właściwości.
GuiState
Gdy palec gracza jest naciskany i trzymany na GuiObject, GuiState z GuiObject zostanie ustawiony na Press .Podobnie, gdy palec gracza jest uwalniany z GuiObject , GuiState z GuiObject zostanie ustawiony na Idle , a gdy Interactable jest wyłączony na GuiObject , Class.GuiState z GuiObject zostanie ustawiony na NonInteractable .
Interactable
Określa, czy GuiButton można wejść w interakcję, czy nie, lub czy GuiState z GuiObject zmienia się lub nie.
Na GuiButton :
- Gdy ustawienie Interactable na GuiButton jest ustawione na false, GuiButton nie będzie już można nacisnąć lub kliknąć, a GuiState będzie stale ustawione na NonInteractable .
- Gdy ustawienie Interactable na GuiButton jest ustawione na true, GuiButton zachowa się normalnie ponownie, a GuiState zachowa się normalnie.
Na GuiObject :
- Gdy ustawienie Interactable na GuiButton jest ustawione na false, GuiState będzie stale ustawione na NonInteractable.
- Gdy ustawienie Interactable na GuiButton jest ustawione na true, GuiState zachowa się normalnie ponownie.
LayoutOrder
Właściwość ta kontroluje kolejność sortowania GuiObject przy użyciu UIGridStyleLayout (takich jak UIListLayout lub UIPageLayout ) z ustawieniem SortOrder na Enum.SortOrder.LayoutOrder .Nie ma funkcjonalności, jeśli obiekt nie ma struktury układu interfejsu użytkownika siostry.
GuiObjects są sortowane w kolejności rosnącej, w której niższe wartości mają pierwszeństwo nad wyższymi wartościami.Obiekty o takich samych wartościach wracają do kolejności, w której zostały dodane.
Jeśli nie jesteś pewien, czy będziesz musiał dodać element między dwoma istniejącymi elementami w przyszłości, dobrym zwyczajem jest używanie wielokrotności 100 ( 0 , 100 , 200 , itp.).Zapewnia to dużą lukę wartości kolejności układu, których możesz używać do elementów zamawianych pomiędzy innymi elementami.
Zobacz także , który określa kolejność renderowania obiektu zamiast kolejności sortowania.
NextSelectionDown
Właściwość ta ustawia GuiObject wybraną, gdy użytkownik przesuwa w dół wyłącznik gamepad.Jeśli ta właściwość jest pusta, przesuwanie gamepada w dół nie zmieni wybranej GUI.
Przesuwanie selektora gamepada w dół ustawia GuiService.SelectedObject na ten obiekt, chyba że interfejs użytkownika nie jest Selectable.Zauważ, że właściwość ta może być ustawiona na element interfejsu graficznego, nawet jeśli nie jest Selectable, więc powinieneś upewnić się, że wartość właściwości wybieralnej interfejsu graficznego odpowiada Twojemu oczekiwanemu zachowaniu.
Zobacz także NextSelectionUp , NextSelectionLeft i NextSelectionRight .
Przykłady kodu
This example demonstrates how to enable Gamepad navigation through a grid of GuiObject|GUI elements without manually having to connect the GuiObject.NextSelectionUp, GuiObject.NextSelectionDown, and GuiObject|NextSelectionRight, and GuiObject.NextSelectionLeft properties for every element in the grid.
Note that this code sample assumes your UIGridLayout is sorted by name, where elements are named in successive numerical order.
The code relies on this to set the NextSelection properties for all GuiObjects in the same level as the UIGridLayout. In our example, the UIGridLayoutObject and GUI elements within the grid are all children of a Frame named "Container". The code gets the children of "Container" and loops through each child. Children that are not GuiObjects are ignored. For each GUI element, the code attempts to assigned the NextSelection properties using the following logic:
- Starting with 1, the name of all GUI elements match their position in the grid
- Left: The item to the left will always be numbered 1 less than the current element
- Right: The item to the left will always be numbered 1 more than the current element
- Up: The item above (up) will always be number of GUIs in a row 1 less than the current element
- Down: The item below (down) will always be the number of GUIs in a row more than the current element This logic also allows for the GUI elements at the begging and end of rows (excluding the first and last element) to wrap around to the next and previous rows. If an element doesn't exist to the left, right, up, or down, the NextSelection will remain nil and moving the Gamepad selector in the direction will not change the selected GUI.
This example also contains code to test the grid using the arrow keys (Up, Down, Left, Right) of your keyboard instead of a gamepad, just in case you don't have a gamepad to test with. This portion of code initially selects the element named "1" by assigning it to the GuiService.SelectedObject property.
-- Setup the Gamepad selection grid using the code below
local container = script.Parent:FindFirstChild("Container")
local grid = container:GetChildren()
local rowSize = container:FindFirstChild("UIGridLayout").FillDirectionMaxCells
for _, gui in pairs(grid) do
if gui:IsA("GuiObject") then
local pos = gui.Name
-- Left edge
gui.NextSelectionLeft = container:FindFirstChild(pos - 1)
-- Right edge
gui.NextSelectionRight = container:FindFirstChild(pos + 1)
-- Above
gui.NextSelectionUp = container:FindFirstChild(pos - rowSize)
-- Below
gui.NextSelectionDown = container:FindFirstChild(pos + rowSize)
end
end
-- Test the Gamepad selection grid using the code below
local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")
GuiService.SelectedObject = container:FindFirstChild("1")
function updateSelection(input)
if input.UserInputType == Enum.UserInputType.Keyboard then
local key = input.KeyCode
local selectedObject = GuiService.SelectedObject
if not selectedObject then
return
end
if key == Enum.KeyCode.Up then
if not selectedObject.NextSelectionUp then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Down then
if not selectedObject.NextSelectionDown then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Left then
if not selectedObject.NextSelectionLeft then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Right then
if not selectedObject.NextSelectionRight then
GuiService.SelectedObject = selectedObject
end
end
end
end
UserInputService.InputBegan:Connect(updateSelection)
NextSelectionLeft
Właściwość ta ustawia GuiObject wybraną, gdy użytkownik przesuwa selektor gamepad w lewo.Jeśli ta właściwość jest pusta, przesunięcie gamepada w lewo nie zmieni wybranej GUI.
Przesunięcie selektora gamepada do lewej strony ustawia GuiService.SelectedObject na ten obiekt, chyba że interfejs użytkownika nie jest Selectable.Zauważ, że właściwość ta może być ustawiona na element interfejsu graficznego, nawet jeśli nie jest Selectable, więc powinieneś upewnić się, że wartość właściwości wybieralnej interfejsu graficznego odpowiada Twojemu oczekiwanemu zachowaniu.
Zobacz także NextSelectionUp , NextSelectionDown i NextSelectionRight .
Przykłady kodu
This example demonstrates how to enable Gamepad navigation through a grid of GuiObject|GUI elements without manually having to connect the GuiObject.NextSelectionUp, GuiObject.NextSelectionDown, and GuiObject|NextSelectionRight, and GuiObject.NextSelectionLeft properties for every element in the grid.
Note that this code sample assumes your UIGridLayout is sorted by name, where elements are named in successive numerical order.
The code relies on this to set the NextSelection properties for all GuiObjects in the same level as the UIGridLayout. In our example, the UIGridLayoutObject and GUI elements within the grid are all children of a Frame named "Container". The code gets the children of "Container" and loops through each child. Children that are not GuiObjects are ignored. For each GUI element, the code attempts to assigned the NextSelection properties using the following logic:
- Starting with 1, the name of all GUI elements match their position in the grid
- Left: The item to the left will always be numbered 1 less than the current element
- Right: The item to the left will always be numbered 1 more than the current element
- Up: The item above (up) will always be number of GUIs in a row 1 less than the current element
- Down: The item below (down) will always be the number of GUIs in a row more than the current element This logic also allows for the GUI elements at the begging and end of rows (excluding the first and last element) to wrap around to the next and previous rows. If an element doesn't exist to the left, right, up, or down, the NextSelection will remain nil and moving the Gamepad selector in the direction will not change the selected GUI.
This example also contains code to test the grid using the arrow keys (Up, Down, Left, Right) of your keyboard instead of a gamepad, just in case you don't have a gamepad to test with. This portion of code initially selects the element named "1" by assigning it to the GuiService.SelectedObject property.
-- Setup the Gamepad selection grid using the code below
local container = script.Parent:FindFirstChild("Container")
local grid = container:GetChildren()
local rowSize = container:FindFirstChild("UIGridLayout").FillDirectionMaxCells
for _, gui in pairs(grid) do
if gui:IsA("GuiObject") then
local pos = gui.Name
-- Left edge
gui.NextSelectionLeft = container:FindFirstChild(pos - 1)
-- Right edge
gui.NextSelectionRight = container:FindFirstChild(pos + 1)
-- Above
gui.NextSelectionUp = container:FindFirstChild(pos - rowSize)
-- Below
gui.NextSelectionDown = container:FindFirstChild(pos + rowSize)
end
end
-- Test the Gamepad selection grid using the code below
local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")
GuiService.SelectedObject = container:FindFirstChild("1")
function updateSelection(input)
if input.UserInputType == Enum.UserInputType.Keyboard then
local key = input.KeyCode
local selectedObject = GuiService.SelectedObject
if not selectedObject then
return
end
if key == Enum.KeyCode.Up then
if not selectedObject.NextSelectionUp then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Down then
if not selectedObject.NextSelectionDown then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Left then
if not selectedObject.NextSelectionLeft then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Right then
if not selectedObject.NextSelectionRight then
GuiService.SelectedObject = selectedObject
end
end
end
end
UserInputService.InputBegan:Connect(updateSelection)
NextSelectionRight
Właściwość ta ustawia GuiObject wybraną, gdy użytkownik przesuwa wybór gamepada w prawo.Jeśli ta właściwość jest pusta, przesunięcie gamepada w prawo nie zmieni wybranej GUI.
Przesunięcie wyboru kontrolera do prawej ustawia GuiService.SelectedObject do tego obiektu, chyba że interfejs użytkownika nie jest Selectable .Zauważ, że właściwość ta może być ustawiona na element interfejsu graficznego, nawet jeśli nie jest Selectable, więc powinieneś upewnić się, że wartość właściwości wybieralnej interfejsu graficznego odpowiada Twojemu oczekiwanemu zachowaniu.
Zobacz także NextSelectionUp , NextSelectionDown i NextSelectionLeft .
Przykłady kodu
This example demonstrates how to enable Gamepad navigation through a grid of GuiObject|GUI elements without manually having to connect the GuiObject.NextSelectionUp, GuiObject.NextSelectionDown, and GuiObject|NextSelectionRight, and GuiObject.NextSelectionLeft properties for every element in the grid.
Note that this code sample assumes your UIGridLayout is sorted by name, where elements are named in successive numerical order.
The code relies on this to set the NextSelection properties for all GuiObjects in the same level as the UIGridLayout. In our example, the UIGridLayoutObject and GUI elements within the grid are all children of a Frame named "Container". The code gets the children of "Container" and loops through each child. Children that are not GuiObjects are ignored. For each GUI element, the code attempts to assigned the NextSelection properties using the following logic:
- Starting with 1, the name of all GUI elements match their position in the grid
- Left: The item to the left will always be numbered 1 less than the current element
- Right: The item to the left will always be numbered 1 more than the current element
- Up: The item above (up) will always be number of GUIs in a row 1 less than the current element
- Down: The item below (down) will always be the number of GUIs in a row more than the current element This logic also allows for the GUI elements at the begging and end of rows (excluding the first and last element) to wrap around to the next and previous rows. If an element doesn't exist to the left, right, up, or down, the NextSelection will remain nil and moving the Gamepad selector in the direction will not change the selected GUI.
This example also contains code to test the grid using the arrow keys (Up, Down, Left, Right) of your keyboard instead of a gamepad, just in case you don't have a gamepad to test with. This portion of code initially selects the element named "1" by assigning it to the GuiService.SelectedObject property.
-- Setup the Gamepad selection grid using the code below
local container = script.Parent:FindFirstChild("Container")
local grid = container:GetChildren()
local rowSize = container:FindFirstChild("UIGridLayout").FillDirectionMaxCells
for _, gui in pairs(grid) do
if gui:IsA("GuiObject") then
local pos = gui.Name
-- Left edge
gui.NextSelectionLeft = container:FindFirstChild(pos - 1)
-- Right edge
gui.NextSelectionRight = container:FindFirstChild(pos + 1)
-- Above
gui.NextSelectionUp = container:FindFirstChild(pos - rowSize)
-- Below
gui.NextSelectionDown = container:FindFirstChild(pos + rowSize)
end
end
-- Test the Gamepad selection grid using the code below
local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")
GuiService.SelectedObject = container:FindFirstChild("1")
function updateSelection(input)
if input.UserInputType == Enum.UserInputType.Keyboard then
local key = input.KeyCode
local selectedObject = GuiService.SelectedObject
if not selectedObject then
return
end
if key == Enum.KeyCode.Up then
if not selectedObject.NextSelectionUp then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Down then
if not selectedObject.NextSelectionDown then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Left then
if not selectedObject.NextSelectionLeft then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Right then
if not selectedObject.NextSelectionRight then
GuiService.SelectedObject = selectedObject
end
end
end
end
UserInputService.InputBegan:Connect(updateSelection)
NextSelectionUp
Właściwość ta ustawia GuiObject wybraną, gdy użytkownik przesuwa suwak gamepad w górę.Jeśli ta właściwość jest pusta, przesuwanie gamepada w górę nie zmieni wybranej GUI.
Przesuwanie przełącznika gamepada w górę ustawia GuiService.SelectedObject na ten obiekt, chyba że interfejs użytkownika nie jest Selectable.Zauważ, że właściwość ta może być ustawiona na element interfejsu graficznego, nawet jeśli nie jest Selectable, więc powinieneś upewnić się, że wartość właściwości wybieralnej interfejsu graficznego odpowiada Twojemu oczekiwanemu zachowaniu.
Zobacz także NextSelectionDown , NextSelectionLeft , NextSelectionRight .
Przykłady kodu
This example demonstrates how to enable Gamepad navigation through a grid of GuiObject|GUI elements without manually having to connect the GuiObject.NextSelectionUp, GuiObject.NextSelectionDown, and GuiObject|NextSelectionRight, and GuiObject.NextSelectionLeft properties for every element in the grid.
Note that this code sample assumes your UIGridLayout is sorted by name, where elements are named in successive numerical order.
The code relies on this to set the NextSelection properties for all GuiObjects in the same level as the UIGridLayout. In our example, the UIGridLayoutObject and GUI elements within the grid are all children of a Frame named "Container". The code gets the children of "Container" and loops through each child. Children that are not GuiObjects are ignored. For each GUI element, the code attempts to assigned the NextSelection properties using the following logic:
- Starting with 1, the name of all GUI elements match their position in the grid
- Left: The item to the left will always be numbered 1 less than the current element
- Right: The item to the left will always be numbered 1 more than the current element
- Up: The item above (up) will always be number of GUIs in a row 1 less than the current element
- Down: The item below (down) will always be the number of GUIs in a row more than the current element This logic also allows for the GUI elements at the begging and end of rows (excluding the first and last element) to wrap around to the next and previous rows. If an element doesn't exist to the left, right, up, or down, the NextSelection will remain nil and moving the Gamepad selector in the direction will not change the selected GUI.
This example also contains code to test the grid using the arrow keys (Up, Down, Left, Right) of your keyboard instead of a gamepad, just in case you don't have a gamepad to test with. This portion of code initially selects the element named "1" by assigning it to the GuiService.SelectedObject property.
-- Setup the Gamepad selection grid using the code below
local container = script.Parent:FindFirstChild("Container")
local grid = container:GetChildren()
local rowSize = container:FindFirstChild("UIGridLayout").FillDirectionMaxCells
for _, gui in pairs(grid) do
if gui:IsA("GuiObject") then
local pos = gui.Name
-- Left edge
gui.NextSelectionLeft = container:FindFirstChild(pos - 1)
-- Right edge
gui.NextSelectionRight = container:FindFirstChild(pos + 1)
-- Above
gui.NextSelectionUp = container:FindFirstChild(pos - rowSize)
-- Below
gui.NextSelectionDown = container:FindFirstChild(pos + rowSize)
end
end
-- Test the Gamepad selection grid using the code below
local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")
GuiService.SelectedObject = container:FindFirstChild("1")
function updateSelection(input)
if input.UserInputType == Enum.UserInputType.Keyboard then
local key = input.KeyCode
local selectedObject = GuiService.SelectedObject
if not selectedObject then
return
end
if key == Enum.KeyCode.Up then
if not selectedObject.NextSelectionUp then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Down then
if not selectedObject.NextSelectionDown then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Left then
if not selectedObject.NextSelectionLeft then
GuiService.SelectedObject = selectedObject
end
elseif key == Enum.KeyCode.Right then
if not selectedObject.NextSelectionRight then
GuiService.SelectedObject = selectedObject
end
end
end
end
UserInputService.InputBegan:Connect(updateSelection)
Position
Właściwość ta określa GuiObject piksel i pozycję skalarną za pomocą UDim2 . Pozycja jest skoncentrowana wokół pozycji obiektu GuiObject.AnchorPoint .
Pozycja skalarna jest względna do rozmiaru elementu GUI rodzica, jeśli istnieje.
Fragmy pikselowe wartości UDim2 są takie same niezależnie od rozmiaru rodzącego się GUI.Wartości reprezentują pozycję obiektu w pikselach.Rzeczywista pozycja piksela obiektu można odczytać z właściwości GuiBase2d.AbsolutePosition.
Rotation
Właściwość ta określa liczbę stopni, w jakich GuiObject obraca się o 90 stopni.Rotacja jest względna do środka obiektu, nie do AnchorPoint, co oznacza, że nie możesz zmienić punktu rotacjiPonadto ta właściwość nie jest kompatybilna z ClipsDescendants .
Selectable
Właściwość ta określa, czy GuiObject można wybrać podczas przeglądania interfejsów graficznych za pomocą gamepada.
Jeśli ta właściwość jest true, można wybrać interfejs użytkownika. Wybór interfejsu użytkownika ustawia również właściwość GuiService.SelectedObject na to obiekt.
Gdy jest to false, nie można wybrać interfejsu użytkownika.Jednak ustawienie tego na false, gdy GUI jest wybrane, nie odznaczy go ani nie zmieni wartości właściwości GuiService.SelectedObject.
Dodaj GuiObject.SelectionGained i GuiObject.SelectionLost nie będą strzelać dla elementu. Aby wyłączyć GuiObject, musisz zmienić właściwość GuiService.SelectedObject.
Właściwość ta jest przydatna, jeśli interfejs użytkownika jest połączony z kilkoma interfejsami za pomocą właściwości takich jak ta GuiObject.NextSelectionUp, GuiObject.NextSelectionDown, NextSelectionRight lub NextSelectionLeft.Zamiast zmieniać wszystkie właściwości, aby Gamepad nie mógł wybrać interfejsu, możesz wyłączyć jego właściwość Wybieralną, aby tymczasowo uniemożliwić jej wybór.Następnie, gdy chcesz, aby wybór kontrolera był w stanie wybrać interfejs użytkownika, po prostu ponownie włącz jego wybieralną właściwość.
Przykłady kodu
The example below offers a simple demonstration on how to use the GuiObject.Selectable property to limit when a GUI element can be selected by the Gamepad navigator.
When a TextBox has gains focus, it can be selected. However, when a TextBox loses focus it can no longer be selected.
Although this is a simple demonstration, the property can also be used to prevent the navigator from selecting UI elements that exist for cosmetic rather than functional purposes. For instance, while the buttons on a menu screen should be selectable, the title image should not be.
local GuiService = game:GetService("GuiService")
local textBox = script.Parent
local function gainFocus()
textBox.Selectable = true
GuiService.SelectedObject = textBox
end
local function loseFocus(_enterPressed, _inputObject)
GuiService.SelectedObject = nil
textBox.Selectable = false
end
-- The FocusLost and FocusGained event will fire because the textBox
-- is of type TextBox
textBox.Focused:Connect(gainFocus)
textBox.FocusLost:Connect(loseFocus)
SelectionImageObject
Właściwość ta zastępuje domyślną ozdobę selekcji używaną do gierpadów.
Zauważ, że wybrane SelectionImageObject nakłada się na wybrane GuiObject z obrazem Size.Aby uzyskać najlepsze wyniki, powinieneś zmienić rozmiar niestandardowego SelectionImageObject poprzez wartości skali UDim2 w celu pomocy w zapewnieniu, że obiekt skaluje się prawidłowo nad wybranym elementem.
Zmiana SelectionImageObject dla elementu GuiObject wpływa tylko na ten element. Aby wpłynąć na wszystkie elementy interfejsu użytkownika, ustaw właściwość PlayerGui.SelectionImageObject.
Aby określić lub ustawić, który element interfejsu użytkownika został wybrany przez użytkownika, możesz użyć właściwości GuiService.SelectedObject.Gracz używa gamepada do wyboru różnych elementów interfejsu użytkownika, wzywając wydarzenia NextSelectionUp, NextSelectionDown, NextSelectionLeft i NextSelectionRight.
SelectionOrder
Obiekty GUI z niższym kolejnością selekcji są wybierane wcześniej niż obiekty GUI z wyższą kolejnością selekcji podczas rozpoczęcia wyboru gamepada lub wezwania GuiService:Select() na przodka.Właściwość ta nie wpływa na nawigację kierunkową.Domyślna wartość to 0.
Size
Właściwość ta określa rozmiar GuiObject skalarny i pikselowy za pomocą UDim2.
Rozmiar skalarny jest względny do rozmiaru elementu GUI rodzica, jeśli istnieje.
Fragmy pikselowe wartości UDim2 są takie same niezależnie od rozmiaru rodzącego się GUI.Wartości reprezentują rozmiar obiektu w pikselach.Rzeczywisty rozmiar piksela obiektu można odczytać z właściwości GuiBase2d.AbsoluteSize.
Jeśli GuiObject ma rodzica, jego rozmiar wzdłuż każdej osi jest również wpływany przez rozmiar rodzica SizeConstraint.
Przykłady kodu
This code sample allows you to create a simple color-changing health bar using two nested Frames. Paste this into a LocalScript on the inner frame.
local Players = game:GetService("Players")
local player = Players.LocalPlayer
-- Paste script into a LocalScript that is
-- parented to a Frame within a Frame
local frame = script.Parent
local container = frame.Parent
container.BackgroundColor3 = Color3.new(0, 0, 0) -- black
-- This function is called when the humanoid's health changes
local function onHealthChanged()
local human = player.Character.Humanoid
local percent = human.Health / human.MaxHealth
-- Change the size of the inner bar
frame.Size = UDim2.new(percent, 0, 1, 0)
-- Change the color of the health bar
if percent < 0.1 then
frame.BackgroundColor3 = Color3.new(1, 0, 0) -- black
elseif percent < 0.4 then
frame.BackgroundColor3 = Color3.new(1, 1, 0) -- yellow
else
frame.BackgroundColor3 = Color3.new(0, 1, 0) -- green
end
end
-- This function runs is called the player spawns in
local function onCharacterAdded(character)
local human = character:WaitForChild("Humanoid")
-- Pattern: update once now, then any time the health changes
human.HealthChanged:Connect(onHealthChanged)
onHealthChanged()
end
-- Connect our spawn listener; call it if already spawned
player.CharacterAdded:Connect(onCharacterAdded)
if player.Character then
onCharacterAdded(player.Character)
end
SizeConstraint
Właściwość ta ustawia osie Size, na których będzie oparta GuiObject w stosunku do rozmiaru jej rodzica.
Właściwość ta jest przydatna do tworzenia obiektów GUI, które mają skalować się z szerokością lub wysokością obiektu rodzica, ale nie obu, skutecznie zachowując proporcję aspektu obiektu.
Visible
Ta właściwość, czy GuiObject i jej potomkowie zostaną wyrenderowane.
Wyrenderowanie poszczególnych komponentów a GuiObject można kontrolować indywidualnie za pomocą właściwości przejrzystości, takich jak GuiObject.BackgroundTransparency , TextLabel.TextTransparency i ImageLabel.ImageTransparency .
Gdy ta właściwość jest false, właściwość GuiObject zostanie zignorowana przez struktury układu takie jak UIListLayout, UIGridLayout i UITableLayout.Innymi słowy, przestrzeń, którą element inaczej zajmowałby w układzie, jest zamiast tego wykorzystywana przez inne elementy.
Przykłady kodu
This code sample adds open/close functionality to a Window UI. Paste as a LocalScript that is a sibling of a Frame named Window, a TextButton/ImageButton named Window, and a TextButton/ImageButton within the Window called Close.
local gui = script.Parent
local window = gui:WaitForChild("Window")
local toggleButton = gui:WaitForChild("ToggleWindow")
local closeButton = window:WaitForChild("Close")
local function toggleWindowVisbility()
-- Flip a boolean using the `not` keyword
window.Visible = not window.Visible
end
toggleButton.Activated:Connect(toggleWindowVisbility)
closeButton.Activated:Connect(toggleWindowVisbility)
ZIndex
Właściwość ta określa kolejność renderowania GuiObject względem innych.
Domyślnie renderowanie renderuje się w kolejności malejącego priorytetu, gdzie ci z niższymi wartościami renderują się pod tymi z wyższymi wartościami.Możesz zmienić kolejność renderowania w ramach ScreenGui, SurfaceGui lub BillboardGui poprzez zmianę wartości jego ZIndexBehavior .
Jeśli nie jesteś pewien, czy będziesz musiał dodać element między dwoma istniejącymi elementami w przyszłości, dobrym zwyczajem jest używanie wielokrotności 100 ( 0 , 100 , 200 , itp.).Zapewnia to dużą lukę wartości kolejności renderowania, których możesz używać do elementów położonych między innymi elementami.
Zobacz także , który kontroluje kolejność sortowania w przypadku użycia struktury układu takiej jak lub .
Metody
TweenPosition
Płynnie przenosi interfejs użytkownika do nowej pozycji UDim2 w określonym czasie za pomocą określonego Enum.EasingDirection i Enum.EasingStyle.
Funkcja ta zwróci, czy nastolatek grać.Nie zagra, jeśli inny nastolatek działa na GuiObject i parametr anulowania jest false .
Zobacz także GuiObject:TweenSize() i GuiObject:TweenSizeAndPosition().
Parametry
Gdzie GUI powinno się przenieść.
Kierunek, w którym łatwiej jest przesunąć interfejs użytkownika do pozycji końcowej.
Styl, w którym ułatwia się GUI do końcowej pozycji.
Jak długo, w sekundach, potrwa ukończenie tweena.
Czy nastolatek zastąpi w toku nastolatek.
Funkcja powrotu, która będzie wykonywana po zakończeniu tweena.
Zwroty
Czy nastolatek będzie grać.
Przykłady kodu
This code sample demonstrates a more involved usage of TweenPosition by detecting when the tween completes/cancels by defining a callback function. It also prints whether the tween will play.
local START_POSITION = UDim2.new(0, 0, 0, 0)
local GOAL_POSITION = UDim2.new(1, 0, 1, 0)
local guiObject = script.Parent
local function callback(state)
if state == Enum.TweenStatus.Completed then
print("The tween completed uninterrupted")
elseif state == Enum.TweenStatus.Canceled then
print("Another tween cancelled this one")
end
end
-- Initialize the GuiObject position, then start the tween:
guiObject.Position = START_POSITION
local willPlay = guiObject:TweenPosition(
GOAL_POSITION, -- Final position the tween should reach
Enum.EasingDirection.In, -- Direction of the easing
Enum.EasingStyle.Sine, -- Kind of easing to apply
2, -- Duration of the tween in seconds
true, -- Whether in-progress tweens are interrupted
callback -- Function to be callled when on completion/cancelation
)
if willPlay then
print("The tween will play")
else
print("The tween will not play")
end
TweenSize
Płynnie zmienia rozmiar GuiObject do nowego UDim2 w określonym czasie za pomocą określonego Enum.EasingDirection i Enum.EasingStyle.
Funkcja ta zwróci, czy nastolatek grać.Zwykle zawsze zwróci true, ale zwróci false, jeśli inny nastolatek jest aktywny i ustawienie przejęcia zostanie ustawione na false.
Zobacz także GuiObject:TweenSize() i GuiObject:TweenSizeAndPosition().
Parametry
Rozmiar, który powinien zmienić się interfejs GUI.
Kierunek, w którym ułatwić GUI do endSize.
Styl, w którym ułatwia się GUI do endSize.
Jak długo, w sekundach, potrwa ukończenie tweena.
Czy nastolatek zastąpi w toku nastolatek.
Funkcja powrotu, która będzie wykonywana po zakończeniu tweena.
Zwroty
Czy nastolatek będzie grać.
Przykłady kodu
This code sample demonstrates the usage of the GuiObject:TweenSize() function. It initiates an animation on the parent's GuiObject.Size property to UDim2.new(0.5, 0, 0.5, 0), which is half the GuiObject's parent size on both axes.
Additionally, it demonstrates how the callback parameter can be used to detect when the tween stops (whether it was cancelled by another tween or completed).
local guiObject = script.Parent
local function callback(didComplete)
if didComplete then
print("The tween completed successfully")
else
print("The tween was cancelled")
end
end
local willTween = guiObject:TweenSize(
UDim2.new(0.5, 0, 0.5, 0), -- endSize (required)
Enum.EasingDirection.In, -- easingDirection (default Out)
Enum.EasingStyle.Sine, -- easingStyle (default Quad)
2, -- time (default: 1)
true, -- should this tween override ones in-progress? (default: false)
callback -- a function to call when the tween completes (default: nil)
)
if willTween then
print("The GuiObject will tween")
else
print("The GuiObject will not tween")
end
TweenSizeAndPosition
Płynnie zmienia rozmiar i przesuwa interfejs użytkownika do nowego rozmiaru UDim2 i pozycji w określonym czasie za pomocą określonego Enum.EasingDirection i Enum.EasingStyle.
Funkcja ta zwróci, czy nastolatek grać.Zwykle zawsze zwróci true, ale zwróci false, jeśli inny nastolatek jest aktywny i ustawienie przejęcia zostanie ustawione na false.
Zobacz także GuiObject:TweenSize() i GuiObject:TweenSizeAndPosition().
Parametry
Rozmiar, który powinien zmienić się interfejs GUI.
Gdzie GUI powinno się przenieść.
Kierunek, w którym ułatwia się GUI do endSize i endPosition.
Styl, w którym ułatwia się GUI do endSize i endPosition.
Jak długo, w sekundach, potrwa ukończenie tweena.
Czy nastolatek zastąpi w toku nastolatek.
Funkcja powrotu, która będzie wykonywana po zakończeniu tweena.
Zwroty
Czy nastolatek będzie grać.
Przykłady kodu
The below example would tween a Frame to the top left of the parent's size and resize it down to 0.
local frame = script.Parent.Frame
frame:TweenSizeAndPosition(UDim2.new(0, 0, 0, 0), UDim2.new(0, 0, 0, 0))
Zdarzenia
InputBegan
To wydarzenie wystrzeliwuje, gdy użytkownik zaczyna interakcję z GuiObject za pomocą urządzenia interfejsu człowiek-komputer (przycisk myszy w dół, dotknięcie początku, przycisk klawiatury w dół itp.).
W UserInputService ma podobnie nazywane wydarzenie, które nie jest ograniczone do konkretnego elementu interfejsu użytkownika: UserInputService.InputBegan .
To wydarzenie zawsze będzie wystrzeliwane niezależnie od stanu gry.
Zobacz także GuiObject.InputEnded i GuiObject.InputChanged.
Parametry
An InputObject , który zawiera użyteczne dane do zapytania o wpis użytkownika, takie jak type of input , state of input i screen coordinates of the input .
Przykłady kodu
The following example demonstrates one of many usage examples of handling user input from InputBegan depending on its type.
In order for this to work as expected, it must be placed in a LocalScript and a child of gui.
-- In order to use the InputBegan event, you must specify the GuiObject
local gui = script.Parent
-- A sample function providing multiple usage cases for various types of user input
local function inputBegan(input)
if input.UserInputType == Enum.UserInputType.Keyboard then
print("A key is being pushed down! Key:", input.KeyCode)
elseif input.UserInputType == Enum.UserInputType.MouseButton1 then
print("The left mouse button has been pressed down at", input.Position)
elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
print("The right mouse button has been pressed down at", input.Position)
elseif input.UserInputType == Enum.UserInputType.Touch then
print("A touchscreen input has started at", input.Position)
elseif input.UserInputType == Enum.UserInputType.Gamepad1 then
print("A button is being pressed on a gamepad! Button:", input.KeyCode)
end
end
gui.InputBegan:Connect(inputBegan)
InputChanged
To wydarzenie wystrzeliwuje się, gdy użytkownik zmienia sposób interakcji za pomocą urządzenia interfejsu człowiek-komputer (przycisk myszy w dół, dotknięcie początku, przycisk klawiatury w dół itp.).
W UserInputService ma podobnie nazywane wydarzenie, które nie jest ograniczone do konkretnego elementu interfejsu użytkownika: UserInputService.InputChanged .
To wydarzenie zawsze będzie wystrzeliwane niezależnie od stanu gry.
Zobacz także GuiObject.InputBegan i GuiObject.InputEnded.
Parametry
An InputObject , który zawiera użyteczne dane do zapytania o wpis użytkownika, takie jak type of input , state of input i screen coordinates of the input .
Przykłady kodu
The following example demonstrates one of many usage examples of handling user input from InputChanged depending on its type.
In order for this to work as expected, it must be placed in a LocalScript and a child of gui.
local UserInputService = game:GetService("UserInputService")
local gui = script.Parent
local function printMovement(input)
print("Position:", input.Position)
print("Movement Delta:", input.Delta)
end
local function inputChanged(input)
if input.UserInputType == Enum.UserInputType.MouseMovement then
print("The mouse has been moved!")
printMovement(input)
elseif input.UserInputType == Enum.UserInputType.MouseWheel then
print("The mouse wheel has been scrolled!")
print("Wheel Movement:", input.Position.Z)
elseif input.UserInputType == Enum.UserInputType.Gamepad1 then
if input.KeyCode == Enum.KeyCode.Thumbstick1 then
print("The left thumbstick has been moved!")
printMovement(input)
elseif input.KeyCode == Enum.KeyCode.Thumbstick2 then
print("The right thumbstick has been moved!")
printMovement(input)
elseif input.KeyCode == Enum.KeyCode.ButtonL2 then
print("The pressure being applied to the left trigger has changed!")
print("Pressure:", input.Position.Z)
elseif input.KeyCode == Enum.KeyCode.ButtonR2 then
print("The pressure being applied to the right trigger has changed!")
print("Pressure:", input.Position.Z)
end
elseif input.UserInputType == Enum.UserInputType.Touch then
print("The user's finger is moving on the screen!")
printMovement(input)
elseif input.UserInputType == Enum.UserInputType.Gyro then
local _rotInput, rotCFrame = UserInputService:GetDeviceRotation()
local rotX, rotY, rotZ = rotCFrame:toEulerAnglesXYZ()
local rot = Vector3.new(math.deg(rotX), math.deg(rotY), math.deg(rotZ))
print("The rotation of the user's mobile device has been changed!")
print("Position", rotCFrame.p)
print("Rotation:", rot)
elseif input.UserInputType == Enum.UserInputType.Accelerometer then
print("The acceleration of the user's mobile device has been changed!")
printMovement(input)
end
end
gui.InputChanged:Connect(inputChanged)
InputEnded
Wydarzenie InputEnded występuje, gdy użytkownik przestaje interakcjonować za pomocą urządzenia interfejsu człowiek-komputer (przycisk myszy w dół, dotknięcie początku, przycisk klawiatury w dół itp.).
W UserInputService ma podobnie nazywane wydarzenie, które nie jest ograniczone do konkretnego elementu interfejsu użytkownika: UserInputService.InputEnded .
To wydarzenie zawsze będzie wystrzeliwane niezależnie od stanu gry.
Zobacz także GuiObject.InputBegan i GuiObject.InputChanged.
Parametry
An InputObject , który zawiera użyteczne dane do zapytania o wpis użytkownika, takie jak Enum.UserInputType , Enum.UserInputState i InputObject.Position .
Przykłady kodu
The following example demonstrates one of many usage examples of handling user input from InputEnded depending on its type.
In order for this to work as expected, it must be placed in a LocalScript and a child of gui.
-- In order to use the InputChanged event, you must specify a GuiObject
local gui = script.Parent
-- A sample function providing multiple usage cases for various types of user input
local function inputEnded(input)
if input.UserInputType == Enum.UserInputType.Keyboard then
print("A key has been released! Key:", input.KeyCode)
elseif input.UserInputType == Enum.UserInputType.MouseButton1 then
print("The left mouse button has been released at", input.Position)
elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
print("The right mouse button has been released at", input.Position)
elseif input.UserInputType == Enum.UserInputType.Touch then
print("A touchscreen input has been released at", input.Position)
elseif input.UserInputType == Enum.UserInputType.Gamepad1 then
print("A button has been released on a gamepad! Button:", input.KeyCode)
end
end
gui.InputEnded:Connect(inputEnded)
MouseEnter
Wydarzenie MouseEnter wystrzeliwuje się, gdy użytkownik przesuwa mysz do elementu GuiObject.
Proszę nie polegać na argumentach x i y przekazanych przez to wydarzenie jako niezawodny sposób określenia, gdzie znajduje się mysz użytkownika, gdy wchodzi do interfejsu GUI.Te koordynaty mogą się różnić nawet wtedy, gdy mysz wchodzi do interfejsu za pomocą tego samego krawędza - szczególnie, gdy mysz szybko wchodzi do elementu.Wynika to z tego, że koordynaty wskazują pozycję myszy, gdy wydarzenie się uruchamia, a nie dokładną chwilę, w której mysz wchodzi do interfejsu.
To wydarzenie wystrzeliwuje się nawet wtedy, gdy element GUI renderuje się poniżej innego elementu.
Jeśli chcesz śledzić, kiedy mysz użytkownika opuści element interfejsu graficznego, możesz użyć wydarzenia GuiObject.MouseLeave.
Zobacz także
Parametry
Koordynaty ekranu myszy X w pikselach, względem lewego górnego rogu ekranu.
Koordynaty ekranu myszy Y w pikselach, względem lewego górnego rogu ekranu.
Przykłady kodu
The following example prints the mouse location, in pixels, when it enters GUI element.
local guiObject = script.Parent
guiObject.MouseEnter:Connect(function(x, y)
print("The user's mouse cursor has entered the GuiObject at position", x, ",", y)
end)
MouseLeave
Wydarzenie MouseLeave wystrzeliwuje się, gdy użytkownik przenosi mysz z poza elementu GuiObject.
Proszę nie polegać na argumentach x i y przekazanych przez to wydarzenie jako niezawodny sposób określenia, gdzie znajduje się mysz użytkownika, gdy opuszcza interfejs graficzny.Te koordynaty mogą się różnić nawet wtedy, gdy mysz opuści interfejs za pomocą tej samej krawędzi - szczególnie wtedy, gdy mysz szybko opuści element.Wynika to z tego, że koordynaty wskazują pozycję myszy, gdy wydarzenie się uruchamia, a nie dokładną chwilę, w której mysz opuszcza interfejs.
To wydarzenie wystrzeliwuje się nawet wtedy, gdy element GUI renderuje się poniżej innego elementu.
Zobacz także
Parametry
Koordynaty ekranu myszy X w pikselach, względem lewego górnego rogu ekranu.
Koordynaty ekranu myszy Y w pikselach, względem lewego górnego rogu ekranu.
MouseMoved
Wystrzeliwuje za każdym razem, gdy użytkownik przesuwa mysz, gdy znajduje się w środku elementu GuiObject.Jest podobny do Mouse.Move, który wystrzeliwuje niezależnie od tego, czy mysz użytkownika jest nad elementem GUI.
Zauważ, że to wydarzenie wystrzeliwuje się, gdy pozycja myszy zostanie zaktualizowana, dlatego będzie wystrzeliwane wielokrotnie podczas przemieszczania.
Argumenty x i y wskazują aktualne koordynaty ekranu myszy użytkownika w pikselach.Mogą one być przydatne do określenia położenia myszy na interfejsie użytkownika, ekranie i delta, od czasu poprzedniej pozycji myszy, jeśli jest śledzona w globalnej zmiennej.
Kod poniżej pokazuje, jak określić przesunięcie Vector2 odległości myszy użytkownika względem elementu GUI:
local Players = game:GetService("Players")
local CustomScrollingFrame = script.Parent
local SubFrame = CustomScrollingFrame:FindFirstChild("SubFrame")
local mouse = Players.LocalPlayer:GetMouse()
local function getPosition(X, Y)
local gui_X = CustomScrollingFrame.AbsolutePosition.X
local gui_Y = CustomScrollingFrame.AbsolutePosition.Y
local pos = Vector2.new(math.abs(X - gui_X), math.abs(Y - gui_Y - 36))
print(pos)
end
CustomScrollingFrame.MouseMoved:Connect(getPosition)
Zauważ, że to wydarzenie może nie wystrzelić dokładnie wtedy, gdy mysz użytkownika wchodzi lub wychodzi z elementu interfejsu.Dlatego argumenty x i y mogą nie pasować idealnie do koordynatów krawędzi GUI.
Zobacz także
Parametry
Koordynaty ekranu myszy X w pikselach, względem lewego górnego rogu ekranu.
Koordynaty ekranu myszy Y w pikselach, względem lewego górnego rogu ekranu.
MouseWheelBackward
Wydarzenie WheelBackward wystrzeliwuje się, gdy użytkownik przewija kółko myszy wstecz, gdy mysz znajduje się nad elementem GuiObject.Jest podobny do Mouse.WheelBackward, który wystrzeliwuje niezależnie od tego, czy mysz użytkownika jest nad elementem GUI.
To wydarzenie wystrzeliwuje jedynie jako wskaźnik ruchu wstecznego kół.Oznacza to, że argumenty koordynaty myszy x i y nie zmieniają się w wyniku tego wydarzenia.Te koordynaty zmieniają się tylko wtedy, gdy porusza się mysz, co można śledzić za pomocą wydarzenia GuiObject.MouseMoved.
Zobacz także
Parametry
Koordynaty ekranu myszy X w pikselach, względem lewego górnego rogu ekranu.
Koordynaty ekranu myszy Y w pikselach, względem lewego górnego rogu ekranu.
MouseWheelForward
Wydarzenie WheelForward wystrzeliwuje się, gdy użytkownik przewija koło myszy do przodu, gdy mysz znajduje się nad elementem GuiObject.Jest podobny do Mouse.WheelForward, który wystrzeliwuje niezależnie od tego, czy mysz użytkownika jest nad elementem GUI.
To wydarzenie wystrzeliwuje jedynie jako wskaźnik przesuwania się kół w przód.Oznacza to, że argumenty koordynaty myszy X i Y nie zmieniają się w wyniku tego wydarzenia.Te koordynaty zmieniają się tylko wtedy, gdy porusza się mysz, co można śledzić za pomocą wydarzenia GuiObject.MouseMoved.
Zobacz także
Parametry
Koordynaty ekranu myszy X w pikselach, względem lewego górnego rogu ekranu.
Koordynata Y z myszy użytkownika.
SelectionGained
To wydarzenie wystrzeliwuje się, gdy wybór Gamepada zaczyna się skupiać na GuiObject.
Jeśli chcesz sprawdzić z Gamepada wybierz przystanki skupiające się na elementach interfejsu graficznego, możesz użyć wydarzenia GuiObject.SelectionLost.
Kiedy GUI uzyskuje skupienie wyboru, wartość właściwości SelectedObject również zmienia się na tę, która uzyskuje wybór.Aby określić, które GUI uzyskało wybór, sprawdź wartość tej właściwości.
Przykłady kodu
The following example prints a message when the user selects the object with a gamepad.
In order for this to work as expected, it must be placed in a LocalScript and a child of gui.
local guiObject = script.Parent
local function selectionGained()
print("The user has selected this button with a gamepad.")
end
guiObject.SelectionGained:Connect(selectionGained)
SelectionLost
To wydarzenie wystrzeliwuje się, gdy wybór Gamepada przestaje skupiać się na GuiObject.
Jeśli chcesz sprawdzić z Gamepada, wybierz początek skupiania się na elementach interfejsu graficznego, możesz użyć wydarzenia GuiObject.SelectionGained.
Kiedy GUI traci skupienie wyboru, wartość właściwości SelectionObject zmienia się na nil lub na element GUI, który zyskuje skupienie wyboru.Aby określić, które GUI otrzymało wybór, lub jeśli nie zostanie wybrane żadne GUI, sprawdź wartość tej właściwości.
Przykłady kodu
The following example prints a message when the element has its focus lost on a gamepad.
In order for this to work as expected, it must be placed in a LocalScript and a child of gui.
local guiObject = script.Parent
local function selectionLost()
print("The user no longer has this selected with their gamepad.")
end
guiObject.SelectionLost:Connect(selectionLost)
TouchLongPress
To wydarzenie wystrzeliwuje po krótkiej chwili, gdy gracz trzyma palec na element interfejsu za pomocą urządzeniez włączonym dotykiem.Strzela z tabelą Vector2, która opisuje pozycję względną ekranu palców zaangażowanych w gest.Ponadto strzela wielokrotnie: Enum.UserInputState.Begin po krótkiej zwłoczce, Enum.UserInputState.Change jeśli gracz porusza palcem podczas gestu, a wreszcie Enum.UserInputState.End .Opóźnienie jest zależne od platformy; w Studio jest nieco dłuższe niż jedna sekunda.
Ponieważ to wydarzenie wymaga tylko jednego palca, można je symulować w Studio za pomocą emulatora i myszy.
Parametry
A Enum.UserInputState, który opisuje stan gestu:
- Rozpoczynaj pożary raz na początku gestu (po krótkiej zwłoczce)
- Zmień ogień, jeśli gracz przesuwa palec, naciskając
- Koniec ognia raz na końcu gestu, gdy uwalniają palec.
Przykłady kodu
This code sample allows the player to manipulate the screen position of some UI element, like a Frame, by holding down on the UI element for a brief moment. Then, the player moves their finger and releases. During the gesture the Frame is colored blue with a white outline.
local frame = script.Parent
frame.Active = true
local dragging = false
local basePosition
local startTouchPosition
local borderColor3
local backgroundColor3
local function onTouchLongPress(touchPositions, state)
if state == Enum.UserInputState.Begin and not dragging then
-- Start a drag
dragging = true
basePosition = frame.Position
startTouchPosition = touchPositions[1]
-- Color the frame to indicate the drag is happening
borderColor3 = frame.BorderColor3
backgroundColor3 = frame.BackgroundColor3
frame.BorderColor3 = Color3.new(1, 1, 1) -- White
frame.BackgroundColor3 = Color3.new(0, 0, 1) -- Blue
elseif state == Enum.UserInputState.Change then
local touchPosition = touchPositions[1]
local deltaPosition =
UDim2.new(0, touchPosition.X - startTouchPosition.X, 0, touchPosition.Y - startTouchPosition.Y)
frame.Position = basePosition + deltaPosition
elseif state == Enum.UserInputState.End and dragging then
-- Stop the drag
dragging = false
frame.BorderColor3 = borderColor3
frame.BackgroundColor3 = backgroundColor3
end
end
frame.TouchLongPress:Connect(onTouchLongPress)
TouchPan
To wydarzenie wystrzeliwuje się, gdy gracz przesuwa palec po elementze interfejsu za pomocą urządzeniez włączonym dotykiem.Wysyła się krótko przed tym, jak GuiObject.TouchSwipe zrobi, i nie strzela z GuiObject.TouchTap.To wydarzenie jest przydatne do umożliwienia graczowi manipulowania pozycją elementów interfejsu na ekranie.
To wydarzenie uruchamia się z tabelą Vector2, która opisuje pozycję względnych ekranów palców zaangażowanych w gest.Ponadto strzela wielokrotnie: Enum.UserInputState.Begin po krótkiej zwłoczce, Enum.UserInputState.Change gdy gracz przesuwa palec podczas gestu, a wreszcie z Enum.UserInputState.End.
To wydarzenie nie może być symulowane w Studio za pomocą emulatora i myszy; musisz mieć prawdziwy urządzenie z włączonym dotykiem, aby go wystrzelić.
Parametry
Układ Luau z Vector2 obiektami, każdy z których wskazuje pozycję wszystkich palców zaangażowanych w gest.
Wskazuje, jak daleko poszła gestka patelni od jej punktu wyjścia.
Wskazuje, jak szybko wykonywany jest gest w każdym wymiarze.
Wskazuje Enum.UserInputState z gestu.
Przykłady kodu
This code sample is meant to be placed in a LocalScript within an inner Frame that is inside an outer Frame, or other GuiObject. It allows the player to manipulate the position of the inner frame by moving their finger on the outer frame.
local innerFrame = script.Parent
local outerFrame = innerFrame.Parent
outerFrame.BackgroundTransparency = 0.75
outerFrame.Active = true
outerFrame.Size = UDim2.new(1, 0, 1, 0)
outerFrame.Position = UDim2.new(0, 0, 0, 0)
outerFrame.AnchorPoint = Vector2.new(0, 0)
outerFrame.ClipsDescendants = true
local dragging = false
local basePosition
local function onTouchPan(_touchPositions, totalTranslation, _velocity, state)
if state == Enum.UserInputState.Begin and not dragging then
dragging = true
basePosition = innerFrame.Position
outerFrame.BackgroundTransparency = 0.25
elseif state == Enum.UserInputState.Change then
innerFrame.Position = basePosition + UDim2.new(0, totalTranslation.X, 0, totalTranslation.Y)
elseif state == Enum.UserInputState.End and dragging then
dragging = false
outerFrame.BackgroundTransparency = 0.75
end
end
outerFrame.TouchPan:Connect(onTouchPan)
TouchPinch
To wydarzenie wystrzeliwuje się, gdy gracz używa dwóch palców, aby wykonać chwyt lub przeciągnąć gest na element interfejsu za pomocą urządzeniez włączonym dotykiem.A ścisk zdarza się, gdy dwa lub więcej palców przesuwa się bliżej siebie, a pociągnięcie zdarza się, gdy się oddzielają.To wydarzenie wystrzeliwuje się w połączeniu z GuiObject.TouchPan.To wydarzenie jest przydatne do umożliwienia graczowi manipulowania skalą (rozmiarem) elementów interfejsu na ekranie i jest najczęściej używane do funkcji skalowania.
To wydarzenie uruchamia się z tabelą Vector2, która opisuje pozycję względnych ekranów palców zaangażowanych w gest.Ponadto strzela wielokrotnie: Enum.UserInputState.Begin po krótkiej zwłoczce, Enum.UserInputState.Change gdy gracz porusza palcem podczas gestu, a wreszcie z Enum.UserInputState.End.Należy zauważyć, że skala powinna być używana mnożnikowo .
Ponieważ to wydarzenie wymaga co najmniej dwóch palców, nie można go symulować w Studio za pomocą emulatora i myszy; musisz mieć prawdziwy urządzenie z włączonym dotykiem.
Parametry
Układ Luau z Vector2 obiektami, każdy z których wskazuje pozycję wszystkich palców zaangażowanych w gest przeciągania.
Pływak, który wskazuje różnicę od początku gestu pinch.
Pływak wskazujący, jak szybko dzieje się gest przeciągania.
Wskazuje Enum.UserInputState z gestu.
Przykłady kodu
This code sample is meant for a LocalScript within an inner Frame that is inside an outer Frame, or other GuiObject. It allows the player to scale the inner frame by performing a GuiObject.TouchPinch gesture on the outer frame.
local innerFrame = script.Parent
local outerFrame = innerFrame.Parent
outerFrame.BackgroundTransparency = 0.75
outerFrame.Active = true
outerFrame.Size = UDim2.new(1, 0, 1, 0)
outerFrame.Position = UDim2.new(0, 0, 0, 0)
outerFrame.AnchorPoint = Vector2.new(0, 0)
outerFrame.ClipsDescendants = true
local dragging = false
local uiScale = Instance.new("UIScale")
uiScale.Parent = innerFrame
local baseScale
local function onTouchPinch(_touchPositions, scale, _velocity, state)
if state == Enum.UserInputState.Begin and not dragging then
dragging = true
baseScale = uiScale.Scale
outerFrame.BackgroundTransparency = 0.25
elseif state == Enum.UserInputState.Change then
uiScale.Scale = baseScale * scale -- Notice the multiplication here
elseif state == Enum.UserInputState.End and dragging then
dragging = false
outerFrame.BackgroundTransparency = 0.75
end
end
outerFrame.TouchPinch:Connect(onTouchPinch)
TouchRotate
To wydarzenie wystrzeliwuje się, gdy gracz używa dwóch palców, aby wykonać chwyt lub przeciągnąć gest na element interfejsu za pomocą urządzeniez włączonym dotykiem.Rotacja występuje, gdy zmienia się kąt linii między dwoma palcami.To wydarzenie wystrzeliwuje się w połączeniu z GuiObject.TouchPan.To wydarzenie jest przydatne do umożliwienia graczowi manipulowania rotacją elementów interfejsu na ekranie.
To wydarzenie uruchamia się z tabelą Vector2, która opisuje pozycję względnych ekranów palców zaangażowanych w gest.Ponadto strzela wielokrotnie: Enum.UserInputState.Begin po krótkiej zwłoczce, Enum.UserInputState.Change gdy gracz porusza palcem podczas gestu, a wreszcie z Enum.UserInputState.End.
Ponieważ to wydarzenie wymaga co najmniej dwóch palców, nie można go symulować w Studio za pomocą emulatora i myszy; musisz mieć prawdziwy urządzenie z włączonym dotykiem.
Parametry
Układ Luau z Vector2 obiektami, każdy z których wskazuje pozycję wszystkich palców zaangażowanych w gest.
Pływanie wskazujące, jak dużo obrót odszedł od początku gestu.
Pływak, który wskazuje, jak szybko wykonywany jest gest.
Wskazuje Enum.UserInputState z gestu.
Przykłady kodu
This code sample is meant for a LocalScript within an inner Frame that is inside an outer Frame, or other GuiObject. It allows the player to rotate the inner frame by performing a GuiObject.TouchRotate gesture on the outer frame.
local innerFrame = script.Parent
local outerFrame = innerFrame.Parent
outerFrame.BackgroundTransparency = 0.75
outerFrame.Active = true
outerFrame.Size = UDim2.new(1, 0, 1, 0)
outerFrame.Position = UDim2.new(0, 0, 0, 0)
outerFrame.AnchorPoint = Vector2.new(0, 0)
outerFrame.ClipsDescendants = true
local dragging = false
local baseRotation = innerFrame.Rotation
local function onTouchRotate(_touchPositions, rotation, _velocity, state)
if state == Enum.UserInputState.Begin and not dragging then
dragging = true
baseRotation = innerFrame.Rotation
outerFrame.BackgroundTransparency = 0.25
elseif state == Enum.UserInputState.Change then
innerFrame.Rotation = baseRotation + rotation
elseif state == Enum.UserInputState.End and dragging then
dragging = false
outerFrame.BackgroundTransparency = 0.75
end
end
outerFrame.TouchRotate:Connect(onTouchRotate)
TouchSwipe
To wydarzenie wystrzeliwuje się, gdy gracz wykonuje gest przesuwania na element interfejsu za pomocą urządzeniez włączonym dotykiem.Strzela z kierunkiem gestu (w górę, w dół, w lewo lub w prawo) i liczbą punktów dotyku zaangażowanych w gest.Gestury przesuwania są często używane do zmiany zakładek w mobilnych interfejsach użytkownika.
Ponieważ to wydarzenie wymaga tylko jednego palca, można je symulować w Studio za pomocą emulatora i myszy.
Parametry
A Enum.SwipeDirection wskazujący kierunek gestu przesuwania (w górę, w dół, w lewo lub w prawo).
Liczba punktów dotyku zaangażowanych w gest (zwykle 1).
Przykłady kodu
This code sample will cause a Frame (or other GuiObject) to bounce when a swipe gesture is performed on a touch-enabled device (or Studio's emulator). Horizontal swipes will change the hue of the GuiObject.BackgroundColor3, while vertical swipes will change the saturation.
local frame = script.Parent
frame.Active = true
-- How far the frame should bounce on a successful swipe
local BOUNCE_DISTANCE = 50
-- Current state of the frame
local basePosition = frame.Position
local hue = 0
local saturation = 128
local function updateColor()
frame.BackgroundColor3 = Color3.fromHSV(hue / 256, saturation / 256, 1)
end
local function onTouchSwipe(swipeDir, _touchCount)
-- Change the BackgroundColor3 based on the swipe direction
local deltaPos
if swipeDir == Enum.SwipeDirection.Right then
deltaPos = UDim2.new(0, BOUNCE_DISTANCE, 0, 0)
hue = (hue + 16) % 255
elseif swipeDir == Enum.SwipeDirection.Left then
deltaPos = UDim2.new(0, -BOUNCE_DISTANCE, 0, 0)
hue = (hue - 16) % 255
elseif swipeDir == Enum.SwipeDirection.Up then
deltaPos = UDim2.new(0, 0, 0, -BOUNCE_DISTANCE)
saturation = (saturation + 16) % 255
elseif swipeDir == Enum.SwipeDirection.Down then
deltaPos = UDim2.new(0, 0, 0, BOUNCE_DISTANCE)
saturation = (saturation - 16) % 255
else
deltaPos = UDim2.new()
end
-- Update the color and bounce the frame a little
updateColor()
frame.Position = basePosition + deltaPos
frame:TweenPosition(basePosition, Enum.EasingDirection.Out, Enum.EasingStyle.Bounce, 0.7, true)
end
frame.TouchSwipe:Connect(onTouchSwipe)
updateColor()
TouchTap
To wydarzenie wystrzeliwuje się, gdy gracz wykonuje gest dotknięcia na element interfejsu za pomocą urządzeniez włączonym dotykiem.Dotknięcie to szybki jednokrotny dotyk bez żadnego zaangażowania ruchu (dłuższe naciśnięcie uruchomiłoby GuiObject.TouchLongPress , a poruszanie się podczas dotknięcia uruchomiłoby GuiObject.TouchPan i/lub GuiObject.TouchSwipe ).Strzela z tabelą Vector2 obiektów, które opisują względne położenia palców zaangażowanych w gest.
Ponieważ to wydarzenie wymaga tylko jednego palca, można je symulować w Studio za pomocą emulatora i myszy.
Parametry
Przykłady kodu
This code sample will toggle the GuiObject.BackgroundTransparency of a UI element, like a Frame, when it is tapped on a touch-enabled device.
local frame = script.Parent
frame.Active = true
local function onTouchTap()
-- Toggle background transparency
if frame.BackgroundTransparency > 0 then
frame.BackgroundTransparency = 0
else
frame.BackgroundTransparency = 0.75
end
end
frame.TouchTap:Connect(onTouchTap)