Este exemplo de código inclui um exemplo simples de como o
`PlayerMouse` do jogador local pode ser obtido usando a função
`Class.Player:GetMouse()` em um `LocalScript`. Este código deve ser
colocado em um `LocalScript` em `StarterPlayerScripts`.

O PlayerMouse se comporta de forma idêntica ao objeto `Class.Mouse` que é
obtido usando `Class.Tool.Equipped`. Ele pode ser acessado a partir de
`Class.LocalScript|LocalScripts` usando o método `Class.Player:GetMouse()` do jogador local. Tanto o PlayerMouse quanto o `Class.Mouse` são
APIs legadas, substituídas pelo `Class.UserInputService`.

A única diferença entre o PlayerMouse e o objeto `Class.Mouse` é que o
PlayerMouse pode ser obtido usando o método `Class.Player:GetMouse()`.

Na maioria dos casos, os desenvolvedores são aconselhados a usar o novo
`Class.UserInputService`. No entanto, os objetos PlayerMouse e Mouse continuam
sendo suportados por uma série de razões. Veja [Input and Camera](/input) para mais informações
sobre como personalizar entradas em sua experiência.


PlayerMouse

O PlayerMouse se comporta de forma idêntica ao objeto `Class.Mouse` que é
obtido usando `Class.Tool.Equipped`. Tanto o PlayerMouse quanto o `Class.Mouse` são
APIs legadas, substituídas pelo `Class.UserInputService`.


**Mouse** foi superado por `Class.UserInputService` e `Class.ContextActionService`, que abrangem um escopo mais amplo, são mais ricos em recursos e suportam padrões **cross-platform** melhor. Ele continua suportado por causa do seu uso generalizado, mas você deve considerar fortemente usar essas alternativas.

O objeto **Mouse** abriga várias APIs para ponteiros, principalmente para botões e raycasting. Ele pode ser acessado através de `Class.Player:GetMouse()` chamado no `Class.Players.LocalPlayer` em um `Class.LocalScript`. Ele também é passado pelo evento `Class.Tool.Equipped`.

- É mais notável pela propriedade `Class.Mouse.Icon|Icon`, que altera a aparência do cursor.
- Ele continuamente raycast a posição do mouse na tela para o mundo 3D usando a propriedade `Class.Mouse.TargetFilter|TargetFilter`, armazenando os resultados do raycast nas propriedades `Class.Mouse.Hit|Hit`, `Class.Mouse.Target|Target` e `Class.Mouse.TargetSurface|TargetSurface`. Essas podem ser úteis para casos simples, mas `Class.WorldRoot:Raycast()` deve ser usado em cenários de [raycasting](/workspace/raycasting) mais complicados.
- `Class.Plugin|Plugins` pode usar `Class.Plugin:GetMouse()` para obter um `Class.PluginMouse`, que se comporta de forma semelhante.

```lua
-- De um LocalScript:
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
-- Definindo o ícone do mouse
mouse.Icon = "rbxasset://SystemCursors/Wait"
```
Nota:

- Este objeto não controla/restringe o movimento do ponteiro. Para isso, veja `Class.UserInputService.MouseBehavior` e `Class.UserInputService.MouseDeltaSensitivity`.
- Se duas funções estiverem conectadas ao mesmo evento de entrada, como `Class.Mouse.Button1Down|Button1Down`, **ambas** as funções serão executadas quando o evento disparar. Não há conceito de afundar/passar entrada, pois os eventos não suportam esse comportamento. No entanto, `Class.ContextActionService` possui esse comportamento através de `Class.ContextActionService:BindAction()|BindAction`.
- Embora um mouse possa não estar disponível em todas as plataformas, o Mouse ainda funcionará em dispositivos móveis (toque) e consoles (gamepad), que geralmente não têm mouses ou hardware de ponteiro. Para comportamentos explícitos cross-platform, use `Class.UserInputService` e `Class.ContextActionService`.

  Veja [Input and Camera](/input) para mais informações sobre como personalizar entradas na sua experiência.

Este evento dispara quando o jogador pressiona o botão esquerdo do mouse. Note que isso pode ser acessado de um `Class.Tool`; por exemplo, quando colocado em um `Class.LocalScript`, o código abaixo imprime `Button1Down` sempre que o botão esquerdo do mouse é pressionado.

```lua
local tool = script.Parent  -- Certifique-se de que isso seja um objeto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button1Down:Connect(function()
		print("Button1Down")
	end)
end)
```
Você pode descobrir a posição do mouse no espaço mundial e se está apontando para algum `Class.BasePart` usando as propriedades `Class.Mouse.Hit|Hit` e `Class.Mouse.Target|Target`.

Mouse.Button1Down

Dispara quando o botão esquerdo do mouse é pressionado.

Este evento dispara quando o jogador libera o botão esquerdo do mouse. Note que isso pode ser acessado de um `Class.Tool`; por exemplo, quando colocado em um `Class.LocalScript`, o código abaixo imprime `Button1Up` sempre que o botão esquerdo do mouse é liberado.

```lua
local tool = script.Parent  -- Certifique-se de que isso seja um objeto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button1Up:Connect(function()
		print("Button1Up")
	end)
end)
```
Você pode descobrir a posição do mouse no espaço mundial e se está apontando para algum `Class.BasePart` usando as propriedades `Class.Mouse.Hit|Hit` e `Class.Mouse.Target|Target`.

Mouse.Button1Up

Dispara quando o botão esquerdo do mouse é liberado.

Este evento dispara quando o jogador pressiona o botão direito do mouse. Note que isso pode ser acessado de um `Class.Tool`; por exemplo, quando colocado em um `Class.LocalScript`, o código abaixo imprime `Button2Down` sempre que o botão direito do mouse é pressionado.

```lua
local tool = script.Parent  -- Certifique-se de que isso seja um objeto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button2Down:Connect(function()
		print("Button2Down")
	end)
end)
```
Você pode descobrir a posição do mouse no espaço mundial e se está apontando para algum `Class.BasePart` usando as propriedades `Class.Mouse.Hit|Hit` e `Class.Mouse.Target|Target`.

Mouse.Button2Down

Dispara quando o botão direito do mouse é pressionado.

Este evento dispara quando o jogador libera o botão direito do mouse. Note que isso pode ser acessado de um `Class.Tool`; por exemplo, quando colocado em um `Class.LocalScript`, o código abaixo imprime `Button2Up` sempre que o botão direito do mouse é liberado.

```lua
local tool = script.Parent  -- Certifique-se de que isso seja um objeto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button2Up:Connect(function()
		print("Button2Up")
	end)
end)
```
Você pode descobrir a posição do mouse no espaço mundial e se está apontando para algum `Class.BasePart` usando as propriedades `Class.Mouse.Hit|Hit` e `Class.Mouse.Target|Target`.

Mouse.Button2Up

Dispara quando o botão direito do mouse é liberado.

Este exemplo demonstra como os eventos do mouse são passados durante cada quadro

Dispara durante cada batimento em que o mouse não está sendo passado para outro evento de mouse.

Nota, este evento não deve ser usado para determinar quando o mouse está parado. Como dispara a cada batimento, ele disparará entre eventos `Class.Mouse.Move`.

Para informações sobre como obter o objeto `Class.Mouse`, veja a página `Class.Mouse`.

