Un `Class.Actor` es un contenedor para código que puede ser dividido de forma segura en su propio
hilo utilizando `Library.task.desynchronize()`. También debe contener las
instancias utilizadas por sus scripts.

Para obtener más información sobre el uso de múltiples Actores para optimizar el rendimiento de los scripts, consulta
[Luau Paralelo](/scripting/multithreading).

#### Notas

- Cada `Actor` se ejecuta en su propia VM de Luau. `Class.ModuleScript|ModuleScripts`
  requeridos por un `Actor` **no** se comparten ni se almacenan en caché entre `Actors` o con
  el hilo principal. Cada VM ejecuta su propia copia del módulo, así que
  el estado a nivel de módulo está aislado por `Actor`. Diseña en consecuencia si tus
  módulos tienen estado que pretendes compartir.
- `script:GetActor()` devuelve `nil` cuando se llama desde un `Class.ModuleScript`
  a menos que el `ModuleScript` sea un descendiente del `Actor`. Los `ModuleScripts`
  almacenados en otro lugar (por ejemplo, `Class.ReplicatedStorage`) y requeridos por un
  `Actor` no se consideran descendientes del `Actor`.

Demuestra `Class.Actor:BindToMessage()`.


Este método se utiliza para vincular un callback de Luau a un mensaje con el
tópico especificado. Cuando se envía un mensaje (usando
`Class.Actor:SendMessage()|SendMessage()`) al tópico especificado, el
callback proporcionado se llamará en un contexto de ejecución _serial_.

Se pueden vincular múltiples callbacks de Luau a un solo actor e incluso a un
tópico de mensaje único.

Nota: Solo los scripts que son descendientes de un Actor pueden vincularse a sus
mensajes.

Actor:BindToMessage

topic

El tema utilizado para identificar el tipo de mensaje.

function

El callback de Luau que se invoca cuando se recibe un mensaje con el tema especificado.
El callback recibe el contenido del mensaje como sus argumentos.


Este objeto de conexión se puede usar para desconectar el callback de Luau
de recibir mensajes.

Vincula un callback de Luau a un mensaje con el tema especificado.

Demuestra `Class.Actor:BindToMessageParallel()`.


Este método se utiliza para vincular un callback de Luau a un mensaje con el
tópico especificado. Cuando se envía un mensaje (usando
`Class.Actor:SendMessage()|SendMessage()`) al tópico especificado, el
callback proporcionado se llamará en un contexto de ejecución _paralelo_.

Se pueden vincular múltiples callbacks de Luau a un solo actor e incluso a un
tópico de mensaje único.

Nota: Solo los scripts que son descendientes de un Actor pueden vincularse a sus
mensajes.

Actor:BindToMessageParallel

Envía un mensaje a un Actor. Los mensajes se envían de forma asíncrona, por lo que el
remitente no bloqueará ni cederá al llamar al
`Class.Actor:SendMessage()|SendMessage()`.

Dado que un solo Actor puede recibir diferentes tipos de mensajes, se utiliza un
parámetro `topic` para distinguir entre varios tipos de mensajes.

Consulta `Class.Actor:BindToMessage()|BindToMessage()` para obtener detalles sobre la recepción
de un mensaje enviado usando `Class.Actor:SendMessage()|SendMessage()`.

Ten en cuenta que los argumentos del mensaje se **pasan por copia** a través de los límites de la VM de Luau,
no por referencia. Enviar tablas grandes incurre en una copia completa en
cada llamada. Las funciones están vinculadas a una VM específica y no se pueden pasar en
mensajes.

Actor:SendMessage

El tema utilizado para identificar el mensaje que se envía.

message

El contenido del mensaje que se enviará al Actor.

Actor

Un `Class.Actor` es un contenedor para código que puede ser dividido de forma segura en su propio
hilo.

El siguiente ejemplo incluye una función básica que toma una tabla de objetos
y los parenta en un nuevo Modelo, devolviendo ese Modelo.

Los modelos son objetos contenedores, lo que significa que agrupan objetos juntos. Son
mejor utilizados para contener colecciones de `Class.BasePart|BaseParts` y tienen un número
de funciones que amplían su funcionalidad.

Los modelos están destinados a representar agrupaciones **geométricas**. Si tu agrupación no tiene
una interpretación geométrica, por ejemplo, una colección de
`Class.Script|Scripts`, utiliza un `Class.Folder` en su lugar.

Los modelos cuyas partes constitutivas están unidas con articulaciones (para que puedan
moverse o ser destruidas a través de simulación física) suelen tener un
`Class.Model.PrimaryPart|PrimaryPart` establecido, ya que especifica qué parte dentro
del modelo seguirá como pivote y caja delimitadora a medida que se mueve el modelo. Los
modelos estáticos que permanecen en un lugar no se benefician de tener una parte primaria configurada.

Los modelos tienen una amplia gama de aplicaciones, incluidos los personajes de jugador de Roblox.
También tienen una serie de comportamientos únicos que son importantes tener en
cuenta:

