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

  Para aprender mais sobre o uso de múltiplos Atores para otimizar o performancedo script, veja [Parallel Luau](/scripting/multithreading).

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

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

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

  ```lua
  local actor = script:GetActor()

  -- Imprimir uma mensagem quando uma mensagem de saudação for enviada ao Actor
  -- este script é um descendente de.
  local connection = actor:BindToMessage("Greeting", function(message)
    print("Received Greeting Message:", message)
  end)
  ```

Actor:BindToMessage

topic

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

function

Esse objeto de conexão pode ser usado para desconectar o retorno de chamada Luau de receber mensagens.

Vincula um retorno de chamada Luau a uma mensagem com o tópico especificado.

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

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

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

  ```lua
  local actor = script:GetActor()

  -- Imprimir uma mensagem quando uma mensagem de saudação for enviada ao Actor
  -- este script é um descendente de.
  local connection = actor:BindToMessageParallel("Greeting", function(message)
    print("Received Greeting Message:", message)
  end)
  ```

Actor:BindToMessageParallel

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

  Como um único Actor 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 receber uma mensagem enviada usando `Class.Actor:SendMessage()|SendMessage()`.

  ```lua
  -- Suponha que `actor` seja uma variável local que se refere a uma instância de Actor
  actor:SendMessage("Greeting", "Hello World")
  ```

Actor:SendMessage

O tópico usado para identificar a mensagem a ser sentença / frase

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 seu próprio Subprocesso.

The following sample includes a basic function that takes a table of objects
and parents them into a new Model, returning that Model.

Modelos são objetos de contêiner, o que significa que eles agrupam objetos juntos.Eles são melhores usados para armazenar coleções de `Class.BasePart|BaseParts` e têm uma série de funções que expandem sua funcionalidade.

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

  Modelos cujas partes constituintes sejam combinadas com juntas (para que possam se mover ou serem destruídos por meio de simulação de física) geralmente têm um conjunto `Class.Model.PrimaryPart|PrimaryPart`, pois especifica qual parte dentro do modelo a alavanca e a caixa de contorno "seguirão" à medida que o modelo se move.Modelos estáticos que permanecem em um único local não se beneficiam de ter um conjunto de peças primárias.

  Modelos têm um amplo leque de aplicações, incluindo personagens de jogadores do Roblox.Eles também têm uma série de comportamentos únicos que são importantes para ter em mente:

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

  Como em todos os tipos `Class.Instance` tipos, 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 estiverem sendo acessadas por código executando no cliente, como em um `Class.LocalScript` .Usar `Class.Model.ModelStreamingMode|ModelStreamingMode` com valores como `Enum.ModelStreamingMode|Atomic` pode garantir que todo o modelo 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 for desejada.

Define esse 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 definido para `Enum.ModelStreamingMode|PersistentPerPlayer` para que o comportamento seja alterado como resultado da adição.

Model:AddPersistentPlayer

playerInstance

O `Class.Player` para tornar esse modelo persistente.

Define esse 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.

In this sample the joints in every Player character Model added will be broken
3 seconds after spawning. Breaking these joints will cause the Humanoid to
die.

This code sample demonstrates manual creation of joints on two parts that are
siblings of the script (PartA and PartB). It creates a joints on two touching
parts with compatible surface types (Studs and Inlet).

Quebra 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 personagem de Jogador `Class.Model`, o personagem de `Class.Humanoid` morrerá enquanto depende do joelho de pescoço.

  Observe que, embora as articulações produzidas por conexões de superfície com Partes adjacentes possam ser tecnicamente recriadas usando `Class.Model:MakeJoints()`, isso só recriará articulações produzidas por superfícies.Desenvolvedores não devem confiar nisso como segue as articulações sendo quebradas peças podem não estar mais em contato umas com as outras.

Model:BreakJoints