Os desenvolvedores podem descobrir a posição do mouse no espaço mundial e se está apontando para algum `Class.BasePart` usando as propriedades `Class.Mouse.Hit` e `Class.Mouse.Target`.

Nota, os desenvolvedores são recomendados a usar `Class.UserInputService` em vez do objeto `Class.Mouse` em novos trabalhos.

Mouse.Idle

Dispara durante cada batimento em que o mouse não está sendo passado para outro evento de mouse.

O exemplo abaixo, assumindo que 'mouse' foi definido, imprimiria a tecla que
foi pressionada (por exemplo, "q") junto com o valor ASCII para essa tecla (por exemplo, 113).

Este evento dispara quando uma tecla é pressionada, com o argumento passado sendo a tecla que foi pressionada.

Nota:

- Nem todas as teclas geram este evento. No entanto, você pode superar isso com algumas das teclas, como "/", usando o evento `Class.Mouse.KeyUp`.
- Algumas teclas geram a mesma string que outras teclas.
- É possível que a string esteja vazia (possivelmente devido ao código da tecla "\\0").

Mouse.KeyDown

Mouse.keyDown

O exemplo abaixo, assumindo que 'mouse' foi definido, imprimirá a tecla que
foi liberada (por exemplo, "q") junto com o valor ascii dessa tecla (por exemplo, 113).


Este evento é disparado quando uma tecla é liberada, com o argumento passado sendo
a tecla que foi liberada.

Nota:

- Nem todas as teclas geram este evento. No entanto, você pode contornar isso com
  algumas das teclas, como "/", usando o evento
  [[API:Class/Mouse/KeyUp|KeyUp]] por exemplo.
- Algumas teclas geram a mesma string que outras teclas.
- É possível que a string esteja vazia (possivelmente devido ao código de
  tecla "\\0").


Mouse.KeyUp

O exemplo abaixo permite que o `Class.Players.LocalPlayer|jogador local` mova
peças com seu mouse.

Quando o jogador pressiona o botão esquerdo do mouse sobre uma peça, essa peça é o
`Class.Mouse.Target|alvo do mouse` e se torna o _ponto_. Até que o jogador
solte o botão esquerdo do mouse, essa peça se moverá para a posição no mundo do mouse
quando o jogador mover o mouse.

Observe que a propriedade `Class.Mouse.TargetFilter` permite que o código ignore
a peça sendo movida ao determinar a posição do mouse no mundo.

O código deve funcionar conforme o esperado quando colocado em um `LocalScript`.

Disparado quando o mouse é movido.

Nota: este evento é disparado quando a posição do mouse é atualizada, portanto
será disparado repetidamente enquanto o mouse estiver em movimento.

Para informações sobre como obter o objeto `Class.Mouse`, consulte a
página `Class.Mouse`.

Os desenvolvedores podem descobrir a posição do mouse no espaço do mundo, e se
está apontando para algum `Class.BasePart` usando as propriedades `Class.Mouse.Hit` e
`Class.Mouse.Target`.

```
mouse.Move:Connect(function()
	local position = mouse.Hit.p
	local target = mouse.Target
	print(target, position)
end)
```
Nota: os desenvolvedores são recomendados a usar `Class.UserInputService` em vez
do objeto `Class.Mouse` em novos trabalhos.


Mouse.Move

O exemplo abaixo assume que você já obteve o mouse do jogador (e
o definiu como uma variável chamada 'mouse'), seja pelo uso de um `Class.Tool`,
`Class.HopperBin` ou pelo método `Class.Player:GetMouse()`. Ele imprimirá
"A roda foi para trás!" quando o jogador rolar para trás.

O evento WheelBackward dispara quando a roda do mouse é rolada para trás.
Possíveis usos para este evento incluem alternar a mira de uma arma em um
jogo de tiro em primeira pessoa (FPS) ou ampliar a câmera do jogador.

Isso pode ser usado junto com o evento de rolagem para frente,
`Class.Mouse.WheelForward`.

Para informações sobre como obter o objeto `Class.Mouse`, consulte a
página `Class.Mouse`.

Nota: os desenvolvedores são recomendados a usar `Class.UserInputService` em vez
do objeto `Class.Mouse` em novos trabalhos.


Mouse.WheelBackward

Dispara quando a roda do mouse é rolada para trás.


O exemplo abaixo pressupõe que você já obteve o mouse do jogador (e o
configurou como uma variável chamada 'mouse'), seja através de um `Tool`, `HopperBin`
ou o método `Class.Player:GetMouse()`. Ele imprimirá "A roda foi para frente!"
quando o jogador rolar para frente.

O evento WheelForward dispara quando a roda do mouse é rolada para
frente. Possíveis usos para este evento incluem alternar a mira de uma arma em um
jogo de tiro em primeira pessoa (FPS) ou ampliar a câmera do jogador.

Isso pode ser usado junto com o evento de rolagem para trás,
`Class.Mouse.WheelBackward`.

Para informações sobre como obter o objeto `Class.Mouse`, consulte a
página `Class.Mouse`.

Nota: os desenvolvedores são recomendados a usar `Class.UserInputService` em vez
do objeto `Class.Mouse` em novos trabalhos.


Mouse.WheelForward

Dispara quando a roda do mouse é rolada para frente.


Mouse

O código neste exemplo, quando colocado dentro de um `LocalScript` em
`StarterPlayerScripts`, desenhará um feixe laser vermelho entre a cabeça do personagem
e `Class.Mouse.Hit` o tempo todo.

Observe que este feixe passará diretamente por obstruções em terceira pessoa, já que o
raycasting do `Mouse` é feito a partir da `Class.Workspace.CurrentCamera` e não da
cabeça.

O código abaixo visualiza a diferença entre `Class.Mouse.Hit` e
`Class.Mouse.Origin`. Para fazer isso, o código usa as
posições `Datatype.Vector3` dos valores de impacto e origem `Datatype.CFrame`
usando `.p`.

A diferença é que a origem é "de onde o mouse veio" (sua origem)
e o impacto é a posição onde o mouse atinge (é quando o jogador pressiona
seu mouse).

Este exemplo também visualiza que a origem do mouse é muito semelhante à
posição da `CurrentCamera`, imprimindo aMagnitude (distância) entre
as duas posições.

Esta propriedade indica o `Datatype.CFrame` da posição do mouse no espaço 3D. Note que `Class.Mouse.TargetFilter` e seus descendentes serão ignorados.

Os desenvolvedores podem obter a posição do Hit assim:

```
local position = mouse.Hit.Position
```
Hit é frequentemente usado por `Class.Tool|Tools` para disparar uma arma em direção ao mouse em terceira pessoa.

Os desenvolvedores que buscam o `Class.BasePart` que o mouse está apontando devem usar `Class.Mouse.Target`.

#### Como o Mouse.Hit é calculado?

A posição do CFrame Hit é calculada como o ponto de interseção entre o `Datatype.Ray` interno do mouse (uma versão estendida do `Class.Mouse.UnitRay`) e um objeto no espaço 3D (como uma parte).

A orientação do CFrame Hit corresponde à direção do `Class.Mouse.UnitRay`.

