Um `Class.Actor` é um contêiner para código que pode ser dividido de forma segura em seu próprio
thread usando `Library.task.desynchronize()`. Também deve conter as
instâncias usadas por seus scripts.

Para saber mais sobre como usar múltiplos Actors para otimizar o desempenho de scripts, veja
[Parallel Luau](/scripting/multithreading).

#### Notas

- Cada `Actor` é executado em sua própria VM Luau. `Class.ModuleScript|ModuleScripts`
  exigidos por um `Actor` **não** são compartilhados ou armazenados em cache entre `Actors` ou com
  a thread principal. Cada VM executa sua própria cópia do módulo, então
  o estado a nível de módulo é isolado por `Actor`. Projete de acordo se seus
  módulos mantiverem estado que você pretende compartilhar.
- `script:GetActor()` retorna `nil` quando chamado de um `Class.ModuleScript`
  a menos que o `ModuleScript` seja um descendente do `Actor`. `ModuleScripts`
  armazenados em outros lugares (por exemplo, `Class.ReplicatedStorage`) e exigidos por um
  `Actor` não são considerados descendentes do `Actor`.

Demonstra `Class.Actor:BindToMessage()`.


Este método é usado para vincular um callback Luau a uma mensagem com o
tópico especificado. Quando uma mensagem é enviada (usando
`Class.Actor:SendMessage()|SendMessage()`) para o tópico especificado, o
callback fornecido será chamado em um contexto de execução _serial_.

Vários callbacks Luau podem ser vinculados a um único ator e até mesmo a um
único tópico de mensagem.

Nota: Apenas os scripts que são descendentes de um Ator podem se vincular às
suas mensagens.

Actor:BindToMessage

topic

O tópico usado para identificar o tipo de mensagem.

function

O callback Luau a ser invocado quando uma mensagem com o tópico especificado é
recebida. O callback recebe o conteúdo da mensagem como seus argumentos.


Este objeto de conexão pode ser usado para desconectar o callback Luau
de receber mensagens.

Vincula um callback Luau a uma mensagem com o tópico especificado.

Demonstra `Class.Actor:BindToMessageParallel()`.


Este método é usado para vincular um callback Luau a uma mensagem com o
tópico especificado. Quando uma mensagem é enviada (usando
`Class.Actor:SendMessage()|SendMessage()`) para o tópico especificado, o
callback fornecido será chamado em um contexto de execução _paralelo_.

Vários callbacks Luau podem ser vinculados a um único ator e até mesmo a um
único tópico de mensagem.

Nota: Apenas os scripts que são descendentes de um Ator podem se vincular às
suas mensagens.

Actor:BindToMessageParallel

Envia uma mensagem para um Ator. As mensagens são enviadas de forma assíncrona, então o
remetente não bloqueará ou cederá ao chamar o
`Class.Actor:SendMessage()|SendMessage()`.

Como um único Ator pode receber diferentes tipos de mensagens, um parâmetro `topic`
é usado para distinguir entre vários tipos de mensagens.

Veja `Class.Actor:BindToMessage()|BindToMessage()` para detalhes sobre como receber
uma mensagem enviada usando `Class.Actor:SendMessage()|SendMessage()`.

Note que os argumentos da mensagem são **passados por cópia** através das
fronteiras da VM Luau, não por referência. Enviar tabelas grandes implica em uma cópia completa em
cada chamada. Funções são vinculadas a uma VM específica e não podem ser passadas em
mensagens.

Actor:SendMessage

O tópico usado para identificar a mensagem que está sendo enviada.

message

O conteúdo da mensagem a ser enviada ao Actor.

Actor

Um `Class.Actor` é um contêiner para código que pode ser dividido com segurança em sua própria
thread.

O seguinte exemplo inclui uma função básica que recebe uma tabela de objetos
 e os adiciona a um novo Modelo, retornando esse Modelo.


Modelos são objetos contêineres, significando que eles agrupam objetos juntos. Eles são
melhor utilizados para manter coleções de `Class.BasePart|BaseParts` e possuem um número
de funções que aumentam sua funcionalidade.

Modelos são destinados a representar grupos **geométricos**. Se seu agrupamento não tem
interpretação geométrica, por exemplo, uma coleção de
`Class.Script|Scripts`, use um `Class.Folder` ao invés disso.

Modelos cujas partes constituintes estão unidas por juntas (para que possam
se mover ou serem destruídas via simulação física) geralmente têm um
`Class.Model.PrimaryPart|PrimaryPart` definido, pois isso especifica qual parte dentro
do modelo o pivô e a caixa delimitadora "seguirão" conforme o modelo se move. Modelos
estáticos que permanecem em um lugar não se beneficiam de ter uma parte primária definida.

Modelos têm uma ampla gama de aplicações, incluindo personagens de jogadores Roblox.
Eles também têm um número de comportamentos únicos que são importantes de ter em
mente:

- Quando um `Class.Humanoid` e uma `Class.Part` chamada **Head** estão parentados a
  um modelo, uma GUI de nome/saúde aparecerá sobre o modelo; veja
  [Exibição de Nome/Saúde do Personagem](/characters/name-health-display)
  para detalhes.
- Se a posição de uma parte no eixo **Y** atinge o
  `Class.Workspace.FallenPartsDestroyHeight`, e era o último objeto
  dentro de um `Class.Model`, o modelo será destruído também.
- Quando usado em um lugar com `Class.Workspace.StreamingEnabled` definido como verdadeiro,
  o valor de `Class.Model.ModelStreamingMode|ModelStreamingMode` controla
  vários comportamentos em como o modelo e quaisquer descendentes são replicados
  e/ou removidos dos clientes. Além disso, o valor de
  `Class.Model.LevelOfDetail|LevelOfDetail` impacta a renderização do modelo.

Assim como todos os tipos de `Class.Instance`, o fato de um pai `Class.Model` ser
replicado para um cliente não garante que todos os seus filhos sejam
replicados. Isso é particularmente importante se essas instâncias estão sendo
acessadas por código em execução no cliente, como em um `Class.LocalScript`.
Usar `Class.Model.ModelStreamingMode|ModelStreamingMode` com valores como
`Enum.ModelStreamingMode|Atomic` pode garantir que o modelo inteiro e todos os
seus descendentes estejam presentes se o modelo pai existir no cliente, ou você
pode usar `Class.Instance:WaitForChild()|WaitForChild()` quando a atomicidade não é
desejada.

Define este modelo para ser persistente para o jogador especificado. Modelos
persistentes permanecem presentes para o jogador, independentemente das configurações ou
condições de streaming.

`Class.Model.ModelStreamingMode|ModelStreamingMode` deve ser definida como
`Enum.ModelStreamingMode|PersistentPerPlayer` para que o comportamento seja alterado
como resultado da adição.

Model:AddPersistentPlayer

playerInstance

O `Class.Player` para o qual tornar este modelo persistente.

Define este modelo para ser persistente para o jogador especificado.
`Class.Model.ModelStreamingMode|ModelStreamingMode` deve ser definido como
`Enum.ModelStreamingMode|PersistentPerPlayer` para que o comportamento seja alterado
como resultado da adição.

Neste exemplo, as juntas em cada Modelo de personagem do Jogador adicionado serão quebradas
3 segundos após o surgimento. Quebrar essas juntas fará com que o Humanoide
morra.

Este exemplo de código demonstra a criação manual de juntas em duas partes que são
irmãs do script (PartA e PartB). Ele cria uma junta em duas partes tocando
com tipos de superfície compatíveis (Studs e Inlet).


Quebra as conexões entre `BaseParts`, incluindo conexões de superfície com
quaisquer partes adjacentes, `Class.WeldConstraint|WeldConstraints`, e todas
as `Class.Weld|Welds` e outras `Class.JointInstance|JointInstances`.

Quando BreakJoints é usado em um modelo de personagem de jogador, o
`Class.Humanoid` do personagem morrerá, pois depende da junta do pescoço.

Note que embora as juntas produzidas por conexões de superfície com partes adjacentes
possam tecnicamente ser recriadas usando `Class.Model:MakeJoints()`, isso
apenas recriará as juntas produzidas por superfícies. Os desenvolvedores não devem confiar
nisso, pois após as juntas serem quebradas as partes podem não estar mais em
contato umas com as outras.

Model:BreakJoints

Quebra as conexões entre `BaseParts`, incluindo conexões de superfície com
quaisquer partes adjacentes, `Class.WeldConstraint|WeldConstraints` e todas
as `Class.Weld|Welds` e outras `Class.JointInstance|JointInstances`.

Model:breakJoints

Demonstra `Class.Model:GetBoundingBox()`.


Esta função retorna uma descrição de um volume que contém todos os filhos `Class.BasePart` dentro de um `Class.Model`. A orientação do volume é baseada na orientação do `Class.Model.PrimaryPart|PrimaryPart`, e corresponde à caixa de seleção renderizada no Studio quando o modelo é selecionado. Espelhando o comportamento de `Class.Terrain:FillBlock()`, ela retorna um `Datatype.CFrame` representando o centro daquela caixa delimitadora e um `Datatype.Vector3` representando seu tamanho. O tamanho pode ser impreciso em tempo de execução se restrições físicas estiverem atuando sobre as partes dentro do `Class.Model`.

A orientação da caixa delimitadora corresponde à orientação do `Class.PVInstance.GetPivot|Pivot` - seja o pivô do `Class.Model.PrimaryPart|PrimaryPart` (se presente) ou o `Class.Model.WorldPivot|WorldPivot` do modelo.