- Cuando un `Class.Humanoid` y un `Class.Part` llamado **Head** están parentados bajo
  un modelo, aparecerá una GUI de nombre/salud sobre el modelo; consulta
  [Visualización de Nombre/Salud del Personaje](/characters/name-health-display)
  para más detalles.
- Si la posición de una parte en el eje **Y** alcanza el
  `Class.Workspace.FallenPartsDestroyHeight`, y era el último objeto
  dentro de un `Class.Model`, el modelo también será destruido.
- Cuando se utiliza en un lugar con `Class.Workspace.StreamingEnabled` configurado en verdadero,
  el valor de `Class.Model.ModelStreamingMode|ModelStreamingMode` controla
  varios comportamientos sobre cómo se replica
  y/o se elimina el modelo y sus descendientes de los clientes. Además, el valor de
  `Class.Model.LevelOfDetail|LevelOfDetail` impacta el renderizado del modelo.

Como con todos los tipos de `Class.Instance`, el hecho de que un padre `Class.Model` sea
replicado a un cliente no garantiza que todos sus hijos se
replicarán. Esto es particularmente importante si estas instancias están siendo
accedidas por código que se ejecuta en el cliente, como en un `Class.LocalScript`.
Usar `Class.Model.ModelStreamingMode|ModelStreamingMode` con valores como
`Enum.ModelStreamingMode|Atomic` puede asegurar que el modelo completo y todos sus
descendientes están presentes si el modelo padre existe en el cliente, o puedes
usar `Class.Instance:WaitForChild()|WaitForChild()` cuando la atomicidad no es
deseada.

Establece este modelo como persistente para el jugador especificado. Los modelos
persistentes permanecen presentes para el jugador independientemente de las configuraciones o
condiciones de streaming.

`Class.Model.ModelStreamingMode|ModelStreamingMode` debe estar configurado en
`Enum.ModelStreamingMode|PersistentPerPlayer` para que el comportamiento cambie
como resultado de la adición.

Model:AddPersistentPlayer

playerInstance

El `Class.Player` para hacer este modelo persistente.

Establece este modelo como persistente para el jugador especificado.
`Class.Model.ModelStreamingMode|ModelStreamingMode` debe estar configurado en
`Enum.ModelStreamingMode|PersistentPerPlayer` para que el comportamiento cambie
como resultado de la adición.

En este ejemplo, las articulaciones en cada modelo de personaje de jugador añadido serán rotas
3 segundos después de aparecer. Romper estas articulaciones hará que el Humanoide
muera.

Este ejemplo de código demuestra la creación manual de juntas en dos partes que son
hermanas del script (PartA y PartB). Crea una junta en dos partes tocantes
con tipos de superficie compatibles (Studs e Inlet).

Rompe conexiones entre `BaseParts`, incluidas conexiones de superficie con
cualquier parte adyacente, `Class.WeldConstraint|WeldConstraints`, y todas
`Class.Weld|Welds` y otras `Class.JointInstance|JointInstances`.

Cuando se utiliza BreakJoints en un modelo de personaje de jugador, el
`Class.Humanoid` del personaje morirá ya que depende de la articulación del cuello.

Ten en cuenta que aunque las uniones producidas por conexiones de superficie con
partes adyacentes pueden técnicamente recrearse usando `Class.Model:MakeJoints()`, esto
solo recreará uniones producidas por superficies. Los desarrolladores no deben confiar
en esto, ya que las partes que siguen a las uniones rotas ya no pueden estar en
contacto entre sí.

Model:BreakJoints

Rompe conexiones entre `BaseParts`, incluidas conexiones de superficie con
cualquier parte adyacente, `Class.WeldConstraint|WeldConstraints` y todas
`Class.Weld|Welds` y otras `Class.JointInstance|JointInstances`.

Model:breakJoints

Demuestra `Class.Model:GetBoundingBox()`.


Esta función devuelve una descripción de un volumen que contiene todos los hijos de `Class.BasePart` dentro de un `Class.Model`. La orientación del volumen se basa en la orientación del `Class.Model.PrimaryPart|PrimaryPart`, y coincide con la caja de selección renderizada en Studio cuando se selecciona el modelo. Reflejando el comportamiento de `Class.Terrain:FillBlock()`, devuelve un `Datatype.CFrame` que representa el centro de esa caja delimitadora y un `Datatype.Vector3` que representa su tamaño. El tamaño puede ser inexacto en tiempo de ejecución si las restricciones físicas están actuando sobre las partes dentro del `Class.Model`.

La orientación de la caja delimitadora coincide con la orientación del `Class.PVInstance.GetPivot|Pivot` - ya sea el pivote del `Class.Model.PrimaryPart|PrimaryPart` (si está presente) o el `Class.Model.WorldPivot|WorldPivot` del modelo.


Model:GetBoundingBox

Un `Datatype.CFrame` que representa la orientación del volumen
seguido de un `Datatype.Vector3` que representa el tamaño del volumen.

Devuelve una descripción de un volumen que contiene todas las partes de un Modelo.

El siguiente ejemplo de código demuestra cómo Model.GetExtentsSize se puede usar para obtener
el tamaño de la caja delimitadora que contiene las piezas.

