El código a continuación demuestra cómo se puede obtener el objeto PluginMouse y
utilizarlo en un complemento. Para usar este código, pégalo en un `Script`, guarda ese script
en la Carpeta de Plugins local haciendo clic derecho, guardar como. La carpeta de plugins
se puede encontrar en la pestaña de Plugins en la barra de herramientas de Roblox Studio.

El objeto PluginMouse da acceso a `Class.Plugin|Plugins` al ratón. Funciona como el objeto `Class.Mouse` y se puede obtener utilizando el método `Class.Plugin:GetMouse()` del plugin.

Ten en cuenta que PluginMouse solo se puede utilizar cuando el plugin ha sido activado usando `Class.Plugin:Activate()`.

Además de las funciones del objeto `Class.Mouse`, el PluginMouse incluye la función `Class.PluginMouse.DragEnter` que mantiene un seguimiento de los elementos seleccionados mientras el ratón está arrastrando.

Para más información sobre cómo usar objetos de ratón, consulta la página de `Class.Mouse`.


Se activa cuando se seleccionan Instancias mientras el ratón está arrastrando.


PluginMouse.DragEnter

instances

PluginMouse

El objeto PluginMouse da acceso a `Class.Plugin|Plugins` al ratón. Funciona como el objeto `Class.Mouse` y se puede obtener utilizando el método `Class.Plugin:GetMouse()` del plugin.


**Mouse** ha sido reemplazado por `Class.UserInputService` y `Class.ContextActionService`, que cubren un alcance más amplio, son más ricos en características y soportan mejor los patrones **multiplataforma**. Sigue estando soportado debido a su uso generalizado, pero deberías considerar seriamente utilizar estas alternativas.

El objeto **Mouse** alberga varias API para punteros, principalmente para botones y raycasting. Puede accederse a través de `Class.Player:GetMouse()` llamado sobre el `Class.Players.LocalPlayer` en un `Class.LocalScript`. También se pasa por el evento `Class.Tool.Equipped`.

- Es notable por la propiedad `Class.Mouse.Icon|Icon`, que cambia la apariencia del cursor.
- Realiza raycasts continuamente de la posición del mouse en la pantalla al mundo 3D utilizando la propiedad `Class.Mouse.TargetFilter|TargetFilter`, almacenando los resultados del raycast en las propiedades `Class.Mouse.Hit|Hit`, `Class.Mouse.Target|Target`, y `Class.Mouse.TargetSurface|TargetSurface`. Estas pueden ser útiles para casos simples, pero se debería usar `Class.WorldRoot:Raycast()` en escenarios de [raycasting](/workspace/raycasting) más complicados.
- `Class.Plugin|Plugins` puede usar `Class.Plugin:GetMouse()` para obtener un `Class.PluginMouse`, que se comporta de manera similar.

```lua
-- Desde un LocalScript:
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
-- Estableciendo el icono del mouse
mouse.Icon = "rbxasset://SystemCursors/Wait"
```
Nota:

- Este objeto no controla/restringe el movimiento del puntero. Para esto, consulta `Class.UserInputService.MouseBehavior` y `Class.UserInputService.MouseDeltaSensitivity`.
- Si dos funciones están conectadas al mismo evento de entrada, como `Class.Mouse.Button1Down|Button1Down`, **ambas** funciones se ejecutarán cuando se dispare el evento. No existe el concepto de hundimiento/pasaje de entrada, ya que los eventos no soportan este comportamiento. Sin embargo, `Class.ContextActionService` sí tiene este comportamiento a través de `Class.ContextActionService:BindAction()|BindAction`.
- Aunque un mouse puede no estar disponible en todas las plataformas, **Mouse** seguirá funcionando en móvil (táctil) y consola (gamepad), que típicamente no tienen hardware de mouse o puntero. Para comportamientos explícitos multiplataforma, utiliza `Class.UserInputService` y `Class.ContextActionService`.

Consulta [Input and Camera](/input) para más información sobre cómo personalizar entradas en tu experiencia.

Este evento se activa cuando el jugador presiona el botón izquierdo del mouse. Ten en cuenta que esto puede accederse desde un `Class.Tool`; por ejemplo, cuando se coloca en un `Class.LocalScript`, el siguiente código imprime `Button1Down` cada vez que se presiona el botón izquierdo del mouse.

```lua
local tool = script.Parent  -- Asegúrate de que este sea un objeto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button1Down:Connect(function()
		print("Button1Down")
	end)
end)
```
Puedes encontrar la posición del mouse en el espacio del mundo y si está apuntando a algún `Class.BasePart` usando las propiedades `Class.Mouse.Hit|Hit` y `Class.Mouse.Target|Target`.

Mouse.Button1Down

Se activa cuando se presiona el botón izquierdo del mouse.

Este evento se activa cuando el jugador libera el botón izquierdo del mouse. Ten en cuenta que esto puede accederse desde un `Class.Tool`; por ejemplo, cuando se coloca en un `Class.LocalScript`, el siguiente código imprime `Button1Up` cada vez que se libera el botón izquierdo del mouse.

```lua
local tool = script.Parent  -- Asegúrate de que este sea un objeto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button1Up:Connect(function()
		print("Button1Up")
	end)
end)
```
Puedes encontrar la posición del mouse en el espacio del mundo y si está apuntando a algún `Class.BasePart` usando las propiedades `Class.Mouse.Hit|Hit` y `Class.Mouse.Target|Target`.

Mouse.Button1Up

Se activa cuando se libera el botón izquierdo del mouse.

Este evento se activa cuando el jugador presiona el botón derecho del mouse. Ten en cuenta que esto puede accederse desde un `Class.Tool`; por ejemplo, cuando se coloca en un `Class.LocalScript`, el siguiente código imprime `Button2Down` cada vez que se presiona el botón derecho del mouse.

```lua
local tool = script.Parent  -- Asegúrate de que este sea un objeto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button2Down:Connect(function()
		print("Button2Down")
	end)
end)
```
Puedes encontrar la posición del mouse en el espacio del mundo y si está apuntando a algún `Class.BasePart` usando las propiedades `Class.Mouse.Hit|Hit` y `Class.Mouse.Target|Target`.

Mouse.Button2Down

Se activa cuando se presiona el botón derecho del mouse.

Este evento se activa cuando el jugador libera el botón derecho del mouse. Ten en cuenta que esto puede accederse desde un `Class.Tool`; por ejemplo, cuando se coloca en un `Class.LocalScript`, el siguiente código imprime `Button2Up` cada vez que se libera el botón derecho del mouse.

```lua
local tool = script.Parent  -- Asegúrate de que este sea un objeto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button2Up:Connect(function()
		print("Button2Up")
	end)
end)
```
Puedes encontrar la posición del mouse en el espacio del mundo y si está apuntando a algún `Class.BasePart` usando las propiedades `Class.Mouse.Hit|Hit` y `Class.Mouse.Target|Target`.

Mouse.Button2Up

Se activa cuando se libera el botón derecho del mouse.

Este ejemplo demuestra cómo se pasan los eventos del ratón durante cada fotograma