```
local unitRayDirection = mouse.UnitRay.Direction
local mouseHitDirection = mouse.Hit.lookVector
-- unitRayDirection ≈ mouseHitDirection
-- os vetores são aproximadamente iguais
```
Note que o ângulo da `Class.Workspace.CurrentCamera` não é usado ao calcular a orientação do CFrame Hit.

O raio interno do mouse se estende por 1.000 studs. Se o mouse não estiver apontando para um objeto no espaço 3D (por exemplo, ao apontar para o céu), esta propriedade estará a 1.000 studs de distância da `Class.Workspace.CurrentCamera`.

Mouse.Hit

O `Datatype.CFrame` da posição do mouse no espaço 3D.

Mouse.hit

Este exemplo muda o ícone do mouse do `Class.Players.LocalPlayer` para parecer com uma
imagem de dragão.


**Ícone** é uma propriedade que determina a imagem usada como ponteiro. Se
estiver em branco, uma seta padrão é utilizada. Enquanto o cursor estiver
pairando sobre um `Class.GuiButton`, esta propriedade é temporariamente
egorada.

Para ocultar completamente o cursor, **não** use uma imagem transparente &ndash;
em vez disso, defina `Class.UserInputService.MouseIconEnabled` como falso.

Para obter/definir o ícone do mouse do usuário em experiências, você deve usar
`Class.UserInputService.MouseIcon`. `Class.Mouse.Icon` será obsoleto
depois que a nova API para plugins para definir o cursor do mouse for
lançada.

##### Projetando um Cursor

As seguintes diretrizes podem ser úteis ao criar seus próprios cursores de
mouse:

- As dimensões da imagem utilizada determinam o tamanho do cursor.
- As dimensões da imagem não devem exceder 256 pixels em nenhum eixo.
- O **centro** da imagem é onde as entradas do mouse são emitidas.
- A imagem padrão do mouse é de 64x64 pixels, com o mouse ocupando 17x24
  pixels de espaço.

##### Cursores do Sistema

Ao usar um `Class.PluginMouse` recuperado de `Class.Plugin:GetMouse()`,
vocês podem usar os seguintes ícones semelhantes aos cursores padrão do seu
sistema, como mãos, setas, vigas em I, etc. Você pode usar isso com eventos
GUI como `Class.GuiObject.MouseEnter|MouseEnter`, `Class.GuiObject.MouseLeave|MouseLeave`,
e `Class.GuiButton.MouseButton1Down|MouseButton1Down` para fornecer uma
experiência consistente no Studio ao interagir com certos tipos de componentes
GUI. Observe que isso funciona apenas para plugins do Studio; eles não
funcionam para outros objetos `Class.Mouse`.

<table>
    <thead>
        <tr>
            <th>Aparência*</th>
            <th>Ativo</th>
            <th>Uso Sugerido</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Pointer.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Arrow</code></td>
            <td>Clique e seleção padrão.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-PointingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/PointingHand</code></td>
            <td>Pairando sobre um link/botão ativo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-OpenHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/OpenHand</code></td>
            <td>Pairando sobre um item arrastável.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-GrabbingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/ClosedHand</code></td>
            <td>Arrastando um item.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-IBeam.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/IBeam</code></td>
            <td>Pairando em um campo de texto.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNS.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNS</code></td>
            <td>Pairando sobre um manipulador de redimensionamento vertical.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeEW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeEW</code></td>
            <td>Pairando sobre um manipulador de redimensionamento horizontal.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNESW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNESW</code></td>
            <td>Pairando sobre um manipulador de redimensionamento de canto.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNWSE.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNWSE</code></td>
            <td>Pairando sobre um manipulador de redimensionamento de canto.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeAll.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeAll</code></td>
            <td>Pairando sobre um manipulador de redimensionamento multidirecional.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitV.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitNS</code></td>
            <td>Pairando sobre um manipulador de "divisão" vertical.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitH.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitEW</code></td>
            <td>Pairando sobre um manipulador de "divisão" horizontal.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Forbidden.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Forbidden</code></td>
            <td>Pairando sobre um item trancado/proibido.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Wait.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Wait</code></td>
            <td>Indicando que uma ação está em andamento.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Busy.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Busy</code></td>
            <td>Indicando que o sistema está ocupado.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Crosshair.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Cross</code></td>
            <td>Pairando sobre uma área de seleção precisa.</td>
        </tr>
    </tbody>
</table>

<figcaption>* Estas aparências são aproximações &mdash; a aparência real depende do seu sistema operacional.</figcaption>


Mouse.Icon

O ID do conteúdo da imagem usada como ícone do `Class.Mouse`.


**Ícone** é uma propriedade que determina a imagem usada como ponteiro. Se
estiver em branco, uma seta padrão é utilizada. Enquanto o cursor estiver
pairando sobre um `Class.GuiButton`, esta propriedade é temporariamente
egorada. Esta propriedade apenas suporta URIs de ativos.

Para ocultar completamente o cursor, **não** use uma imagem transparente &ndash;
em vez disso, defina `Class.UserInputService.MouseIconEnabled` como falso.

Para obter/definir o ícone do mouse do usuário em experiências, você deve usar
`Class.UserInputService.MouseIcon`. `Class.Mouse.Icon` será obsoleto
depois que a nova API para plugins para definir o cursor do mouse for
lançada.

##### Projetando um Cursor

As seguintes diretrizes podem ser úteis ao criar seus próprios cursores de
mouse:

- As dimensões da imagem utilizada determinam o tamanho do cursor.
- As dimensões da imagem não devem exceder 256 pixels em nenhum eixo.
- O **centro** da imagem é onde as entradas do mouse são emitidas.
- A imagem padrão do mouse é de 64x64 pixels, com o mouse ocupando 17x24
  pixels de espaço.

##### Cursores do Sistema

Ao usar um `Class.PluginMouse` recuperado de `Class.Plugin:GetMouse()`,
vocês podem usar os seguintes ícones semelhantes aos cursores padrão do seu
sistema, como mãos, setas, vigas em I, etc. Você pode usar isso com eventos
GUI como `Class.GuiObject.MouseEnter|MouseEnter`, `Class.GuiObject.MouseLeave|MouseLeave`,
e `Class.GuiButton.MouseButton1Down|MouseButton1Down` para fornecer uma
experiência consistente no Studio ao interagir com certos tipos de componentes
GUI. Observe que isso funciona apenas para plugins do Studio; eles não
funcionam para outros objetos `Class.Mouse`.

<table>
    <thead>
        <tr>
            <th>Aparência*</th>
            <th>Ativo</th>
            <th>Uso Sugerido</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Pointer.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Arrow</code></td>
            <td>Clique e seleção padrão.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-PointingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/PointingHand</code></td>
            <td>Pairando sobre um link/botão ativo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-OpenHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/OpenHand</code></td>
            <td>Pairando sobre um item arrastável.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-GrabbingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/ClosedHand</code></td>
            <td>Arrastando um item.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-IBeam.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/IBeam</code></td>
            <td>Pairando em um campo de texto.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNS.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNS</code></td>
            <td>Pairando sobre um manipulador de redimensionamento vertical.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeEW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeEW</code></td>
            <td>Pairando sobre um manipulador de redimensionamento horizontal.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNESW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNESW</code></td>
            <td>Pairando sobre um manipulador de redimensionamento de canto.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNWSE.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNWSE</code></td>
            <td>Pairando sobre um manipulador de redimensionamento de canto.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeAll.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeAll</code></td>
            <td>Pairando sobre um manipulador de redimensionamento multidirecional.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitV.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitNS</code></td>
            <td>Pairando sobre um manipulador de "divisão" vertical.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitH.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitEW</code></td>
            <td>Pairando sobre um manipulador de "divisão" horizontal.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Forbidden.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Forbidden</code></td>
            <td>Pairando sobre um item trancado/proibido.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Wait.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Wait</code></td>
            <td>Indicando que uma ação está em andamento.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Busy.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Busy</code></td>
            <td>Indicando que o sistema está ocupado.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Crosshair.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Cross</code></td>
            <td>Pairando sobre uma área de seleção precisa.</td>
        </tr>
    </tbody>