Devuelve el tamaño de la caja delimitadora más pequeña que contiene todas las
`Class.BasePart|BaseParts` en el `Class.Model`. La orientación coincide
con la orientación de la `Class.PVInstance.GetPivot|Pivot`, ya sea el
pivote de la `Class.Model.PrimaryPart|PrimaryPart` (si está presente) o el
`Class.Model.WorldPivot|WorldPivot` del modelo.

Ten en cuenta que esta función solo devuelve el tamaño de la caja delimitadora más pequeña,
y el desarrollador debe emplear su propio método para obtener la posición de la
caja delimitadora.

Model:GetExtentsSize

El tamaño de extensión del `Datatype.Vector3` del `Class.Model`.

Devuelve el tamaño de la caja delimitadora más pequeña que contiene todas las
`Class.BasePart|BaseParts` en el `Class.Model`, alineada con el
`Class.Model.PrimaryPart` si está establecida.

Este valor, históricamente, devolvía el CFrame de una posición central en el
modelo.

Model:GetModelCFrame

Este código crearía un modelo, pondría algunas piezas en él, las posicionaría aleatoriamente,
y luego imprimiría su tamaño:

La función GetModelSize devuelve el tamaño `Datatype.Vector3` del
`Class.Model`.

Model:GetModelSize

Cuando este método se llama desde un `Class.Script`, devuelve todos los
objetos `Class.Player` para los que este modelo es persistente. Cuando se llama desde
un `Class.LocalScript`, este método solo comprueba si este modelo es persistente
para el `Class.Players.LocalPlayer|LocalPlayer`.

Model:GetPersistentPlayers

Una tabla con todos los objetos `Class.Player` para los que este modelo es
persistente.

Devuelve todos los objetos `Class.Player` para los que este modelo es
persistente. El comportamiento varía según si este método se llama
desde un `Class.Script` o un `Class.LocalScript`.

El siguiente código demuestra cómo GetPrimaryPartCFrame y
SetPrimaryPartCFrame pueden usarse para rotar un modelo.

Se crea un modelo simple en el Workspace y se inicia un bucle que
rotará el modelo 10 grados alrededor del eje Y cada 0.2 segundos.

Esta función ha sido reemplazada por `Class.PVInstance:GetPivot()` que
actúa como un reemplazo y no cambia el comportamiento de tu código. Usa
`Class.PVInstance:GetPivot()` para nuevos trabajos y migra tus existentes
llamadas a `Class.Model:GetPrimaryPartCFrame()` cuando sea conveniente.

Devuelve el `Datatype.CFrame` de la `Class.Model.PrimaryPart` del modelo.

Esta función es equivalente a lo siguiente.

    Model.PrimaryPart.CFrame

Ten en cuenta que esta función lanzará un error si no existe parte primaria para el
`Class.Model`. Si este comportamiento no es deseado, los desarrolladores pueden hacer lo siguiente,
lo cual será igual a `nil` si no hay parte primaria.

    local cFrame = Model.PrimaryPart y Model.PrimaryPart.CFrame

Model:GetPrimaryPartCFrame

Devuelve el `Datatype.CFrame` de la `Class.Model.PrimaryPart` del modelo.
Esta función lanzará un error si no existe parte primaria para el
`Class.Model`.

Este ejemplo de código demuestra cómo sustituir en un reemplazo para todas las copias
de un modelo de árbol usando `Class.Model:PivotTo()` y `Class.Model:ScaleTo()`. El
pivot y la escala de los modelos se utilizan como referencia, asegurando que los
sizes y ubicaciones relativas de los modelos de reemplazo coincidan con los de los
originales.

Los modelos contienen un factor de escala canónica persistente, que empieza en 1
para los modelos recién creados y cambia a medida que se escala el modelo al llamar
`Class.Model:ScaleTo()`. Esta función devuelve el factor de escala canónica actual del modelo.

El factor de escala actual no impacta _directamente_ el tamaño de las instancias
bajo el modelo. Se utiliza para la creación de contenido y propósitos de scripting
para recordar cómo se ha escalado el modelo en relación a su tamaño original.

Dentro de una sesión dada, el modelo almacenará en caché la información del tamaño original
preciso de las instancias descendientes después de la primera llamada a
`Class.Model:ScaleTo()`. Eso significa que llamar a
`Class.Model:ScaleTo()|ScaleTo(x)` seguido de
`Class.Model:ScaleTo()|ScaleTo(1)` te devolverá _exactamente_
el configuración original del modelo sin deriva de punto flotante. Evitar
la deriva de punto flotante es la motivación para tener una función Scale**To**
 en lugar de una función Scale**By**.

El factor de escala impacta el comportamiento del motor de una manera: El factor de escala
del modelo se aplicará a los desplazamientos de las uniones de
`Class.Animation|Animations` reproducidas en un `Class.AnimationController`
bajo ese modelo, para que los rigs animados reproduzcan correctamente
las animaciones incluso cuando se escalen.

Model:GetScale

El factor de escala canónica actual del modelo.

