A Flag é uma unidade gerada com um objeto `Class.FlagStand`, e irá reaparecer
quando capturada. Quando um jogador toca na Handle deste objeto, que deve ser um
filho do objeto Flag, que é uma Parte chamada "Handle", a bandeira será
adicionada à mochila do jogador e aparecerá em sua mão. Um jogador não pode
selecionar outras armas enquanto estiver carregando uma bandeira, e pode soltar a
bandeira a qualquer momento pressionando "Backspace" no teclado. Se o jogador
que está carregando uma bandeira pisa em outro FlagStand de uma cor de equipe
diferente, a bandeira será removida da mochila do jogador e um ponto será adicionado
às leaderstats do usuário, se fornecido. A bandeira irá então regenerar no
FlagStand original.


Flag

A `Class.Team` para a qual esta bandeira é destinada. Corresponde às TeamColors no
serviço `Class.Teams`.

Os objetos `Class.Flag` e `Class.FlagStand` foram criados para permitir
que os desenvolvedores criem jogos no estilo 'capture the flag' rapidamente.


Flag.TeamColor

A `Class.Team` para a qual esta bandeira é destinada. Corresponde às TeamColors no
serviço `Class.Teams`.


O objeto Flag ajuda você a criar jogos no estilo 'capture the flag'.


Este código deve ser colocado em um Script dentro de uma Ferramenta. Ele permite que um jogador
coloque explosões ao equipar a ferramenta e clicar no chão. Isso é feito
definindo uma função, `explode`, que cria uma explosão não letal em
um ponto dado. Em seguida, define uma função, `onActivated`, que é executada quando a
ferramenta é ativada. Finalmente, conecta o evento Activated da ferramenta ao
função `onActivated`.

Para testar este código, tente criar uma Ferramenta e coloque uma Parte dentro dela. Nomeie a
Parte como "Handle". Em seguida, coloque um Script dentro da Ferramenta e cole o código nele.
Por fim, coloque a Ferramenta no StarterPack.

Este exemplo de código é para um objeto Ferramenta com uma Parte chamada Handle. Ele detecta
quando Humanos que não são o portador atual atingem o punho, e causa algum
dano a eles. Além disso, quando a Ferramenta é ativada, ela ativa uma animação de corte
nos scripts de animação padrão do personagem. Experimente este script criando
um objeto Ferramenta no StarterPack. Coloque uma Parte dentro dela e nomeie-a
Handle. Cole este código em um Script dentro da Ferramenta, e então tente cortar
outro Humano!

Um `Tool` é um objeto que um objeto `Class.Humanoid` pode equipar. Para jogadores,
estes são armazenados em um objeto `Class.Backpack` parentado a um objeto `Class.Player`
. Durante a experiência, os jogadores podem ter várias ferramentas que aparecem como ícones
na parte inferior da tela. Equipar uma ferramenta move-a do
`Class.Backpack` para um modelo `Class.Player.Character` no
`Class.Workspace`. Por padrão, as ferramentas são seguradas na mão direita e possuem um
punho nelas, que é uma `Class.BasePart` nomeada `Handle` dentro (embora
um não seja necessário se `Class.Tool.RequiresHandle` for `false`). Ferramentas que devem
ser fornecidas para jogadores (re)entrantes devem ser armazenadas no
`Class.StarterPack`.


Este evento dispara quando o jogador clica enquanto o `Class.Tool` está
equipado. Ele **não** é disparado se a tecla <kbd>Ctrl</kbd> estiver pressionada durante
o clique.

Este evento é normalmente usado para realizar uma ação quando o jogador usa a
tool, por exemplo, lançar um foguete de uma ferramenta de lançador de foguetes.

O código abaixo, quando colocado em um `Class.LocalScript`, cria uma ferramenta na
`Class.Backpack` do jogador local e imprime "Tool activated" quando o
jogador clica enquanto a ferramenta criada está equipada.

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

local tool = Instance.new("Tool")
tool.RequiresHandle = false
tool.Parent = Players.LocalPlayer.Backpack

function onActivation()
	print("Tool activated")
end

tool.Activated:Connect(onActivation)
```


Tool.Activated

Dispara quando o jogador clica enquanto a ferramenta está equipada.


Este evento dispara quando o jogador solta o clique enquanto o
`Class.Tool` está equipado e ativado. Ele é tipicamente usado para realizar uma
ação quando o jogador para de usar uma ferramenta.

O código abaixo, quando colocado em um `Class.LocalScript`, cria uma ferramenta na
`Class.Backpack` do jogador local e imprime "Tool deactivated" quando o
jogador solta o clique enquanto a ferramenta está equipada e ativada.

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

local tool = Instance.new("Tool")
tool.RequiresHandle = false
tool.Parent = Players.LocalPlayer.Backpack

function toolDeactivated()
	print("Tool deactivated")
end

tool.Deactivated:Connect(toolDeactivated)
```