</table>

<figcaption>* Estas aparências são aproximações &mdash; a aparência real depende do seu sistema operacional.</figcaption>


Mouse.IconContent

O conteúdo da imagem usada como ícone do `Class.Mouse`. Apenas suporta
URIs de ativos.


A propriedade de origem `Class.Mouse` é um `Datatype.CFrame` que indica onde
o mouse se originou. Ele está posicionado na
`Class.Workspace.CurrentCamera` e orientado em direção à posição 3D do
mouse.

`Class.Mouse.UnitRay` começa na mesma posição que Origem e se estende
por um estúdio na mesma direção.

```lua
local unitRay = mouse.UnitRay
local origin = mouse.Origin
-- unitRay.Direction = origin.p
-- unitRay.Direction ≈ origin.lookVector
```
Para a posição do `Class.Mouse` no espaço 3D, veja `Class.Mouse.Hit`.


Mouse.Origin

Um `Datatype.CFrame` posicionado na `Class.Workspace.CurrentCamera` e
orientado em direção à posição 3D do mouse.


Quando colocado em um `LocalScript` em `StarterPlayerScripts`, o seguinte código
altera a `Class.BasePart.BrickColor` de cada `BasePart` que o jogador clica
, como a localização de spawn ou baseplate.


Esta propriedade determina um objeto a ser ignorado pelo mouse ao calcular `Class.Mouse.Hit` e `Class.Mouse.Target`. Os descendentes do objeto também são ignorados, portanto, é possível ignorar múltiplos objetos desde que sejam descendentes do objeto ao qual esta propriedade é definida. Esta propriedade é útil ao filtrar modelos contendo efeitos especiais ou decorações que não devem afetar `Class.Mouse.Hit` ou `Class.Mouse.Target`.

Esta propriedade pode ser definida como qualquer `Class.Instance` ou `nil`, por exemplo:

```lua
local Players = game:GetService("Players")
local Workspace = game:GetService("Workspace")

local player = Players.LocalPlayer
local mouse = player:GetMouse()
mouse.TargetFilter = Workspace.Model
```
Note que o `Class.Player.Character|Character` do `Class.Players.LocalPlayer` é ignorado automaticamente pelo mouse.

Mouse.Target

O objeto no espaço 3D para o qual o `Class.Mouse|mouse` está apontando.


Mouse.target

Esta propriedade determina um objeto a ser ignorado pelo mouse ao
calcular `Class.Mouse.Hit` e `Class.Mouse.Target`. Os descendentes do
objeto também são ignorados, portanto, é possível ignorar vários objetos
desde que sejam descendentes do objeto ao qual esta propriedade está
definida. Esta propriedade é útil ao filtrar modelos contendo efeitos
especiais ou decorações que não devem afetar `Class.Mouse.Hit` ou
`Class.Mouse.Target`.

Esta propriedade pode ser definida como qualquer `Class.Instance` ou
`nil`, por exemplo:

```lua
local Players = game:GetService("Players")
local Workspace = game:GetService("Workspace")

local player = Players.LocalPlayer
local mouse = player:GetMouse()
mouse.TargetFilter = Workspace.Model
```
Observe que a `Class.Player.Character|Character` do
`Class.Players.LocalPlayer` é ignorada automaticamente pelo mouse.


Mouse.TargetFilter

Determina um objeto (e seus descendentes) a ser ignorado ao determinar
`Class.Mouse.Hit` e `Class.Mouse.Target`.


O código neste exemplo, quando colocado em um `LocalScript` dentro de
`StarterPlayerScripts` irá definir a superfície de qualquer `BasePart` clicado em uma
superfície aleatória.

Esta propriedade indica o `Enum.NormalId` da superfície `Class.BasePart`
onde o mouse está apontando. Esta propriedade é derivada da
posição mundial do mouse (`Class.Mouse.Hit`) e da parte para a qual o
mouse está apontando (`Class.Mouse.Target`).

Esta propriedade não é significativa quando o mouse não está apontando para
uma parte, por exemplo, quando o mouse está apontando para o céu. No
momento, esta propriedade é definida como 'Direita' nessas circunstâncias. Antes de usar esta
propriedade, verifique se o alvo do mouse não é `nil`.

```lua
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
-- Verifique se existe uma parte para a qual o mouse está apontando
if mouse.Target then
	print("O mouse está apontando para o lado " .. mouse.TargetSurface.Name .. " de " .. mouse.Target.Name)
else
	print("O mouse não está apontando para nada.")
end
```


Mouse.TargetSurface

Indica o `Enum.NormalId` da superfície `Class.BasePart` onde o
mouse está apontando.


A propriedade UnitRay é um `Datatype.Ray` direcionado para a posição do
mouse no espaço 3D (descrito por `Class.Mouse.Hit`). Ela se origina do
`Class.Camera.CFrame|CFrame` da `Class.Workspace.CurrentCamera`.
Como todos os raios unitários, possui uma distância de 1.

```lua
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
print(mouse.UnitRay.Direction.Magnitude) -- Sempre 1
```


Mouse.UnitRay

Um `Datatype.Ray` direcionado para a posição mundial do mouse, originando-se
 da posição mundial do `Class.Workspace.CurrentCamera`.


Este exemplo de código mostra como você pode criar um `Datatype.Vector2` representando
a posição do objeto `Mouse` na tela (`Class.Mouse.X|X()` e
`Class.Mouse.Y|Y()`) e o tamanho da tela em si
(`Class.Mouse.ViewSizeX|ViewSizeX()` e `Class.Mouse.ViewSizeY|ViewSizeY()`).
Usando esses dados, você pode normalizar a posição do mouse na tela de modo que
o canto superior esquerdo logo abaixo da barra superior mapeie para (0, 0) e o canto inferior direito mapeie para
(1, 1). Esta posição normalizada é calculada e impressa à medida que o mouse se move
usando o evento `Class.Mouse.Move|Move()`.

A propriedade ViewSizeX descreve o componente horizontal do tamanho da
janela do jogo em pixels.


Mouse.ViewSizeX

Descreve a largura da janela do jogo em pixels.


A propriedade ViewSizeY descreve o componente vertical do tamanho da
janela do jogo em pixels. Esse comprimento inclui o espaço utilizado pela
topbar.


Mouse.ViewSizeY

Descreve a altura da janela do jogo em pixels.


Ao detectar mudanças na posição do mouse na tela, recomenda-se que você use `Class.ContextActionService:BindAction()` com
`Enum.UserInputType.MouseMovement` ou `Class.UserInputService.InputChanged`, que descrevem a posição do
mouse usando o `Class.InputObject.Position|Position` (um `Datatype.Vector3`) de um
`Class.InputObject`, em vez de usar esta e propriedades relacionadas.