Devuelve la escala canónica del modelo, que por defecto es 1 para los modelos
recién creados y cambiará a medida que se escale mediante
`Class.Model:ScaleTo()`.

Este ejemplo de código demuestra cómo se pueden hacer juntas usando la
función Model:MakeJoints.

Se instancia un modelo, con dos partes una encima de la otra. La parte superior está
anclada y la parte inferior no. Normalmente, cuando está parentada al Workspace
la parte inferior caería al Baseplate.

Sin embargo, como la propiedad TopSurface de la parte inferior está configurada en
Enum.SurfaceType.Weld, esto significa que cuando se ejecuta Model:MakeJoints se
hace una conexión entre ellas.

Por lo tanto, la parte inferior no cae hasta que se rompen las juntas en el modelo.
Esto suele hacerse usando Model:BreakJoints, pero en este ejemplo la
conexión se rompe usando una explosión.

Este ejemplo de código demuestra la creación de juntas en dos partes que son
hermanas del script (PartA y PartB). Utiliza MakeJoints en dos partes que tocan
con tipos de superficie compatibles (Studs y Inlet).

La unión basada en SurfaceType está en desuso. No uses MakeJoints para nuevos
proyectos. Usa `Class.WeldConstraint|WeldConstraints` y
`Class.HingeConstraint|HingeConstraints` en su lugar.

Revisa todos los `Class.BasePart|Parts` en el `Class.Model` y crea
uniones entre las Partes especificadas y cualquier superficie plana en contacto,
 dependiendo de las superficies de las partes.

- Las superficies suaves no crearán uniones
- Las superficies de pegamento crearán una unión `Class.Glue`
- La soldadura creará una unión `Class.Weld` con cualquier superficie, excepto
  Unjoinable
- Studs, Inlet o Universal crearán cada uno una unión `Class.Snap` con
  cualquiera de las otras dos superficies (por ejemplo, Studs con Inlet y
  Universal)
- Superficies de bisagra y motor crean instancias de unión `Class.Rotate` y
  `Class.RotateV`

Esta función no funciona si la Parte no es un descendiente de
`Class.Workspace`. Por lo tanto, debes asegurarte primero de que el Modelo esté parentado
a Workspace antes de usar MakeJoints.

Model:MakeJoints

Revisa todos los `Class.BasePart|BaseParts` en el `Class.Model`. Si algún
lado de parte tiene un SurfaceType que puede crear una unión, creará una unión
con cualquier parte adyacente.

Model:makeJoints

Model:move

location

Este ejemplo demuestra cómo `Class.Model:MoveTo()` evita colisiones.

Se crea un simple `Class.Model` de dos partes, y su `Class.Model.PrimaryPart`
es configurado. Una gran parte de obstrucción se coloca al lado.

Después de 5 segundos, se usa `Class.Model:MoveTo()` para dirigir el modelo a
moverse dentro de la parte de obstrucción. Sin embargo, como MoveTo no moverá un modelo dentro
de una obstrucción, el `Class.Model` se mueve hacia arriba en el eje Y y se coloca encima
de la obstrucción.

Mueve la `Class.Model.PrimaryPart|PrimaryPart` a la posición dada. Si
no se ha especificado una parte primaria, se usará la parte raíz del modelo,
pero la parte raíz no es determinista y se recomienda que
siempre configures una parte primaria al usar `Class.Model:MoveTo()|MoveTo()`.

Si hay obstrucciones donde se debe mover el modelo, como
`Class.Terrain` u otros `Class.BasePart|BaseParts`, el modelo se moverá
verticalmente hacia arriba hasta que no haya nada en el camino. Si este
comportamiento no es deseado, se debe utilizar `Class.PVInstance:PivotTo()`
en su lugar.

Ten en cuenta que la rotación no se preserva al mover un modelo con
`Class.Model:MoveTo()|MoveTo()`. Se recomienda usar ya sea
`Class.Model:TranslateBy()|TranslateBy()` o `Class.PVInstance:PivotTo()`
si se necesita preservar la rotación actual del modelo.

Model:MoveTo

position

El `Datatype.Vector3` al que se mueve el `Class.Model`.

Mueve la `Class.Model.PrimaryPart|PrimaryPart` a la posición dada. Si
no se ha especificado una parte primaria, se usará la parte raíz del modelo.

Model:moveTo

Hace que este modelo ya no sea persistente para el jugador especificado. Esto no
garantiza que el modelo se eliminará inmediatamente para el jugador; después
de llamar a este método, el modelo se tratará como
`Enum.ModelStreamingMode|Atomic` para ese jugador y permanecerá presente
siempre que esté dentro del radio de streaming objetivo.

`Class.Model.ModelStreamingMode|ModelStreamingMode` debe estar configurado en
`Enum.ModelStreamingMode|PersistentPerPlayer` para que el comportamiento cambie
como resultado de la eliminación.

Model:RemovePersistentPlayer

El `Class.Player` para hacer que este modelo ya no sea persistente.

Hace que este modelo ya no sea persistente para el jugador especificado.
`Class.Model.ModelStreamingMode|ModelStreamingMode` debe estar establecido en
`Enum.ModelStreamingMode|PersistentPerPlayer` para que el comportamiento cambie
como resultado de la eliminación.