Model:GetBoundingBox

Um `Datatype.CFrame` representando a orientação do volume
seguido por um `Datatype.Vector3` representando o tamanho do volume.

Retorna uma descrição de um volume que contém todas as partes de um Modelo.

O exemplo de código abaixo demonstra como Model.GetExtentsSize pode ser usado para obter
o tamanho da caixa delimitadora que contém as partes.


Retorna o tamanho da menor caixa delimitadora que contém todos os
`Class.BasePart|BaseParts` no `Class.Model`. A orientação corresponde
a orientação do `Class.PVInstance.GetPivot|Pivot` - seja o
pivô do `Class.Model.PrimaryPart|PrimaryPart` (se presente) ou o
`Class.Model.WorldPivot|WorldPivot` do modelo.

Observe que esta função apenas retorna o tamanho da menor caixa delimitadora, e
o desenvolvedor deve empregar seu próprio método para obter a posição da
caixa delimitadora.

Model:GetExtentsSize

O tamanho de extensão `Datatype.Vector3` do `Class.Model`.

Retorna o tamanho da menor caixa delimitadora que contém todos os
`Class.BasePart|BaseParts` no `Class.Model`, alinhada com o
`Class.Model.PrimaryPart` se estiver definido.

Este valor historicamente retornava o CFrame de uma posição central no
modelo.

Model:GetModelCFrame

Este código criaria um modelo, colocaria algumas partes nele, as posicionaria aleatoriamente,
e então imprimiria seu tamanho:


A função GetModelSize retorna o tamanho `Datatype.Vector3` do
`Class.Model`.

Model:GetModelSize

Quando este método é chamado de um `Class.Script`, ele retorna todos os
objetos `Class.Player` para os quais este modelo é persistente. Quando chamado de
um `Class.LocalScript`, este método apenas verifica se este modelo é persistente
para o `Class.Players.LocalPlayer|LocalPlayer`.

Model:GetPersistentPlayers

Uma tabela com todos os objetos `Class.Player` para os quais este objeto modelo é
persistente.

Retorna todos os objetos `Class.Player` para os quais este objeto modelo é
persistente. O comportamento varia dependendo se este método é chamado
em um `Class.Script` ou em um `Class.LocalScript`.

O código a seguir demonstra como GetPrimaryPartCFrame e
SetPrimaryPartCFrame podem ser usados para rotacionar um modelo.

Um modelo simples é criado no Workspace e um loop é iniciado que irá
rotacionar o modelo 10 graus ao redor do eixo Y a cada 0,2 segundos.


Esta função foi substituída por `Class.PVInstance:GetPivot()` que
atua como uma substituição e não altera o comportamento do seu código. Use
`Class.PVInstance:GetPivot()` para novos trabalhos e migre suas chamadas atuais
`Class.Model:GetPrimaryPartCFrame()` quando for conveniente.

Retorna o `Datatype.CFrame` da `Class.Model.PrimaryPart` do modelo.

Esta função é equivalente ao seguinte:

    Model.PrimaryPart.CFrame

Observe que esta função gerará um erro se não existir parte primária para o
`Class.Model`. Se esse comportamento não for desejado, os desenvolvedores podem fazer o
seguinte, o que será igual a `nil` se não houver parte primária.

    local cFrame = Model.PrimaryPart e Model.PrimaryPart.CFrame

Model:GetPrimaryPartCFrame

Retorna o `Datatype.CFrame` da `Class.Model.PrimaryPart` do modelo.
Esta função gerará um erro se não existir parte primária para o
`Class.Model`.

Este exemplo de código demonstra a substituição de todos os cópias
 de um modelo de árvore usando `Class.Model:PivotTo()` e `Class.Model:ScaleTo()`. O
 pivô e a escala dos modelos são usados como referência, garantindo que os
 tamanhos e locais relativos dos modelos de substituição correspondam aos dos
 originais.


Modelos contêm um fator de escala canônica persistente, que começa em 1
para modelos recém criados e muda à medida que o modelo é escalado ao chamar
`Class.Model:ScaleTo()`. Esta função retorna o fator de escala canônico atual
do modelo.

O fator de escala atual não impacta _diretamente_ o tamanho das Instâncias
sob o modelo. É usado para fins de autoria de conteúdo e scripting
para lembrar como o modelo foi escalado em relação ao seu tamanho original.

Dentro de uma determinada sessão, o modelo irá armazenar as informações precisas do tamanho
das Instâncias descendentes após a primeira chamada de `Class.Model:ScaleTo()`. Isso significa que
chamar `Class.Model:ScaleTo()|ScaleTo(x)` seguido por
`Class.Model:ScaleTo()|ScaleTo(1)` te devolverá _exatamente_ a
configuração original do modelo sem deriva de ponto flutuante. Evitar
deriva de ponto flutuante é a motivação para ter uma função Scale**To**
e não uma função Scale**By**.