Se activa durante cada latido mientras el mouse no se esté pasando a otro evento de mouse.

Nota: Este evento no debe usarse para determinar cuándo el mouse está quieto. Como se activa en cada latido, se activará entre eventos `Class.Mouse.Move`.

Para información sobre cómo obtener el objeto `Class.Mouse`, consulta la página `Class.Mouse`.

Los desarrolladores pueden encontrar la posición del mouse en el espacio del mundo y si está apuntando a algún `Class.BasePart` usando las propiedades `Class.Mouse.Hit` y `Class.Mouse.Target`.

Nota: Se recomienda a los desarrolladores usar `Class.UserInputService` en lugar del objeto `Class.Mouse` en nuevos trabajos.

Mouse.Idle

Se activa durante cada latido mientras el mouse no se esté pasando a otro evento de mouse.

El siguiente ejemplo, asumiendo que 'mouse' se ha definido, imprimiría la tecla que
fue presionada (por ejemplo, "q") junto con el valor ascii de esa tecla (por ejemplo, 113).

Este evento se activa cuando se presiona una tecla, siendo el argumento pasado la tecla que fue presionada.

Nota:

- No todas las teclas generan este evento. Sin embargo, puedes evitar esto con algunas teclas, como "/" usando el evento `Class.Mouse.KeyUp`.
- Algunas teclas generan la misma cadena que otras teclas.
- Es posible que la cadena esté vacía (posiblemente debido al código de tecla "\\0").

Mouse.KeyDown

Mouse.keyDown

El siguiente ejemplo, asumiendo que 'mouse' fue definido, imprimiría la tecla que
fue liberada (por ejemplo, "q") junto con el valor ascii de esa tecla (por ejemplo, 113).

Este evento se activa cuando una tecla es liberada, con el argumento pasado siendo
la tecla que fue liberada.

Nota:

- No todas las teclas generan este evento. Sin embargo, puedes esquivar esto con
a algunas de las teclas, "/" por ejemplo, utilizando el
  [[API:Class/Mouse/KeyUp|KeyUp]] evento.
- Algunas teclas generan la misma cadena que otras teclas.
- Es posible que la cadena esté vacía (posiblemente debido al código de tecla "\\0").


Mouse.KeyUp

El ejemplo a continuación permite que el `Class.Players.LocalPlayer|jugador local` mueva
partes con su ratón.

Cuando el jugador presiona el botón izquierdo del ratón sobre una parte, esa parte es el
`Class.Mouse.Target|objetivo del ratón` y se convierte en el _punto_. Hasta que el jugador
suelte el botón izquierdo del ratón, esa parte se moverá a la posición mundial
del ratón cuando el jugador mueva su ratón.

Ten en cuenta que la propiedad `Class.Mouse.TargetFilter` permite que el código ignore
la parte que se está moviendo al determinar la posición mundial del ratón.

El código debería funcionar como se espera cuando se coloca en un `LocalScript`.

Se activa cuando se mueve el ratón.

Nota, este evento se activa cuando se actualiza la posición del ratón, por lo tanto
se activará repetidamente mientras se esté moviendo.

Para obtener información sobre cómo obtener el objeto `Class.Mouse`, consulta la
página `Class.Mouse`.

Los desarrolladores pueden averiguar la posición del ratón en el espacio mundial, y si
está apuntando a alguna `Class.BasePart` usando las propiedades `Class.Mouse.Hit` y
`Class.Mouse.Target`.

```
mouse.Move:Connect(function()
	local position = mouse.Hit.p
	local target = mouse.Target
	print(target, position)
end)
```
Nota, se recomienda a los desarrolladores que utilicen `Class.UserInputService` en
lugar del objeto `Class.Mouse` en nuevos trabajos.


Mouse.Move

El siguiente ejemplo supone que ya has obtenido el ratón del jugador (y
lo has establecido como una variable llamada 'mouse'), ya sea mediante el uso de `Class.Tool`,
`Class.HopperBin` o el método `Class.Player:GetMouse()`. Imprimirá
"¡La rueda se movió hacia atrás!" cuando el jugador desplaza hacia atrás.

El evento WheelBackward se activa cuando la rueda del ratón se desplaza hacia atrás.
Los usos posibles para este evento incluyen alternar el alcance de un arma en un
tiroteo en primera persona (FPS) o acercar la cámara del jugador.

Esto se puede usar junto con el evento de desplazamiento hacia adelante,
`Class.Mouse.WheelForward`.

Para obtener información sobre cómo obtener el objeto `Class.Mouse`, consulta la
página `Class.Mouse`.

Nota, se recomienda a los desarrolladores que utilicen `Class.UserInputService` en
lugar del objeto `Class.Mouse` en nuevos trabajos.


Mouse.WheelBackward

Se activa cuando la rueda del ratón se desplaza hacia atrás.


El siguiente ejemplo asume que ya has obtenido el ratón del jugador (y
lo has asignado a una variable llamada 'mouse'), ya sea mediante un `Tool`, `HopperBin`
o el método `Class.Player:GetMouse()`. Imprimirá "¡La rueda avanzó!"
cuando el jugador desplaza hacia adelante.

El evento WheelForward se activa cuando la rueda del ratón se desplaza hacia adelante.
Los usos posibles para este evento incluyen alternar el alcance de un arma en un
tiroteo en primera persona (FPS) o acercar la cámara del jugador.

Esto se puede usar junto con el evento de desplazamiento hacia atrás,
`Class.Mouse.WheelBackward`.

Para obtener información sobre cómo obtener el objeto `Class.Mouse`, consulta la
página `Class.Mouse`.

Nota, se recomienda a los desarrolladores que utilicen `Class.UserInputService` en
lugar del objeto `Class.Mouse` en nuevos trabajos.


Mouse.WheelForward

Se activa cuando la rueda del ratón se desplaza hacia adelante.


Mouse

El código en este ejemplo, cuando se coloca dentro de un `LocalScript` en
`StarterPlayerScripts`, dibujará un rayo láser rojo entre la cabeza del personaje
y `Class.Mouse.Hit` en todo momento.
Nota: este rayo pasará directamente a través de obstrucciones en tercera persona ya que
el raycasting del `Mouse` se realiza desde la `Class.Workspace.CurrentCamera`, no desde la
cabeza.

El código a continuación visualiza la diferencia entre `Class.Mouse.Hit` y
`Class.Mouse.Origin`. Para hacer esto, el código utiliza las
posiciones `Datatype.Vector3` de los valores de hit y origen `Datatype.CFrame`
utilizando `.p`.

La diferencia es que el origen es "de dónde vino el ratón" (su origen)
y el impacto es la posición donde el ratón golpea (es cuando el jugador presiona
tu ratón).

Este ejemplo también visualiza que el origen del ratón es muy similar a la
posición del `CurrentCamera` al imprimir la magnitud (distancia) entre
las dos posiciones.


Esta propiedad indica la `Datatype.CFrame` de la posición del mouse en el espacio 3D. Ten en cuenta que `Class.Mouse.TargetFilter` y sus descendientes serán ignorados.