Restablece la rotación de las partes del modelo a la rotación de identidad
anteriormente establecida, que se hace a través del método
`Class.Model:SetIdentityOrientation()`.

Model:ResetOrientationToIdentity

Los modelos contienen un factor de escala canónica persistente, que empieza en 1
para los modelos recién creados. Esta función escala el modelo, alrededor de la ubicación del pivote,
en relación a cómo se vería con un factor de escala de 1. Para
lograr esto, hace dos cosas:

- Establece el factor de escala actual del modelo al valor especificado
- Redimensiona y reposiciona todas las instancias descendientes en consecuencia

La escala de las ubicaciones se realiza alrededor de la ubicación del pivote.

Todas las propiedades "geométricas" de las instancias descendientes serán escaladas. Eso
obviamente incluye los tamaños de las partes, pero aquí hay algunos otros ejemplos de
propiedades que se escalan:

- La longitud de las uniones como `Class.WeldConstraint|WeldConstraints`, y
  `Class.RopeConstraint`
- Velocidades y fuerzas físicas como `Class.HingeConstraint`
- Propiedades visuales como tamaños de emisores de partículas
- Otras propiedades de longitud como `Class.Sound.RollOffMinDistance`

Model:ScaleTo

newScaleFactor

Establece el factor de escala del modelo, ajustando el tamaño y la ubicación de
 todas las instancias descendientes para que tengan ese factor de escala en relación a
sus tamaños y ubicaciones iniciales cuando el factor de escala era 1.

Establece la rotación de identidad del modelo dado, permitiéndote restablecer la
rotación de todo el modelo más tarde, a través del uso del método
`ResetOrientationToIdentity`.

Model:SetIdentityOrientation

Esta función ha sido reemplazada por `Class.PVInstance:PivotTo()` que
actúa como un reemplazo más eficiente y no cambia el comportamiento de tu
código. Usa `Class.PVInstance:PivotTo()` para nuevos trabajos y migra tus
existentes llamadas a `Class.Model:SetPrimaryPartCFrame()` cuando sea conveniente.

Establece el `Class.BasePart.CFrame` de la `Class.Model.PrimaryPart` del modelo.
Todas las demás partes en el modelo también se moverán y mantendrán su
orientación y desplazamiento respectivos respecto a la `Class.Model.PrimaryPart`.

Ten en cuenta que esta función lanzará un error si no existe `Class.Model.PrimaryPart`
para el modelo. Esto puede causar problemas si, por ejemplo, la parte primaria
nunca se estableció o ha sido destruida.

Model:SetPrimaryPartCFrame

cframe

El `Datatype.CFrame` que se debe establecer.

Establece el `Class.BasePart.CFrame` de la `Class.Model.PrimaryPart` del modelo.
Todas las demás partes en el modelo también se moverán y mantendrán su
orientación y desplazamiento respectivos respecto a la `Class.Model.PrimaryPart`.

Este ejemplo demuestra cómo `Class.Model:TranslateBy()` ignora las colisiones
y respeta la orientación del modelo.

Se crea un `Class.Model` simple de dos partes, rotado 45 grados en el eje Y,
y se establece su `Class.Model.PrimaryPart`. Se coloca una gran parte de obstrucción
al lado.

Después de 5 segundos, se utiliza `Class.Model:TranslateBy()` para dirigir el modelo a
moverse dentro de la parte de obstrucción. El modelo se moverá dentro de la
obstrucción y mantendrá su orientación actual.

Desplaza un `Class.Model` por el desplazamiento `Datatype.Vector3` dado, preservando
la orientación del modelo. Si ya existe otro `Class.BasePart` o `Class.Terrain`
en la nueva posición, entonces el `Class.Model` se superpondrá
con dicho objeto.

La traducción se aplica en el espacio mundial en lugar del espacio del objeto,
lo que significa que incluso si las partes del modelo están orientadas de manera diferente, aún
se moverá a lo largo del eje estándar.

Model:TranslateBy

delta

El `Datatype.Vector3` por el cual se traduce el `Class.Model`.

Desplaza un `Class.Model` por el desplazamiento `Datatype.Vector3` dado, preservando
la orientación del modelo. Si ya existe otro `Class.BasePart` o `Class.Terrain`
en la nueva posición, entonces el `Class.Model` se superpondrá
con dicho objeto.

Model

Establece el nivel de detalle en el modelo para experiencias con
[streaming](/workspace/streaming) habilitado. Los modelos compuestos o
imposter no admiten física, detección de colisiones ni
raycasting.

Cuando se establece en `Enum.ModelLevelOfDetail|StreamingMesh`, un modelo
"imposter" de menor resolución (malla coloreada y gruesa que envuelve todos los
componentes secundarios del modelo) se renderiza fuera del radio de streaming. No admite
texturas.