A propriedade X descreve o componente horizontal da posição do mouse
na tela. A posição é medida em pixels em relação ao canto superior
a esquerda, abaixo da topbar. Esta propriedade pode ser usada em conjunto com
`Class.Mouse.Y` para produzir um `Datatype.Vector2` representando a posição do mouse:

```lua
local position = Vector2.new(mouse.X, mouse.Y)
```
Esta propriedade não dispara `Class.Object.Changed|Changed` ou o sinal
retornado de `Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal`. Use o evento
`Class.Mouse.Move` em vez disso.


Mouse.X

Descreve o componente X (horizontal) da posição do mouse na
tela.


Ao detectar mudanças na posição do mouse na tela, recomenda-se que você use `Class.ContextActionService:BindAction()` com
`Enum.UserInputType.MouseMovement` ou `Class.UserInputService.InputChanged`, que descrevem a posição do
mouse usando o `Class.InputObject.Position|Position` (um `Datatype.Vector3`) de um
`Class.InputObject`, em vez de usar esta e propriedades relacionadas.

A propriedade Y descreve o componente vertical da posição do mouse na
tela. A posição é medida em pixels em relação ao canto superior esquerda,
depois da topbar. Esta propriedade pode ser usada em conjunto com
`Class.Mouse.X` para produzir um `Datatype.Vector2` representando a posição do mouse:

```lua
local position = Vector2.new(mouse.X, mouse.Y)
```
Esta propriedade não dispara `Class.Object.Changed|Changed` ou o sinal
retornado de `Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal`. Use o evento
`Class.Mouse.Move` em vez disso.


Mouse.Y

Descreve o componente Y (vertical) da posição do mouse na tela.


Objeto legado que contém membros úteis para entrada de ponteiro.

`Instance` é a classe base para todas as classes na hierarquia de classes do Roblox
que podem fazer parte da árvore `Class.DataModel`.

Não é possível criar diretamente objetos `Instance` raiz, mas o construtor especial
`Datatype.Instance.new()` cria objetos via código, recebendo o
nome da classe como um parâmetro e retornando o objeto criado.

Demonstra como detectar mudanças na ancestralidade de uma instância conectando-se ao
`Class.Instance.AncestryChanged` evento.

O Parent do ChangingPart é definido para valores diferentes ao longo do tempo. O pai da
peça é o ancestral da peça, então o evento `Class.Instance.AncestryChanged`
será acionado sempre que mudar.


Dispara quando esta instância é reparentada ou quando qualquer um de seus
ancestrais é reparentado.

Você pode usar este evento para rastrear a exclusão de uma instância no
Studio, como exclusão manual no Explorer ou por meio de um plugin. Se
você precisar detectar quando uma instância é destruída usando
`Class.Instance:Destroy()`, use o evento `Class.Instance.Destroying`
em vez disso.

Instance.AncestryChanged

child

A instância cuja propriedade `Class.Instance.Parent|Parent` foi alterada,
que pode ser esta instância ou um ancestral mais distante, **não**
necessariamente a instância à qual o manipulador está conectado.

parent

Dispara quando a propriedade `Class.Instance.Parent` deste objeto ou um de
seus ancestrais é alterada.

Este evento dispara sempre que qualquer atributo é alterado na instância,
 incluindo quando um atributo é definido como `nil`. O nome do atribuito que foi
alterado é passado para a função conectada.

Por exemplo, o seguinte trecho de código conecta a função
`attributeChanged()` para disparar sempre que um dos atributos do
objeto muda:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "mudou")
end

part.AttributeChanged:Connect(attributeChanged)
```
Veja também `Class.Instance:GetAttributeChangedSignal()` que retorna um
evento que dispara quando um atributo específico é alterado.

Instance.AttributeChanged

attribute

Dispara sempre que um atributo é alterado na `Class.Instance`.

Este trecho imprime os nomes dos objetos à medida que são adicionados ao Workspace:

Dispara após um objeto ser parentado a esta `Class.Instance`.

Observe que, ao usar este método em um cliente para detectar objetos
criados pelo servidor, é necessário usar `Class.Instance:WaitForChild()` ao
indexar os descendentes desses objetos. Isso ocorre porque o objeto e seus
descendentes não são garantidos a serem replicados do servidor para o cliente
simultaneamente. Por exemplo:

```
local Workspace = game:GetService("Workspace")

Workspace.ChildAdded:Connect(function(child)
	-- Use WaitForChild() já que os descendentes podem não ter sido replicados ainda
	local head = child:WaitForChild("Head")
end)
```
Observe que este evento opera apenas para filhos imediatos do
`Class.Instance`. Para um evento que captura todos os descendentes, use
`Class.Instance.DescendantAdded`.

Veja também `Class.Instance.ChildRemoved`.

Instance.ChildAdded

Dispara após um objeto ser parentado a esta `Class.Instance`.

Instance.childAdded

Este trecho imprime os nomes dos objetos à medida que são removidos do
Workspace:

Dispara após um filho ser removido deste `Class.Instance`.

Removido refere-se a quando o pai de um objeto é alterado de
este `Class.Instance` para algo diferente deste `Class.Instance`. Observe que,
este evento também disparará quando um filho for destruído (usando
`Class.Instance:Destroy()`), já que a função de destruição define o pai de um objeto como `nil`.

Este evento opera apenas para filhos imediatos do `Class.Instance`.
Para um evento que captura todos os descendentes, use
`Class.Instance.DescendantRemoving`.

Veja também `Class.Instance.ChildAdded`.

Instance.ChildRemoved

Dispara após um filho ser removido deste `Class.Instance`.

Este exemplo a seguir imprimirá o nome de qualquer objeto que for adicionado ao
Espaço de Trabalho:

Este evento dispara após um descendente ser adicionado à `Class.Instance`.

Como ele dispara para cada descendente, parentear um objeto à
`Class.Instance` fará com que o evento dispare para este objeto e todos os seus
descendentes individualmente.

Se você está apenas preocupado com os **filhos diretos** do
`Class.Instance`, use `Class.Instance.ChildAdded` em vez disso.

Veja também `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

Dispara após um descendente ser adicionado à `Class.Instance`.

O seguinte exemplo imprime o nome de qualquer descendente enquanto está sendo removido
do Workspace:

Este evento dispara **imediatamente antes** de o pai `Class.Instance`
ser alterado de forma que uma instância **descendente** não será mais um
descendente. `Class.Instance:Destroy()|Destroy()` altera o
`Class.Instance.Parent|Parent` de uma instância para `nil`, então chamar esse método em um
descendente do pai fará com que este evento dispare.

Como este evento dispara **antes** da remoção do descendente, o pai do
descendente permanecerá inalterado no momento da disparação deste evento. Se o
descendente também for um **filho direto** do pai, este evento disparará
antes de `Class.Instance.ChildRemoved`.

Se um descendente tiver filhos, este evento dispara primeiro com o descendente,
seguido por seus descendentes.

#### Aviso

Este evento dispara com o objeto descendente que está sendo removido.
Tentar definir o `Class.Instance.Parent|Parent` do descendente para
algo diferente falhará. Abaixo está um exemplo que demonstra isso:

```
local Workspace = game:GetService("Workspace")

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Não manipule o pai do descendente nesta função!
	-- Este evento dispara POR CAUSA de a parentagem ter sido manipulada, e a alteração
	-- ainda não aconteceu
	-- Portanto, é problemático alterar o pai assim:
	descendant.Parent = game
end)

local part = Instance.new("Part")
part.Parent = Workspace
part.Parent = nil
```
Veja também `Class.Instance.DescendantAdded|DescendantAdded`.

Instance.DescendantRemoving

O `Class.Instance` que está sendo removido.

Dispara imediatamente antes de um descendente do `Class.Instance` ser removido.

Este exemplo demonstra como, ao usar o comportamento de sinal Imediato, uma
Instância sendo destruída permanece no lugar até que a função conectada faça yield.


Este exemplo demonstra como, ao usar o comportamento de sinal Deferred, uma Instância
é destruída antes que o sinal seja acionado.


O `Class.Instance` nunca será excluído da memória enquanto uma função conectada
estiver ainda usando-o. No entanto, se a função pausar em algum momento,
o `Class.Instance` e seus descendentes serão parentados para `nil`.

Se a propriedade `Class.Workspace.SignalBehavior` estiver definida como
`Enum.SignalBehavior.Immediate`, este evento dispara imediatamente antes do
`Class.Instance` ou um de seus ancestrais ser destruído com
`Class.Instance:Destroy()`.

Se a propriedade `Class.Workspace.SignalBehavior` estiver definida como
`Enum.SignalBehavior.Deferred`, este evento dispara no próximo
ponto de retomar, que será após o `Class.Instance` ou um de seus
ancestrais serem destruídos com `Class.Instance:Destroy()`.

Com o comportamento `Enum.SignalBehavior.Deferred|Deferred`, conectar um script
ao seu próprio evento `Class.Instance.Destroying` é problemático, já que o script
será destruído antes que o callback possa ser chamado (o que significa que não
será executado).

Ao excluir um `Class.Instance` no Studio, como excluir manualmente
por meio do [Explorer](/studio/explorer) ou por meio de um plugin,
o `Class.Instance` não é destruído. Em vez disso, o pai é definido como `nil`
que você pode rastrear com `Class.Instance.AncestryChanged`.

Instance.Destroying

Dispara imediatamente antes (ou é adiado até depois) da instância ser
 destruída através de `Class.Instance:Destroy()`.

Este evento dispara sempre que qualquer propriedade de estilo é alterada na instância,
incluindo quando uma propriedade é definida como `nil`.

```lua
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")
local meterBar = HUDContainer.MeterBar

local function stylePropertyChanged()
	print("Propriedades de estilo alteradas")
end

meterBar:StyledPropertiesChanged():Connect(stylePropertyChanged)
```

Instance.StyledPropertiesChanged

Dispara sempre que qualquer propriedade de estilo é alterada na instância, incluindo
quando uma propriedade é definida como `nil`.

Este método aplica uma tag à instância, sem efeito se a tag já estiver
aplicada. Adicionar uma tag com sucesso acionará um sinal criado por
`Class.CollectionService:GetInstanceAddedSignal()` com a tag fornecida.

#### Avisos

- As tags de uma instância que foram adicionadas do lado do cliente serão
  descartadas se o servidor posteriormente adicionar ou remover uma tag nessa
  instância, porque o servidor replica todas as tags juntas e
  sobrepõe as tags anteriores.

- Ao marcar uma instância, é comum que alguns recursos sejam usados para
dar funcionalidade à tag, por exemplo, conexões de eventos ou tabelas.
  Para evitar vazamentos de memória, é uma boa ideia limpar esses recursos
enquanto não forem mais necessários para uma tag. Faça isso ao
  chamar `Class.Instance:RemoveTag()`, chamando
  `Class.Instance:Destroy()`, ou em uma função conectada a um sinal
  retornado por `Class.CollectionService:GetInstanceRemovedSignal()`.

Instance:AddTag

A função filhos retorna um array dos filhos do objeto.

Instance:children

Este método destrói todos os filhos e descendentes de uma instância.

```
local part = Instance.new("Part")

-- Adiciona alguns brilhos
for i = 1, 3 do
	local sparkles = Instance.new("Sparkles")
	sparkles.Parent = part

  local sc = Instance.new("Sparkles")
  sc.Parent = sparkles
end

print("Children:", #part:GetChildren())  --> Children: 3

part:ClearAllChildren()

print("Children:", #part:GetChildren())  --> Children: 0
```
Se você não desejar destruir **todos** os filhos e descendentes, use
`Class.Instance:GetChildren()` ou `Class.Instance:GetDescendants()` para
desloopar esses filhos/descendentes e selecionar o que deve ser destruído. Por
exemplo, o seguinte exemplo de código destruirá todos os`Class.BasePart|BaseParts`
descendentes de um `Class.Model`:

```
local Workspace = game:GetService("Workspace")

local model = Workspace:FindFirstChild("TestModel")

for _, descendant in model:GetDescendants() do
	if descendant:IsA("BasePart") then
		descendant:Destroy()
	end
end
```

Instance:ClearAllChildren

Este método destrói todos os filhos de uma instância.

Demonstra como clonar um modelo usando `Class.Instance:Clone()`.

`Clone()` cria uma cópia de uma instância e todos os seus descendentes,
ignorando todas as instâncias que não são
`Class.Instance.Archivable|Archivable`. A cópia da instância raiz é
retornada por este método e seu `Class.Instance.Parent|Parent` é definido como
`nil`. Observe que, se a própria instância tiver
`Class.Instance.Archivable|Archivable` definido como `false`, este método
retornará `nil`.

Se uma propriedade de referência, como `Class.ObjectValue.Value`, estiver definida em uma
instância clonada, o valor da propriedade da cópia depende do valor do
original:

- Se uma propriedade de referência se referir a uma instância que também foi
  clonada, a cópia se referirá à cópia.
- Se uma propriedade de referência se referir a uma instância que **não** foi clonada,
  o mesmo valor é mantido na cópia.

Instance:Clone

Cria uma cópia de uma instância e todos os seus descendentes, ignorando instâncias
que não são `Class.Instance.Archivable|Archivable`.

Instance:clone

Demonstra a destruição de uma Parte usando a função `Class.Instance:Destroy()`.

Esta função é a maneira correta de descartar objetos que não são mais
necessários.


Define a propriedade `Class.Instance.Parent` como `nil`, tranca a
propriedade `Class.Instance.Parent`, desconecta todas as conexões e chama
`Destroy()` em todos os filhos. Este método é a maneira correta de descartar
objetos que não são mais necessários.

Descartar objetos desnecessários é importante, uma vez que objetos e
conexões desnecessárias em um lugar ocupam memória que pode levar a sérios problemas de
desempenho ao longo do tempo.

Como uma boa prática, após chamar `Destroy()` em um objeto, defina qualquer
variável que referencia o objeto (ou seus descendentes) como `nil`. Isso
impede que seu código acesse qualquer coisa relacionada ao objeto.

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- Não faça isso:
print(part.Name)  --> "Hello, world"
-- Faça isso para evitar que a linha acima funcione:
part = nil
```
Uma vez que uma `Class.Instance` tenha sido destruída por este método, não pode ser
reutilizada porque a propriedade `Class.Instance.Parent` é trancada. Para
remover **temporariamente** um objeto em vez de destruí-lo, defina
`Class.Instance.Parent|Parent` como `nil`. Por exemplo:

```
local Workspace = game:GetService("Workspace")

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
Para destruir um objeto após um tempo determinado, use
`Class.Debris:AddItem()`.