Quebra 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` .

Essa função retorna uma descrição de um volume que contém todos os `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.Refletindo o comportamento de `Class.Terrain:FillBlock()` , ele retorna um `Datatype.CFrame` representando o centro da caixa de delimitação e um `Datatype.Vector3` representando seu tamanho.

  Se não houver `Class.Model.PrimaryPart|PrimaryPart` para o modelo, a caixa de delimitação será alinhada com os eixos do mundo.

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

  local model = Workspace.Model
  local part = Workspace.Part
  local orientation, size = model:GetBoundingBox()

  -- Redimensionar e posicionar a peça igual à caixa de modelo
  part.Size = size
  part.CFrame = orientation
  ```

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.

The code sample below demonstrates how Model.GetExtentsSize can be used to get
the size of the bounding box containing the parts.

Retorna o tamanho da caixa de contorno mais pequena que contém todo o `Class.BasePart|BaseParts` na `Class.Model`.Se `Class.Model.PrimaryPart` existir, então a caixa de borda será alinhada àquela parte.Se uma parte primária não foi definida, a função escolherá uma parte no modelo para alinhar a caixa de borda.Como a seleção dessa parte não é determinística, é recomendado definir um `Class.Model.PrimaryPart` para obter resultados consistentes com essa função.

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

Model:GetExtentsSize

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

Retorna o tamanho da caixa de contorno mais pequena que contém todo o `Class.BasePart|BaseParts` na `Class.Model`, alinhado com o `Class.Model.PrimaryPart` se for definido.

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

Model:GetModelCFrame

Este código criaria um modelo, colocaria algumas partes nele, posicioná-las aleatoriamente e, em seguida, 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` persistentes para os quais este modelo é persistente.Quando chamado a partir de um `Class.LocalScript` , este método verifica apenas se este modelo é persistente para o `Class.Players.LocalPlayer|LocalPlayer` .

Model:GetPersistentPlayers

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

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

The following code demonstrates how GetPrimaryPartCFrame and
SetPrimaryPartCFrame can be used to rotate a model.

A simple model is created in the Workspace and a loop is started that will
rotate the model 10 degrees around the Y axis every 0.2 seconds.

Essa função foi substituída por `Class.PVInstance:GetPivot()` que atua como substituto e não altera o comportamento do seu código.Use `Class.PVInstance:GetPivot()` para novo trabalho e migre suas chamadas existentes `Class.Model:GetPrimaryPartCFrame()` quando conveniente.

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

  Essa função é equivalente ao seguinte.

  Modelo.PrimaryPart.CFrame

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

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

Model:GetPrimaryPartCFrame

Retorna o `Datatype.CFrame` do modelo de `Class.Model.PrimaryPart`. Esta função irá lançar um erro se não existir uma parte primária para o `Class.Model`.

This code sample demonstrates substituting in a replacement for all the copies of a tree model using PivotTo and ScaleTo. The pivot and scale of the models are used as a reference ensuring that the relative sizes and locations of the replacement models match those of the originals.

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

  O fator de escala atual não tem *direto* impacto no tamanho das Instâncias sob o modelo.É usado para fins de autoria de conteúdo e programação para lembrar como o modelo foi escalado em relação ao seu tamanho original.

  Dentro de uma sessão dada, o modelo armazenará as informações precisas de tamanho original das Instâncias descendentes após a primeira chamada `Model/ScaleTo`.Isso significa que chamar `ScaleTo(x)` seguido por `ScaleTo(1)` vai te trazer de volta *exatamente* a configuração original do modelo sem derivação de ponto flutuante.Evitar a derivação de ponto flutuante é a motivação para ter uma função Escala **Para** em vez de uma função Escala **Por** .

  O fator de escala impacta o comportamento do motor em uma maneira: o fator de escala de um modelo será aplicado a deslocamentos conjuntos de `Class.Animation|animations` jogados em um `Class.AnimationController` sob esse modelo, para que os rigs animados reproduzam corretamente as animações mesmo quando escalados.

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 for escalado via `Model/ScaleTo`.

This code sample demonstrates how joints can be made using the
Model:MakeJoints function.

A model is instanced, with two parts on top of each other. The top part is
anchored and the bottom part is not. Normally, when parented to the Workspace
the bottom part would fall to the Baseplate.

However, as TopSurface property of the bottom part is set to
Enum.SurfaceType.Weld, this means that when Model:MakeJoints is ran a
connection is made between them.