Cuando se establece en `Enum.ModelLevelOfDetail|SLIM`, un modelo **SLIM** (Modelo
Interactivo Ligero Escalable) renderiza un compuesto de todos los componentes
secundarios a resoluciones progresivamente más bajas a distancias basadas en el
radio de streaming. Esto mejora enormemente la calidad visual en comparación con
`Enum.ModelLevelOfDetail|StreamingMesh`.

Cuando se establece en `Enum.ModelLevelOfDetail|Disabled` o
`Enum.ModelLevelOfDetail|Automatic`, las mallas de menor resolución no se
displayarán.

Model.LevelOfDetail

Establece el nivel de detalle en el modelo para experiencias con
streaming de instancias habilitado.

Controla cómo se transmiten hacia adentro y hacia afuera los `Class.Model|Models` cuando
se habilita el [streaming](/workspace/streaming) de instancias. El comportamiento
depende del enum seleccionado. No tiene efecto cuando el streaming no está habilitado.

Esta propiedad solo debe modificarse en Studio a través de la
ventana de [Propiedades](/studio/properties) cuando el streaming está
habilitado, o en `Class.Script|Scripts`, pero nunca en
`Class.LocalScript|LocalScripts` (hacerlo puede resultar en un comportamiento indefinido).

Model.ModelStreamingMode

Controla el comportamiento de streaming del modelo en `Class.Model|Models` cuando
se habilita el streaming de instancias.

Este ejemplo de código crea y lanza un modelo de dado, luego indica si
aterrizó con el lado azul hacia arriba. Si `Class.Model.PrimaryPart` no se establece,
el pivote / caja delimitadora del dado rotaría, ya que las partes dentro de él
son simuladas físicamente durante el lanzamiento.

Apunta a la parte primaria del `Class.Model`. La parte primaria es la
`Class.BasePart` que actúa como la referencia física para el pivote del
modelo. Es decir, cuando las partes dentro del modelo se mueven debido a la
simulación física u otros medios, el pivote se moverá sincronizado con la parte
primaria.

Ten en cuenta que los `Class.Model|Models` no tienen `PrimaryPart` configurado por defecto.
Si estás creando un modelo que necesita ser afectado por la física, debes
configurar manualmente esta propiedad en Studio o dentro de un script. Si la
parte primaria **no** está configurada, el pivote permanecerá en la misma ubicación en
el espacio mundial, incluso si las partes dentro del modelo son movidas.

También ten en cuenta que al establecer esta propiedad, debe ser un
`Class.BasePart` que sea descendiente del modelo. Si intentas establecer
`Class.Model.PrimaryPart` en un `Class.BasePart` que **no** es un
descendiente del modelo, se configurará en esa parte pero se restablecerá a `nil`
 durante el siguiente paso de simulación &mdash; este es un comportamiento heredado para
soportar scripts que suponen que pueden configurar temporalmente la parte primaria en un
`Class.BasePart` que no es un descendiente del modelo.

La regla general para los modelos es que:

- Los modelos cuyas partes están unidas a través de uniones físicas como
  `Class.WeldConstraint|WeldConstraints` o `Class.Motor6D|Motor6Ds`
  deben tener una parte primaria asignada. Por ejemplo, los modelos de
  personajes de Roblox tienen su `Class.Model.PrimaryPart` configurado en el
  **HumanoidRootPart** por defecto.
- Los modelos estáticos (generalmente `Class.BasePart.Anchored|Anchored`) que permanecen en
  un lugar a menos que un script los mueva explícitamente no requieren un
  `Class.Model.PrimaryPart` y tienden a no beneficiarse de tener uno configurado.

Model.PrimaryPart

La parte primaria del `Class.Model`, o `nil` si no está configurada explícitamente.

Configurar esta propiedad en la ventana de Propiedades escalará el modelo como
si se hubiera llamado a `Class.Model:ScaleTo()` en él, escalando todas las instancias
hijas en el modelo, como materiales, imágenes y la geometría 3D de las
partes, para que el modelo tenga el factor de escala especificado en relación a su
 tamaño original.

Esta propiedad solo está disponible en Studio y lanzará un error si se utiliza
en un `Class.Script` o `Class.LocalScript`. Se recomienda usar
`Class.Model:ScaleTo()` y `Class.Model:GetScale()` desde scripts.

Model.Scale

Propiedad solo para editores utilizada para escalar el modelo alrededor de su pivote. Configurar
esta propiedad moverá la escala como si se hubiera llamado a `Class.Model:ScaleTo()` en ella.

Este ejemplo de código muestra una función personalizada para restablecer el pivot de un modelo
de vuelta al centro de la caja delimitadora de ese modelo.

Esta propiedad determina dónde se encuentra el pivote de un `Class.Model` que no tiene un `Class.Model.PrimaryPart` establecido. Si el `Class.Model` **tiene** un `Class.Model.PrimaryPart|PrimaryPart`, el pivote del `Class.Model` es igual al pivote de esa parte principal en su lugar, y esta propiedad `Class.Model.WorldPivot|WorldPivot` se ignora.

Para un `Class.Model` recién creado, su pivote se tratará como el centro de la caja delimitadora de su contenido hasta la **primera vez** que se establezca su propiedad `Class.Model.WorldPivot`. Una vez que se establece el pivote mundial por primera vez, es imposible restaurar este comportamiento inicial.