Los desarrolladores pueden obtener la posición del Hit de la siguiente manera:

```
local position = mouse.Hit.Position
```
Hit es a menudo utilizado por `Class.Tool|Tools` para disparar un arma hacia el mouse en tercera persona.

Los desarrolladores que busquen el `Class.BasePart` al que apunta el mouse deben usar `Class.Mouse.Target`.

#### ¿Cómo se calcula Mouse.Hit?

La posición de la CFrame de Hit se calcula como el punto de intersección entre el `Datatype.Ray` interno del mouse (una versión extendida de `Class.Mouse.UnitRay`) y un objeto en el espacio 3D (como una parte).

La orientación de la CFrame de Hit corresponde con la dirección del `Class.Mouse.UnitRay`.

```
local unitRayDirection = mouse.UnitRay.Direction
local mouseHitDirection = mouse.Hit.lookVector
-- unitRayDirection ≈ mouseHitDirection
-- los vectores son aproximadamente iguales
```
Nota, el rollo de la `Class.Workspace.CurrentCamera` no se utiliza al calcular la orientación de la `Datatype.CFrame` de Hit.

El rayo interno del mouse se extiende por 1,000 studs. Si el mouse no está apuntando a un objeto en el espacio 3D (por ejemplo, cuando apunta al cielo), esta propiedad estará a 1,000 studs de distancia de la `Class.Workspace.CurrentCamera`.

Mouse.Hit

La `Datatype.CFrame` de la posición del mouse en el espacio 3D.

Mouse.hit

Este ejemplo cambia el ícono del mouse de `Class.Players.LocalPlayer` para que parezca una
imagen de dragón.


**Icono** es una propiedad que determina la imagen utilizada como el puntero. Si
está en blanco, se utiliza una flecha predeterminada. Mientras el cursor está sobre un
`Class.GuiButton`, esta propiedad se ignora temporalmente.

Para ocultar completamente el cursor, **no** utilices una imagen transparente &ndash;
en su lugar, establece `Class.UserInputService.MouseIconEnabled` en falso.

Para obtener/configurar el ícono del ratón del usuario en las experiencias, deberías usar
`Class.UserInputService.MouseIcon`. `Class.Mouse.Icon` será obsoleto
una vez que se publique la nueva API para que los complementos configuren el cursor del ratón.

##### Diseñando un Cursor

Las siguientes pautas pueden ser útiles al crear tus propios cursores de ratón:

- Las dimensiones de la imagen utilizada determinan el tamaño del cursor.
- Las dimensiones de la imagen no deben exceder los 256 píxeles en ningún eje.
- El **centro** de la imagen es donde se emiten las entradas del ratón.
- La imagen predeterminada del ratón es de 64x64 píxeles, con el ratón ocupando 17x24
  píxeles de espacio.

##### Cursores del Sistema

Al usar un `Class.PluginMouse` obtenido de `Class.Plugin:GetMouse()`,
podrás usar los siguientes íconos similares a los cursores predeterminados de tu sistema,
como manos, flechas, vigas en I, etc. Puedes usarlos con eventos GUI
como `Class.GuiObject.MouseEnter|MouseEnter`,
`Class.GuiObject.MouseLeave|MouseLeave`, y
`Class.GuiButton.MouseButton1Down|MouseButton1Down` para proporcionar una
experiencia consistente en Studio al interactuar con ciertos tipos de componentes GUI.
Ten en cuenta que estos solo funcionan para complementos de Studio; no funcionarán
para otros objetos `Class.Mouse`.

<table>
    <thead>
        <tr>
            <th>Apariencia*</th>
            <th>Activo</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>Predeterminado para clics y selección.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-PointingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/PointingHand</code></td>
            <td>Pasar sobre un enlace/botón activo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-OpenHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/OpenHand</code></td>
            <td>Pasar sobre un elemento arrastrable.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-GrabbingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/ClosedHand</code></td>
            <td>Arrastrar un objeto.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-IBeam.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/IBeam</code></td>
            <td>Pasar por un 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>Pasar sobre un controlador de redimensionamiento vertical.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeEW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeEW</code></td>
            <td>Pasar sobre un controlador de redimensionamiento horizontal.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNESW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNESW</code></td>
            <td>Pasar sobre un controlador de redimensionamiento en esquina.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNWSE.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNWSE</code></td>
            <td>Pasar sobre un controlador de redimensionamiento en esquina.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeAll.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeAll</code></td>
            <td>Pasar sobre un controlador de redimensionamiento multidireccional.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitV.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitNS</code></td>
            <td>Pasar sobre un controlador de "división" vertical.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitH.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitEW</code></td>
            <td>Pasar sobre un controlador de "división" horizontal.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Forbidden.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Forbidden</code></td>
            <td>Pasar sobre un elemento bloqueado/prohibido.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Wait.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Wait</code></td>
            <td>Indica que una acción está en progreso.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Busy.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Busy</code></td>
            <td>Indica que el 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>Pasar sobre un área de selección precisa.</td>
        </tr>
    </tbody>
</table>

<figcaption>* Estas apariencias son aproximaciones &mdash; el aspecto real depende de tu sistema operativo.</figcaption>


Mouse.Icon

El ID de contenido de la imagen utilizada como el ícono de `Class.Mouse`.


**Icono** es una propiedad que determina la imagen utilizada como el puntero. Si
está en blanco, se utiliza una flecha predeterminada. Mientras el cursor está sobre un
`Class.GuiButton`, esta propiedad se ignora temporalmente. Esta propiedad
solo soporta URI de activos.

Para ocultar completamente el cursor, **no** utilices una imagen transparente &ndash;
en su lugar, establece `Class.UserInputService.MouseIconEnabled` en falso.

Para obtener/configurar el ícono del ratón del usuario en las experiencias, deberías usar
`Class.UserInputService.MouseIcon`. `Class.Mouse.Icon` será obsoleto
after the new API for plugins to set the mouse cursor is released.

##### Diseñando un Cursor

Las siguientes pautas pueden ser útiles al crear tus propios cursores de ratón:

- Las dimensiones de la imagen utilizada determinan el tamaño del cursor.
- Las dimensiones de la imagen no deben exceder los 256 píxeles en ningún eje.
- El **centro** de la imagen es donde se emiten las entradas del ratón.
- La imagen predeterminada del ratón es de 64x64 píxeles, con el ratón ocupando 17x24
  píxeles de espacio.

##### Cursores del Sistema

Al usar un `Class.PluginMouse` obtenido de `Class.Plugin:GetMouse()`,
podrás usar los siguientes íconos similares a los cursores predeterminados de tu sistema,
como manos, flechas, vigas en I, etc. Puedes usarlos con eventos GUI
como `Class.GuiObject.MouseEnter|MouseEnter`,
`Class.GuiObject.MouseLeave|MouseLeave`, y
`Class.GuiButton.MouseButton1Down|MouseButton1Down` para proporcionar una
experiencia consistente en Studio al interactuar con ciertos tipos de componentes GUI.
Ten en cuenta que estos solo funcionan para complementos de Studio; no funcionarán
para otros objetos `Class.Mouse`.