Therefore the bottom part does not drop until the joints in the model are
broken. This is often done using Model:BreakJoints, but in this example the
connection is broken using an explosion.

Este exemplo de código mostra a criação de juntas em duas partes que são irmãs do script (ParteA e ParteB).Ele usa MakeJoints em duas peças tocantes com tipos de superfície compatíveis (Studs e Inlet).

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

  Passa por todo o `Class.BasePart|Parts` na `Class.Model` e cria juntas entre as Peças especificadas e quaisquer superfícies de contato planas, dependendo das superfícies das peças.

  *   Superfícies lisas não criarão juntas
  *   Superfícies de cola criarão uma junta `Class.Glue`
  *   A solda criará uma junta `Class.Weld` com qualquer superfície, exceto Inseparável
  *   Studs, Inlet ou Universal cada um criará uma junta `Class.Snap` com qualquer uma das outras duas superfícies (por exemplo, Studs com Inlet e Universal)
  *   Superfícies de dobradiça e motor criam instâncias conjuntas `Class.Rotate` e `Class.RotateV`

  Essa função não funciona se a Peça não for descendente de `Class.Workspace`.Portanto, você deve primeiro garantir que o Modelo esteja ligado ao Workspace antes de usar o MakeJoints.

Model:MakeJoints

Passa por todo o `Class.BasePart|BaseParts` na `Class.Model`.Se algum lado de uma peça tiver um tipo de superfície que possa fazer uma junta, ela criará uma junta com quaisquer peças adjacentes.

This sample demonstrates how Model:MoveTo avoids collisions.

A simple two part Model is created, and its PrimaryPart is set. An large
obstruction part is placed next to it.

After 5 seconds Model:MoveTo is used to direct the model to move inside the
obstruction part. However, as MoveTo will not move a model inside of an
obstruction the Model is moved up on the Y axis and placed above the
obstruction.

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

  Se houver qualquer obstrução onde o modelo deve ser movido, como `Class.Terrain` ou outro `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()` .Recomenda-se usar `Class.Model:TranslateBy()|TranslateBy()` ou `Class.PVInstance:PivotTo()` se a rotação atual do modelo precisar ser preservada.

Model:MoveTo

position

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

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

Torna esse modelo não persistente mais para o jogador especificado.Isso não garante que o modelo será imediatamente removido para o jogador; depois de chamar esse 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 para `Enum.ModelStreamingMode|PersistentPerPlayer` para que o comportamento seja alterado como resultado da remoção.

Model:RemovePersistentPlayer

O `Class.Player` para tornar esse modelo não persistente mais.

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

Redefine a rotação das peças do modelo para a rotação de identidade previamente definida, 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.Essa função escala o modelo, em torno da localização de pivô, em relação a como ele olharia para um fator de escala de 1.Para realizar isso, ele 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 de locais é feito em torno da localização de pivô.

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

  *   O comprimento de juntas como `Class.WeldConstraint|WeldConstraints` e `Class.Rope|Ropes`
  *   Velocidades e forças físicas como `Hinge.MaxServoTorque`
  *   Propriedades visuais como tamanhos de emissores de partículas
  *   Outras propriedades de comprimento como `Sound.RollOffMinDistance`

Model:ScaleTo

newScaleFactor

Define o fator de escala do modelo, ajustando o tamanho e a localização de todas as Instâncias descendentes de modo que elas tenham esse fator de escala em relação aos seus tamanhos e locais iniciais quando o fator de escala era 1.

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

Model:SetIdentityOrientation

Essa 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 novo trabalho e migre suas chamadas existentes `Class.Model:SetPrimaryPartCFrame()` quando conveniente.

  Define o `Class.BasePart.CFrame` do modelo `Class.Model.PrimaryPart`.Todas as outras partes no modelo também serão movidas e manterão sua orientação e deslocamento em relação ao `Class.Model.PrimaryPart`.

  Observe, essa função irá lançar um erro se não existir `Class.Model.PrimaryPart` nenhuma para o modelo.Isso pode causar problemas se, por exemplo, a parte principal nunca foi definida ou foi destruída.

