O objeto Platform cria um bloco que, quando tocado por um `Class.Player`, ancorará
seu torso ao bloco. Isso permite a criação de veículos onde os jogadores podem ficar em pé
e não serem arremessados pela cabine/deck do veículo.

O Platform é quase idêntico ao objeto `Class.Seat`, exceto que em vez de se sentar,
o jogador ficará em pé enquanto estiver preso ao lugar. Bom para navios.

O objeto Platform é muito útil para fazer com que os personagens das pessoas fiquem em
um só lugar enquanto se movem, como em um navio ou caminhão. Quando um jogador
toca o Platform, uma restrição `Class.Weld` é criada, então eles estão
'ligados' ao Platform e não podem se mover até que essa solda seja quebrada. Pode ser
removido pressionando a barra de espaço, quando o jogador pula para sair do Platform.


Platform

Historicamente uma forma de `Class.Seat` que não colocava o jogador em uma
posição de sentado. Este objeto não pode mais ser criado e não pode ser usado por
desenvolvedores.


O script abaixo gera uma nova instância de `Part` e define várias das
propriedades da parte.

Notavelmente, o script define a propriedade `Class.Part.Shape` como
`Enum.PartType.Ball`. Também nomeia a parte _JurassicPart_, a fixa,
a torna um filho de _Workspace_ e define sua cor como branca.

O objeto Part é um tipo de `Class.BasePart`. Ele vem em cinco formas primitivas diferentes: Bola, Bloco, Cilindro, Wedge e CornerWedge.


Part

A propriedade Shape define a forma geral do objeto como uma das formas pré-determinadas na lista de formas embutidas.

O enum `Enum.PartType` controla o valor da forma e possui cinco formas possíveis:

| Forma/Valor  | Descrição                                |
| ------------ | ---------------------------------------- |
| Bola        | Uma forma esférica.                      |
| Bloco       | Uma forma de bloco.                      |
| Cilindro    | Uma forma de cilindro.                   |
| Wedge       | Uma forma de wedge com uma inclinação de um lado. |
| CornerWedge | Uma forma de wedge com inclinações em dois lados. |

`Class.MeshPart` e [modelagem sólida](/parts/solid-modeling) podem ser usados para obter formas de partes totalmente personalizadas.

As colisões entre bolas, blocos e wedges, e corner wedges são exatas, enquanto as colisões entre terreno, cilindros, TriangleMeshes e outros tipos de geometria são aproximações. Isso significa que a forma de bola pode ser útil para criar colisores estáveis para rodas de carro.


Part.Shape

Um tipo comum de `Class.BasePart` que vem em diferentes formas primitivas.


A classe FormFactorPart é uma classe abstrata. Ela herda da
`Class.BasePart` e adiciona a propriedade `Class.FormFactorPart.FormFactor`
 às classes que dela herdam.


FormFactorPart

Isso costumava especificar uma restrição de grade do tamanho da parte. Não faz mais
nada.


FormFactorPart.FormFactor

Determina como uma parte age quando redimensionada e os valores que seu tamanho
pode assumir.


FormFactorPart.formFactor

A classe FormFactorPart é uma classe abstrata. Ela herda da classe BasePart
 e adiciona a propriedade FormFactor às classes que dela herdam.


Cria uma peça azul e uma peça alvo vermelha. A peça azul tentará suavemente
atingir a peça alvo vermelha. Mova e rotacione o alvo para ver o comportamento.
Mudar o smoothTime resultará em diferentes velocidades de suavização.


`Class.BasePart` é uma classe base abstrata para objetos no mundo que renderizam
 e são simulados fisicamente enquanto estão no `Class.Workspace`. Existem várias
 implementações de `Class.BasePart`, as mais comuns sendo `Class.Part` e
 `Class.MeshPart`. Outras incluem `Class.WedgePart`, `Class.SpawnLocation` e
 o objeto singleton `Class.Terrain`. Geralmente, quando a documentação se refere a
 um "parte", a maioria das implementações de `Class.BasePart` funcionará e não apenas
 `Class.Part`.

Para informações sobre como `Class.BasePart|BaseParts` são agrupados em corpos
 rígidos simulados, veja [Assemblies](/physics/assemblies).

Existem muitos objetos diferentes que interagem com `Class.BasePart` (exceto
 `Class.Terrain`), incluindo:

- Várias `Class.BasePart|BaseParts` podem ser agrupadas dentro de um `Class.Model` e
  movidas ao mesmo tempo usando `Class.PVInstance:PivotTo()`. Veja
  [Models](/parts/models).
- Um `Class.Decal` aplica uma textura de imagem esticada às faces de um
  `Class.BasePart`, enquanto um `Class.Texture` aplica uma textura de imagem
  em ladrilho às faces. Veja [Textures and Decals](/parts/textures-decals).
- Um `Class.SurfaceGui` renderiza `Class.GuiObject|GuiObjects` na face de um
  parte. Veja
  [In-Experience UI Containers](/ui/in-experience-containers).
- `Class.Attachment|Attachments` podem ser adicionados a um `Class.BasePart` para especificar
  `Datatype.CFrame|CFrames` em relação à parte. Esses são frequentemente usados por
  objetos físicos `Class.Constraint`, conforme descrito em
  [Mechanical Constraints](/physics/mechanical-constraints) e
  [Mover Constraints](/physics/mover-constraints).
- Objetos `Class.ParticleEmitter` emitem partículas uniformemente no volume do
  `Class.BasePart` ao qual estão conectados. Veja
  [Particle Emitters](/effects/particle-emitters).