Instance:Destroy

Define a propriedade `Class.Instance.Parent` como `nil`, tranca a
propriedade `Class.Instance.Parent`, desconecta todas as conexões e chama
`Destroy()` em todos os filhos.

Instance:destroy

Retorna o primeiro ancestral da `Class.Instance` cujo
`Class.Instance.Name` é igual ao nome fornecido.

Este método funciona para cima, o que significa que começa no
`Class.Instance.Parent` imediato da instância e sobe em direção ao
`Class.DataModel`. Se nenhum ancestral correspondente for encontrado, retorna
`nil`.

O seguinte trecho de código encontraria o primeiro ancestral do objeto
chamado `Car`.

```
local car = object:FindFirstAncestor("Car")
```
Para variantes deste método que encontram ancestrais de uma classe específica,
veja `Class.Instance:FindFirstAncestorOfClass()` e
`Class.Instance:FindFirstAncestorWhichIsA()`.

Instance:FindFirstAncestor

name

Retorna o primeiro ancestral da `Class.Instance` cujo
`Class.Instance.Name` é igual ao nome fornecido.

Retorna o primeiro ancestral da `Class.Instance` cujo
`Class.Object.ClassName` é igual ao nome da classe fornecida.

Este método funciona para cima, o que significa que começa no
`Class.Instance.Parent` imediato da instância e sobe em direção ao
`Class.DataModel`. Se nenhum ancestral correspondente for encontrado, retorna `nil`.

Um uso comum deste método é encontrar o `Class.Model` a que um
`Class.BasePart` pertence. Por exemplo:

```
local model = part:FindFirstAncestorOfClass("Model")
```
Este método é uma variante de `Class.Instance:FindFirstAncestor()` que
verifica a propriedade `Class.Object.ClassName` em vez de
`Class.Instance.Name`. `Class.Instance:FindFirstAncestorWhichIsA()` também
existe, usando o método `Class.Object:IsA()` em vez disso para respeitar a
herança de classe.

Instance:FindFirstAncestorOfClass

className

O `Class.Object.ClassName` a ser procurado.

Retorna o primeiro ancestral da `Class.Instance` cujo
`Class.Object.ClassName` é igual ao nome da classe fornecida.

Retorna o primeiro ancestral da `Class.Instance` para quem
`Class.Object:IsA()` retorna verdadeiro para o nome da classe fornecida.

Este método funciona para cima, o que significa que começa no
`Class.Instance.Parent` imediato da instância e sobe em direção ao
`Class.DataModel`. Se nenhum ancestral correspondente for encontrado, retorna
`nil`.

Diferente de `Class.Instance:FindFirstAncestorOfClass()`, este método usa
`Class.Object:IsA()` que respeita a herança de classe. Por exemplo:

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```
Portanto, o seguinte exemplo de código retornará o primeiro
ancestral `Class.BasePart`, independentemente de ser um `Class.WedgePart`,
`Class.MeshPart` ou `Class.Part`.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```
Veja também `Class.Instance:FindFirstAncestor()`.

Instance:FindFirstAncestorWhichIsA

Retorna o primeiro ancestral da `Class.Instance` para quem
`Class.Object:IsA()` retorna verdadeiro para o nome da classe fornecida.

O abaixo procurará no Workspace por um objeto chamado "Brick". Se encontrado, ele
mudará o nome do objeto para "Foo".

Retorna o primeiro filho da `Class.Instance` com o nome fornecido, ou
`nil` se não existir tal filho. Se o argumento opcional `recursive` for
`true`, este método busca todos os descendentes em vez de apenas os
filhos imediatos da `Class.Instance`.

#### Verificando a Existência de um Objeto

`FindFirstChild()` é necessário se você precisa verificar se um objeto existe
antes de continuar. Tentar indexar um filho pelo nome usando o operador de ponto
gera um erro se o filho não existir.

```lua
local Workspace = game:GetService("Workspace")

-- A linha a seguir gera um erro se a parte não existir no workspace
Workspace.Part.Transparency = 0.5
```
Uma abordagem melhor é usar `FindFirstChild()` para primeiro verificar o `Part`,
seguido de uma instrução `if` para executar o código que precisa dele.

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace:FindFirstChild("Part")
if part then
	part.Transparency = 0.5
end
```

#### Encontrando um Filho Cujo Nome Corresponde a uma Propriedade

Às vezes o `Class.Instance.Name|Name` de um objeto é o mesmo que o de uma
propriedade do seu `Class.Instance.Parent|Parent`. Ao usar o operador de ponto,
propriedades têm precedência sobre filhos se compartilharem um nome.

No exemplo a seguir, uma `Class.Folder` chamada `Color` é adicionada a um
`Class.Part`, que também tem a propriedade `Class.Part.Color`. Observe que
`part.Color` se refere ao valor da propriedade `Datatype.Color3`, não à instância do filho
`Class.Folder`. Uma vantagem de usar
`Class.Instance:FindFirstChild()|FindFirstChild()` é que a introdução de novas
propriedades não impõe risco ao seu código.

```lua
local part = Instance.new("Part")
local folder = Instance.new("Folder")
folder.Name = "Color"
folder.Parent = part
local c1 = part.Color  -- A propriedade
local c2 = part:FindFirstChild("Color")  -- A pasta filha
```

#### Notas de Desempenho

`Class.Instance:FindFirstChild()|FindFirstChild()` leva cerca de 20% mais
com tempo do que usar o operador de ponto e quase 8 vezes mais do que apenas armazenar
uma referência a um objeto. Portanto, você deve evitar chamá-lo em
código dependente de desempenho, como em loops apertados ou funções conectadas
a `Class.RunService.Heartbeat` e `Class.RunService.PreRender`. Em vez disso,
estocou o resultado em uma variável, ou considere usar
`Class.Instance.ChildAdded|ChildAdded` ou
`Class.Instance:WaitForChild()|WaitForChild()` para detectar quando um filho de um
dado nome se torna disponível.

Instance:FindFirstChild

recursive

Se a busca deve ser realizada recursivamente.

Retorna o primeiro filho da `Class.Instance` encontrado com o nome fornecido.

Instance:findFirstChild

Retorna o primeiro filho da `Class.Instance` cuja
`Class.Object.ClassName|ClassName` é igual ao `className` fornecido.
Diferente de `Class.Instance:FindFirstChildWhichIsA()`, este método só
retorna objetos cuja classe corresponde ao `className`, ignorando a herança
de classe. Se nenhum filho correspondente for encontrado, este método
retorna `nil`.

Instance:FindFirstChildOfClass

Retorna o primeiro filho da `Class.Instance` cuja
`Class.Object.ClassName|ClassName` é igual ao nome da classe fornecida.

Retorna o primeiro filho da `Class.Instance` para quem
`Class.Object:IsA()` retorna verdadeiro para o nome da classe fornecida.

Se nenhum filho correspondente for encontrado, este método retorna `nil`. Se o argumento
o opcional recursivo for `true`, este método busca todos os descendentes em vez
apenas dos filhos imediatos da `Class.Instance`.

Diferente de `Class.Instance:FindFirstChildOfClass()`, este método usa
`Class.Object:IsA()` que respeita a herança de classe. Por exemplo:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
Portanto, o seguinte exemplo de código retornará o primeiro
filho `Class.BasePart`, independentemente de ser um `Class.WedgePart`,
`Class.MeshPart` ou `Class.Part`.

```
local part = object:FindFirstChildWhichIsA("BasePart")
```
Desenvolvedores que procuram um filho pelo nome devem usar
`Class.Instance:FindFirstChild()` em vez disso.

Instance:FindFirstChildWhichIsA

Retorna o primeiro filho da `Class.Instance` para quem
`Class.Object:IsA()` retorna verdadeiro para o nome da classe fornecida.

Retorna o primeiro descendente encontrado com o dado `Class.Instance.Name`.

Este método está desabilitado e não pode ser usado. Para encontrar o primeiro descendente
 de uma instância, considere usar o parâmetro `recursive` em
 `Class.Instance:FindFirstChild()` em vez disso.

Instance:FindFirstDescendant

Retorna o primeiro descendente encontrado com o dado `Class.Instance.Name`.

Se a `Class.Instance` for um `Class.Actor`, o próprio `Class.Actor` é
retornado. Caso contrário, seu ancestral `Class.Actor` mais próximo é retornado. Se nenhum
ancestral for um `Class.Actor`, o resultado é `nil`.

Instance:GetActor

Retorna o `Class.Actor` associado à Instância, se houver.

Este método retorna o valor que foi atribuído ao nome do atributo fornecido. Se
nenhum atributo foi atribuído, `nil` é retornado.

Por exemplo, o seguinte trecho de código define e depois obtém o valor do
atributo `InitialPosition` da instância:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local initialPosition = instance:GetAttribute("InitialPosition")
print(initialPosition)
```