<table>
    <thead>
        <tr>
            <th>Apariencia*</th>
            <th>Activo</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>Predeterminado para clics y selección.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-PointingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/PointingHand</code></td>
            <td>Pasar sobre un enlace/botón activo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-OpenHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/OpenHand</code></td>
            <td>Pasar sobre un elemento arrastrable.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-GrabbingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/ClosedHand</code></td>
            <td>Arrastrar un objeto.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-IBeam.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/IBeam</code></td>
            <td>Pasar por un 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>Pasar sobre un controlador de redimensionamiento vertical.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeEW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeEW</code></td>
            <td>Pasar sobre un controlador de redimensionamiento horizontal.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNESW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNESW</code></td>
            <td>Pasar sobre un controlador de redimensionamiento en esquina.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNWSE.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNWSE</code></td>
            <td>Pasar sobre un controlador de redimensionamiento en esquina.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeAll.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeAll</code></td>
            <td>Pasar sobre un controlador de redimensionamiento multidireccional.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitV.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitNS</code></td>
            <td>Pasar sobre un controlador de "división" vertical.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitH.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitEW</code></td>
            <td>Pasar sobre un controlador de "división" horizontal.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Forbidden.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Forbidden</code></td>
            <td>Pasar sobre un elemento bloqueado/prohibido.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Wait.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Wait</code></td>
            <td>Indica que una acción está en progreso.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Busy.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Busy</code></td>
            <td>Indica que el 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>Pasar sobre un área de selección precisa.</td>
        </tr>
    </tbody>
</table>

<figcaption>* Estas apariencias son aproximaciones &mdash; el aspecto real depende de tu sistema operativo.</figcaption>


Mouse.IconContent

El contenido de la imagen utilizada como el ícono de `Class.Mouse`. Solo soporta
URI de activos.


La propiedad de origen `Class.Mouse` es un `Datatype.CFrame` que indica dónde
se originó el ratón. Está posicionado en el
`Class.Workspace.CurrentCamera` y orientado hacia la posición 3D
 del ratón.

`Class.Mouse.UnitRay` comienza en la misma posición que Origin, y se extiende
por un stud en la misma dirección.

```lua
local unitRay = mouse.UnitRay
local origin = mouse.Origin
-- unitRay.Direction = origin.p
-- unitRay.Direction ≈ origin.lookVector
```
Para la posición de `Class.Mouse` en el espacio 3D, consulta `Class.Mouse.Hit`.


Mouse.Origin

Un `Datatype.CFrame` posicionado en `Class.Workspace.CurrentCamera` y
orientado hacia la posición 3D del ratón.


Cuando se coloca en un `LocalScript` en `StarterPlayerScripts`, el siguiente código
cambia el `Class.BasePart.BrickColor` de cada `BasePart` sobre el que el jugador hace clic,
como la ubicación de aparición o la placa base.


El objeto en el espacio 3D al que apunta el `Class.Mouse|mouse`.

Nota:

- Si `Class.Mouse.TargetFilter` se ha establecido, el filtro de destino y sus
descendientes serán ignorados.
- Cuando el ratón no apunta a una `Class.BasePart`, por ejemplo, cuando
éste apunta al cielo, Target será `nil`.
- Los desarrolladores que busquen la posición del ratón en el espacio 3D deben usar
`Class.Mouse.Hit`.


Mouse.Target

El objeto en el espacio 3D al que apunta el `Class.Mouse|mouse`.


Mouse.target

Esta propiedad determina un objeto que será ignorado por el ratón al
calcular `Class.Mouse.Hit` y `Class.Mouse.Target`. Los descendientes de
este objeto también se ignoran, por lo que es posible ignorar múltiples objetos
siempre que sean descendientes del objeto al que se establece esta propiedad.
Esta propiedad es útil al filtrar modelos que contienen efectos especiales o decoraciones que no deben afectar a `Class.Mouse.Hit` o
`Class.Mouse.Target`.

Esta propiedad puede establecerse en cualquier `Class.Instance` o `nil`, por ejemplo:

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

local player = Players.LocalPlayer
local mouse = player:GetMouse()
mouse.TargetFilter = Workspace.Model
```
Ten en cuenta que el `Class.Player.Character|Character` del
`Class.Players.LocalPlayer` es ignorado por el ratón automáticamente.


Mouse.TargetFilter

Determina un objeto (y sus descendientes) que se ignorará al determinar
`Class.Mouse.Hit` y `Class.Mouse.Target`.


El código en este ejemplo, cuando se coloca en un `LocalScript` dentro de
`StarterPlayerScripts`, establecerá la superficie de cualquier `BasePart` que se haga clic en una
superficie aleatoria.

Esta propiedad indica el `Enum.NormalId` de la superficie de `Class.BasePart`
a la cual apunta el ratón. Esta propiedad se deriva de la
posición mundial del ratón (`Class.Mouse.Hit`) y la parte hacia la cual el
ratón está apuntando (`Class.Mouse.Target`).

Esta propiedad no tiene sentido cuando el ratón no apunta a una parte,
por ejemplo, cuando el ratón apunta al cielo. En este momento, esta
propiedad se establece en 'Derecha' bajo estas circunstancias. Antes de usar esta
propiedad, verifica que el objetivo del ratón no sea `nil`.

```lua
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
-- Verifica que exista una parte a la que apunta el ratón
if mouse.Target then
	print("El ratón está apuntando al lado " .. mouse.TargetSurface.Name .. " de " .. mouse.Target.Name)
else
	print("El ratón no está apuntando a nada.")
end
```


Mouse.TargetSurface

Indica el `Enum.NormalId` de la superficie de `Class.BasePart` a la cual
apunta el ratón.


La propiedad UnitRay es un `Datatype.Ray` dirigido hacia la posición del ratón
en el espacio 3D (descrito por `Class.Mouse.Hit`). Se origina desde
el `Class.Camera.CFrame|CFrame` de `Class.Workspace.CurrentCamera`.
Al igual que todos los rayos unitarios, tiene una distancia de 1.

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


Mouse.UnitRay

Un `Datatype.Ray` dirigido hacia la posición mundial del ratón, originándose
desde la posición mundial de `Class.Workspace.CurrentCamera`.


Este ejemplo de código muestra cómo puedes crear un `Datatype.Vector2` que representa
la posición del objeto `Mouse` en pantalla (`Class.Mouse.X|X()` y
`Class.Mouse.Y|Y()`) y el tamaño de la pantalla en sí
(`Class.Mouse.ViewSizeX|ViewSizeX()` y `Class.Mouse.ViewSizeY|ViewSizeY()`).
Usando estos, puedes normalizar la posición del ratón en pantalla de tal manera que
la esquina superior izquierda justo debajo de la barra superior se mapee a (0, 0) y la esquina inferior derecha se mapee a
(1, 1). Esta posición normalizada se calcula e imprime a medida que se mueve el ratón
utilizando el evento `Class.Mouse.Move|Move()`.

La propiedad ViewSizeX describe el componente horizontal del tamaño de la
ventana del juego en píxeles.


Mouse.ViewSizeX

Describe el ancho de la ventana del juego en píxeles.


La propiedad ViewSizeY describe el componente vertical del tamaño de la
ventana del juego en píxeles. Esta longitud incluye el espacio utilizado por la
barra superior.


Mouse.ViewSizeY

Describe la altura de la ventana del juego en píxeles.


Al detectar cambios en la posición del ratón en la pantalla, se recomienda
que utilices `Class.ContextActionService:BindAction()` con
`Enum.UserInputType.MouseMovement` o
`Class.UserInputService.InputChanged`, que describen la posición del
ratón utilizando `Class.InputObject.Position|Position` (un
`Datatype.Vector3`) de un `Class.InputObject`, en lugar de usar esta y
propiedades relacionadas.

La propiedad X describe el componente horizontal de la posición del ratón
en la pantalla. La posición se mide en píxeles en relación a la esquina superior izquierda,
debajo de la barra superior. Esta propiedad se puede usar junto con
`Class.Mouse.Y` para producir un `Datatype.Vector2` representando la posición del ratón:

```lua
local position = Vector2.new(mouse.X, mouse.Y)
```
Esta propiedad no activa `Class.Object.Changed|Changed` o la señal
devuelta de
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal`. Usa el evento
`Class.Mouse.Move` en su lugar.