O fator de escala impacta o comportamento do motor de uma forma: O fator de escala
de um modelo será aplicado aos deslocamentos de juntas de
`Class.Animation|Animations` reproduzidas em um `Class.AnimationController`
debaixo daquele modelo, para que rigs animados reproduzam corretamente
animações mesmo quando escaladas.

Model:GetScale

O fator de escala canônico atual do modelo.

Retorna a escala canônica do modelo, que padrão é 1 para modelos recém
criados e mudará à medida que é escalado via
`Class.Model:ScaleTo()`.

Este exemplo de código demonstra como as juntas podem ser feitas usando a
função Model:MakeJoints.

Um modelo é instanciado, com duas partes uma em cima da outra. A parte de cima é
ancorada e a parte de baixo não. Normalmente, quando parentada ao Workspace,
a parte de baixo cairia sobre a Baseplate.

No entanto, como a propriedade TopSurface da parte de baixo está definida como
Enum.SurfaceType.Weld, isso significa que quando Model:MakeJoints é executado,
uma conexão é feita entre elas.

Portanto, a parte de baixo não cai até que as juntas no modelo sejam
quebradas. Isso é frequentemente feito usando Model:BreakJoints, mas neste exemplo a
conexão é quebrada usando uma explosão.


Este exemplo de código demonstra a criação de juntas em duas partes que são
irmãs do script (PartA e PartB). Ele usa MakeJoints em duas partes tocando
com tipos de superfície compatíveis (Studs e Inlet).


A junção baseada em SurfaceType está obsoleta. Não use MakeJoints para novos
projetos. Use `Class.WeldConstraint|WeldConstraints` e
`Class.HingeConstraint|HingeConstraints` em vez disso.

Percorre todas as `Class.BasePart|Parts` no `Class.Model` e cria
juntas entre as partes especificadas e quaisquer superfícies planas de contato,
basedo-se nas superfícies das partes.

- Superfícies suaves não criarão juntas
- Superfícies adesivas criarão uma junta `Class.Glue`
- Weld criará uma junta `Class.Weld` com qualquer superfície, exceto
  Unjoinable
- Studs, Inlet ou Universal criarão cada uma uma junta `Class.Snap` com
  qualquer uma das outras duas superfícies (por exemplo, Studs com Inlet e
  Universal)
- Superfícies de Hinge e Motor criam instâncias de joint `Class.Rotate` e
  `Class.RotateV`

Esta função não funciona se a Parte não for um descendente do
`Class.Workspace`. Portanto, você deve primeiro garantir que o Modelo esteja parentado
no Workspace antes de usar MakeJoints.

Model:MakeJoints

Percorre todas as `Class.BasePart|BaseParts` no `Class.Model`. Se algum
lado de uma parte tiver um SurfaceType que pode fazer uma junta, será criada uma junta
com quaisquer partes adjacentes.

Model:makeJoints

Model:move

location

Este exemplo demonstra como `Class.Model:MoveTo()` evita colisões.

Um simples modelo de duas partes `Class.Model` é criado, e sua `Class.Model.PrimaryPart`
esetada. Uma grande parte de obstrução é colocada ao lado.

Após 5 segundos, `Class.Model:MoveTo()` é usado para direcionar o modelo a se mover
para dentro da parte de obstrução. No entanto, como MoveTo não moverá um modelo para dentro
de uma obstrução, o `Class.Model` é movido para cima no eixo Y e colocado acima
da obstrução.


Move o `Class.Model.PrimaryPart|PrimaryPart` para a posição dada. Se
a parte primária não foi especificada, a parte raiz do modelo será
usada, mas a parte raiz não é determinística e é recomendável que
você sempre defina uma parte primária ao usar `Class.Model:MoveTo()|MoveTo()`.

Se houver quaisquer obstruções onde o modelo deve ser movido, como
`Class.Terrain` ou outras `Class.BasePart|BaseParts`, o modelo será
movido verticalmente para cima até que não haja nada no caminho. Se esse
comportamento não for desejado, `Class.PVInstance:PivotTo()` deve ser usado
em vez disso.

Observe que a rotação não é preservada ao mover um modelo com
`Class.Model:MoveTo()|MoveTo()`. É recomendável usar seja
`Class.Model:TranslateBy()|TranslateBy()` ou `Class.PVInstance:PivotTo()`
se a rotação atual do modelo precisar ser preservada.

Model:MoveTo

position

O `Datatype.Vector3` para onde o `Class.Model` é movido.

Move o `Class.Model.PrimaryPart|PrimaryPart` para a posição dada. Se
a parte primária não foi especificada, a parte raiz do modelo será
usada.

Model:moveTo