Tool.Deactivated

Dispara quando o jogador solta o clique enquanto a ferramenta está equipada e
ativada.


O exemplo mostrado abaixo imprimirá "Uma ferramenta foi equipada" cada vez que a ferramenta for
equipada pelo jogador. Por favor, note que o exemplo abaixo assume que você já definiu o que "Ferramenta" é.

Este evento dispara quando um jogador equipa o `Class.Tool` (retira-o da
`Class.Backpack`).

O oposto deste evento, `Class.Tool.Unequipped`, pode ser usado para
determinar quando o jogador unequipa a ferramenta ao colocá-la em sua
mochila.

Observe que este evento **não** dispara quando `Class.Tool.RequiresHandle` está
ativado e nenhum punho está presente.


Tool.Equipped

mouse

Dispara quando a ferramenta é equipada.


Este evento dispara quando um jogador des equipa o `Class.Tool` (coloca-o em
sua `Class.Backpack`).

O oposto deste evento, `Class.Tool.Equipped`, pode ser usado para
determinar quando o jogador equipa a ferramenta ao retirá-la da
mochila.

Observe que este evento **não** dispara quando `Class.Tool.RequiresHandle` está
ativado e nenhum punho está presente.


Tool.Unequipped

Dispara quando a ferramenta é desquipada.


O código abaixo cria uma `Class.Tool` na `Class.Backpack` do jogador local
que torna o jogador invisível quando ativado e visível quando desativado.

Quando equipado, o script simula a ativação da ferramenta e torna o
jogador invisível por 3 segundos e depois simula a desativação da ferramenta.
Segurar o botão esquerdo do mouse torna o jogador invisível por até 3
segundos, com um tempo de recarga de 1 segundo, ou até que o jogador solte
o botão esquerdo do mouse.

Essa função simula a ativação do `Class.Tool`. A ferramenta deve estar
equipada para que essa função funcione.


Tool:Activate

Essa função simula a desativação do `Class.Tool`. A ferramenta deve estar
equipada para que essa função funcione.


Tool:Deactivate

Tool

A propriedade CanBeDropped controla se o jogador pode soltar o
`Class.Tool`.

Se for verdadeiro, quando a tecla backspace for pressionada, a ferramenta será parentada
ao `Class.Workspace` e removida da `Class.Backpack` do jogador. Se
falso, nada acontecerá quando a tecla backspace for pressionada, e a ferramenta permanecerá equipada.


Tool.CanBeDropped

Controla se o jogador pode soltar a ferramenta.


O código de exemplo abaixo cria `Class.Tool` na mochila do jogador local
`Class.Backpack` que aumenta seu `Class.Humanoid.JumpPower|JumpPower`
de `50` para `150` por 5 segundos.

Este exemplo usa a propriedade `Class.Tool.Enabled` da ferramenta como um debounce,
definindo a propriedade como `true` quando o jogador pula e de volta para `false` após
a duração de 5 segundos.

Desequipar a ferramenta também impede que o jogador faça um super pulo, mudando o
`Class.Humanoid.JumpPower|JumpPower` de volta para `50`.

A propriedade **Enabled** relaciona-se a se o `Class.Tool` pode ser
usado. Isso é útil se você deseja impedir que um jogador use uma ferramenta,
mastendo-a na `Class.Backpack`.

Quando definido como `true`, o jogador pode usar a ferramenta. Quando definido como `false`, a
tool é desativada e o jogador não pode usá-la; isso impede que a ferramenta seja
ativada ou desativada pelos métodos `Class.Tool:Activate()` e
`Class.Tool:Deactivate()`, e impede que os
eventos `Class.Tool.Activated` e `Class.Tool.Deactivated` sejam disparados.


Tool.Enabled

Relata se a ferramenta pode ou não ser usada.


O código abaixo insere uma `Class.Tool` chamada **Bastão** na mochila do jogador local `Class.BackPack`. Quando o jogador ativa a ferramenta, o código imprime os valores das propriedades de agarre da ferramenta.

A propriedade `Grip` armazena as propriedades de "pegada" da ferramenta como um único
`Datatype.CFrame`. Essas propriedades posicionam como o jogador segura a ferramenta
incluindo `Class.Tool.GripUp|GripUp`, `Class.Tool.GripRight|GripRight`,
`Class.Tool.GripForward|GripForward`, e `Class.Tool.GripPos|GripPos`.