Model:SetPrimaryPartCFrame

cframe

Define o `Class.BasePart.CFrame` do modelo `Class.Model.PrimaryPart`.Todas as outras partes no modelo também serão movidas e manterão sua orientação e deslocamento em relação ao `Class.Model.PrimaryPart`.

This sample demonstrates how Model:TranslateBy ignores collisions and respects
the orientation of the model.

A simple two part Model is created, rotated 45 degrees on the Y axis, and its
PrimaryPart is set. An large obstruction part is placed next to it.

After 5 seconds Model:TranslateBy is used to direct the model to move inside
the obstruction part. The model will move inside of the obstruction and
maintain it's current orientation.

Muda um `Class.Model` por o deslocamento dado `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` vai sobrepor o objeto dito.

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

Model:TranslateBy

delta

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

Muda um `Class.Model` por o deslocamento dado `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` vai sobrepor o objeto dito.

Model:breakJoints

Model:makeJoints

Model:move

location

Model:moveTo

Model

Define o nível de detalhe no modelo para experiências com streaming de instância [ativado](/workspace/streaming).

  Quando definido para `Enum.ModelLevelOfDetail|StreamingMesh` , uma malha de "impostor" de resolução mais baixa (colorida, malha grossa que envolve todas as partes filhas do modelo) rende fora do raio de streaming.

  Quando definido para `Enum.ModelLevelOfDetail|Disabled` ou `Enum.ModelLevelOfDetail|Automatic`, malhas de resolução inferior não serão exibidas.

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 a instância [streaming](/workspace/streaming) for ativada.O comportamento depende do enum selecionado.Não tem efeito quando o streaming não está ativado.

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

Model.ModelStreamingMode

Controla o comportamento de streaming de modelo em `Class.Model|Models`.

This code sample creates and throws a dice model, then outputs whether it
landed with the blue side facing up. If `Class.Model.PrimaryPart` was not set,
the pivot / bounding box of the dice would rotate, as the parts inside of it
are physically simulated during the roll.

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

  Observe que `Class.Model|Models` não tem `PrimaryPart` definido por padrão.Se você estiver criando um modelo que precisa ser atuado pela física, você deve definir manualmente essa propriedade no Studio ou dentro de um script.Se a parte principal não for **definida** , o pivô permanecerá no mesmo local no espaço do mundo, mesmo que as partes dentro do modelo sejam movidas.

  Observe também que ao definir essa propriedade, deve ser um `Class.BasePart` que é um descendente do modelo.Se você tentar definir `Class.Model.PrimaryPart` para um `Class.BasePart` que é **não** um descendente do modelo, ele será definido para essa parte, mas redefinido para `nil` durante o próximo passo de simulação — este é o comportamento legado para suportar scripts que presumem que podem definir temporariamente a parte principal para um `Class.BasePart` que não é um descendente do modelo.

  A regra geral para modelos é que:

  *   Modelos cujas partes sejam combinadas através de juntas físicas, como `Class.WeldConstraint|WeldConstraints` ou `Class.Motor6D|Motor6Ds`, devem ter uma parte primária atribuída.Por exemplo, os modelos de personagens do Roblox têm seu `Class.Model.PrimaryPart` definido para o **HumanoidRootPart** por padrão.
  *   Modelos estáticos (normalmente `Class.BasePart.Anchored|Anchored` ) que permanecem em um lugar a menos que um script os mova explicitamente não requerem um `Class.Model.PrimaryPart` e tendem a não se beneficiar de ter um conjunto.

Model.PrimaryPart

A parte principal do `Class.Model` ou `nil` se não for explicitamente definida.

Definir esta propriedade na janela Propriedades escalará o modelo como se `Model/ScaleTo` fosse chamado sobre ele, escalando todas as Instâncias descendentes no modelo, como materiais, imagens e a geometria 3D de peças, para que o modelo tenha o fator de escala especificado em relação ao seu tamanho original.

  Essa propriedade está disponível apenas no Studio e causará um erro se usada em um `Script` ou `LocalScript`.`Model/ScaleTo` e `Model/GetScale` devem ser usados a partir de scripts.