Faz com que este modelo não seja mais persistente para o jogador especificado. Isso não
garante que o modelo será imediatamente removido para o jogador; após
chamar este método, o modelo será tratado como
`Enum.ModelStreamingMode|Atomic` para aquele jogador e permanecerá presente
enquanto estiver dentro do raio de streaming alvo.

`Class.Model.ModelStreamingMode|ModelStreamingMode` deve ser definido como
`Enum.ModelStreamingMode|PersistentPerPlayer` para que o comportamento seja
alterado como resultado da remoção.

Model:RemovePersistentPlayer

O `Class.Player` para o qual tornar este modelo não persistente.

Faz com que este modelo não seja mais persistente para o jogador especificado.
`Class.Model.ModelStreamingMode|ModelStreamingMode` deve ser definido como
`Enum.ModelStreamingMode|PersistentPerPlayer` para que o comportamento seja
alterado como resultado da remoção.

Redefine a rotação das partes do modelo para a rotação de identidade definida anteriormente,
que é feita através do método `Class.Model:SetIdentityOrientation()`.

Model:ResetOrientationToIdentity

Modelos contêm um fator de escala canônico persistente, que começa em 1
para modelos recém criados. Esta função escala o modelo, em torno da localização do pivô,
relativo a como pareceria com um fator de escala de 1. Para
realizar isso, faz duas coisas:

- Define o fator de escala atual do modelo para o valor especificado
- Redimensiona e reposiciona todas as Instâncias descendentes de acordo

A escalonamento das localizações é feito em torno da localização do pivô.

Todas as propriedades "geométricas" de Instâncias descendentes serão escalonadas. Isso
obviamente inclui os tamanhos das partes, mas aqui estão alguns outros exemplos de
propriedades que são escalonadas:

- O comprimento de juntas como `Class.WeldConstraint|WeldConstraints`, e
  `Class.RopeConstraint`
- Velocidades e forças físicas como `Class.HingeConstraint`
- Propriedades visuais como tamanhos de emissores de partículas
- Outras propriedades de comprimento como `Class.Sound.RollOffMinDistance`

Model:ScaleTo

newScaleFactor

Define o fator de escala do modelo, ajustando o tamanho e a localização de
todas as Instâncias filhas de modo que tenham esse fator de escala em relação às
suas tamanho e localizações iniciais quando o fator de escala era 1.

Define a rotação de identidade do modelo dado, permitindo que você redefina a
rotação do modelo inteiro mais tarde, através do uso do método
`ResetOrientationToIdentity`.

Model:SetIdentityOrientation

Esta função foi substituída por `Class.PVInstance:PivotTo()` que
atua como uma substituição mais eficiente e não altera o comportamento do seu
código. Use `Class.PVInstance:PivotTo()` para novos trabalhos e migre suas
chamadas existentes `Class.Model:SetPrimaryPartCFrame()` quando for conveniente.

Define o `Class.BasePart.CFrame` da `Class.Model.PrimaryPart` do modelo.
Todas as outras partes do modelo também serão movidas e manterão suas
orientações e offsets em relação ao `Class.Model.PrimaryPart`.

Observe que esta função gerará um erro se não existir uma `Class.Model.PrimaryPart`
para o modelo. Isso pode causar problemas se, por exemplo, a parte primária
nunca foi definida ou foi destruída.

Model:SetPrimaryPartCFrame

cframe

Define o `Class.BasePart.CFrame` da `Class.Model.PrimaryPart` do modelo.
Todas as outras partes do modelo também serão movidas e manterão suas
orientações e offsets em relação ao `Class.Model.PrimaryPart`.

Este exemplo demonstra como `Class.Model:TranslateBy()` ignora colisões
 e respeita a orientação do modelo.

Um simples modelo de duas partes `Class.Model` é criado, rotacionado 45 graus no eixo Y,
e sua `Class.Model.PrimaryPart` é definida. Uma grande parte de obstrução é colocada
 ao lado.

Após 5 segundos, `Class.Model:TranslateBy()` é usado para direcionar o modelo a
 mover-se para dentro da parte de obstrução. O modelo se moverá para dentro da
 obstrução e manterá sua orientação atual.


Desloca um `Class.Model` pelo dado deslocamento `Datatype.Vector3`, preservando
a orientação do modelo. Se outro `Class.BasePart` ou `Class.Terrain`
já existir na nova posição, então o `Class.Model` irá sobrepor
esse objeto.

A tradução é aplicada no espaço mundial em vez de no espaço do objeto,
significando que mesmo se as partes do modelo estiverem orientadas de forma diferente,
ele ainda se moverá ao longo do eixo padrão.

Model:TranslateBy

delta

O `Datatype.Vector3` para traduzir o `Class.Model`.

Desloca um `Class.Model` pelo dado deslocamento `Datatype.Vector3`, preservando
a orientação do modelo. Se outro `Class.BasePart` ou `Class.Terrain`
já existir na nova posição, então o `Class.Model` irá sobrepor
esse objeto.