Tool.Grip

Armazena as propriedades de "pegada" da ferramenta como um `Datatype.CFrame`.


Uma das propriedades que especifica a orientação de uma ferramenta na mão de um
personagem. Isso representa os valores `R02`, `R12`, e `R22` da matriz de rotação da pegada
`Datatype.CFrame`.

Outras propriedades da ferramenta que controlam como um personagem segura uma ferramenta incluem
`Class.Tool.GripUp`, `Class.Tool.GripRight`, e `Class.Tool.GripPos`. Todas
essas propriedades são armazenadas em um único `Datatype.CFrame` na
propriedade `Class.Tool.Grip`.


Tool.GripForward

Representa os valores `R02`, `R12` e `R22` da matriz de rotação
`Datatype.CFrame` da pegada.


Esta propriedade controla o deslocamento posicional da matriz de solda da ferramenta.
É uma das várias propriedades usadas para posicionar como o jogador
segura a ferramenta.

Outras propriedades que controlam como um personagem segura uma ferramenta incluem
`Class.Tool.GripUp`, `Class.Tool.GripRight`, e `Class.Tool.GripForward`.
Todas essas propriedades são armazenadas em um único `Datatype.CFrame` na
propriedade `Class.Tool.Grip`.


Tool.GripPos

O deslocamento posicional da matriz de solda da ferramenta.


Uma das propriedades que especifica a orientação de uma ferramenta na mão de um
personagem. Isso representa os valores `R00`, `R10`, e `R20` da matriz de rotação da pegada
`Datatype.CFrame`.

Outras propriedades da ferramenta que controlam como um personagem segura uma ferramenta incluem
`Class.Tool.GripUp`, `Class.Tool.GripForward`, e `Class.Tool.GripPos`.
Todas essas propriedades são armazenadas em um único `Datatype.CFrame` na
propriedade `Class.Tool.Grip`.


Tool.GripRight

Representa os valores `R00`, `R10` e `R20` da matriz de rotação
`Datatype.CFrame` da pegada.


Uma das propriedades que especifica a orientação de uma ferramenta na mão de um
personagem. Isso representa os valores `R01`, `R11`, e `R21` da matriz de rotação da pegada
`Datatype.CFrame`.

Outras propriedades da ferramenta que controlam como um personagem segura uma ferramenta incluem
`Class.Tool.GripRight`, `Class.Tool.GripForward`, e
`Class.Tool.GripPos`. Todas essas propriedades são armazenadas em um único
`Datatype.CFrame` na propriedade `Class.Tool.Grip`.


Tool.GripUp

Representa os valores `R01`, `R11` e `R21` da matriz de rotação
`Datatype.CFrame` da pegada.


O exemplo de código abaixo cria `Class.Tool` na
`Class.Backpack` do jogador local que aumenta seu
`Class.Humanoid.Walkspeed|WalkSpeed` de `16` para `30` por 5 segundos.

Este exemplo usa a propriedade `Class.Tool.ManualActivationOnly` da ferramenta como um
debounce, definindo a propriedade como `true` quando o jogador começa a correr
e como `false` quando o jogador para de correr. Como resultado, quando o jogador
está correndo, a ferramenta não pode ser reativada.

Desequipar a ferramenta também impede que o jogador corra, alterando a
`Class.Humanoid.Walkspeed|WalkSpeed` para `16`.

Esta propriedade controla se o `Class.Tool` pode ser ativado sem
executar explicitamente `Class.Tool:Activate()` em um script.

Quando definido como `true`, a ferramenta disparará `Class.Tool.Activated` apenas quando
`Class.Tool:Activate()` for chamado. Isso também suprime a
função `Class.ContextActionService:BindActivate()`.

Quando definido como `false`, cliques do mouse (quando a ferramenta está equipada) também
dispararão `Class.Tool.Activated`.


Tool.ManualActivationOnly

Controla se o `Class.Tool` pode ser ativado sem executar
`Class.Tool:Activate()`.


Esta propriedade determina se um `Class.Tool` funciona sem um
punho.

Uma ferramenta tem um punho quando contém uma parte filha chamada **Handle**. Ferramentas
com punhos geralmente requerem que o jogador as equipe para segurar um objeto
para usá-las, por exemplo, armas. Ferramentas sem punhos geralmente não
requerem que o jogador as equipe para segurar algo para usá-las, por
exemplo, ferramentas de "voar" ou "invocar".