Model.Scale

Propriedade exclusiva do editor usada para escalar o modelo em torno de seu pivô. Definir essa propriedade moverá a escala como se `Model/ScaleTo` fosse chamada sobre ela.

This code sample shows a custom function for resetting the pivot of a model
back to the center of that model's bounding box.

Essa propriedade determina onde está localizado o pivô de um que não tem um conjunto não definido.Se o `Class.Model` **faz** tem 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 recém-criado , seu pivô será tratado como o centro da caixa de delimitação de seus conteúdos até que a propriedade primeira vez seja definida.Uma vez que o pivô mundial é definido pela primeira vez, é impossível restaurar esse comportamento inicial.

  Na maioria das vezes, 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 objetivo desse comportamento é permitir que o código Luau obtenha um pivô sensato simplesmente criando um novo modelo e associando objetos a ele, evitando a necessidade de definir explicitamente `Class.Model.WorldPivot`.

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

  local model = Instance.new("Model")
  Workspace.BluePart.Parent = model
  Workspace.RedPart.Parent = model
  model.Parent = Workspace

  print(model:GetPivot())  -- Currently equal to the center of the bounding box containing "BluePart" and "RedPart"

  model:PivotTo(CFrame.new(0, 10, 0))  -- This works without needing to explicitly set "model.WorldPivot"
  ```

Model.WorldPivot

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

Modelos são objetos de contêiner, o que significa que eles agrupam objetos juntos.Eles são melhores usados para armazenar coleções de `Class.BasePart|BaseParts` e têm uma série de funções que expandem sua funcionalidade.

Um `Class.PVInstance` ("Instância de Velocidade de Posição") é 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, especificamente `Class.BasePart|BaseParts` e `Class.Model|Models`.

Este exemplo de código é um simples script de teletransporte que move seu personagem 10 studs para frente na direção que você está atualmente enfrentando quando 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 a frente.

Essa função obtém o pivô de um `Class.PVInstance` . Isso é frequentemente usado 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, portanto, ambos têm essa função.

PVInstance:GetPivot

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

Transforma o `Class.PVInstance` ao longo de todos os seus descendentes `Class.PVInstance|PVInstances` de modo que o pivô agora está localizado no `Datatype.CFrame` especificado.Esta é a função principal que deve ser usada para mover `Class.Model|Models` via scripting.

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

  Observe que, para fins 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 dessa maneira; eles são disparados apenas para `Datatype.CFrame` .

  Ao chamar `Class.PVInstance:PivotTo()|PivotTo` em `Class.Model|Models` , os deslocamentos das peças descendentes e modelos são armazenados, de modo que chamadas subsequentes a `Class.PVInstance:PivotTo()|PivotTo` no mesmo modelo não acumulam débito de ponto flutuante entre as peças 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, portanto, ambos têm essa função.

PVInstance:PivotTo

targetCFrame

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

Transforma o `Class.PVInstance` ao longo de todos os seus descendentes `Class.PVInstance|PVInstances` de modo que o pivô agora está localizado no `Datatype.CFrame` especificado.

PVInstance

PVInstance.Origin

PVInstance.Pivot Offset

Classe abstrata para todos os objetos que têm uma localização física no mundo, especificamente `Class.BasePart|BaseParts` e `Class.Model|Models`.

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

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

Demonstrates detecting changes to an instance's ancestry by connecting to the `Class.Instance.AncestryChanged` event.

The ChangingPart's Parent is set to different values overtime. The parent of the part is the part's ancestor, so the `Class.Instance.AncestryChanged` event will fire whenever it changes.

Incêndios quando a propriedade `Class.Instance.Parent` do objeto ou uma de suas ancestrais é alterada.

  Este evento inclui dois parâmetros: `child` refere-se ao `Class.Instance` cujo `Class.Instance.Parent` foi realmente alterado, enquanto `parent` refere-se ao novo `Class.Instance.Parent` desta instância.

  Você pode usar esse evento para rastrear a exclusão de uma instância no Studio, como 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

O `Class.Instance` cujo `Class.Instance.Parent` foi alterado.

parent

O novo `Class.Instance.Parent` da `Class.Instance` cujo `Class.Instance.Parent` foi alterado.

Incêndios quando a propriedade `Class.Instance.Parent` do objeto ou uma de suas ancestrais é alterada.

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

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

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

  local part = Workspace.Part

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

  part.AttributeChanged:Connect(attributeChanged)
  ```

  Veja também `Class.Instance:GetAttributeChangedSignal()` que retorna um evento que dispara quando um atributo específico for modificado.