Model

Define o nível de detalhe no modelo para experiências com a
[streaming](/workspace/streaming) ativado. Malhas composites ou
imposter não suportam física, detecção de colisão ou
raycasting.

Quando definido como `Enum.ModelLevelOfDetail|StreamingMesh`, uma malha
"imposter" de resolução mais baixa (malha colorida e grosseira que envolve todas as partes filhas do
modelo) é renderizada fora do raio de streaming. Não suporta
texturas.

Quando definido como `Enum.ModelLevelOfDetail|SLIM`, um modelo **SLIM**
(Modelo Interativo Leve e Escalável) renderiza uma composição de todas as partes filhas em
resoluções progressivamente mais baixas a distâncias com base no raio de
streaming. Isso melhora muito a qualidade visual em relação a
`Enum.ModelLevelOfDetail|StreamingMesh`.

Quando definido como `Enum.ModelLevelOfDetail|Disabled` ou
`Enum.ModelLevelOfDetail|Automatic`, malhas de resolução mais baixa não serão
displayadas.

Model.LevelOfDetail

Define o nível de detalhe no modelo para experiências com streaming de instâncias
ativado.

Controla como `Class.Model|Models` são transmitidos para dentro e para fora quando o
[streaming](/workspace/streaming) de instâncias está ativado. O comportamento
depende do enum selecionado. Não tem efeito quando o streaming não está ativado.

Esta propriedade só deve ser alterada no Studio através da janela de
[Propriedades](/studio/properties) quando o streaming está
ativado, ou em `Class.Script|Scripts`, mas nunca em
`Class.LocalScript|LocalScripts` (fazer isso pode resultar em comportamento indefinido).

Model.ModelStreamingMode

Controla o comportamento de streaming do modelo em `Class.Model|Models` quando
o streaming de instâncias está ativado.

Este exemplo de código cria e lança um modelo de dado, e então informa se ele
caiu com o lado azul voltado para cima. Se `Class.Model.PrimaryPart` não estiver definido,
o pivô / caixa delimitadora do dado irá girar, pois as partes dentro dele
são simuladas fisicamente durante o lançamento.


Aponta para a parte primária do `Class.Model`. A parte primária é a
`Class.BasePart` que atua como a referência física para o pivô do
modelo. Ou seja, quando as partes dentro do modelo são movidas devido a simulação
física ou outros meios, o pivô se moverá em sincronia com a parte primária.

Observe que `Class.Model|Models` não têm `PrimaryPart` definido por padrão.
Se você estiver criando um modelo que precisa ser afetado pela física,
você deve definir manualmente esta propriedade no Studio ou dentro de um script. Se a
parte primária **não** for definida, o pivô permanecerá na mesma localização no
espaço mundial, mesmo que partes dentro do modelo sejam movidas.

Além disso, observe que ao definir esta propriedade, deve ser uma
`Class.BasePart` que seja um descendente do modelo. Se você tentar definir
`Class.Model.PrimaryPart` para um `Class.BasePart` que **não** seja um
descendente do modelo, ele será definido para essa parte, mas será redefinido para `nil`
durante o próximo passo de simulação &mdash; esse é um comportamento legado para suportar
scripts que assumem que podem temporariamente definir a parte primária para um
`Class.BasePart` que não é um descendente do modelo.

A regra geral para modelos é que:

- Modelos cujas partes estão unidas por juntas físicas como
  `Class.WeldConstraint|WeldConstraints` ou `Class.Motor6D|Motor6Ds`
  devem ter uma parte primária atribuída. Por exemplo, modelos de
  personagens Roblox têm sua `Class.Model.PrimaryPart` definida como a
  **HumanoidRootPart** por padrão.
- Modelos estáticos (geralmente `Class.BasePart.Anchored|Anchored`) que ficam em
  um lugar a menos que um script os mova explicitamente não requerem uma
  `Class.Model.PrimaryPart` e tendem a não se beneficiar de ter uma.

Model.PrimaryPart

A parte primária do `Class.Model`, ou `nil` se não for explicitamente definida.

Definir esta propriedade na janela de Propriedades escalará o modelo como
se `Class.Model:ScaleTo()` tivesse sido chamado nele, escalando todas as Instâncias descendentes
no modelo, como materiais, imagens e a geometria 3D das
partes, de modo que o modelo tenha o fator de escala especificado em relação ao seu
tamanho original.

Esta propriedade está disponível apenas no Studio e gerará um erro se
for usada em um `Class.Script` ou `Class.LocalScript`. `Class.Model:ScaleTo()` e
`Class.Model:GetScale()` devem ser usados a partir de scripts.

Model.Scale

Propriedade exclusiva para editor usada para escalar o modelo em torno de seu pivô. Definir
esta propriedade moverá a escala como se `Class.Model:ScaleTo()` tivesse
sido chamado nela.