- Objetos de luz como `Class.PointLight` emitem luz do centro de um
  `Class.BasePart`, como ilustrado em
  [Light Sources](/effects/light-sources).
- Se conectado a um `Class.Tool` e dado o nome **Handle**, um
  `Class.BasePart` pode ser segurado por personagens. Veja
  [In-Experience Tools](/players/tools).

Disparado quando outra peça entra em contato com outro objeto. Este evento
apenas envia dados ao cliente notificando que duas peças colidiram,
 enquanto `Class.BasePart.Touched` envia dados ao servidor.

BasePart.LocalSimulationTouched

part

Disparado se a aparência da peça for afetada pela classe `Class.Shirt`.

BasePart.OutfitChanged

BasePart.StoppedTouching

otherPart

Este exemplo de código cria um BillboardGui em uma parte que exibe o número de
partes que atualmente estão em contato com ela.

Este exemplo de código demonstra como conectar o evento `Class.BasePart.Touched`
de várias partes em um `Class.Model` a uma função.


O evento **Touched** dispara quando uma peça entra em contato com outra
peça. Por exemplo, se **PartA** colidir com **PartB**, então
`Class.BasePart.Touched|PartA.Touched` dispara com **PartB**, e
`Class.BasePart.Touched|PartB.Touched` dispara com **PartA**.

Este evento só disparará como resultado do movimento físico, assim não disparará
se a propriedade `Class.BasePart.CFrame|CFrame` foi alterada de tal forma que
 a peça se sobreponha a outra peça. Isso também significa que pelo menos uma das
 peças envolvidas deve **não** estar `Class.BasePart.Anchored|Anchored` no
 momento da colisão.