Comúnmente, mover el modelo con las herramientas de Studio, o con funciones de movimiento de modelos como `Class.PVInstance:PivotTo()` y `Class.Model:MoveTo()`, establecerá el pivote mundial y, por lo tanto, finalizará este nuevo comportamiento del modelo.

El propósito de este comportamiento es permitir que el código Luau obtenga un pivote sensato simplemente creando un nuevo modelo y parentando objetos a él, evitando la necesidad de establecer explícitamente `Class.Model.WorldPivot` cada vez que creas un modelo en el código.


Model.WorldPivot

Determina dónde está ubicado el pivote de un `Class.Model` que **no** tiene un
`Class.Model.PrimaryPart` establecido.

Los modelos son objetos contenedores, lo que significa que agrupan objetos juntos. Son
mejor utilizados para contener colecciones de `Class.BasePart|BaseParts` y tienen un número
de funciones que amplían su funcionalidad.

Una `Class.PVInstance` es una clase abstracta que no se puede crear. Es la
base para todos los objetos que tienen una ubicación física en el mundo.

Este ejemplo de código es un script simple de teleportación que mueve tu personaje
10&nbsp;studs hacia adelante en la dirección en la que actualmente estás mirando cuando presionas
la <kbd>F</kbd> tecla. Lo hace obteniendo el pivot actual con
`Class.PVInstance:GetPivot()` y llamando a `PVInstance|PivotTo` para mover el
personaje hacia adelante.

Esta función obtiene el pivote de una `Class.PVInstance`. A menudo se
utiliza con `Class.PVInstance:PivotTo()` para mover un modelo.

`Class.Model|Models` y `Class.BasePart|BaseParts` son ambos
`Class.PVInstance|PVInstances` ("Instancias de Velocidad de Posición") y por lo tanto ambos
poseen esta función.

PVInstance:GetPivot

El `Datatype.CFrame` en el espacio mundial del pivot de la instancia.


Obtiene el pivote de una `Class.PVInstance`.

Transforma la `Class.PVInstance` junto con todas sus
`Class.PVInstance|PVInstances` descendientes de modo que el pivote ahora se
ubique en el `Datatype.CFrame` especificado. Esta es la función principal que
se debe utilizar para mover `Class.Model|Models` mediante scripting.

`Class.BasePart|BaseParts` se mueven de esta manera transformando su
`Datatype.CFrame` por el desplazamiento necesario.
`Class.Model|Models` se mueven de esta manera transformando su
`Class.Model.WorldPivot` por el desplazamiento necesario.

Tenga en cuenta que por motivos de eficiencia, los eventos
`Class.Object.Changed` no se activan para `Class.BasePart.Position|Position` y
`Class.BasePart.Orientation|Orientation` de los `Class.BasePart|BaseParts`
movidos de esta manera; solo se activan para `Datatype.CFrame`.

Al llamar a `Class.PVInstance:PivotTo()|PivotTo` en `Class.Model|Models`,
los desplazamientos de las partes y modelos descendientes se almacenan en caché,
de modo que las llamadas subsecuentes a `Class.PVInstance:PivotTo()|PivotTo` en el mismo modelo
o no acumulan deriva de punto flotante entre las partes que componen el
modelo.

`Class.Model|Models` y `Class.BasePart|BaseParts` son ambos
`Class.PVInstance|PVInstances` ("Instancias de Velocidad de Posición") y por lo tanto ambos
poseen esta función.

PVInstance:PivotTo

targetCFrame

El `Datatype.CFrame` al que el pivote de la `Class.PVInstance` debe igualar
despues de moverlo.

Transforma la `Class.PVInstance` junto con todas sus
`Class.PVInstance|PVInstances` descendientes de modo que el pivote ahora se
ubique en el `Datatype.CFrame` especificado.

PVInstance

Propiedad solo para editores, mostrada en la ventana de Propiedades del Studio como **Posición
de Origen** y **Orientación de Origen** bajo **Transformar**. Su valor es
el `Datatype.CFrame` en el espacio mundial del pivot de la instancia; leerlo
devuelve el mismo `Datatype.CFrame` que `Class.PVInstance:GetPivot()`. No
tiene un valor almacenado propio y siempre refleja el pivot actual.

Establecerlo desde la ventana de Propiedades mueve toda la instancia para que su
pivot se sitúe en el nuevo `Datatype.CFrame`, muy parecido a
`Class.PVInstance:PivotTo()`. Editar a través de la ventana de Propiedades
desactiva temporalmente `Class.WeldConstraint|WeldConstraints` a otros
objetos para el movimiento; `PivotTo` no modifica las uniones.

No disponible para scripts; usa `Class.PVInstance:GetPivot()` y
`Class.PVInstance:PivotTo()` en tiempo de ejecución en su lugar.


PVInstance.Origin

Propiedad solo para editores que lee y establece el `Datatype.CFrame` mundial del
pivot de la `Class.PVInstance`, moviendo toda la instancia cuando se cambia
desde la ventana de Propiedades del Studio.