Instance.AttributeChanged

attribute

Incêndios sempre que um atributo é alterado no `Class.Instance`.

This snippet prints the names of objects as they are added to the Workspace:

Incêndios após um objeto ser associado a este `Class.Instance` .

  Observe, ao usar essa função em um cliente para detectar objetos criados pelo servidor, é necessário usar `Class.Instance:WaitForChild()`.Isso ocorre porque o objeto e seus descendentes não são garantidos de se replicarem do servidor para o cliente simultaneamente.Por exemplo:

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

  Workspace.ChildAdded:Connect(function(child)
  	-- Use WaitForChild() since descendants may not have replicated yet
  	local head = child:WaitForChild("Head")
  end)
  ```

  Observe, essa função só funciona para filhos imediatos do `Class.Instance`. Para uma função que captura todos os descendentes, use `Class.Instance.DescendantAdded` .

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

Instance.ChildAdded

Incêndios após um objeto ser associado a este `Class.Instance` .

This snippet prints the names of objects as they are removed from the
Workspace:

Incêndios após uma criança ser removida deste `Class.Instance` .

  Removido se refere a quando o pai de um objeto é alterado deste `Class.Instance` para algo diferente deste `Class.Instance`.Observe, este evento também será disparado quando uma criança for destruída (usando `Class.Instance:Destroy()` ) pois a função de destruição define o pai de um objeto para `nil` .

  Essa função só funciona para filhos imediatos do `Class.Instance`. Para uma função que captura todos os descendentes, use `Class.Instance.DescendantRemoving`.

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

Instance.ChildRemoved

Incêndios após uma criança ser removida deste `Class.Instance` .

O seguinte exemplo imprimirá o nome de qualquer objeto que seja adicionado ao Espaço de Trabalho:

Este evento é acionado após um descendente ser adicionado ao `Class.Instance`.

  Ao disparar para cada descendente, cuidar de um objeto para o `Class.Instance` disparará o evento para esse objeto e todos os seus descendentes individualmente.

  Se você está apenas preocupado com as crianças diretas **do** da `Class.Instance`, use `Class.Instance.ChildAdded`.

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

Instance.DescendantAdded

descendant

Incêndios após um descendente for adicionado ao `Class.Instance`.

The following example prints the name of any descendant as it is being removed
from the Workspace:

Este evento dispara **imediatamente antes de** as alterações do pai `Class.Instance` para que uma instância **descendente** não seja mais descendente.`Class.Instance:Destroy()|Destroy()` altera o `Class.Instance.Parent|Parent` de uma instância para `nil`, então chamar esse método em um descrente do pai fará com que esse evento seja disparado.

  Como este evento dispara **antes de** a remoção do descendente, o pai do descendente será mantido inalterado no momento do disparo deste evento.Se o descrente também for uma criança direta do pai, este evento será disparado antes de .

  Se um descendente tem filhos, este evento dispara 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 outra coisa falhará.Abaixo está um exemplo que demonstra isso:

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

  Workspace.DescendantRemoving:Connect(function(descendant)
  	-- Do not manipulate the parent of the descendant in this function!
  	-- This event fires BECAUSE the parent was manipulated, and the change hasn't happened yet
  	-- Therefore, it is problematic to change the parent like this:
  	descendant.Parent = game
  end)

  local part = Instance.new("Part")
  part.Parent = Workspace
  part.Parent = nil
  ```

  Veja também `Class.Instance.DescendantAdded|DescendantAdded` .

Instance.DescendantRemoving

Incêndios imediatamente antes de um descendente do `Class.Instance` ser removido.

