TextLabel

Mostrar obsoleto

*Este conteúdo é traduzido por IA (Beta) e pode conter erros. Para ver a página em inglês, clique aqui.

Um TextLabel rende um retângulo, como um Frame , com texto estilado. O retângulo pode ser usado para definir limites de texto, escalonamento de texto ( TextLabel.TextScaled ) e envoltura ( TextLabel.TextWrapped , 1> Class.TextLabel.TextXAlignment

Essa classe contém propriedades que controlam a exibição do texto, como TextLabel.Font e TextLabel.TextColor3. Todo o texto renderizado por um único Class.TextLabel objeto terá as mesmas propriedades visuais; vários objetos 1> Class.TextLabel devem ser usados para renderizar vários estilos de texto. Para

TextService:GetTextSize() pode ser usado para obter o tamanho (边界) do texto que seria renderizado em um TextLabel dado um tamanho de fonte, fonte e tamanho de quadro.

Um objeto UITextSizeConstraint pode ser usado para restringir o tamanho do texto com TextLabel.TextScaled ativado. Recomenda-se que o tamanho do texto não seja inferior a 9, caso contrário, pode não ser visível para a maioria dos usuários.

Amostras de código

Countdown Text

-- Place this code in a LocalScript within a TextLabel/TextButton
local textLabel = script.Parent
-- Some colors we'll use with TextColor3
local colorNormal = Color3.new(0, 0, 0) -- black
local colorSoon = Color3.new(1, 0.5, 0.5) -- red
local colorDone = Color3.new(0.5, 1, 0.5) -- green
-- Loop infinitely
while true do
-- Count backwards from 10 to 1
for i = 10, 1, -1 do
-- Set the text
textLabel.Text = "Time: " .. i
-- Set the color based on how much time is left
if i > 3 then
textLabel.TextColor3 = colorNormal
else
textLabel.TextColor3 = colorSoon
end
task.wait(1)
end
textLabel.Text = "GO!"
textLabel.TextColor3 = colorDone
task.wait(2)
end
Game State Text

local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Place a StringValue called "GameState" in the ReplicatedStorage
local vGameState = ReplicatedStorage:WaitForChild("GameState")
-- Place this code in a TextLabel
local textLabel = script.Parent
-- Some colors we'll use with TextColor3
local colorNormal = Color3.new(0, 0, 0) -- black
local colorCountdown = Color3.new(1, 0.5, 0) -- orange
local colorRound = Color3.new(0.25, 0.25, 1) -- blue
-- We'll run this function to update the TextLabel as the state of the
-- game changes.
local function update()
-- Update the text
textLabel.Text = "State: " .. vGameState.Value
-- Set the color of the text based on the current game state
if vGameState.Value == "Countdown" then
textLabel.TextColor3 = colorCountdown
elseif vGameState.Value == "Round" then
textLabel.TextColor3 = colorRound
else
textLabel.TextColor3 = colorNormal
end
end
-- Pattern: update once when we start and also when vGameState changes
-- We should always see the most updated GameState.
update()
vGameState.Changed:Connect(update)

Resumo

Propriedades

Propriedades herdados de GuiObjectPropriedades herdados de GuiBase2d

Métodos

Métodos herdados de GuiObject

Eventos

Eventos herdados de GuiObjectEventos herdados de GuiBase2d

Propriedades

ContentText

Somente leitura
Não replicado
Ler Parallel

Essa propriedade fornece uma cópia de TextLabel.Text que contém exatamente o que está sendo renderizado pela TextLabel. Isso é útil para eliminar tags de estilo usados para texto rico.

Exemplo

Quando TextLabel.RichText é ativado, a propriedade TextLabel.ContentText mostra o texto como ele aparece para o jogador.


<tbody>
<tr>
<td>falso</td>
<td>\<b>Olá, mundo!\</b></td>
<td>\<b>Olá, mundo!\</b></td>
</tr>
<tr>
<td>verdade</td>
<td>\<b>Olá, mundo!\</b></td>
<td>Olá, mundo!</td>
</tr>
</tbody>
Texto RicoTextoTexto de Conteúdo
Oculto
Não replicado
Ler Parallel

A propriedade Fonte seleciona uma das várias fontes pré-definidas com quais o elemento da interface renderizará seu texto. Algumas fontes têm itálicos, negritos e/ou variações de luz (como não há propriedades de peso de fonte ou estilo de fonte).

Com a exceção da fonte "Legacy", cada fonte renderizará texto com a altura da linha igual à propriedade TextLabel.TextSize. A fonte "Code" é a única fonte de mono- espaço. Tem a propriedade única que cada personagem tem o mesmo largura e altura de relação de 1:2. A largura de cada personagem é aproximadamente metade da propriedade Class.TextLabel.TextSize</

Essa propriedade é mantida em sincronia com a propriedade TextLabel.FontFace. Ao definir a fonte, a fonte será definida como Font.fromEnum(value) .

Amostras de código

Cycle Font

local textLabel = script.Parent
while true do
-- Iterate over all the different fonts
for _, font in pairs(Enum.Font:GetEnumItems()) do
textLabel.Font = font
textLabel.Text = font.Name
task.wait(1)
end
end
Show All Fonts

local frame = script.Parent
-- Create a TextLabel displaying each font
for _, font in pairs(Enum.Font:GetEnumItems()) do
local textLabel = Instance.new("TextLabel")
textLabel.Name = font.Name
-- Set the text properties
textLabel.Text = font.Name
textLabel.Font = font
-- Some rendering properties
textLabel.TextSize = 24
textLabel.TextXAlignment = Enum.TextXAlignment.Left
-- Size the frame equal to the height of the text
textLabel.Size = UDim2.new(1, 0, 0, textLabel.TextSize)
-- Add to the parent frame
textLabel.Parent = frame
end
-- Layout the frames in a list (if they aren't already)
if not frame:FindFirstChildOfClass("UIListLayout") then
local uiListLayout = Instance.new("UIListLayout")
uiListLayout.Parent = frame
end

FontFace

Ler Parallel

A propriedade FontFace é semelhante à propriedade Font, mas permite definir fontes que não existem no índice de fontes.

Essa propriedade é mantida em sincronia com a propriedade TextLabel.Font. Ao definir oFontFace, oFont é definido para o valor de lista correspondente ou para Enum.Font.Unknown se não houver correspondências.

LineHeight

Ler Parallel

Controla a altura das linhas, como uma multiplicação do tamanho do ponto da fonte, escalando a espaçamento entre linhas de texto na TextLabel. Valores válidos variam de 1.0 a 3.0, padrão para 1.0.

LocalizedText

Oculto
Somente leitura
Não replicado
Ler Parallel

Essa propriedade define se um TextLabel deve ser GuiBase2d.Localize ou não.

MaxVisibleGraphemes

Ler Parallel

Essa propriedade controla o número máximo de графема (ou unidades de texto) que são mostrados no TextLabel . É fornecido principalmente como uma maneira fácil de criar um "efeito de tipo" onde os personagens aparecem um por um.

Alterar a propriedade não muda a posição ou tamanho dos gráficos visíveis - a layout será calculada como se todos os gráficos fossem visíveis.

Configurar a propriedade para -1 desativa o limite e mostra a totalidade do TextLabel.Text .

Amostras de código

Typewriter Effect with MaxVisibleGraphemes

local TweenService = game:GetService("TweenService")
local textObject = script.Parent
local tweenInfo = TweenInfo.new(
4, -- it takes 4 seconds for the effect to complete
Enum.EasingStyle.Sine, -- typing starts fast and slows near the end
Enum.EasingDirection.Out
)
local tween = TweenService:Create(textObject, tweenInfo, {
-- Final value should be the total grapheme count
MaxVisibleGraphemes = utf8.len(textObject.ContentText),
})
tween:Play()
tween.Completed:Wait()
-- Reset the value so it can be tweened again
textObject.MaxVisibleGraphemes = -1

OpenTypeFeatures

Ler Parallel

OpenTypeFeaturesError

Somente leitura
Não replicado
Ler Parallel

RichText

Ler Parallel

Essa propriedade determina se o TextLabel renderiza a string TextLabel.Text usando formatação de texto rico. O texto rico usa tags de marca simples para estilizar seções de texto em negrito, itálicos, cores específicas e muito mais.

Para usar texto rico, simplesmente inclua TextLabel.Text tags de formatação na string / cadeia / texto.

Text

Ler Parallel

As propriedades de texto determinam o conteúdo renderizado pelo elemento UI. As propriedades visuais da string renderizada para a tela são determinadas por Class.TextLabel.TextColor3

É possível renderizar emoji (por exemplo, 😃) e outros símbolos. Esses símbolos especiais não são afetados pela propriedade TextLabel.TextColor3. Esses podem ser colados em Script e LocalScript objetos, bem como na janela de propriedades.

Esta propriedade pode conter caracteres de nova linha, no entanto, não é possível digitar caracteres de nova linha dentro da janela Propriedades. Da mesma forma, esta propriedade pode conter um personagem tab, mas ele será renderizado como um espaço em vez disso.

Amostras de código

Fading Banner

local TweenService = game:GetService("TweenService")
local textLabel = script.Parent
local content = {
"Welcome to my game!",
"Be sure to have fun!",
"Please give suggestions!",
"Be nice to other players!",
"Don't grief other players!",
"Check out the shop!",
"Tip: Don't die!",
}
local tweenInfo = TweenInfo.new(1, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)
local RNG = Random.new()
local fadeIn = TweenService:Create(textLabel, tweenInfo, {
TextTransparency = 0,
})
local fadeOut = TweenService:Create(textLabel, tweenInfo, {
TextTransparency = 1,
})
local lastIndex
while true do
-- Step 0: Fade out before doing anything
fadeOut:Play()
task.wait(tweenInfo.Time)
-- Step 1: pick content that wasn't the last displayed
local index
repeat
index = RNG:NextInteger(1, #content)
until lastIndex ~= index
-- Make sure we don't show the same thing next time
lastIndex = index
-- Step 2: show the content
textLabel.Text = content[index]
fadeIn:Play()
task.wait(tweenInfo.Time + 1)
end
"Kaboom!" Text

local textLabel = script.Parent
textLabel.Text = "Kaboom!"
while true do
for size = 5, 100, 5 do
textLabel.TextSize = size
textLabel.TextTransparency = size / 100
task.wait()
end
task.wait(1)
end
Show All Fonts

local frame = script.Parent
-- Create a TextLabel displaying each font
for _, font in pairs(Enum.Font:GetEnumItems()) do
local textLabel = Instance.new("TextLabel")
textLabel.Name = font.Name
-- Set the text properties
textLabel.Text = font.Name
textLabel.Font = font
-- Some rendering properties
textLabel.TextSize = 24
textLabel.TextXAlignment = Enum.TextXAlignment.Left
-- Size the frame equal to the height of the text
textLabel.Size = UDim2.new(1, 0, 0, textLabel.TextSize)
-- Add to the parent frame
textLabel.Parent = frame
end
-- Layout the frames in a list (if they aren't already)
if not frame:FindFirstChildOfClass("UIListLayout") then
local uiListLayout = Instance.new("UIListLayout")
uiListLayout.Parent = frame
end
Long Text Wrapping

local textLabel = script.Parent
-- This text wrapping demo is best shown on a 200x50 px rectangle
textLabel.Size = UDim2.new(0, 200, 0, 50)
-- Some content to spell out
local content = "Here's a long string of words that will "
.. "eventually exceed the UI element's width "
.. "and form line breaks. Useful for paragraphs "
.. "that are really long."
-- A function that will spell text out two characters at a time
local function spellTheText()
-- Iterate from 1 to the length of our content
for i = 1, content:len() do
-- Get a substring of our content: 1 to i
textLabel.Text = content:sub(1, i)
-- Color the text if it doesn't fit in our box
if textLabel.TextFits then
textLabel.TextColor3 = Color3.new(0, 0, 0) -- Black
else
textLabel.TextColor3 = Color3.new(1, 0, 0) -- Red
end
-- Wait a brief moment on even lengths
if i % 2 == 0 then
task.wait()
end
end
end
while true do
-- Spell the text with scale/wrap off
textLabel.TextWrapped = false
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with wrap on
textLabel.TextWrapped = true
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with text scaling on
-- Note: Text turns red (TextFits = false) once text has to be
-- scaled down in order to fit within the UI element.
textLabel.TextScaled = true
-- Note: TextWrapped is enabled implicitly when TextScaled = true
--textLabel.TextWrapped = true
spellTheText()
task.wait(1)
end
Emoji in Text

local textLabel = script.Parent
local moods = {
["happy"] = "😃",
["sad"] = "😢",
["neutral"] = "😐",
["tired"] = "😫",
}
while true do
for mood, face in pairs(moods) do
textLabel.Text = "I am feeling " .. mood .. "! " .. face
task.wait(1)
end
end

TextBounds

Somente leitura
Não replicado
Ler Parallel

A propriedade TextBounds reflete o tamanho absoluto do texto renderizado em deslocos. Em outras palavras, se você tentar ajustar o texto em um retângulo, esta propriedade refletirá as dimensões mínimas do retângulo que você precisaria para ajustar o texto.

Usando TextService:GetTextSize() , você pode prever o que TextBounds estará em um TextLabel dado uma string / cadeia / texto, TextLabel.Font , TextLabel.TextSize e tamanho de quadro.

Amostras de código

Dynamic TextBox Size

local textBox = script.Parent
-- The smallest the TextBox will go
local minWidth, minHeight = 10, 10
-- Set alignment so our text doesn't wobble a bit while we type
textBox.TextXAlignment = Enum.TextXAlignment.Left
textBox.TextYAlignment = Enum.TextYAlignment.Top
local function updateSize()
textBox.Size = UDim2.new(0, math.max(minWidth, textBox.TextBounds.X), 0, math.max(minHeight, textBox.TextBounds.Y))
end
textBox:GetPropertyChangedSignal("TextBounds"):Connect(updateSize)

TextColor3

Ler Parallel

Essa propriedade determina a cor de todo o texto renderizado por um elemento GUI. Essa propriedade, juntamente com TextLabel.Font, TextLabel.TextSize e 2>Class.TextLabel.Transparency2>, determinará as propriedades visuais do texto. O texto é renderizado ap

É importante que o texto seja facilmente lido por jogadores! Certifique-se de escolher cores com baixa saturação, como branco, cinza ou preto. Certifique-se de que a cor do seu texto seja contrasteada com o TextLabel.BackgroundColor3 do elemento GUI. Se o elemento tiver um fundo transparente, tente aplicar um preto Class.TextLabel

Amostras de código

Vowel Detector

local textBox = script.Parent
local function hasVowels(str)
return str:lower():find("[aeiou]")
end
local function onTextChanged()
local text = textBox.Text
-- Check for vowels
if hasVowels(text) then
textBox.TextColor3 = Color3.new(0, 0, 0) -- Black
else
textBox.TextColor3 = Color3.new(1, 0, 0) -- Red
end
end
textBox:GetPropertyChangedSignal("Text"):Connect(onTextChanged)
TextBox Secret Word

-- Place this code in a LocalScript inside a TextBox
local textBox = script.Parent
local secretWord = "roblox"
local colorNormal = Color3.new(1, 1, 1) -- white
local colorWrong = Color3.new(1, 0, 0) -- red
local colorCorrect = Color3.new(0, 1, 0) -- green
-- Initialize the state of the textBox
textBox.ClearTextOnFocus = true
textBox.Text = ""
textBox.Font = Enum.Font.Code
textBox.PlaceholderText = "What is the secret word?"
textBox.BackgroundColor3 = colorNormal
local function onFocused()
textBox.BackgroundColor3 = colorNormal
end
local function onFocusLost(enterPressed, _inputObject)
if enterPressed then
local guess = textBox.Text
if guess == secretWord then
textBox.Text = "ACCESS GRANTED"
textBox.BackgroundColor3 = colorCorrect
else
textBox.Text = "ACCESS DENIED"
textBox.BackgroundColor3 = colorWrong
end
else
-- The player stopped editing without pressing Enter
textBox.Text = ""
textBox.BackgroundColor3 = colorNormal
end
end
textBox.FocusLost:Connect(onFocusLost)
textBox.Focused:Connect(onFocused)
Countdown Text

-- Place this code in a LocalScript within a TextLabel/TextButton
local textLabel = script.Parent
-- Some colors we'll use with TextColor3
local colorNormal = Color3.new(0, 0, 0) -- black
local colorSoon = Color3.new(1, 0.5, 0.5) -- red
local colorDone = Color3.new(0.5, 1, 0.5) -- green
-- Loop infinitely
while true do
-- Count backwards from 10 to 1
for i = 10, 1, -1 do
-- Set the text
textLabel.Text = "Time: " .. i
-- Set the color based on how much time is left
if i > 3 then
textLabel.TextColor3 = colorNormal
else
textLabel.TextColor3 = colorSoon
end
task.wait(1)
end
textLabel.Text = "GO!"
textLabel.TextColor3 = colorDone
task.wait(2)
end
Game State Text

local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Place a StringValue called "GameState" in the ReplicatedStorage
local vGameState = ReplicatedStorage:WaitForChild("GameState")
-- Place this code in a TextLabel
local textLabel = script.Parent
-- Some colors we'll use with TextColor3
local colorNormal = Color3.new(0, 0, 0) -- black
local colorCountdown = Color3.new(1, 0.5, 0) -- orange
local colorRound = Color3.new(0.25, 0.25, 1) -- blue
-- We'll run this function to update the TextLabel as the state of the
-- game changes.
local function update()
-- Update the text
textLabel.Text = "State: " .. vGameState.Value
-- Set the color of the text based on the current game state
if vGameState.Value == "Countdown" then
textLabel.TextColor3 = colorCountdown
elseif vGameState.Value == "Round" then
textLabel.TextColor3 = colorRound
else
textLabel.TextColor3 = colorNormal
end
end
-- Pattern: update once when we start and also when vGameState changes
-- We should always see the most updated GameState.
update()
vGameState.Changed:Connect(update)

TextDirection

Ler Parallel

TextFits

Somente leitura
Não replicado
Ler Parallel

O TextFits é uma propriedade de leitura que é falsa se TextLabel.Text conteúdo não encaixa dentro do GuiBase2d.AbsoluteSize quando renderizado. Se Class.TextLabel.Text

Amostras de código

Long Text Wrapping

local textLabel = script.Parent
-- This text wrapping demo is best shown on a 200x50 px rectangle
textLabel.Size = UDim2.new(0, 200, 0, 50)
-- Some content to spell out
local content = "Here's a long string of words that will "
.. "eventually exceed the UI element's width "
.. "and form line breaks. Useful for paragraphs "
.. "that are really long."
-- A function that will spell text out two characters at a time
local function spellTheText()
-- Iterate from 1 to the length of our content
for i = 1, content:len() do
-- Get a substring of our content: 1 to i
textLabel.Text = content:sub(1, i)
-- Color the text if it doesn't fit in our box
if textLabel.TextFits then
textLabel.TextColor3 = Color3.new(0, 0, 0) -- Black
else
textLabel.TextColor3 = Color3.new(1, 0, 0) -- Red
end
-- Wait a brief moment on even lengths
if i % 2 == 0 then
task.wait()
end
end
end
while true do
-- Spell the text with scale/wrap off
textLabel.TextWrapped = false
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with wrap on
textLabel.TextWrapped = true
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with text scaling on
-- Note: Text turns red (TextFits = false) once text has to be
-- scaled down in order to fit within the UI element.
textLabel.TextScaled = true
-- Note: TextWrapped is enabled implicitly when TextScaled = true
--textLabel.TextWrapped = true
spellTheText()
task.wait(1)
end

TextScaled

Ler Parallel

Em vez de usar TextScaled, recomendamos que você considere usar AutomaticSize, um novo método para dimensionar dinamicamente a UI que lhe dará o melhor resultado visual possível.

A propriedade TextScaled determina se o texto é escalado para que ele preencha todo o espaço do elemento da interface. Quando isso estiver ativado, TextLabel.TextSize é ignorado e TextLabel.TextWrapped é ativado automaticamente. Essa propriedade é útil para renderizar elementos de texto dentro de BillboardGuis.

Quando esta propriedade é usada para a interface do usuário do espaço de tela, pode ser desejável usar um UITextSizeConstraint para restringir o alcance de tamanhos de texto possíveis.

TextScaled e AutomaticSize

Recomenda-se que os desenvolvedores evitem o uso de TextScaled e ajustem a interface do usuário para aproveitar a propriedade AutomaticSize em vez disso. Aqui estão as diferenças principais entre as duas propriedades:

  • O TextScaled escala o conteúdo (texto) para acomodar a UI. Sem uma atenção cuidadosa, alguns textos podem ficar ilegíveis se escalados muito pequenos.
  • O tamanho automático redimensiona a UI para acomodar o conteúdo.

Com o tamanho automático, você pode ajustar sua UI para acomodar o conteúdo (texto) ao mesmo tempo que mantém um tamanho de fonte consistente. Para mais informações sobre como usar o tamanho automático, consulte o artigo Automatic Size da UI.

Recomendamos que você não aplique tanto o TextScaled quanto o AutomaticSize na mesma instância de Objeto. Se você aplicar ambas as propriedades:

  • O tamanho automático determina a quantidade máxima de espaço disponível que um GuiObject pode usar (neste caso, texto)
  • O TextScaled usa o espaço disponível determinado pelo AutomaticSize, para escalar o tamanho do tipo para ajustar o tamanho da fonte ao espaço disponível, o que expandirá até o tamanho máximo do tipo (100), se houver restrições de tamanho
  • O resultado final será: o texto irá para o tamanho de 100 caracteres e o objeto de UI irá expandir para ajustar esse texto

Usar ambos AutomaticSize e TextScaled ao mesmo tempo pode resultar em diferenças de escalonamento significativas ao usar AutomaticSize desligado.

Amostras de código

Long Text Wrapping

local textLabel = script.Parent
-- This text wrapping demo is best shown on a 200x50 px rectangle
textLabel.Size = UDim2.new(0, 200, 0, 50)
-- Some content to spell out
local content = "Here's a long string of words that will "
.. "eventually exceed the UI element's width "
.. "and form line breaks. Useful for paragraphs "
.. "that are really long."
-- A function that will spell text out two characters at a time
local function spellTheText()
-- Iterate from 1 to the length of our content
for i = 1, content:len() do
-- Get a substring of our content: 1 to i
textLabel.Text = content:sub(1, i)
-- Color the text if it doesn't fit in our box
if textLabel.TextFits then
textLabel.TextColor3 = Color3.new(0, 0, 0) -- Black
else
textLabel.TextColor3 = Color3.new(1, 0, 0) -- Red
end
-- Wait a brief moment on even lengths
if i % 2 == 0 then
task.wait()
end
end
end
while true do
-- Spell the text with scale/wrap off
textLabel.TextWrapped = false
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with wrap on
textLabel.TextWrapped = true
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with text scaling on
-- Note: Text turns red (TextFits = false) once text has to be
-- scaled down in order to fit within the UI element.
textLabel.TextScaled = true
-- Note: TextWrapped is enabled implicitly when TextScaled = true
--textLabel.TextWrapped = true
spellTheText()
task.wait(1)
end

TextSize

Ler Parallel

A propriedade TextSize determina a altura em deslocamento de uma linha de texto renderizada. A unidade está em deslocamento, não pontos (o que é usado na maioria dos programas de edição de textos). Vale a pena notar que a altura da linha do tipo "Legado" difere, e não corresponderá exatamente à essa propriedade.

Essa propriedade e TextLabel.TextColor3 , TextLabel.TextTransparency , TextLabel.TextStrokeColor3 e 1> Class.TextLabel.TextStrokeTransparency1> cada uma afeta a maneira como o texto é renderizado.

Essa propriedade substitui TextLabel.FontSize pois é um número e não um índice. Internamente, o Roblox usa vários conjuntos de imagens de personagens pré-rendidas para cada tamanho de cada fonte. Ele escolhe o tamanho mais próximo para TextSize, então escala essas imagens de personagens pré-rendidas para renderizar texto. Antes da introdução dest

Amostras de código

"Kaboom!" Text

local textLabel = script.Parent
textLabel.Text = "Kaboom!"
while true do
for size = 5, 100, 5 do
textLabel.TextSize = size
textLabel.TextTransparency = size / 100
task.wait()
end
task.wait(1)
end

TextStrokeColor3

Ler Parallel

A propriedade TextStrokeColor3 define a cor do stroke, ou contorno, do texto renderizado. Essa propriedade e TextLabel.TextStrokeTransparency determinam as propriedades visuais do stroke.

O texto é renderizado antes do texto normal e é simplesmente 4 renderizações do mesmo texto em +/- 1 pixel de deslocamento em cada direção. A renderização de texto funciona independentemente e idêntica a TextLabel.TextColor3 e TextLabel.TextTransparency .

Amostras de código

Text Highlight Oscillation

local textLabel = script.Parent
-- How fast the highlight ought to blink
local freq = 2
-- Set to yellow highlight color
textLabel.TextStrokeColor3 = Color3.new(1, 1, 0)
while true do
-- math.sin oscillates from -1 to 1, so we change the range to 0 to 1:
local transparency = math.sin(workspace.DistributedGameTime * math.pi * freq) * 0.5 + 0.5
textLabel.TextStrokeTransparency = transparency
task.wait()
end

TextStrokeTransparency

Ler Parallel

A propriedade TextStrokeTransparency define a transparência do traço, ou contorno, do texto renderizado. Essa propriedade e TextLabel.TextStrokeColor3 determinam as propriedades visuais do traço.

O texto é renderizado antes do texto normal e é simplesmente 4 renderizações do mesmo texto em +/- 1 pixel de distância em cada direção. A renderização de texto é independ

Amostras de código

Text Highlight Oscillation

local textLabel = script.Parent
-- How fast the highlight ought to blink
local freq = 2
-- Set to yellow highlight color
textLabel.TextStrokeColor3 = Color3.new(1, 1, 0)
while true do
-- math.sin oscillates from -1 to 1, so we change the range to 0 to 1:
local transparency = math.sin(workspace.DistributedGameTime * math.pi * freq) * 0.5 + 0.5
textLabel.TextStrokeTransparency = transparency
task.wait()
end

TextTransparency

Ler Parallel

A propriedade TextColor3 determina a transparência de todo o texto renderizado por um elemento da UI. Essa propriedade, juntamente com TextLabel.Font , TextLabel.TextSize e TextLabel.TextColor3, determinará as propriedades visuais do texto. O texto é renderizado após o traço de texto ( 1> Class

Fazer texto desvanecer ao usar um for-Loop numérico é uma ótima maneira de chamar a atenção do jogador para o texto aparecendo na tela.


-- Count backwards from 1 to 0, decrementing by 0.1
for i = 1, 0, -0.1 do
textLabel.TextTransparency = i
task.wait(0.1)
end

Amostras de código

Fading Banner

local TweenService = game:GetService("TweenService")
local textLabel = script.Parent
local content = {
"Welcome to my game!",
"Be sure to have fun!",
"Please give suggestions!",
"Be nice to other players!",
"Don't grief other players!",
"Check out the shop!",
"Tip: Don't die!",
}
local tweenInfo = TweenInfo.new(1, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)
local RNG = Random.new()
local fadeIn = TweenService:Create(textLabel, tweenInfo, {
TextTransparency = 0,
})
local fadeOut = TweenService:Create(textLabel, tweenInfo, {
TextTransparency = 1,
})
local lastIndex
while true do
-- Step 0: Fade out before doing anything
fadeOut:Play()
task.wait(tweenInfo.Time)
-- Step 1: pick content that wasn't the last displayed
local index
repeat
index = RNG:NextInteger(1, #content)
until lastIndex ~= index
-- Make sure we don't show the same thing next time
lastIndex = index
-- Step 2: show the content
textLabel.Text = content[index]
fadeIn:Play()
task.wait(tweenInfo.Time + 1)
end
"Kaboom!" Text

local textLabel = script.Parent
textLabel.Text = "Kaboom!"
while true do
for size = 5, 100, 5 do
textLabel.TextSize = size
textLabel.TextTransparency = size / 100
task.wait()
end
task.wait(1)
end

TextTruncate

Ler Parallel

Controla a cortar o texto exibido neste TextLabel.

TextWrapped

Ler Parallel

Quando ativado, essa propriedade renderizará texto em várias linhas dentro do espaço de um GUI elemento, para que TextLabel.TextBounds nunca exceda o GuiBase2d.AbsoluteSize do elemento da interface.

Isso é obtido quebrando longas linhas de texto em várias linhas. Quebra de linhas preferirá espaço em branco; se uma longa palavra não escrita exceder a largura do elemento, essa palavra será quebrada em várias linhas.

Se quebra de linha adicional causaria a altura vertical do texto (o componente Y de TextLabel.TextBounds ) a exceder a altura vertical do elemento (o componente Y de GuiBase2d.AbsoluteSize), então essa linha não será renderizada em todas / todosos casos.

Amostras de código

Long Text Wrapping

local textLabel = script.Parent
-- This text wrapping demo is best shown on a 200x50 px rectangle
textLabel.Size = UDim2.new(0, 200, 0, 50)
-- Some content to spell out
local content = "Here's a long string of words that will "
.. "eventually exceed the UI element's width "
.. "and form line breaks. Useful for paragraphs "
.. "that are really long."
-- A function that will spell text out two characters at a time
local function spellTheText()
-- Iterate from 1 to the length of our content
for i = 1, content:len() do
-- Get a substring of our content: 1 to i
textLabel.Text = content:sub(1, i)
-- Color the text if it doesn't fit in our box
if textLabel.TextFits then
textLabel.TextColor3 = Color3.new(0, 0, 0) -- Black
else
textLabel.TextColor3 = Color3.new(1, 0, 0) -- Red
end
-- Wait a brief moment on even lengths
if i % 2 == 0 then
task.wait()
end
end
end
while true do
-- Spell the text with scale/wrap off
textLabel.TextWrapped = false
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with wrap on
textLabel.TextWrapped = true
textLabel.TextScaled = false
spellTheText()
task.wait(1)
-- Spell the text with text scaling on
-- Note: Text turns red (TextFits = false) once text has to be
-- scaled down in order to fit within the UI element.
textLabel.TextScaled = true
-- Note: TextWrapped is enabled implicitly when TextScaled = true
--textLabel.TextWrapped = true
spellTheText()
task.wait(1)
end

TextXAlignment

Ler Parallel

O texto X렬 determina o alinhamento horizontal (eixo X) do texto renderizado dentro do espaço de um elemento da interface. Funciona da mesma forma que a propriedade text-align da CSS, com valores de esquerda, direita e centro (não há opção de justificação). Para a esquerda e direita, o texto é renderizado para que os limites de texto esquerdo/direito toquem no lado do retângulo do elemento da interface. Para o centro, cada linha de texto é centralizada no centro do

Essa propriedade é usada em conjunto com TextLabel.TextYAlignment para determinar totalmente a alinhamento do texto em ambos os eixos. Essa propriedade não afetará as propriedades de leitura TextLabel.TextBounds e TextLabel.TextFits.

Amostras de código

Text Alignment

-- Paste this in a LocalScript within a TextLabel/TextButton/TextBox
local textLabel = script.Parent
local function setAlignment(xAlign, yAlign)
textLabel.TextXAlignment = xAlign
textLabel.TextYAlignment = yAlign
textLabel.Text = xAlign.Name .. " + " .. yAlign.Name
end
while true do
-- Iterate over both TextXAlignment and TextYAlignment enum items
for _, yAlign in pairs(Enum.TextYAlignment:GetEnumItems()) do
for _, xAlign in pairs(Enum.TextXAlignment:GetEnumItems()) do
setAlignment(xAlign, yAlign)
task.wait(1)
end
end
end

TextYAlignment

Ler Parallel

O textoYAlignment determina o alinhamento vertical (Y-axis) do texto renderizado dentro do espaço de um elemento da interface. Para o topo e para baixo, o texto é renderizado para que os limites de texto/cima/tenda toquem a borda do espaço do elemento. Para o centro, o texto é renderizado para que haja um espaço igual dos limites de texto/cima/tenda para a parte superior do elemento e dos limites de texto/cima/tenda para a parte inferior do elemento.

Essa propriedade é usada em conjunto com TextLabel.TextXAlignment para determinar totalmente a alinhamento do texto em ambos os eixos. Essa propriedade não afetará as propriedades de leitura TextLabel.TextBounds e TextLabel.TextFits.

Amostras de código

Text Alignment

-- Paste this in a LocalScript within a TextLabel/TextButton/TextBox
local textLabel = script.Parent
local function setAlignment(xAlign, yAlign)
textLabel.TextXAlignment = xAlign
textLabel.TextYAlignment = yAlign
textLabel.Text = xAlign.Name .. " + " .. yAlign.Name
end
while true do
-- Iterate over both TextXAlignment and TextYAlignment enum items
for _, yAlign in pairs(Enum.TextYAlignment:GetEnumItems()) do
for _, xAlign in pairs(Enum.TextXAlignment:GetEnumItems()) do
setAlignment(xAlign, yAlign)
task.wait(1)
end
end
end

Métodos

Eventos