Mouse.X

Describe el componente X (horizontal) de la posición del ratón en la
pantalla.


Al detectar cambios en la posición del ratón en la pantalla, se recomienda
que utilices `Class.ContextActionService:BindAction()` con
`Enum.UserInputType.MouseMovement` o
`Class.UserInputService.InputChanged`, que describen la posición del
ratón utilizando `Class.InputObject.Position|Position` (un
`Datatype.Vector3`) de un `Class.InputObject`, en lugar de usar esta y
propiedades relacionadas.

La propiedad Y describe el componente vertical de la posición del ratón en
la pantalla. La posición se mide en píxeles en relación a la esquina superior izquierda,
debajo de la barra superior. Esta propiedad se puede usar junto con
`Class.Mouse.X` para producir un `Datatype.Vector2` representando la posición del ratón:

```lua
local position = Vector2.new(mouse.X, mouse.Y)
```
Esta propiedad no activa `Class.Object.Changed|Changed` o la señal
devuelta de
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal`. Usa el evento
`Class.Mouse.Move` en su lugar.


Mouse.Y

Describe el componente Y (vertical) de la posición del ratón en la pantalla.


Objeto legado que contiene miembros útiles para la entrada de puntero.

`Instance` es la clase base para todas las clases de la jerarquía de clases de Roblox
que pueden ser parte del árbol de `Class.DataModel`.

No es posible crear directamente objetos `Instance` en la raíz, pero el constructor especial
`Datatype.Instance.new()` crea objetos a través de código, tomando el
nombre de la clase como parámetro y devolviendo el objeto creado.

Demuestra cómo detectar cambios en la ascendencia de una instancia al conectarse al
`Class.Instance.AncestryChanged` evento.

El Parent de ChangingPart se establece en diferentes valores con el tiempo. El padre de
la parte es el ancestro de la parte, por lo que el evento `Class.Instance.AncestryChanged`
se activará cada vez que cambie.


Se activa cuando esta instancia es reparentada o cuando cualquiera de sus
ancestros es reparentado.

Puedes usar este evento para rastrear la eliminación de una instancia en el
Studio, como la eliminación manual en el Explorador o a través de un
plugin. Si necesitas detectar cuándo una instancia es destruida usando
`Class.Instance:Destroy()`, usa en su lugar el evento
`Class.Instance.Destroying`.

Instance.AncestryChanged

child

La instancia cuya propiedad `Class.Instance.Parent|Parent` ha cambiado,
que puede ser esta instancia o un ancestro más distante, **no**
es necesariamente la instancia a la que el controlador está conectado.

parent

Se activa cuando la propiedad `Class.Instance.Parent` de este objeto o uno de
sus ancestros es cambiada.

Este evento se activa cada vez que se cambia cualquier atributo en la instancia,
incluyendo cuando un atributo se establece en `nil`. El nombre del
atributo cambiado se pasa a la función conectada.

Por ejemplo, el siguiente fragmento de código conecta la función
`attributeChanged()` para que se active cada vez que cambia uno de los
atributos de la parte:

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

local part = Workspace.Part

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

part.AttributeChanged:Connect(attributeChanged)
```
Consulta también `Class.Instance:GetAttributeChangedSignal()` que devuelve un
evento que se activa cuando un atributo específico cambia.

Instance.AttributeChanged

attribute

El nombre del atributo que ha sido cambiado.

Se activa cada vez que se cambia un atributo en la `Class.Instance`.

Este fragmento imprime los nombres de los objetos a medida que se añaden al Espacio de Trabajo:

Se activa después de que un objeto es parentado a esta `Class.Instance`.

Nota, al usar este método en un cliente para detectar objetos creados por el
servidor, es necesario usar `Class.Instance:WaitForChild()` al
indexar los descendientes de este objeto. Esto se debe a que el objeto y sus
descendientes no se garantiza que se repliquen desde el servidor al cliente
simultáneamente. Por ejemplo:

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

Workspace.ChildAdded:Connect(function(child)
	-- Usa WaitForChild() ya que los descendientes pueden no haberse replicado aún
	local head = child:WaitForChild("Head")
end)
```
Nota, este evento solo opera para hijos inmediatos de la
`Class.Instance`. Para un evento que capture todos los descendientes, usa
`Class.Instance.DescendantAdded`.

Consulta también `Class.Instance.ChildRemoved`.

Instance.ChildAdded

La `Class.Instance` que ha sido añadida.

Se activa después de que un objeto es parentado a esta `Class.Instance`.

Instance.childAdded

Este fragmento imprime los nombres de los objetos a medida que se eliminan del
Espacio de trabajo:

Se activa después de que un hijo es eliminado de esta `Class.Instance`.

Eliminado se refiere a cuando el padre de un objeto se cambia de esta
`Class.Instance` a algo diferente de esta `Class.Instance`. Nota, este
evento también se activará cuando un hijo sea destruido (usando
`Class.Instance:Destroy()`) ya que la función de destrucción establece el
padre de un objeto a `nil`.

Este evento solo opera para hijos inmediatos de la `Class.Instance`.
Para un evento que capture todos los descendientes, usa
`Class.Instance.DescendantRemoving`.

Consulta también `Class.Instance.ChildAdded`.

Instance.ChildRemoved

La `Class.Instance` que ha sido eliminada.

Se activa después de que un hijo es eliminado de esta `Class.Instance`.

Este siguiente ejemplo imprimirá el nombre de cualquier objeto que se agregue al
Espacio de trabajo:

Este evento se activa después de que se añade un descendiente a la `Class.Instance`.

Al activarse para cada descendiente, parentar un objeto a la
`Class.Instance` activará el evento para este objeto y todos sus
descendientes individualmente.

Si solo te preocupas por los **hijos directos** de la
`Class.Instance`, usa `Class.Instance.ChildAdded` en su lugar.

Consulta también `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