This sample demonstrates how, when using Immediate signal behavior, an Instance being destroyed remains in place until the connected function yields.

This sample demonstrates how, when using Deferred signal behavior,
an Instance is destroyed before the signal fires.

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

  Se a propriedade `Class.Workspace.SignalBehavior` for definida como `Enum.SignalBehavior.Immediate`, este evento é disparado imediatamente antes que o `Class.Instance` ou um de seus ancestrais seja destruído com `Class.Instance:Destroy()`.

  Se a propriedade `Class.Workspace.SignalBehavior` for definida como `Enum.SignalBehavior.Deferred`, este evento será disparado no próximo ponto de retomada, que será depois que o `Class.Instance` ou um de seus ancestrais for 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 retorno de chamada possa ser chamado (o que significa que não será executado).

  Ao excluir um `Class.Instance` em 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

Incêndios imediatamente antes (ou são adiados até depois) que a instância seja destruída via `Class.Instance:Destroy()` .

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

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

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

  local function stylePropertyChanged()
  	print("Styled properties changed")
  end

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

Instance.StyledPropertiesChanged

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

Instance.childAdded

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

  ##### Avertimentos

  *   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, pois o servidor replica todas as tags juntas e substitui as tags anteriores.

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

Instance:AddTag

Essa função destrói todos os filhos e descendentes de uma instância.

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

  -- Add some sparkles
  for i = 1, 3 do
  	local sparkles = Instance.new("Sparkles")
  	sparkles.Parent = part

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

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

  part:ClearAllChildren()

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

  Se você não deseja destruir **todas** as crianças e descendentes, use `Class.Instance:GetChildren()` ou `Class.Instance:GetDescendants()` para percorrer essas crianças/descendentes e selecionar o que deve destruir.Por exemplo, o seguinte código de exemplo 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

Essa função destrói todos os filhos de uma instância.

Demonstrates cloning a model using `Class.Instance:Clone()`.

`Clone()` cria uma cópia de uma instância e todos os seus descendentes, ignorando todas as instâncias que não são `Class.Instance.Archivable|Archivable` .A cópia da instância raiz é retornada por este método e seu `Class.Instance.Parent|Parent` é definido como `nil` .Observe que, se a própria instância tiver `Class.Instance.Archivable|Archivable` definido para `false`, essa função 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 da propriedade 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 um objeto que não foi **clonado** , o mesmo valor é mantido na cópia.

Instance:Clone

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

Demonstrates destroying a Part using the `Class.Instance:Destroy()` function.

This function is the correct way to dispose of objects that are no longer required.

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

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

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

  ```lua
  local part = Instance.new("Part")
  part.Name = "Hello, world"
  part:Destroy()
  -- Não faça isso:
  print(part.Name)  --> "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 temporariamente remover um objeto em vez de destruí-lo, defina para >.Por exemplo:

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

  object.Parent = nil
  task.wait(2)
  object.Parent = Workspace
  ```

  Para destruir um objeto após um período de tempo definido, use `Class.Debris:AddItem()` .

Instance:Destroy

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

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

  Essa função funciona em direção ao topo, o que significa que ela começa no imediato da instância `Class.Instance.Parent` e funciona em direção ao `Class.DataModel`.Se nenhum ancestral correspondente for encontrado, ele retorna `nil` .

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

  ```
  local car = object:FindFirstAncestor("Car")
  ```

  Para variantes dessa função que encontram ancestrais de uma classe específica, consulte `Class.Instance:FindFirstAncestorOfClass()` e `Class.Instance:FindFirstAncestorWhichIsA()`.

Instance:FindFirstAncestor

name

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 à classe dada.

  Essa função funciona em direção ao topo, o que significa que ela começa no imediato da instância `Class.Instance.Parent` e funciona em direção ao `Class.DataModel`.Se nenhum ancestral correspondente for encontrado, ele retorna `nil` .

  Um uso comum dessa função é encontrar o `Class.Model` a `Class.BasePart` pertence. Por exemplo:

  ```
  local model = part:FindFirstAncestorOfClass("Model")
  ```

  Essa função é 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 de respeitar a herança de classe.