Propiedad solo para editores, mostrada en la ventana de Propiedades del Studio como **Posición
 del Pivot** y **Orientación del Pivot** bajo **Pivot**. Es el
`Datatype.CFrame` del pivot relativo al propio marco de la instancia.

Cambiarlo desde la ventana de Propiedades mueve el pivot relativo a la
instancia mientras deja la instancia en su lugar, a diferencia de `Origen`, que mueve
toda la instancia. Para un `Class.BasePart`, el desplazamiento predeterminado es el
`Datatype.CFrame` de identidad, por lo que el pivot coincide con el centro de la parte.
Para un `Class.Model`, esta propiedad aparece solo cuando el modelo tiene un
`Class.Model.PrimaryPart|PrimaryPart`; entonces refleja y edita el
`Class.BasePart.PivotOffset|PivotOffset` de esa parte, y
`Class.Model:GetPivot()` es un alias del pivot de la parte principal.

No disponible para scripts; los scripts leen y escriben el equivalente a través
de la clase concreta, como `Class.BasePart.PivotOffset`.


PVInstance.Pivot Offset

Propiedad solo para editores que muestra y edita el `Datatype.CFrame` del pivot
relativo a la instancia, moviendo solo el pivot y dejando la instancia
en su lugar.


Clase abstracta para todos los objetos que tienen una ubicación física en el mundo.

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

No es posible crear objetos `Instance` raíz directamente, 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 Studio,
suchas como la eliminación manual en el Explorador o a través de un complemento. Si necesitas
detectar cuándo se destruye una instancia usando `Class.Instance:Destroy()`,
usa el evento `Class.Instance.Destroying` en su lugar.


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 está conectado el manejador.


parent

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


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 uno de los atributos de la parte cambie:

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

local part = Workspace.Part

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

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


Instance.AttributeChanged

attribute

El nombre del atributo que ha sido cambiado.


Se activa cada vez que se cambia un atributo en el `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 se haya parentado a este `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 estos objetos. Esto se debe a que el objeto y sus
descendientes no están garantizados para replicarse del 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 del
`Class.Instance`. Para un evento que captura todos los descendientes, usa
`Class.Instance.DescendantAdded`.

Véase también `Class.Instance.ChildRemoved`.


Instance.ChildAdded

El `Class.Instance` que ha sido agregado.


Se activa después de que un objeto se haya parentado a este `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 este `Class.Instance`.

Eliminado se refiere a cuando el padre de un objeto se cambia de este
`Class.Instance` a algo diferente de este `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
como `nil`.

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

Véase también `Class.Instance.ChildAdded`.


Instance.ChildRemoved

El `Class.Instance` que ha sido eliminado.


Se activa después de que un hijo es eliminado de este `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 un descendiente se agrega al `Class.Instance`.

Como se activa para cada descendiente, parentar un objeto al
`Class.Instance` activará el evento para este objeto y todos sus
descendientes individualmente.

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

Véase también `Class.Instance.DescendantRemoving`.


Instance.DescendantAdded

descendant

Se activa después de que un descendiente se agrega al `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 `Class.Instance`
cambie de tal manera 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 llamar a ese método en un
descendiente del padre hará que este evento se active.

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 activa primero con el descendiente,
seguido de sus descendientes.

#### Advertencia

Este evento se activa con el objeto descendiente que se está eliminando.
Intentar establecer el `Class.Instance.Parent|Parent` del descendiente a
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
```
Véase también `Class.Instance.DescendantAdded|DescendantAdded`.


Instance.DescendantRemoving

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


Se activa inmediatamente antes de que un descendiente del `Class.Instance` sea eliminado.


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.

El `Class.Instance` nunca será eliminado de la memoria mientras una función conectada
lo esté utilizando. Sin embargo, si la función se suspende en algún momento,
el `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 de que el
`Class.Instance` o uno de sus ancestros sea 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 será después de que el `Class.Instance` o uno de sus ancestros sea
destruido con `Class.Instance:Destroy()`.

Con el comportamiento `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 a la devolución de llamada (lo que significa que no
se ejecutará).

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


Instance.Destroying

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


Demuestra `Class.Instance.StyledPropertiesChanged`.


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


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 está
aplicada. Agregar una etiqueta con éxito activará una señal creada por
`Class.CollectionService:GetInstanceAddedSignal()` con la etiqueta dada.

#### Advertencias

- Las etiquetas de una instancia que se agregaron del lado del cliente se eliminarán si el
  servidor agrega o elimina una etiqueta en esa instancia más tarde 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 funcionalidad a la etiqueta, 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 se necesiten 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 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 fragmento 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 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` establecido 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 del
original:

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


Instance:Clone

Una copia de la instancia, o `nil` si la instancia no es
`Class.Instance.Archivable|Archivable`.


Crea una copia de una instancia y todos sus descendientes, ignorando las 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 forma correcta de eliminar
objetos que ya no son necesarios.

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

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 = "Hello, world"
part:Destroy()
-- No hagas esto:
print(part.Name)  --> "Hello, world"
-- 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 funciona 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

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


Instance

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