Se activa después de que se añade un descendiente a la `Class.Instance`.

El siguiente ejemplo imprime el nombre de cualquier descendiente mientras se está eliminando
del Workspace:

Este evento se activa **inmediatamente antes** de que el padre de la `Class.Instance`
cambie de forma que una instancia **descendiente** ya no será un
descendiente. `Class.Instance:Destroy()|Destroy()` cambia el
`Class.Instance.Parent|Parent` de una instancia a `nil`, por lo que al llamar a
ese método en un descendiente del padre, este evento se activará.

Dado que este evento se activa **antes** de la eliminación del descendiente,
el padre del descendiente no cambiará en el momento de la activación de
este evento. Si el descendiente también es un **hijo directo** del
padre, este evento se activará antes de `Class.Instance.ChildRemoved`.

Si un descendiente tiene hijos, este evento se activará primero con el
descendiente, seguido por sus descendientes.

#### Advertencia

Este evento se activa con el objeto descendiente que se está eliminando.
Intentar establecer el `Class.Instance.Parent|Parent` del descendiente en
algo más fallará. A continuación se muestra un ejemplo que demuestra esto:

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

Workspace.DescendantRemoving:Connect(function(descendant)
	-- ¡No manipules el padre del descendiente en esta función!
	-- Este evento se activa PORQUE el padre fue manipulado, y el cambio aún no ha ocurrido
	-- Por lo tanto, es problemático cambiar el padre de esta manera:
	descendant.Parent = game
end)

local part = Instance.new("Part")
part.Parent = Workspace
part.Parent = nil
```
Consulta también `Class.Instance.DescendantAdded|DescendantAdded`.

Instance.DescendantRemoving

La `Class.Instance` que se está eliminando.

Se activa inmediatamente antes de que se elimine un descendiente de la `Class.Instance`.

Este ejemplo demuestra cómo, al usar el comportamiento de señal Inmediata, una
Instancia que está siendo destruida permanece en su lugar hasta que la función conectada se detiene.


Este ejemplo demuestra cómo, al usar el comportamiento de señal diferida, una Instancia
se destruye antes de que se dispare la señal.


La `Class.Instance` nunca se eliminará de la memoria mientras una función conectada
la esté utilizando. Sin embargo, si la función se bloquea en algún momento,
la `Class.Instance` y sus descendientes serán parentados a `nil`.

Si la propiedad `Class.Workspace.SignalBehavior` está establecida en
`Enum.SignalBehavior.Immediate`, este evento se activa inmediatamente antes del
`Class.Instance` o de uno de sus ancestros es destruido con
`Class.Instance:Destroy()`.

Si la propiedad `Class.Workspace.SignalBehavior` está establecida en
`Enum.SignalBehavior.Deferred`, este evento se activa en el siguiente
punto de reanudación, que estará después de que el `Class.Instance` o uno de
sus ancestros sean destruidos con `Class.Instance:Destroy()`.

Con el comportamiento de `Enum.SignalBehavior.Deferred|Deferred`, conectar un
script a su propio evento `Class.Instance.Destroying` es problemático, ya que el
script será destruido antes de que se pueda llamar al callback (lo que significa
que no se ejecutará).

Al eliminar una `Class.Instance` en Studio, como eliminar manualmente
a través del [Explorador](/studio/explorer) o a través de un
plugin, la `Class.Instance` no es destruida. En su lugar, el padre se establece
en `nil` lo que puedes rastrear con `Class.Instance.AncestryChanged`.

Instance.Destroying

Se activa inmediatamente antes (o se difiere hasta después) de que la instancia se
destruya a través de `Class.Instance:Destroy()`. 

Este evento se activa cada vez que se cambia cualquier propiedad de estilo en la instancia,
incluyendo cuando una propiedad se establece en `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("Las propiedades de estilo han cambiado")
end

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

Instance.StyledPropertiesChanged

Se activa cada vez que se cambia cualquier propiedad de estilo en la instancia,
incluyendo cuando una propiedad se establece en `nil`.

Este método aplica una etiqueta a la instancia, sin efecto si la etiqueta ya
ha sido aplicada. Agregar una etiqueta con éxito generará una señal creada por
`Class.CollectionService:GetInstanceAddedSignal()` con la etiqueta dada.

#### Advertencias

- Las etiquetas de una instancia que fueron añadidas del lado del cliente se eliminarán si el
  servidor más tarde añade o elimina una etiqueta en esa instancia porque el servidor
  replica todas las etiquetas juntas y sobrescribe las etiquetas anteriores.

- Al etiquetar una instancia, es común que se utilicen algunos recursos para
darle a la etiqueta su funcionalidad, por ejemplo conexiones de eventos o tablas.
  Para prevenir fugas de memoria, es una buena idea limpiar estos recursos
  (desconectar, establecer en `nil`, etc.) cuando ya no sean necesarios para una etiqueta. Haz esto al
  llamar a `Class.Instance:RemoveTag()`, al
  llamar a `Class.Instance:Destroy()`, o en una función conectada a una señal
  devuelta por `Class.CollectionService:GetInstanceRemovedSignal()`.

Instance:AddTag

La función de los hijos devuelve un array de los hijos del objeto.

Instance:children

Devuelve un array de los hijos del objeto.

Este método destruye todos los hijos y descendientes de una instancia.

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

-- Agregar algunos destellos
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
```
Si no deseas destruir **todos** los hijos y descendientes, usa ya sea
`Class.Instance:GetChildren()` o `Class.Instance:GetDescendants()` para
recorrer esos hijos/descendientes y seleccionar qué destruir. Por
ejemplo, el siguiente extracto de código destruirá todos
`Class.BasePart|BaseParts` descendientes de un `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 destruye todos los hijos de una instancia.

Demuestra cómo clonar un modelo usando `Class.Instance:Clone()`.

`Clone()` crea una copia de una instancia y de todos sus descendientes,
ignorando todas las instancias que no son
`Class.Instance.Archivable|Archivable`. La copia de la instancia raíz es
devuelta por este método y su `Class.Instance.Parent|Parent` se establece en
`nil`. Ten en cuenta que si la instancia misma tiene
`Class.Instance.Archivable|Archivable` establecida en `false`, este método devolverá
`nil`.

Si una propiedad de referencia como `Class.ObjectValue.Value` se establece en una
instancia clonada, el valor de la propiedad de la copia depende del
valor original:

- Si una propiedad de referencia se refiere a una instancia que también fue clonada,
  la copia se referirá a la copia.
- Si una propiedad de referencia se refiere a una instancia que no fue clonada,
  se mantiene el mismo valor en la copia.

Instance:Clone

Crea una copia de una instancia y de todos sus descendientes, ignorando instancias
que no son `Class.Instance.Archivable|Archivable`.

Instance:clone

Demuestra cómo destruir una Parte utilizando la función `Class.Instance:Destroy()`.

Esta función es la manera correcta de eliminar objetos que ya no son
necesarios.