Quando definido como `true`, a ferramenta funcionará apenas com um punho. Quando definido como
`false`, a ferramenta funcionará mesmo sem um punho.


Tool.RequiresHandle

Determina se um `Class.Tool` funciona sem um punho.


A propriedade ToolTip controla a mensagem que será exibida quando o
mouse do jogador `Class.Mouse` passar sobre a `Class.Tool` em sua
`Class.Backpack`.

Geralmente, o valor desta propriedade deve descrever o que a ferramenta é
ou seu uso. Por exemplo, para uma ferramenta pá, você pode optar por definir o
ToolTip como:

```lua
tool.ToolTip = "Pá"
```
ou

```lua
tool.ToolTip = "Use para cavar"
```
ou

```lua
tool.ToolTip = "Pá - Use para cavar"
```


Tool.ToolTip

Controla a mensagem exibida quando o mouse do jogador passa sobre a
tool em sua mochila.


Um objeto, como uma arma, que pode ser equipado por um `Class.Humanoid`.


BackpackItem é uma classe abstrata para itens de mochila, como HopperBins e
Ferramentas.


BackpackItem

O ícone de textura que é exibido para uma ferramenta na mochila do jogador.

Esta propriedade deve ser definida como o ID de conteúdo de uma imagem carregada no
site do Roblox. Apenas URIs de ativos são suportados para esta propriedade.

Se esta propriedade for deixada em branco, a GUI `Class.Backpack` exibirá o
nome da ferramenta em vez disso.


BackpackItem.TextureContent

O ícone de textura que é exibido para uma ferramenta na mochila do jogador.
Apenas suporta URIs de ativos.


O ícone de textura que é exibido para uma ferramenta na mochila do jogador.

Esta propriedade deve ser definida como o ID de conteúdo de uma imagem carregada no
site do Roblox.

Se esta propriedade for deixada em branco, a GUI `Class.Backpack` exibirá o
nome da ferramenta em vez disso.


BackpackItem.TextureId

O ícone de textura que é exibido para uma ferramenta na mochila do jogador.


O seguinte exemplo inclui uma função básica que aceita uma tabela de objetos
e os coloca dentro de 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 (ParteA e ParteB). Ele cria uma junta em duas partes que estão em contato
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

Esta função retorna uma descrição de um volume que contém todos os
`Class.BasePart` filhos dentro de um `Class.Model`. A orientação do volume
baseia-se 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()`, 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 de física estiverem agindo 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.

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

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

-- Redimensiona e posiciona a parte igual à caixa delimitadora do 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.

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, 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 seguinte código 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 em 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 como substituir em uma substituição para todas as cópias
de um modelo de árvore usando `Class.Model:PivotTo()` e `Class.Model:ScaleTo()`. O
pivot 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 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 pai do Workspace
a parte de baixo cairia no Baseplate.

No entanto, como a propriedade TopSurface da parte de baixo é configurada para
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 geralmente é 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 (ParteA e ParteB). 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 em duas partes `Class.Model` é criado, e sua `Class.Model.PrimaryPart`
és definida. 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 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 em 45 graus no eixo Y,
e a 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 for definido,
o pivô / caixa delimitadora do dado giraria, já que as partes dentro dele
são simuladas fisicamente durante a jogada.

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 ponto de pivot de um modelo
de volta ao centro da caixa delimitadora daquele 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` **tem** um `Class.Model.PrimaryPart|PrimaryPart`, o
pivô do `Class.Model` é igual ao pivô daquela parte primária
em vez disso, e esta propriedade `Class.Model.WorldPivot|WorldPivot` é ignorada.

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

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ô do mundo e, portanto, 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 no código.

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

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

print(model:GetPivot())  -- Atualmente igual ao centro da caixa delimitadora contendo "BluePart" e "RedPart"

model:PivotTo(CFrame.new(0, 10, 0))  -- Isso funciona sem precisar definir explicitamente "model.WorldPivot"
```

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á mirando ao pressionar
a tecla <kbd>F</kbd>. Ele faz isso obtendo o pivot 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

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

PVInstance.Origin

PVInstance.Pivot Offset

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 diretamente objetos `Instance` raiz, mas o construtor especial
`Datatype.Instance.new()` cria objetos via código, recebendo o
nome da classe como um parâmetro e retornando o objeto criado.

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

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


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

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

Instance.AncestryChanged

child

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

parent

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

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

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

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

local part = Workspace.Part

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

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

Instance.AttributeChanged

attribute

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

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

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

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

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

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

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

Instance.ChildAdded

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

Instance.childAdded

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

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

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

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

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

Instance.ChildRemoved

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

Instance

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