Este exemplo de código mostra uma função personalizada para redefinir o pivô de um modelo
para o centro da caixa delimitadora desse modelo.


Esta propriedade determina onde o pivô de um `Class.Model` que **não** tem um `Class.Model.PrimaryPart` definido está localizado. Se o `Class.Model` **tiver** um `Class.Model.PrimaryPart|PrimaryPart`, o pivô do `Class.Model` é igual ao pivô dessa parte primária em vez disso, e esta propriedade `Class.Model.WorldPivot|WorldPivot` é ignorada.

Para um `Class.Model` recém-criado, seu pivô será tratado como o centro da caixa delimitadora de seu conteúdo até a **primeira vez** que sua propriedade `Class.Model.WorldPivot` for definida. Uma vez que o pivô mundial é definido pela primeira vez, é impossível restaurar esse comportamento inicial.

Mais comumente, mover o modelo com as ferramentas do Studio, ou com funções de movimento de modelo como `Class.PVInstance:PivotTo()` e `Class.Model:MoveTo()`, definirá o pivô mundial e, assim, encerrará esse novo comportamento do modelo.

O propósito desse comportamento é permitir que o código Luau obtenha um pivô sensato simplesmente criando um novo modelo e parentando objetos a ele, evitando a necessidade de definir explicitamente `Class.Model.WorldPivot` toda vez que você cria um modelo em código.


Model.WorldPivot

Determina onde o pivô de um `Class.Model` que não tem um
`Class.Model.PrimaryPart` definido está localizado.

Modelos são objetos contêineres, o que significa que eles agrupam objetos juntos. Eles são
melhor utilizados para manter coleções de `Class.BasePart|BaseParts` e possuem um número
de funções que aumentam sua funcionalidade.

Uma `Class.PVInstance` é uma classe abstrata que não pode ser criada. É a
base para todos os objetos que têm uma localização física no mundo.

Este exemplo de código é um script de teletransporte simples que move seu personagem
10&nbsp;studs para frente na direção que você está olhando quando você pressiona
a tecla <kbd>F</kbd>. Ele faz isso obtendo o pivô atual com
`Class.PVInstance:GetPivot()` e chamando `PVInstance|PivotTo` para mover o
personagem para frente.


Esta função obtém o pivô de uma `Class.PVInstance`. Isso é frequentemente utilizado
com `Class.PVInstance:PivotTo()` para mover um modelo.

`Class.Model|Models` e `Class.BasePart|BaseParts` são ambos
`Class.PVInstance|PVInstances` ("Instâncias de Velocidade de Posição") e assim ambos
possuem esta função.

PVInstance:GetPivot

O `Datatype.CFrame` no espaço mundial do pivot da instância.


Obtém o pivô de uma `Class.PVInstance`.

Transforma a `Class.PVInstance` junto com todos os seus descendentes
`Class.PVInstance|PVInstances` de modo que o pivô agora esteja localizado na
`Datatype.CFrame` especificada. Esta é a função principal que deve ser
usada para mover `Class.Model|Models` via script.

`Class.BasePart|BaseParts` são movidos dessa forma ao ter seu
`Datatype.CFrame` transformado pelo deslocamento necessário.
`Class.Model|Models` são movidos dessa forma ao ter seu
`Class.Model.WorldPivot` transformado pelo deslocamento necessário.

Note que, por questões de eficiência, eventos `Class.Object.Changed` não são
disparados para `Class.BasePart.Position|Position` e
`Class.BasePart.Orientation|Orientation` de `Class.BasePart|BaseParts`
movidos desta forma; eles são disparados apenas para `Datatype.CFrame`.

Ao chamar `Class.PVInstance:PivotTo()|PivotTo` em `Class.Model|Models`,
os deslocamentos das partes e modelos descendentes são armazenados em cache, de
modo que chamadas subsequentes a `Class.PVInstance:PivotTo()|PivotTo` no mesmo modelo
dnão acumulam deriva de ponto flutuante entre as partes que compõem o
modelo.

`Class.Model|Models` e `Class.BasePart|BaseParts` são ambos
`Class.PVInstance|PVInstances` ("Instâncias de Velocidade de Posição") e assim ambos
possuem esta função.

PVInstance:PivotTo

targetCFrame

O `Datatype.CFrame` que o pivô da `Class.PVInstance` deve igualar
depois de movê-lo.

Transforma a `Class.PVInstance` junto com todos os seus descendentes
`Class.PVInstance|PVInstances` de modo que o pivô agora esteja localizado na
`Datatype.CFrame` especificada.

PVInstance

Propriedade exclusiva do editor, exibida na janela de Propriedades do Studio como **Posição
Origem** e **Orientação Origem** sob **Transformar**. Seu valor é
o `Datatype.CFrame` no espaço mundial do pivot da instância; lê-lo
retorna o mesmo `Datatype.CFrame` que `Class.PVInstance:GetPivot()`. Ele
não possui valor armazenado próprio e sempre reflete o pivot atual.