Establece la propiedad `Class.Instance.Parent` en `nil`, bloquea la
propiedad `Class.Instance.Parent`, desconecta todas las conexiones, y llama a
`Destroy()` en todos los hijos. Este método es la manera correcta de eliminar
objetos que ya no son necesarios.

Eliminar objetos innecesarios es importante, ya que objetos y
conexiones innecesarias en un lugar consumen memoria lo que puede llevar
con el tiempo a problemas serios de rendimiento.

Como mejor práctica después de llamar a `Destroy()` en un objeto, establece cualquier
variable que haga referencia al objeto (o sus descendientes) en `nil`. Esto
previene que tu código acceda a cualquier cosa relacionada con el objeto.

```lua
local part = Instance.new("Part")
part.Name = "Hola, mundo"
part:Destroy()
-- No hagas esto:
print(part.Name)  --> "Hola, mundo"
-- Haz esto para prevenir que la línea anterior funcione:
part = nil
```
Una vez que un `Class.Instance` ha sido destruido por este método, no puede ser
reutilizado porque la propiedad `Class.Instance.Parent` está bloqueada. Para
**eliminar temporalmente** un objeto en lugar de destruirlo, establece
`Class.Instance.Parent|Parent` en `nil`. Por ejemplo:

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

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
Para destruir un objeto después de un tiempo determinado, usa
`Class.Debris:AddItem()`.

Instance:Destroy

Establece la propiedad `Class.Instance.Parent` en `nil`, bloquea la
propiedad `Class.Instance.Parent`, desconecta todas las conexiones, y llama a
`Destroy()` en todos los hijos.

Instance:destroy

Devuelve el primer ancestro del `Class.Instance` cuyo
`Class.Instance.Name` es igual al nombre dado.

Este método trabaja hacia arriba, lo que significa que comienza en el `Class.Instance.Parent`
inmediato de la instancia y trabaja hacia el `Class.DataModel`. Si no se
encuentra un ancestro coincidente, devuelve `nil`.

El siguiente fragmento de código encontraría el primer ancestro del objeto
llamado `Car`.

```
local car = object:FindFirstAncestor("Car")
```
Para variantes de este método que encuentran ancestros de una clase específica,
consulta `Class.Instance:FindFirstAncestorOfClass()` y
`Class.Instance:FindFirstAncestorWhichIsA()`.

Instance:FindFirstAncestor

name

Devuelve el primer ancestro del `Class.Instance` cuyo
`Class.Instance.Name` es igual al nombre dado.

Devuelve el primer ancestro del `Class.Instance` cuyo
`Class.Object.ClassName` es igual al className dado.

Este método trabaja hacia arriba, lo que significa que comienza en el `Class.Instance.Parent`
inmediato de la instancia y trabaja hacia el `Class.DataModel`. Si no se
encuentra un ancestro coincidente, devuelve `nil`.

Un uso común de este método es encontrar el `Class.Model` al que
pertenece un `Class.BasePart`. Por ejemplo:

```
local model = part:FindFirstAncestorOfClass("Model")
```
Este método es una variante de `Class.Instance:FindFirstAncestor()` que
verifica la propiedad `Class.Object.ClassName` en lugar de `Class.Instance.Name`. También
existe `Class.Instance:FindFirstAncestorWhichIsA()`, que usa el método `Class.Object:IsA()` en su lugar para respetar la
herencia de clases.

Instance:FindFirstAncestorOfClass

className

Devuelve el primer ancestro del `Class.Instance` cuyo
`Class.Object.ClassName` es igual al className dado.

Devuelve el primer ancestro del `Class.Instance` para quien
`Class.Object:IsA()` devuelve verdadero para el className dado.

Este método trabaja hacia arriba, lo que significa que comienza en el `Class.Instance.Parent`
inmediato de la instancia y trabaja hacia el `Class.DataModel`. Si no se
encuentra un ancestro coincidente, devuelve `nil`.

A diferencia de `Class.Instance:FindFirstAncestorOfClass()`, este método utiliza
`Class.Object:IsA()` que respeta la herencia de clases. Por ejemplo:

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```
Por lo tanto, el siguiente fragmento de código devolverá el primer
ancestro `Class.BasePart`, independientemente de si es un `Class.WedgePart`,
`Class.MeshPart` o `Class.Part`.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```
Consulta también `Class.Instance:FindFirstAncestor()`.

Instance:FindFirstAncestorWhichIsA

Devuelve el primer ancestro del `Class.Instance` para quien
`Class.Object:IsA()` devuelve verdadero para el className dado.

A continuación, buscaría en Workspace un objeto llamado "Brick". Si se encuentra, cambiará el nombre del objeto a "Foo".

Devuelve el primer hijo del `Class.Instance` con el nombre dado, o
`nil` si no existe tal hijo. Si el argumento opcional `recursive` es
`true`, este método busca todos los descendientes en lugar de solo los
hijos inmediatos del `Class.Instance`.

#### Verificando la Existencia de un Objeto

`FindFirstChild()` es necesario si necesitas verificar que un objeto existe
antes de continuar. Intentar indexar un hijo por nombre usando el operador
punto generará un error si el hijo no existe.

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