#### Veja Também

- `Class.Instance:SetAttribute()` que define o atributo com o nome fornecido
  para o valor fornecido.
- `Class.Instance:GetAttributes()` que retorna um dicionário de pares chave-valor
  para cada um dos atributos da instância.

Instance:GetAttribute

O nome do atributo que está sendo recuperado.

O valor que foi atribuído ao nome do atributo fornecido. Se nenhum
atributo foi atribuído, `nil` é retornado.

Retorna o valor que foi atribuído ao nome do atributo fornecido.

Este método retorna um evento que se comporta exatamente como o
evento `Class.Object.Changed|Changed`, exceto que ele só é acionado quando o
atributo específico fornecido muda; efetivamente é similar a
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` mas
para atributos.

É geralmente uma boa ideia usar este método em vez de uma conexão para
`Class.Object.Changed|Changed` com uma função que verifica o nome do atributo.
Chamadas subsequentes para este método no mesmo objeto com o mesmo
nome de atributo retornam o mesmo evento.

O seguinte exemplo de código retorna um sinal que dispara a função
`attributeChanged()` quando o atributo `InitialPosition` da parte muda:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local function attributeChanged()
	print("Atributo alterado")
end

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```
Veja também `Class.Instance.AttributeChanged` que é acionado sempre que qualquer
atributo é alterado na instância.

Instance:GetAttributeChangedSignal

O nome do atributo especificado para o qual o sinal de mudança está
sendo retornado.

Um evento que é acionado quando o atributo fornecido muda.

Retorna um evento que é acionado quando o atributo fornecido muda.

Este método retorna um dicionário de pares chave-valor para cada atributo
onde a chave é o nome do atributo e o valor é um valor não-nulo.

Por exemplo, o seguinte trecho de código exibe os atributos
 e valores de uma instância:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)
part:SetAttribute("CanUse", true)

for name, value in part:GetAttributes() do
	print(name .. " = " .. value)
end
```
Veja também `Class.Instance:GetAttribute()` que retorna o valor que foi
atribuído ao nome do atributo fornecido.

Instance:GetAttributes

Um dicionário de pares string → variante para cada atributo onde a
string é o nome do atributo e a variante é um valor não-nulo.

Retorna um dicionário dos atributos da instância.

O abaixo imprimiria o nome de todos os objetos atualmente no Workspace quando executado.

Retorna um array (uma tabela indexada numericamente) contendo todos os
filhos diretos da instância, ou cada `Class.Instance` cujo
`Class.Instance.Parent|Parent` é igual ao objeto. O array pode ser
iterado usando um loop numérico ou genérico:

```lua
local Workspace = game:GetService("Workspace")

-- Exemplo de loop numérico
local children = Workspace:GetChildren()
for i = 1, #children do
	local child = children[i]
	print(child.Name .. " é filho número " .. i)
end
```

```lua
local Workspace = game:GetService("Workspace")

-- Exemplo de loop genérico
local children = Workspace:GetChildren()
for i, child in children do
	print(child.Name .. " é filho número " .. i)
end
```
Observe que o array retornado **não** é ordenado em nenhuma ordem particular, então
uma ordenação manual (por exemplo, usando `Library.table.sort()`) é recomendada para
ordenar os filhos retornados por este método.

Veja também o método `Class.Instance:GetDescendants()|GetDescendants()`.

Instance:GetChildren

Um array contendo os filhos da instância.

Retorna um array contendo todos os filhos da instância.

Instance:getChildren

Retorna uma string codificada do ID de depuração usado internamente pelo Roblox. Observe que:

- Este item é protegido. Tentar usá-lo em um `Class.Script` ou
  `Class.LocalScript` causará um erro.
- Um ID de depuração é um ID usado em processos de depuração. Ele permite que um depurador leia
  cada instrução antes que um aplicativo a processe. Todos os objetos no
  Roblox agem como processos e cada execução de instruções (ou 'código')
pode ser depurada se necessário.
- Isso pode ser útil para plugins que precisam distinguir objetos similares
de um ao outro (como objetos que compartilham o mesmo nome).

Instance:GetDebugId

scopeLength

Retorna uma string codificada do ID de depuração usado internamente pelo Roblox.

GetDescendants é frequentemente usado para fazer algo com todos os descendentes que são de um
tipo específico de objeto. O código neste exemplo usa GetDescendants e
`Class.Instance:IsA()` para encontrar todas as partes no workspace e as torna
verdes.

Este método de objeto retorna um array que contém todos os descendentes
 daquele objeto. Diferente de `Class.Instance:GetChildren()`, que só retorna
 os filhos imediatos de um objeto, este método encontra cada filho do
 objeto, cada filho desses filhos, e assim por diante.

Observe que o array retornado **não** é ordenado em nenhuma ordem particular, então
uma ordenação manual (por exemplo, usando `Library.table.sort()`) é recomendada para
ordenar os descendentes retornados por este método. Também considere o
método `Class.Instance:QueryDescendants()|QueryDescendants()` para consultar
descendentes por uma combinação de seletores e combinadores.

Instance:GetDescendants

Um array contendo os descendentes da instância.

Retorna um array contendo todos os descendentes da instância.

Instance

`Instance` é a classe base para todas as classes na hierarquia de classes do Roblox
que podem fazer parte da árvore `Class.DataModel`.

/reference/engine/classes/PlayerMouse.yaml