Defini-lo a partir da janela de Propriedades move toda a instância para que seu
pivot fique na nova `Datatype.CFrame`, muito parecido com
`Class.PVInstance:PivotTo()`. Editar através da janela de Propriedades
desabilita temporariamente `Class.WeldConstraint|WeldConstraints` para outros
objetos durante o movimento; `PivotTo` não modifica juntas.

Não disponível para scripts; use `Class.PVInstance:GetPivot()` e
`Class.PVInstance:PivotTo()` em tempo de execução em vez disso.


PVInstance.Origin

Propriedade exclusiva do editor que lê e define o `Datatype.CFrame` mundial do
pivot do `Class.PVInstance`, movendo toda a instância quando alterado
na janela de Propriedades do Studio.


Propriedade exclusiva do editor, exibida na janela de Propriedades do Studio como **Posição
Pivot** e **Orientação Pivot** sob **Pivot**. É o
`Datatype.CFrame` do pivot relativo ao próprio quadro da instância.

Alterá-lo a partir da janela de Propriedades move o pivot em relação à
instância enquanto deixa a instância no lugar, ao contrário de `Origem`, que move
toda a instância. Para um `Class.BasePart`, o deslocamento padrão é o
`Datatype.CFrame` identidade, então o pivot coincide com o centro da parte.
Para um `Class.Model`, esta propriedade aparece apenas quando o modelo tem um
`Class.Model.PrimaryPart|PrimaryPart`; ela então reflete e edita o
`Class.BasePart.PivotOffset|PivotOffset` daquela parte, e
`Class.Model:GetPivot()` é um alias do pivot da parte primária.

Não disponível para scripts; scripts leem e escrevem o equivalente através
da classe concreta, como `Class.BasePart.PivotOffset`.


PVInstance.Pivot Offset

Propriedade exclusiva do editor que exibe e edita o `Datatype.CFrame` do pivot
relativo à instância, movendo apenas o pivot e deixando a instância
no lugar.


Classe abstrata para todos os objetos que têm uma localização física no mundo.

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

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


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

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

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

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


Instance.AncestryChanged

child

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


parent

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


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

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

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

local part = Workspace.Part

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

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


Instance.AttributeChanged

attribute

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


Este trecho imprime os nomes dos objetos à medida que são adicionados ao Espaço de Trabalho:


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

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

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

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

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


Instance.ChildAdded

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


Instance.childAdded

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


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

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

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

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


Instance.ChildRemoved

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


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

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

Como ele dispara para cada descendente, parentar um objeto à
`Class.Instance` disparará o evento para este objeto e todos os seus
descendentes individualmente.

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

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


Instance.DescendantAdded

descendant

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


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

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

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

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

#### Aviso

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

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

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Não manipule o pai do descendente nesta função!
	-- Este evento dispara PORQUE o pai foi manipulado, e a mudança ainda não aconteceu
	-- Portanto, é problemático mudar o pai assim:
	descendant.Parent = game
end)

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


Instance.DescendantRemoving

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


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


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

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

O `Class.Instance` nunca será deletado da memória enquanto uma função conectada
estiver ainda usando-o. No entanto, se a função suspender em algum ponto,
o `Class.Instance` e seus descendentes serão parentados a `nil`.

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

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

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

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


Instance.Destroying

Dispara imediatamente antes (ou é adiado até depois) que a instância é
destruída via `Class.Instance:Destroy()`.


Demonstra `Class.Instance.StyledPropertiesChanged`.


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


Instance.StyledPropertiesChanged

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


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

#### Avisos

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

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


Instance:AddTag

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


Instance:children

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

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

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

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

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

part:ClearAllChildren()

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

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

local model = Workspace:FindFirstChild("TestModel")

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


Instance:ClearAllChildren

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


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

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

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

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


Instance:Clone

Uma cópia da instância, ou `nil` se a instância não for
`Class.Instance.Archivable|Archivable`.


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


Instance:clone

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

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

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

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

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

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

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

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


Instance:Destroy

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


Instance:destroy

Retorna o primeiro ancestral do `Class.Instance` cujo
`Class.Instance.Name` é igual ao nome dado.

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

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

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


Instance:FindFirstAncestor

name

O `Class.Instance.Name` a ser procurado.


Retorna o primeiro ancestral do `Class.Instance` cujo
`Class.Instance.Name` é igual ao nome dado.


Retorna o primeiro ancestral do `Class.Instance` cujo
`Class.Object.ClassName` é igual ao className dado.

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

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

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


Instance:FindFirstAncestorOfClass

Retorna o primeiro ancestral do `Class.Instance` cujo
`Class.Object.ClassName` é igual ao className dado.


Instance

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