Instance:FindFirstAncestorOfClass

className

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

Retorna o primeiro ancestral do `Class.Instance` cujo `Class.Object.ClassName` é igual à classe dada.

Retorna o primeiro ancestral do `Class.Instance` para quem `Class.Object:IsA()` retorna verdadeiro para a classe dada.

  Essa função funciona em direção ao topo, o que significa que ela começa no imediato da instância `Class.Instance.Parent` e funciona em direção ao `Class.DataModel`.Se nenhum ancestral correspondente for encontrado, ele retorna `nil` .

  Ao contrário de `Class.Instance:FindFirstAncestorOfClass()`, esta função usa `Class.Object:IsA()` que respeita a herança de classe. Por exemplo:

  ```
  print(part:IsA("Part"))  --> true
  print(part:IsA("BasePart"))  --> true
  print(part:IsA("Instance"))  --> true
  ```

  Portanto, o seguinte exemplo de código retornará o primeiro ancestral `Class.BasePart` , independentemente de se ele é um `Class.WedgePart` , `Class.MeshPart` ou `Class.Part`.

  ```
  local part = object:FindFirstAncestorWhichIsA("BasePart")
  ```

  Veja também `Class.Instance:FindFirstAncestor()` .

Instance:FindFirstAncestorWhichIsA

Retorna o primeiro ancestral do `Class.Instance` para quem `Class.Object:IsA()` retorna verdadeiro para a classe dada.

O abaixo procuraria no Espaço de Trabalho por um nome de objeto "Tijolo". Se encontrado, mudaria o nome do objeto para "Foo".

Retorna o primeiro filho do `Class.Instance` com o nome dado, ou `nil` se não existir tal filho.Se o argumento opcional `recursive` for `true`, esta função pesquisa todos os descendentes em vez de apenas os filhos imediatos do `Class.Instance`.

  ##### Verificando a existência de um objeto

  `FindFirstChild()` é necessário se você precisar verificar se um objeto existe antes de continuar.Tentar indexar uma criança por nome usando o operador ponto lança um erro se a criança não existir.

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

  -- Os seguintes erros de linha ocorrem se a peça não existir no espaço de trabalho
  Workspace.Part.Transparency = 0.5
  ```

  Uma abordagem melhor é usar `FindFirstChild()` para verificar primeiro `Part` , então usar uma declaração `if` para executar código que precisa dela.

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

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

  ##### Encontrando uma criança cujo nome corresponde a uma propriedade

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

  No seguinte exemplo, um `Class.Folder` chamado `Color` é adicionado a um `Class.Part`, que também tem a propriedade `Class.Part.Color`.Observe que `part.Color` refere-se ao valor da propriedade `Datatype.Color3` , não à instância filha `Class.Folder`.Um benefício de usar `Class.Instance:FindFirstChild()|FindFirstChild()` é que a introdução de novas propriedades não impõe um risco ao seu código.

  ```lua
  local part = Instance.new("Part")
  local folder = Instance.new("Folder")
  folder.Name = "Color"
  folder.Parent = part
  local c1 = part.Color  -- Propriedade
  local c2 = part:FindFirstChild("Color")  -- The child folder
  ```

  ##### Notas de desempenho

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

Instance:FindFirstChild

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

recursive

Se a pesquisa deve ser conduzida recursivamente ou não.

Retorna o primeiro filho do `Class.Instance` encontrado com o nome dado.

Retorna o primeiro filho do `Class.Instance` cujo `Class.Object.ClassName|ClassName` é igual ao dado `className` .Ao contrário de `Class.Instance:FindFirstChildWhichIsA()`, esta função retorna apenas objetos cuja classe corresponda a `className`, ignorando a herança de classe.Se nenhuma criança correspondente for encontrada, esta função retorna `nil` .

Instance:FindFirstChildOfClass

Retorna o primeiro filho do `Class.Instance` cujo `Class.Object.ClassName|ClassName` é igual ao nome da classe dado.

Instance

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

Actor

Resumo

Propriedades

Propriedades

Propriedades

Métodos

Métodos

Métodos

Eventos

Propriedades

Métodos

Eventos