-- La siguiente línea da error si la parte no existe en el espacio de trabajo
Workspace.Part.Transparency = 0.5
```
Un enfoque mejor es usar `FindFirstChild()` para primero comprobar si `Part`,
luego usar una instrucción `if` para ejecutar código que lo necesite.

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

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

#### Encontrar un Hijo cuyo Nombre Coincida con una Propiedad

A veces el `Class.Instance.Name|Name` de un objeto es el mismo que el de una
propiedad de `Class.Instance.Parent|Parent`. Al usar el operador punto, las
propiedades tienen prioridad sobre los hijos si comparten un nombre.

En el siguiente ejemplo, se añade una `Class.Folder` llamada `Color` a un
`Class.Part`, que también tiene la propiedad `Class.Part.Color`. Ten en cuenta que
`part.Color` se refiere al valor de la propiedad `Datatype.Color3`, no a la instancia hija
`Class.Folder`. Un beneficio de usar
`Class.Instance:FindFirstChild()|FindFirstChild()` es que la
introducción de nuevas propiedades no pone en riesgo tu código.

```lua
local part = Instance.new("Part")
local folder = Instance.new("Folder")
folder.Name = "Color"
folder.Parent = part
local c1 = part.Color  -- La propiedad
local c2 = part:FindFirstChild("Color")  -- La carpeta hija
```

#### Notas de Rendimiento

`Class.Instance:FindFirstChild()|FindFirstChild()` toma aproximadamente un 20% más de
tiempo que usar el operador punto y casi 8 veces más que simplemente guardar un
referencia a un objeto. Por lo tanto, debes evitar llamarlo en
código dependiente del rendimiento, como en bucles ajustados o funciones conectadas
a `Class.RunService.Heartbeat` y `Class.RunService.PreRender`. En su lugar,
almacena el resultado en una variable, o considera usar
`Class.Instance.ChildAdded|ChildAdded` o
`Class.Instance:WaitForChild()|WaitForChild()` para detectar cuándo un hijo de un
dado nombre se convierte disponible.

Instance:FindFirstChild

recursive

Si la búsqueda debe ser realizada de forma recursiva.

Devuelve el primer hijo del `Class.Instance` encontrado con el nombre dado.

Instance:findFirstChild

Devuelve el primer hijo del `Class.Instance` cuyo
`Class.Object.ClassName|ClassName` es igual al `className` dado.
A diferencia de `Class.Instance:FindFirstChildWhichIsA()`, este método solo devuelve
objetos cuya clase coincide con `className`, ignorando la herencia de clases. Si no se
encuentra un hijo coincidente, este método devuelve `nil`.

Instance:FindFirstChildOfClass

Devuelve el primer hijo del `Class.Instance` cuyo
`Class.Object.ClassName|ClassName` es igual al nombre de clase dado.

Devuelve el primer hijo del `Class.Instance` para quien
`Class.Object:IsA()` devuelve verdadero para el className dado.

Si no se encuentra un hijo coincidente, este método devuelve `nil`. Si el argumento
opcional recursivo es verdadero, este método busca todos los descendientes en lugar
de solo los hijos inmediatos del `Class.Instance`.

A diferencia de `Class.Instance:FindFirstChildOfClass()`, este método utiliza
`Class.Object:IsA()` que respeta la herencia de clases. Por ejemplo:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
Por lo tanto, el siguiente fragmento de código devolverá el primer
hijo `Class.BasePart`, independientemente de si es un `Class.WedgePart`,
`Class.MeshPart` o `Class.Part`.

```
local part = object:FindFirstChildWhichIsA("BasePart")
```
Los desarrolladores que busquen un hijo por nombre, deben usar
`Class.Instance:FindFirstChild()` en su lugar.

Instance:FindFirstChildWhichIsA

Devuelve el primer hijo del `Class.Instance` para quien
`Class.Object:IsA()` devuelve verdadero para el className dado.

Devuelve el primer descendiente encontrado con el `Class.Instance.Name` dado.

Este método está deshabilitado y no se puede usar. Para encontrar el primer descendiente
de una instancia, considera usar el parámetro `recursive` en
`Class.Instance:FindFirstChild()` en su lugar.

Instance:FindFirstDescendant

Devuelve el primer descendiente encontrado con el `Class.Instance.Name` dado.

Si el `Class.Instance` es un `Class.Actor`, se devuelve el `Class.Actor` mismo.
De lo contrario, se devuelve su ancestro más cercano `Class.Actor`. Si no
hay ancestro que sea un `Class.Actor`, el resultado es `nil`.

Instance:GetActor

Devuelve el `Class.Actor` asociado con la instancia, si lo hay.

Este método devuelve el valor que se ha asignado al nombre de
atributo dado. Si no se ha asignado ningún atributo, se devuelve `nil`.

Por ejemplo, el siguiente fragmento de código establece y luego obtiene el valor del
atributo `InitialPosition` de la instancia:

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

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

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

#### Consulta También

- `Class.Instance:SetAttribute()` que establece el atributo con el nombre dado en el valor dado.
- `Class.Instance:GetAttributes()` que devuelve un diccionario de pares clave-valor
  para cada uno de los atributos de la instancia.

Instance:GetAttribute

El nombre del atributo que se está recuperando.

El valor que se ha asignado al nombre de atributo dado. Si no se
ha asignado ningún atributo, se devuelve `nil`.

Devuelve el valor que se ha asignado al nombre de atributo dado.

Este método devuelve un evento que se comporta exactamente como el
evento `Class.Object.Changed|Changed`, excepto que solo se activa cuando
el atributo específico dado cambia; efectivamente es similar a
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` pero
para atributos.

Es generalmente una buena idea usar este método en lugar de una conexión a
`Class.Object.Changed|Changed` con una función que verifica el nombre del atributo.
Las llamadas posteriores a este método en el mismo objeto con el mismo
nombre de atributo devuelven el mismo evento.

El siguiente ejemplo de código devuelve una señal que activa la función
`attributeChanged()` cuando cambia el atributo `InitialPosition` de la parte:

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

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

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

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```
Consulta también `Class.Instance.AttributeChanged` que se activa cada vez que se
cambia cualquier atributo en la instancia.

Instance:GetAttributeChangedSignal

El nombre del atributo especificado para el cual se devuelve la señal de cambio.

Un evento que se activa cuando cambia el atributo dado.

Devuelve un evento que se activa cuando cambia el atributo dado.

Este método devuelve un diccionario de pares clave-valor para cada atributo
donde la clave es el nombre del atributo y el valor es un valor no `nil`.

Por ejemplo, el siguiente código devuelve los atributos de una instancia
y sus valores:

```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
```
Consulta también `Class.Instance:GetAttribute()` que devuelve el valor que se ha
asignado al nombre de atributo dado.

Instance:GetAttributes

Un diccionario de pares string → variante para cada atributo donde la
string es el nombre del atributo y la variante es un valor no nulo.

Devuelve un diccionario de los atributos de la instancia.

A continuación se imprimiría el nombre de todos los objetos actualmente en Workspace cuando se ejecuta.

Devuelve un array (una tabla numerada) que contiene todos los
hijos directos de la instancia, o cada `Class.Instance` cuyo
`Class.Instance.Parent|Parent` es igual al objeto. El array puede ser
iterado usando ya sea un bucle numérico o un bucle genérico:

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

-- Ejemplo de bucle numérico
local children = Workspace:GetChildren()
for i = 1, #children do
	local child = children[i]
	print(child.Name .. " es el hijo número " .. i)
end
```

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

-- Ejemplo de bucle genérico
local children = Workspace:GetChildren()
for i, child in children do
	print(child.Name .. " es el hijo número " .. i)
end
```
Ten en cuenta que el array devuelto **no** está ordenado de ninguna manera,
sí que se recomienda realizar un ordenamiento manual (por ejemplo, usando
`Library.table.sort()`) para ordenar los hijos devueltos por este método.

Consulta también el método `Class.Instance:GetDescendants()|GetDescendants()`.

Instance:GetChildren

Un array que contiene los hijos de la instancia.

Devuelve un array que contiene todos los hijos de la instancia.

Instance:getChildren

Devuelve una cadena codificada del ID de depuración utilizado internamente por Roblox. Ten en cuenta que:

- Este elemento está protegido. Intentar usarlo en un `Class.Script` o
  `Class.LocalScript` causará un error.
- Un ID de depuración es un ID utilizado en procesos de depuración. Permite que un depurador
  lea cada instrucción antes de que una aplicación la procese. Todos los objetos en
  Roblox actúan como procesos y cada uno ejecuta instrucciones (o 'código') que pueden
  ser depuradas si es necesario.
- Esto puede ser útil para complementos que necesitan distinguir objetos similares
  entre sí (como objetos que comparten el mismo nombre).

Instance:GetDebugId

scopeLength

Devuelve una cadena codificada del ID de depuración utilizado internamente por Roblox.

Instance

`Instance` es la clase base para todas las clases de la jerarquía de clases de Roblox
que pueden ser parte del árbol de `Class.DataModel`.

/reference/engine/classes/PluginMouse.yaml