Este evento funciona em conjunto com
`Class.Workspace.TouchesUseCollisionGroups` para especificar se
[grupos de colisão](/workspace/collisions#collision-filtering)
são reconhecidos para a detecção.

BasePart.Touched

A outra peça que entrou em contato com a peça dada.

Dispara quando uma peça toca outra peça como resultado do movimento físico.

Dispara quando uma peça para de tocar outra peça em condições similares à
quelas de `Class.BasePart.Touched`.

Este evento funciona em conjunto com
`Class.Workspace.TouchesUseCollisionGroups` para especificar se
[grupos de colisão](/workspace/collisions#collision-filtering)
são reconhecidos para a detecção.

BasePart.TouchEnded

Dispara quando uma peça para de tocar outra peça como resultado do movimento físico.

Retorna o vetor de torque em espaço mundial que deve ser aplicado na montagem da
peça para alcançar a aceleração angular especificada. Este resultado pode ser
usado para determinar o torque que deve ser aplicado através de uma
instância `Class.Torque` ou `Class.BasePart:ApplyAngularImpulse()`.

O cálculo utiliza a equação de rotação de Euler onde _I_ é o tensor de inércia
da montagem no espaço mundial, _α_ é a aceleração angular desejada e
_ω_ é a velocidade angular.

_τ = I · α + ω × (I · ω)_

Se a peça não for um descendente de `Class.Workspace`, este método retorna
um vetor de infinito. Se a montagem estiver ancorada, também retorna um
vetor de infinito.

#### Efeitos Giroscópicos

Quando uma montagem giratória tem um tensor de inércia assimétrico, o torque
necessário para alcançar uma aceleração angular especificada é aumentado devido
a orientação em mudança do corpo. O parâmetro opcional `angVelocity`
contabiliza esses efeitos giroscópicos. Se omitido, esses efeitos giroscópicos
são omitidos do cálculo.

```lua
local part = workspace.Part
local angularVelocity = part.AssemblyAngularVelocity
local desiredAcceleration = Vector3.new(0, 10, 0)

-- Computa o torque necessário para alcançar a aceleração desejada
local torque = part:AngularAccelerationToTorque(desiredAcceleration, angularVelocity)
```

BasePart:AngularAccelerationToTorque

angAcceleration

O vetor de aceleração angular desejada em espaço mundial.

angVelocity

A velocidade angular atual da montagem em espaço mundial. Por padrão
é igual a `(0, 0, 0)`. Forneça a velocidade angular da montagem para levar em
conta efeitos giroscópicos.

Um `Datatype.Vector3` representando o torque em espaço mundial necessário para
produzir a aceleração angular especificada.

Retorna o torque necessário para alcançar uma determinada aceleração angular na
montagem desta peça, contabilizando opcionalmente efeitos giroscópicos.

Aplica um impulso de força angular instantânea na montagem desta peça, fazendo
com que a montagem gire.

A velocidade angular resultante do impulso depende da `Class.BasePart.AssemblyMass|massa`
da montagem. Portanto, um impulso maior é necessário para mover montagens
mais massivas. Impulsos são úteis para casos em que você quer que uma força
seja aplicada instantaneamente, como uma explosão ou colisão.

Se a peça for [possessa](/physics/network-ownership) pelo
servidor, essa função deve ser chamada de um `Class.Script`
does servidor (não de um `Class.LocalScript` ou de um `Class.Script` com
`Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
Se a peça for possessa por um cliente através da propriedade **automática**,
a função pode ser chamada de um script de cliente **ou** um script de servidor;
chamá-la de um script de cliente para uma peça possessa pelo servidor não terá
nenhum efeito.

BasePart:ApplyAngularImpulse

impulse

Um vetor de impulso angular a ser aplicado na montagem.

Esta função aplica um impulso de força instantânea na montagem desta peça.

A força é aplicada no `Class.BasePart.AssemblyCenterOfMass|centro de massa` da montagem,
portanto o movimento resultante será apenas linear.

A velocidade resultante do impulso depende da `Class.BasePart.AssemblyMass|massa`
da montagem. Portanto, um impulso maior é necessário para mover montagens
mais massivas. Impulsos são úteis para casos em que você quer que uma força
seja aplicada instantaneamente, como uma explosão ou colisão.

Se a peça for [possessa](/physics/network-ownership) pelo
servidor, essa função deve ser chamada de um `Class.Script`
does servidor (não de um `Class.LocalScript` ou de um `Class.Script` com
`Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
Se a peça for possessa por um cliente através da propriedade **automática**,
a função pode ser chamada de um script de cliente **ou** um script de servidor;
chamá-la de um script de cliente para uma peça possessa pelo servidor não terá
nenhum efeito.

BasePart:ApplyImpulse

Um vetor de impulso linear a ser aplicado na montagem.

Aplica um impulso na montagem no `Class.BasePart.AssemblyCenterOfMass|centro de massa`
da montagem.

Esta função aplica um impulso de força instantânea na montagem desta peça, na
posição especificada em espaço mundial.

Se a posição não estiver no `Class.BasePart.AssemblyCenterOfMass|centro de massa`
da montagem, o impulso causará um movimento posicional e rotacional.

A velocidade resultante do impulso depende da `Class.BasePart.AssemblyMass|massa`
da montagem. Portanto, um impulso maior é necessário para mover montagens
mais massivas. Impulsos são úteis para casos em que os desenvolvedores
queiram que uma força seja aplicada instantaneamente, como uma explosão ou
colisão.

Se a peça for [possessa](/physics/network-ownership) pelo
servidor, essa função deve ser chamada de um `Class.Script`
does servidor (não de um `Class.LocalScript` ou de um `Class.Script` com
`Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
Se a peça for possessa por um cliente através da propriedade **automática**,
a função pode ser chamada de um script de cliente **ou** um script de servidor;
chamá-la de um script de cliente para uma peça possessa pelo servidor não terá
nenhum efeito.

BasePart:ApplyImpulseAtPosition

Um vetor de impulso a ser aplicado na montagem.

position

A posição, em espaço mundial, para aplicar o impulso.

Aplica um impulso na montagem em uma posição especificada.

Desfaz qualquer conexão de superfície com qualquer peça adjacente, incluindo
`Class.Weld` e outras `Class.JointInstance`.

BasePart:BreakJoints

BasePart:breakJoints

Retorna se as peças podem colidir entre si ou não. Esta
função leva em conta os grupos de colisão das duas peças. Esta
função gerará um erro se a peça especificada não for um BasePart.

BasePart:CanCollideWith

A peça especificada sendo verificada quanto à possibilidade de colisão.

Retorna se as peças podem colidir entre si.

Este exemplo verifica se a propriedade de rede da primeira
`BasePart` chamada _Part_ no `Workspace` pode ser definida.

A função CanSetNetworkOwnership verifica se você pode definir a propriedade de rede de uma peça.

O valor de retorno da função verifica se você pode ou não chamar
`Class.BasePart:SetNetworkOwner()` ou
`Class.BasePart:SetNetworkOwnershipAuto()` sem encontrar um erro.
Ela retorna verdadeiro se você pode modificar/ler a propriedade de rede, ou retorna
falso e a razão pela qual você não pode, como uma string.

BasePart:CanSetNetworkOwnership

Se você pode modificar ou ler a propriedade de rede e o motivo.

Verifica se você pode definir a propriedade de rede de uma peça.

Retorna o ponto mais próximo na superfície da peça à posição dada em
espaço mundial. Se a posição fornecida estiver dentro da peça, ela será retornada
como está.

Para instâncias `Class.MeshPart` e `Class.PartOperation`, este método
respeita o valor de `Enum.CollisionFidelity` da peça. Os valores de retorno podem
diferençar dependendo se a malha está sendo tratada como uma caixa, um casco, ou uma
forma mais complexa.

BasePart:GetClosestPointOnSurface

O ponto em espaço mundial para encontrar o ponto mais próximo da superfície.

O ponto mais próximo na superfície da peça em espaço mundial.

Retorna o ponto mais próximo na superfície da peça ao ponto dado.

Retorna uma tabela de peças conectadas ao objeto por qualquer tipo de junta
rígida.

Se `recursive` for verdadeiro, essa função retornará todas as peças na
montagem rigidamente conectadas ao BasePart.

#### Juntas Rígidas

Quando uma junta conecta duas peças `(Part0 → Part1)`, uma junta é
**rígida** se a física de `Part1` estiver completamente travada por `Part0`.
Isso se aplica apenas aos seguintes tipos de juntas:

- `Class.Weld`
- `Class.Snap`
- `Class.ManualWeld`
- `Class.Motor`
- `Class.Motor6D`
- `Class.WeldConstraint`

BasePart:GetConnectedParts

recursive

Uma tabela de peças conectadas ao objeto por qualquer tipo de
`Class.JointInstance|junta`.

Retorna uma tabela de peças conectadas ao objeto por qualquer tipo de junta
rígida.

Retorna todas as Juntas ou Restrições que estão conectadas a esta Parte.

BasePart:GetJoints

Um array de todas as Juntas ou Restrições conectadas à Parte.

Este exemplo cria uma nova parte, myPart, no Workspace do jogo, com
dimensões 4x6x4 studs. A parte também está ancorada.

Então, myMass é definido para ser igual à massa da nova parte. A massa da parte é
impressa ao final da instrução de impressão:

> A massa da minha parte é ...

**GetMass** retorna o valor da propriedade somente leitura `Class.BasePart.Mass|Mass`
.

Esta função é anterior à propriedade Mass. Ela permanece suportada por
compatibilidade retroativa; você deve usar a propriedade Mass diretamente.

BasePart:GetMass

Retorna o valor da propriedade `Class.BasePart.Mass|Mass`.

BasePart:getMass

Retorna o jogador atual que é o proprietário de rede desta peça, ou `nil`
caso do servidor.

BasePart:GetNetworkOwner

O jogador atual que é o proprietário de rede desta peça, ou `nil` no
caso do servidor.

Retorna verdadeiro se o motor do jogo decide automaticamente o proprietário de rede
para esta peça.

BasePart:GetNetworkOwnershipAuto

Se o motor do jogo decide automaticamente o proprietário de rede para
esta peça.

BasePart:GetNoCollisionConstraints

Esta função costumava ser relevante quando a interpolação compensatória de
atraso do Roblox era interna. A interpolação agora é aplicada ao `Datatype.CFrame`
 diretamente.

BasePart:GetRenderCFrame

OBSOLETO. Retorna um CFrame descrevendo onde a peça está sendo renderizada.

Retorna a peça base de uma montagem. Ao mover uma montagem de peças
usando um `Datatype.CFrame`. é importante mover esta peça base (isso
moverá todas as outras peças conectadas a ela de acordo). Mais informações
estão disponíveis no artigo [Assemblies](/physics/assemblies).

Esta função precede a propriedade `Class.BasePart.AssemblyRootPart|AssemblyRootPart`.
Ela permanece suportada para compatibilidade retroativa, mas você deve usar
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` diretamente.

BasePart:GetRootPart

A peça base de uma montagem (uma coleção de peças conectadas
juntas).

Retorna a peça base de uma montagem de peças.

Retorna uma tabela de todas as peças que estão interagindo fisicamente com esta
peça. Se a própria peça tiver CanCollide definido como falso, esta função
retornará uma tabela vazia, a menos que a peça tenha um
d objeto `Class.TouchTransmitter|TouchInterest` parente (significa que
algo está conectado ao seu evento Touched). Peças que estão adjacentes mas
não se intersectam não são consideradas tocando. Esta função precede a
função `Class.WorldRoot:GetPartsInPart()`, que fornece mais
flexibilidade e evita as regras especiais de `Class.TouchTransmitter|TouchInterest`
 descritas acima. Use `Class.WorldRoot:GetPartsInPart()` em vez disso.

BasePart:GetTouchingParts

Uma tabela de todas as peças que se intersectam e podem colidir com esta peça.

Retorna uma tabela de todos os `Class.BasePart.CanCollide` verdadeiros que
intersectam com esta peça.

Retorna a velocidade linear da montagem da peça na posição dada
em relação a esta peça. Pode ser usado para identificar a velocidade linear de
peças em uma montagem que não seja a peça raiz. Se a montagem não tiver
velocidade angular, então a velocidade linear sempre será a mesma para
uma posição qualquer.

BasePart:GetVelocityAtPosition

Retorna a velocidade linear da montagem da peça na posição dada
em relação a esta peça.

Cria uma nova `Class.IntersectOperation` a partir da geometria que se intersecta
da parte e outras partes no array dado. Apenas `Class.Part|Parts`
 são suportados, não `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semelhante a
 `Class.Instance:Clone()|Clone()`, o objeto retornado não possui um
`Class.Instance.Parent|Parent` configurado.

As seguintes propriedades da parte chamadora são aplicadas ao
`Class.IntersectOperation` resultante:

- `Class.BasePart.Color|Color`, `Class.BasePart.Material|Material`,
  `Class.BasePart.MaterialVariant|MaterialVariant`,
  `Class.BasePart.Reflectance|Reflectance`,
  `Class.BasePart.Transparency|Transparency`
- `Class.BasePart.CanCollide|CanCollide`
- `Class.BasePart.Anchored|Anchored`, `Class.BasePart.Density|Density`,
  `Class.BasePart.Elasticity|Elasticity`,
  `Class.BasePart.ElasticityWeight|ElasticityWeight`,
  `Class.BasePart.Friction|Friction`,
  `Class.BasePart.FrictionWeight|FrictionWeight`

Na comparação de imagens a seguir,
`Class.BasePart:IntersectAsync()|IntersectAsync()` é chamada no bloco roxo
usando uma tabela que contém o bloco azul. A operação `Class.IntersectOperation`
resulta em uma forma da geometria que se intersecta das duas partes.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Intersect.jpg"
width="720" alt="Duas partes de blocos sobrepondo" />
<figcaption>Partes separadas</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Intersect-Result.jpg"
width="720" alt="Partes intersectadas em um novo modelo sólido" />
<figcaption>Resultado <code>Class.IntersectOperation</code></figcaption>
</figure>

#### Notas

- As partes originais permanecem intactas após uma operação de interseção bem-sucedida.
 Na maioria dos casos, você deve `Class.Instance.Destroy|Destroy()` todas as
 partes originais e parentar a `Class.IntersectOperation` retornada ao mesmo lugar
do que a `Class.BasePart` chamadora.
- Por padrão, as cores das faces da interseção resultante são emprestadas da
  propriedade `Class.BasePart.Color|Color` das partes originais. Para
  mudar toda a interseção para uma cor específica, defina sua
  propriedade `Class.PartOperation.UsePartColor|UsePartColor` como `true`.
- Se uma operação de interseção resultar em uma parte com mais de 20.000
  triângulos, ela será simplificada para 20.000 triângulos.

BasePart:IntersectAsync

parts

Os objetos que participam da interseção.

collisionfidelity

O valor de `Enum.CollisionFidelity` para o resulting
`Class.IntersectOperation`.

renderFidelity

O valor de `Enum.RenderFidelity` do resulting
`Class.PartOperation`.

Resultado de `Class.IntersectOperation` com o nome padrão **Intersect**.

Nota: É altamente recomendável usar a nova
`Class.GeometryService:IntersectAsync` em vez desta função. Além de ter
melhor desempenho e mais recursos, a nova função difere da seguinte maneira:

- A saída é um array de instâncias em vez de uma única instância.
- As partes de entrada não precisam estar parentadas à cena, permitindo
  operações em segundo plano.
- Quando a opção `SplitApart` é definida como `true` (padrão), cada corpo distinto
  será retornado em sua própria `Class.PartOperation`.
- Todas as partes retornadas estão no espaço de coordenadas da parte principal, então
  suas posições `Class.PVInstance.Origin` são as mesmas que a da parte principal.
 Isso mantém os vértices da malha na mesma posição em relação ao objeto
 que antes da operação, mas isso também significa que o `(0, 0, 0)` de uma parte
 retornada não está necessariamente no centro de seu corpo.

  Cria uma nova `Class.IntersectOperation` a partir da geometria sobreposta
  da parte e outras partes no array dado.

Retorna verdadeiro se o objeto estiver conectado a uma peça que o segurará em
um lugar (por exemplo, uma parte `Class.BasePart.Anchored|Anchored`), caso contrário, retorna
falso. Em uma montagem que tem uma parte `Class.BasePart.Anchored|Anchored`,
toda outra parte está aterrada.

BasePart:IsGrounded

Se o objeto está conectado a uma peça que o segurará em um lugar.

Retorna verdadeiro se o objeto estiver conectado a uma peça que o segurará em
um lugar (por exemplo, uma parte `Class.BasePart.Anchored|Anchored`), caso contrário, retorna
falso.

Cria uma junta em qualquer lado da `Class.BasePart|Part` que tenha um
`Enum.SurfaceType` que pode fazer uma junta, criará uma junta com qualquer
peças adjacentes.

As juntas serão criadas entre os lados e quaisquer superfícies planas que estão
tocando, dependendo das superfícies dos lados.

- Superfícies lisas não criarão juntas
- Superfícies adesivas criarão uma junta `Class.Glue`
- Soldas criarão uma junta `Class.Weld` com qualquer superfície exceto por
  NãoJuntável
- Studs, Inlet ou Universal criarão cada um 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 de juntas `Class.Rotate` e
  `Class.RotateV`

Diferentemente de `Class.Model:MakeJoints()`, esta função requer um array de
peças como parâmetro. Este array é fornecido da seguinte maneira:

```
part:MakeJoints({part1, part2, part3})
```
As juntas são quebradas se uma força suficiente for aplicada a elas devido a uma
`Class.Explosion`, a menos que um objeto `Class.ForceField` esteja parentado à
`Class.BasePart` ou ao ancestral `Class.Model`. Por esse motivo, elas são
frequentemente usadas para fazer edifícios destrutíveis simples e outros modelos.

BasePart:MakeJoints

Cria uma junta em qualquer lado do objeto que tenha um ID de superfície que pode
fazer uma junta.

BasePart:makeJoints

Muda o tamanho de um objeto exatamente como usar a ferramenta de redimensionamento do Studio.

BasePart:Resize

normalId

deltaAmount

Quanto aumentar/reduzir no lado especificado.

BasePart:resize

Define o jogador dado como proprietário da rede para esta e todas as partes conectadas.
Quando playerInstance é `nil`, o servidor será o proprietário em vez de um
jogador.

BasePart:SetNetworkOwner

playerInstance

O jogador a quem é dada a propriedade de rede da peça.

Define o jogador dado como proprietário da rede para esta e todas as partes conectadas.

Deixa o motor do jogo decidir dinamicamente quem lidará com a física da peça
(um dos clientes ou o servidor).

BasePart:SetNetworkOwnershipAuto

Este exemplo demonstra como subtrair parte(s) de outra
`Class.BasePart` para formar uma `Class.UnionOperation` negada.

Cria uma nova `Class.UnionOperation` a partir da parte, menos a geometria
ocupada pelas partes no array dado. Apenas `Class.Part|Parts` são
 suportados, não `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semelhante a
 `Class.Instance:Clone()|Clone()`, o objeto retornado não possui um
`Class.Instance.Parent|Parent` configurado.

Nota que a união resultante não pode estar vazia devido a subtrações. Se a
operação resultar em uma geometria completamente vazia, ela falhará.

Na comparação de imagens a seguir,
`Class.BasePart:SubtractAsync()|SubtractAsync()` é chamada no cilindro azul
usando uma tabela que contém o bloco roxo. A operação `Class.UnionOperation`
resulta em uma forma que omite a geometria do bloco daquela do cilindro.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Subtract.jpg"
width="720" alt="Bloco longo sobrepondo um cilindro" />
<figcaption>Partes separadas</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Negate-Result.jpg" width="720"
alt="Parte do bloco subtraído do cilindro" />
<figcaption>Resultado <code>Class.UnionOperation</code></figcaption>
</figure>

BasePart:SubtractAsync

Os objetos que participam da subtração.

O valor de `Enum.CollisionFidelity` para o resulting
`Class.UnionOperation`.

Resultado de `Class.UnionOperation` com o nome padrão **Union**.

Nota: É altamente recomendável usar a nova
`Class.GeometryService:UnionAsync` em vez desta função. Além de ter
melhor desempenho e mais recursos, a nova função difere da seguinte maneira:

- A saída é um array de instâncias em vez de uma única instância.
- As partes de entrada não precisam estar parentadas à cena, permitindo
  operações em segundo plano.
- Quando a opção `SplitApart` é definida como `true` (padrão), cada corpo distinto
  será retornado em sua própria `Class.PartOperation`.
- Todas as partes retornadas estão no espaço de coordenadas da parte principal, então
  suas posições `Class.PVInstance.Origin` são as mesmas que a da parte principal.
 Isso mantém os vértices da malha na mesma posição em relação ao objeto
 que antes da operação, mas isso também significa que o `(0, 0, 0)` de uma parte
 retornada não está necessariamente no centro de seu corpo.

  Cria uma nova `Class.UnionOperation` a partir da parte, menos a geometria
  ocupada pelas partes no array dado.

Retorna a aceleração angular em espaço mundial que resultaria da
aplicação do torque especificado à montagem da peça, levando em conta
opcionalmente efeitos giroscópicos.

Isso é o inverso de `Class.BasePart:AngularAccelerationToTorque()`. É
útil para prever como uma montagem responderá a um torque aplicado.

O cálculo utiliza:

**α = I⁻¹ · (τ − ω × (I · ω))**

onde **I** é o tensor de inércia no espaço mundial da montagem, **τ** é o
torque aplicado, e **ω** é a velocidade angular.

Se a peça não for um descendente de `Class.Workspace`, retorna `(0, 0, 0)`.
Se a montagem estiver ancorada, retorna `(0, 0, 0)`.

#### Efeitos Giroscópicos

Quando uma montagem giratória tem um tensor de inércia assimétrico, a
aceleração resultante de um torque aplicado também depende da velocidade
angular atual. O parâmetro `angVelocity` contabiliza esses
efeitos giroscópicos. Se omitido (padrão é zero), o resultado ignora
essa contribuição do resultado.

```lua
local part = workspace.Part
local angularVelocity = part.AssemblyAngularVelocity
local appliedTorque = Vector3.new(0, 100, 0)

-- Prever a aceleração angular deste torque
local angAccel = part:TorqueToAngularAcceleration(appliedTorque, angularVelocity)
```

BasePart:TorqueToAngularAcceleration

torque

O vetor de torque aplicado à montagem em espaço mundial.

A velocidade angular atual da montagem em espaço mundial. Por padrão
é igual a `(0, 0, 0)`. Forneça a velocidade angular da montagem para contabilizar
os efeitos giroscópicos.

Um `Datatype.Vector3` representando a aceleração angular resultante
em espaço mundial.

Retorna a aceleração angular que resultaria da aplicação de um dado
torque à montagem desta peça, contabilizando opcionalmente os efeitos giroscópicos.

Este exemplo demonstra como combinar a geometria de uma `Class.BasePart`
com a geometria de outra(s) parte(s) para formar uma `Class.UnionOperation`.

Cria uma nova `Class.UnionOperation` a partir da parte, mais a geometria
ocupada pelas partes no array dado. Apenas `Class.Part|Parts` são
 suportados, não `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semelhante a
 `Class.Instance:Clone()|Clone()`, o objeto retornado não possui um
`Class.Instance.Parent|Parent` configurado.

As seguintes propriedades da parte chamadora são aplicadas ao
`Class.UnionOperation` resultante:

- `Class.BasePart.Color|Color`, `Class.BasePart.Material|Material`,
  `Class.BasePart.MaterialVariant|MaterialVariant`,
  `Class.BasePart.Reflectance|Reflectance`,
  `Class.BasePart.Transparency|Transparency`
- `Class.BasePart.CanCollide|CanCollide`
- `Class.BasePart.Anchored|Anchored`, `Class.BasePart.Density|Density`,
  `Class.BasePart.Elasticity|Elasticity`,
  `Class.BasePart.ElasticityWeight|ElasticityWeight`,
  `Class.BasePart.Friction|Friction`,
  `Class.BasePart.FrictionWeight|FrictionWeight`

Na comparação de imagens a seguir,
`Class.BasePart:UnionAsync()|UnionAsync()` é chamada no bloco azul
usando uma tabela que contém o cilindro roxo. A operação `Class.UnionOperation`
resulta em uma forma da geometria combinada das duas partes.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Union.jpg"
width="720" alt="Partes de bloco e cilindro sobrepondo" />
<figcaption>Partes separadas</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Union-Result.jpg" width="720"
alt="Partes unidas em uma única união sólida" />
<figcaption>Resultado <code>Class.UnionOperation</code></figcaption>
</figure>

#### Notas

- As partes originais permanecem intactas após uma operação de união bem-sucedida.
  Na maioria dos casos, você deve `Class.Instance.Destroy|Destroy()` todas as
  partes originais e parentar a `Class.UnionOperation` retornada ao mesmo lugar
  que a `Class.BasePart` chamadora.
- Por padrão, a união resultante respeita a
  `Class.BasePart.Color|Color` de cada uma de suas partes. Para mudo
  toda a união para uma cor específica, defina sua
  propriedade `Class.PartOperation.UsePartColor|UsePartColor` como `true`.
- Se uma operação de união resultar em uma parte com mais de 20.000
  triângulos, ela será simplificada para 20.000 triângulos.

BasePart:UnionAsync

Os objetos que participam da união com a parte chamadora.

Nota: É altamente recomendável usar a nova
`Class.GeometryService:UnionAsync` em vez desta função. Além de ter
melhor desempenho e mais recursos, a nova função difere da seguinte maneira:

- A saída é um array de instâncias em vez de uma única instância.
- As partes de entrada não precisam estar parentadas à cena, permitindo
  operações em segundo plano.
- Quando a opção `SplitApart` é definida como `true` (padrão), cada corpo distinto
  será retornado em sua própria `Class.PartOperation`.
- Todas as partes retornadas estão no espaço de coordenadas da parte principal, então
  suas posições `Class.PVInstance.Origin` são as mesmas que a da parte principal.
 Isso mantém os vértices da malha na mesma posição em relação ao objeto
 que antes da operação, mas isso também significa que o `(0, 0, 0)` de uma parte
 retornada não está necessariamente no centro de seu corpo.

        Cria uma nova `Class.UnionOperation` a partir da parte, mais a geometria

  ocupada pelas partes no array dado.

BasePart

Este exemplo de código permitirá que uma parte seja clicada para alternar sua propriedade ancorada.
Ao ser alternada, a aparência visual da parte é atualizada (vermelho
significa ancorada, amarelo significa livre).


A propriedade `Anchored` determina se a parte será imutável por
 física. Quando ativada, uma parte nunca mudará de posição devido à gravidade,
 colisões de outras partes, sobreposição com outras partes, ou qualquer outra
 causa relacionada à física. Como resultado, duas partes ancoradas nunca ativarão
o evento `Class.BasePart.Touched|Touched` uma na outra.

Uma parte ancorada ainda pode ser movida mudando seu
 `Class.BasePart.CFrame|CFrame` ou `Class.BasePart.Position|Position`, e
 ainda pode ter um
 `Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity` e
 `Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity` diferentes de zero.

Finalmente, se uma parte não ancorada estiver unida a uma parte ancorada por
 meio de um objeto como um `Class.Weld`, esta também agirá como ancorada. Se tal
 junta se quebrar, a parte poderá ser afetada pela física novamente. Veja
 [Assemblies](/physics/assemblies) para mais detalhes.

A propriedade de propriedade de rede não pode ser definida em partes ancoradas. Se o
 status de ancoragem de uma parte mudar no servidor, a propriedade de rede dessa parte será
 afetada.

BasePart.Anchored

Determina se uma parte é imutável pela física.

O vetor de velocidade angular do conjunto desta parte. É a taxa de
 mudança da orientação em radianos por segundo.

A velocidade angular é a mesma em todos os pontos do conjunto.

Definir a velocidade diretamente pode levar a movimentos irreais. Usar
 `Class.Torque` ou `Class.AngularVelocity` como restrição é preferido, ou use
 `Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()` se você quiser
 alteração instantânea na velocidade.

Se a parte for [possuída](/physics/network-ownership) pelo
 servidor, esta propriedade deve ser alterada a partir de um `Class.Script`
 do servidor (não a partir de um `Class.LocalScript` ou um `Class.Script` com
 `Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
 Se a parte for possuída por um cliente através de **autonomia**,
 esta propriedade pode ser alterada a partir de um script de cliente **ou** um script
 do servidor; alterá-la a partir de um script de cliente para uma parte possuída pelo servidor não
 terá efeito.

BasePart.AssemblyAngularVelocity

A velocidade angular do conjunto da parte.

Uma posição calculada através da `Class.BasePart.Mass|Mass` e
 `Class.BasePart.Position|Position` de todas as partes no conjunto.

Se o conjunto tiver uma parte ancorada, o centro de massa dessa parte será o
 centro de massa do conjunto, e o conjunto terá massa infinita.

Conhecer o centro de massa pode ajudar o conjunto a manter a estabilidade. Uma
 força aplicada ao centro de massa não causará aceleração angular,
 apenas linear. Um conjunto com um baixo centro de massa terá uma melhor
 estabilidade sob o efeito da gravidade.

BasePart.AssemblyCenterOfMass

O centro de massa do conjunto da parte no espaço mundial.

O vetor de velocidade linear deste conjunto de parte. É a taxa de
 mudança na posição do
 `Class.BasePart.AssemblyCenterOfMass|AssemblyCenterOfMass` em studs por
 segundo.

Se você quiser saber a velocidade em um ponto diferente do centro de massa do conjunto,
 use
 `Class.BasePart:GetVelocityAtPosition()|GetVelocityAtPosition()`.

Definir a velocidade diretamente pode levar a movimentos irreais. Usar uma
 `Class.VectorForce` como restrição é preferido, ou use
 `Class.BasePart:ApplyImpulse()|ApplyImpulse()` se você quiser alteração
 instantânea na velocidade.

Se a parte for [possuída](/physics/network-ownership)
 pelo servidor, esta propriedade deve ser alterada a partir de um `Class.Script`
 do servidor (não a partir de um `Class.LocalScript` ou um `Class.Script` com
 `Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
 Se a parte for possuída por um cliente através de **autonomia**, esta
 propriedade pode ser alterada a partir de um script de cliente **ou** de um script
 do servidor; alterá-la a partir de um script de cliente para uma parte possuída pelo servidor não
 terá efeito.

BasePart.AssemblyLinearVelocity

A velocidade linear do conjunto da parte.

A soma da massa de todas as `Class.BasePart|BaseParts` neste conjunto de
 parte. Partes que são `Class.BasePart.Massless|Massless` e não são a
 parte raiz do conjunto não contribuirão para a `AssemblyMass`.

Se o conjunto tiver uma parte ancorada, a massa do conjunto é considerada
 infinita. Restrições e outras interações físicas entre conjuntos não ancorados
 com uma grande diferença de massa podem causar instabilidades.

BasePart.AssemblyMass

Esta propriedade indica o `Class.BasePart` escolhido automaticamente para
 representar a parte raiz do conjunto. Se a parte não estiver conectada ao
 `Class.Workspace`, esta propriedade será `nil`.

A parte raiz pode ser mudada alterando o
 `Class.BasePart.RootPriority|RootPriority` das partes no conjunto.

Partes que compartilham o mesmo `AssemblyRootPart` estão no mesmo conjunto.

Para mais informações sobre partes raiz, veja
 [Assemblies](/physics/assemblies).

BasePart.AssemblyRootPart

Uma referência à parte raiz do conjunto.

`AudioCanCollide` determina se a parte interagirá fisicamente
 com a simulação de áudio, similar ao `Class.BasePart.CastShadow|CastShadow`
 para iluminação.

Quando desativado, o áudio passa através da parte; não é
 ocluído ou refletido.

BasePart.AudioCanCollide

Determina se a parte interagirá fisicamente com a simulação de áudio,
 similar ao `Class.BasePart.CastShadow|CastShadow` para
 iluminação.

Este exemplo de código demonstra como as propriedades de superfície podem ser definidas usando apenas um
NormalId (Cima, Frente, etc). Ele altera a -SurfaceInput de um motor de NoInput,
Constante e Sin para mostrar como cada um funciona usando as propriedades -ParamA e -ParamB.

A propriedade `BackParamA` é relevante quando a
 `Class.BasePart.BackSurface` de uma parte está configurada como Motor ou
 SteppingMotor e `Class.BasePart.BackSurfaceInput` está configurada como Sin. Isso
 determina a **amplitude** da velocidade rotacional do motor.

BasePart.BackParamA

Determina o primeiro parâmetro para o SurfaceType na face traseira de uma
 parte.

A propriedade `BackParamB` é relevante quando a
 `Class.BasePart.BackSurface` de uma parte está configurada como Motor ou
 SteppingMotor e `Class.BasePart.BackSurfaceInput` está configurada como Constant ou Sin. Para Constant,
 determina a velocidade rotacional constante do motor. Para Sin, determina a
 **frequência** da velocidade rotacional do motor.

BasePart.BackParamB

Determina o segundo parâmetro para o SurfaceType na face traseira de uma
 parte.

A propriedade `BackSurface` determina o tipo de superfície usada para o
 direcional **Z** positivo de uma parte. Quando as faces de duas partes estão
 colocadas uma ao lado da outra, podem criar uma junta entre elas.

BasePart.BackSurface

Determina o tipo de superfície para a face traseira de uma parte.

A propriedade `BackSurfaceInput` determina o tipo de entrada fornecida a uma
 superfície `Class.BasePart.BackSurface`. Isso é relevante apenas para Motor ou
 SteppingMotor SurfaceTypes. Esta propriedade determina como
 `Class.BasePart.BackParamA` e `Class.BasePart.BackParamB` são usadas. Para
 brevidade, essas propriedades serão referidas como ParamA e ParamB,
 respectivamente.

- Por padrão, isso é definido como NoInput. Isso para o motor completamente.
- Para Constant, o motor gira a uma velocidade constante igual a
  `ParamB`.
- Para Sin, o motor gira a uma velocidade igual a
  `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. Veja
  `Class.Workspace.DistributedGameTime`.

BasePart.BackSurfaceInput

Determina o tipo de entrada para a face traseira de uma parte.

A propriedade `BottomParamA` é relevante quando a parte
 `Class.BasePart.BottomSurface` está configurada como Motor ou
 SteppingMotor e `Class.BasePart.BottomSurfaceInput` está configurada como Sin. Isso
 determina a **amplitude** da velocidade rotacional do motor.

BasePart.BottomParamA

Determina o primeiro parâmetro para o SurfaceType na face inferior de uma
 parte.

A propriedade `BottomParamB` é relevante quando a parte
 `Class.BasePart.BottomSurface` está configurada como Motor ou
 SteppingMotor e `Class.BasePart.BottomSurfaceInput` está configurada como Constant ou Sin. Para
 Constant, determina a velocidade rotacional constante do motor. Para Sin, determina a
 **frequência** da velocidade rotacional do motor.

BasePart.BottomParamB

Determina o segundo parâmetro para o SurfaceType na face inferior de uma
 parte.

A propriedade `BottomSurface` determina o tipo de superfície usada para o
 direcional **Y** negativo de uma parte. Quando as faces de duas partes estão
 colocadas uma ao lado da outra, podem criar uma junta entre elas.

BasePart.BottomSurface

Determina o tipo de superfície para a face inferior de uma parte.

A classe base abstrata para objetos que interagem fisicamente no mundo.