A classe FormFactorPart é uma classe abstrata. Ela herda da classe `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 peça. Não faz mais nada.

FormFactorPart.FormFactor

Determina como uma peça se comporta 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.

`Class.BasePart` é uma classe base abstrata para objetos no mundo que são renderizados
 e são fisicamente simulados 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` (além
 de `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 mosaico às faces. Veja [Texturas e Decais](/parts/textures-decals).
- Um `Class.SurfaceGui` renderiza `Class.GuiObject|GuiObjects` na face de uma
  parte. Veja
  [Contêineres de UI In-Experience](/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
  [Restrições Mecânicas](/physics/mechanical-constraints) e
  [Restrições de Mover](/physics/mover-constraints).
- Objetos `Class.ParticleEmitter` emitem partículas uniformemente no volume do
  `Class.BasePart` ao qual estão parentados. Veja
  [Emissores de Partículas](/effects/particle-emitters).
- Objetos de luz como `Class.PointLight` emitem luz do centro de um
  `Class.BasePart`, como ilustrado em
  [Fontes de Luz](/effects/light-sources).
- Se parentado a um `Class.Tool` e dado o nome **Handle**, uma
  `Class.BasePart` pode ser segurada por personagens. Veja
  [Ferramentas In-Experience](/players/tools).


Disparado quando uma parte entra em contato com outro objeto. Este evento
apenas envia dados ao cliente notificando que duas partes colidiram,
 enquanto `Class.BasePart.Touched` envia dados ao servidor.


BasePart.LocalSimulationTouched

part

Disparado se a aparência da parte 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.

Dispara quando uma parte para de tocar outra parte em condições semelhantes às
 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 detecção.


BasePart.TouchEnded

Dispara quando uma parte para de tocar outra parte como resultado de movimento físico.


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 parte entra em contato com outra
parte. 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ó dispara como resultado de movimento físico, portanto, não
será disparado se a propriedade `Class.BasePart.CFrame|CFrame` foi alterada de forma que
 a parte sobreponha outra parte. Isso também significa que pelo menos uma das
partes envolvidas deve **não** estar `Class.BasePart.Anchored|Anchored` no
tempo 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 detecção.


BasePart.Touched

A outra parte que entrou em contato com a parte dada.


Dispara quando uma parte toca outra parte como resultado de movimento físico.


BasePart:AngularAccelerationToTorque

angAcceleration

angVelocity

Aplica uma força angular instantânea ao conjunto desta parte, fazendo
com que o conjunto gire.

A velocidade angular resultante do impulso depende da `Class.BasePart.AssemblyMass|massa`
do conjunto. Portanto, um impulso maior é necessário para mover conjuntos mais
massivos. Impulsos são úteis para casos onde você deseja aplicar uma força instantaneamente,
como uma explosão ou colisão.

Se a parte for [possuída](/physics/network-ownership) pelo
servidor, esta função deve ser chamada de um `Class.Script` do servidor (não
por 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 **propriedade** automática,
esta função pode ser chamada de um script de cliente **ou** de um script do servidor;
chamá-la de um script de cliente para uma parte do servidor não terá efeito.


BasePart:ApplyAngularImpulse

impulse

Um vetor de impulso angular a ser aplicado ao conjunto.


Esta função aplica um impulso de força instantâneo ao conjunto desta parte.

A força é aplicada no
`Class.BasePart.AssemblyCenterOfMass|centro de massa` do conjunto, então o movimento
resultante será apenas linear.

A velocidade resultante do impulso depende da `Class.BasePart.AssemblyMass|massa`
do conjunto. Portanto, um impulso maior é necessário para mover conjuntos mais
massivos. Impulsos são úteis para casos onde você deseja aplicar uma força instantaneamente,
como uma explosão ou colisão.

Se a parte for [possuída](/physics/network-ownership) pelo
servidor, esta função deve ser chamada de um `Class.Script` do servidor (não
por 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 **propriedade** automática,
esta função pode ser chamada de um script de cliente **ou** de um script do servidor;
chamá-la de um script de cliente para uma parte do servidor não terá efeito.


BasePart:ApplyImpulse

Um vetor de impulso linear a ser aplicado ao conjunto.


Aplica um impulso a um conjunto no
`Class.BasePart.AssemblyCenterOfMass|centro de massa` do conjunto.


Esta função aplica um impulso de força instantâneo ao conjunto desta parte, na
posição especificada no espaço do mundo.

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

A velocidade resultante do impulso depende da `Class.BasePart.AssemblyMass|massa`
do conjunto. Portanto, um impulso maior é necessário para mover conjuntos mais
massivos. Impulsos são úteis para casos onde
desenvolvedores querem uma força aplicada instantaneamente, como uma explosão ou
colisão.

Se a parte for [possuída](/physics/network-ownership) pelo
servidor, esta função deve ser chamada de um `Class.Script` do servidor (não
por 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 **propriedade** automática,
esta função pode ser chamada de um script de cliente **ou** de um script do servidor;
chamá-la de um script de cliente para uma parte do servidor não terá efeito.


BasePart:ApplyImpulseAtPosition

Um vetor de impulso a ser aplicado ao conjunto.


position

A posição, no espaço do mundo, para aplicar o impulso.


Aplica um impulso ao conjunto em uma posição especificada.


Quebra qualquer conexão de superfície com qualquer parte adjacente, incluindo
`Class.Weld` e outros `Class.JointInstance`.


BasePart:BreakJoints

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


BasePart:CanCollideWith

A parte especificada que está sendo verificada para colidibilidade.


Retorna se as partes 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 parte.

O valor de retorno da função verifica se você pode chamar
`Class.BasePart:SetNetworkOwner()` ou
`Class.BasePart:SetNetworkOwnershipAuto()` sem encontrar um erro.
Retorna verdadeiro se você pode modificar/ler a propriedade de rede, ou
retorna falso e o motivo pelo 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 parte.


BasePart:GetClosestPointOnSurface

Retorna uma tabela de partes conectadas ao objeto por qualquer tipo de junta
rígida.

Se `recursive` for verdadeiro, essa função retornará todas as partes do
conjunto rigidamente conectadas ao BasePart.

#### Juntas Rígidas

Quando uma junta conecta duas partes juntas `(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 junta:

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


BasePart:GetConnectedParts

recursive

Uma tabela de partes conectadas ao objeto por qualquer tipo de
`Class.JointInstance|joint`.


Retorna uma tabela de partes conectadas ao objeto por qualquer tipo de junta
rígida.


Retorna todos os Joints ou Constraints que estão conectados a esta Parte.


BasePart:GetJoints

Uma matriz de todos os Joints ou Constraints conectados à 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 precede a propriedade Mass. Ela permanece suportada para
compatibilidade retroativa; você deve usar a propriedade Mass diretamente.


BasePart:GetMass

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


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


BasePart:GetNetworkOwner

O jogador atual que é o proprietário de rede desta parte, ou `nil` em
caso do servidor.


Retorna verdadeiro se o mecanismo do jogo decidir automaticamente o proprietário de rede
para esta parte.


BasePart:GetNetworkOwnershipAuto

Se o mecanismo do jogo automaticamente decide o proprietário de rede para
esta parte.


BasePart:GetNoCollisionConstraints

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


BasePart:GetRenderCFrame

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


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

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


BasePart:GetRootPart

A parte base de um conjunto (uma coleção de partes conectadas
todas juntas).


Retorna a parte base de um conjunto de partes.


Retorna uma tabela de todas as partes que estão fisicamente interagindo com esta
parte. Se a própria parte tiver CanCollide definido como falso, essa função
retorna uma tabela vazia, a menos que a parte tenha um
`Class.TouchTransmitter|TouchInterest` objeto parentado a ela (significando
que algo está conectado ao seu evento Touched). Partes que estão adjacentes, mas
não estão se sobrepondo, não são consideradas tocando. Esta função precede a
`Class.WorldRoot:GetPartsInPart()` função, 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 partes que intersectam e podem colidir com esta parte.


Retorna uma tabela de todas as partes `Class.BasePart.CanCollide` verdadeiras que
intersectam com esta parte.


Retorna a velocidade linear do conjunto da parte na posição dada
relativa a esta parte. Ela pode ser usada para identificar a velocidade linear de
partes em um conjunto que não sejam a parte raiz. Se o conjunto não tiver
velocidade angular, a velocidade linear será sempre a mesma para
cada posição.


BasePart:GetVelocityAtPosition

Retorna a velocidade linear do conjunto da parte na posição dada
relativa a esta parte.


Cria uma nova `Class.IntersectOperation` a partir da geometria que se interseca da
parte e das outras partes na matriz dada. Apenas `Class.Part|Parts`
são suportadas, não `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semelhante a
`Class.Instance:Clone()|Clone()`, o objeto retornado não tem um
`Class.Instance.Parent|Parent` definido.

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

- `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()` é chamado no bloco roxo usando
uma tabela contendo o bloco azul. O `Class.IntersectOperation` resultante se resolve
em uma forma da geometria que se intersecta de ambas as partes.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Intersect.jpg"
width="720" alt="Duas peças de bloco sobrepostas" />
<figcaption>Pecas 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 o `Class.IntersectOperation` retornado
  ao mesmo lugar que a parte chamadora `Class.BasePart`.
- 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
  `Class.PartOperation.UsePartColor|UsePartColor` propriedade como `true`.
- Se uma operação de interseção resultasse 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 `Enum.CollisionFidelity` para o resultado
`Class.IntersectOperation`.


renderFidelity

O valor `Enum.RenderFidelity` do resultado
`Class.PartOperation`.


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


Cria uma nova `Class.IntersectOperation` a partir da geometria sobreposta da
parte e das outras partes na matriz dada.


Retorna verdadeiro se o objeto estiver conectado a uma parte que o manterá no
lugar (por exemplo, uma parte `Class.BasePart.Anchored|Anchored`), caso contrário, retorna
falso. Em um conjunto que contém uma parte `Class.BasePart.Anchored|Anchored`,
todas as outras partes estão fixas.


BasePart:IsGrounded

Se o objeto está conectado a uma parte que o manterá no lugar.


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


Cria uma junta em qualquer lado do `Class.BasePart|Part` que tenha um
`Enum.SurfaceType` que pode fazer uma junta, ela criará uma junta com quaisquer
partes adjacentes.

As juntas serão criadas entre os lados e quaisquer superfícies planas tocantes,
dependendo nas superfícies dos lados.

- Superfícies lisas não criarão juntas.
- Superfícies de cola criarão uma junta `Class.Glue`.
- Juntas de solda criarão uma junta `Class.Weld` com qualquer superfície, exceto
  Unjoinable.
- Estúdios, Inlet ou Universal criarão cada uma uma junta `Class.Snap`
  com outras duas superfícies (por exemplo, Estúdios com Inlet e
  Universal).
- Superfícies de articulação e motor criam instâncias de juntas `Class.Rotate`
e `Class.RotateV`.

Diferente de `Class.Model:MakeJoints()`, esta função requer um array de
partes como parâmetro. Este array é dado da seguinte forma:

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


BasePart:MakeJoints

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


Muda o tamanho de um objeto exatamente como usar a ferramenta de redimensionamento do Estúdio.


BasePart:Resize

normalId

deltaAmount

Quanto crescer/reduzir no lado especificado.


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


BasePart:SetNetworkOwner

playerInstance

O jogador a quem está sendo dado a propriedade de rede da parte.


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


Permite que o mecanismo do jogo decida dinamicamente quem irá lidar com a física da parte
(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 na matriz dada. Apenas `Class.Part|Parts` são
suportadas, não `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semelhante a
`Class.Instance:Clone()|Clone()`, o objeto retornado não tem um
`Class.Instance.Parent|Parent` definido.

Note 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()` é chamado no cilindro azul usando uma tabela contendo o bloco roxo. O
`Class.UnionOperation` resultante se resolve 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 mais 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ída do cilindro" />
<figcaption>Resultado <code>Class.UnionOperation</code></figcaption>
</figure>


BasePart:SubtractAsync

Os objetos que participam da subtração.


O valor `Enum.CollisionFidelity` para o resultado
`Class.UnionOperation`.


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


Cria uma nova `Class.UnionOperation` a partir da parte, menos a geometria
ocupada pelas partes na matriz dada.


BasePart:TorqueToAngularAcceleration

torque

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` da parte, mais a geometria
ocupada pelas partes na matriz dada. Apenas `Class.Part|Parts` são
suportadas, não `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semelhante a
`Class.Instance:Clone()|Clone()`, o objeto retornado não tem um
`Class.Instance.Parent|Parent` definido.

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

- `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()` é chamado no bloco azul usando
uma tabela contendo o cilindro roxo. O `Class.UnionOperation` resultante se
resolve em uma forma da geometria combinada de ambas as partes.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Union.jpg"
width="720" alt="Bloco e partes de cilindro sobrepostos" />
<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 o `Class.UnionOperation` retornado ao
  mesmo lugar que a parte chamadora `Class.BasePart`.
- Por padrão, a união resultante respeita a
  `Class.BasePart.Color|Color` propriedade de cada uma de suas partes. Para
  mudar toda a união para uma cor específica, defina sua
  `Class.PartOperation.UsePartColor|UsePartColor` propriedade como `true`.
- Se uma operação de união resultasse 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.


Cria uma nova `Class.UnionOperation` da parte, mais a geometria
ocupada pelas partes na matriz dada.


BasePart:breakJoints

BasePart:getMass

BasePart:makeJoints

BasePart:resize

BasePart

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

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

Uma parte ancorada pode ser ainda movida alterando seu
`Class.BasePart.CFrame|CFrame` ou `Class.BasePart.Position|Position`, e
pode ainda 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 através de
um objeto como um `Class.Weld`, ela também funcionará como ancorada. Se tal junta
se romper, a parte poderá ser afetada pela física novamente. Veja
[Assemblies](/physics/assemblies) para mais detalhes.

A propriedade de propriedade da rede não pode ser definida em partes ancoradas. Se o
tipo de ancoragem de uma parte mudar no servidor, a propriedade de rede daquela 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 de orientação em radianos por segundo.

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

Definir a velocidade diretamente pode levar a um movimento não realista. Usar
`Class.Torque` ou `Class.AngularVelocity` como restrição é preferível, ou use
`Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()` se você quiser
uma mudança instantânea na velocidade.

Se a parte for [possessa](/physics/network-ownership) pelo
servidor, esta propriedade deve ser alterada de um `Class.Script` no servidor (não
 de um `Class.LocalScript` ou de um `Class.Script` com
`Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
Se a parte for possessa por um cliente através de uma propriedade **automática**,
esta propriedade pode ser alterada tanto de um script cliente **ou** de um script
no servidor; mudar isso de um script cliente para uma parte de propriedade do 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.

Saber 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,
só linear. Um conjunto com um baixo centro de massa terá um desempenho melhor
em permanecer em pé sob a influência da gravidade.


BasePart.AssemblyCenterOfMass

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


O vetor de velocidade linear do conjunto desta 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 um movimento não realista. Usar uma
restrição `Class.VectorForce` é preferível, ou use
`Class.BasePart:ApplyImpulse()|ApplyImpulse()` se você quiser uma
mudança instantânea na velocidade.

Se a parte for [possessa](/physics/network-ownership) pelo
servidor, esta propriedade deve ser alterada de um `Class.Script` no servidor (não
 de um `Class.LocalScript` ou de um `Class.Script` com
`Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
Se a parte for possessa por um cliente através de uma propriedade **automática**, esta
propriedade pode ser alterada tanto de um script cliente **ou** de um script no servidor;
mudar isso de um script cliente para uma parte de propriedade do servidor não terá
efeito.


BasePart.AssemblyLinearVelocity

A velocidade linear do conjunto da parte.


A soma da massa de todos os `Class.BasePart|BaseParts` no conjunto desta 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 causarinstabilidade.


BasePart.AssemblyMass

Essa propriedade indica a `Class.BasePart` escolhida automaticamente para
representar a parte raiz do conjunto. Se a parte não estiver parentada ao
`Class.Workspace`, essa propriedade será `nil`.

A parte raiz pode ser alterada mudando a
`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 raízes, 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, semelhante a `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 a `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`
está configurada para Motor ou SteppingMotor e `Class.BasePart.BackSurfaceInput`
está definida como Sin. Ela 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`
está configurada para Motor ou SteppingMotor e `Class.BasePart.BackSurfaceInput`
está definida como Constante ou Sin. Para Constante, 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 usado para a
direção positiva **Z** de uma parte. Quando as faces de duas partes sã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 para a
`Class.BasePart.BackSurface` de uma parte. Isso é relevante apenas para Motor ou
SteppingMotor SurfaceTypes. Essa propriedade determina como
`Class.BasePart.BackParamA` e `Class.BasePart.BackParamB` são usados. Para
abreviar, essas propriedades serão referidas como ParamA e ParamB,
respectivamente.

- Por padrão, isso está definido como NoInput. Isso para o motor completamente.
- Para Constante, 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 `Class.BasePart.BottomSurface`
está configurada para Motor ou SteppingMotor e `Class.BasePart.BottomSurfaceInput`
está definida como Sin. Ela 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 `Class.BasePart.BottomSurface`
está configurada para Motor ou SteppingMotor e `Class.BasePart.BottomSurfaceInput`
está definida como Constante ou Sin. Para Constante, 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 usado para a
direção negativa **Y** de uma parte. Quando as faces de duas partes sã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 propriedade `BottomSurfaceInput` determina o tipo de entrada fornecida para
 uma parte `Class.BasePart.BottomSurface`. Isso é relevante apenas para Motor
ou SteppingMotor SurfaceTypes. Esta propriedade determina como
`Class.BasePart.BottomParamA` e `Class.BasePart.BottomParamB` são usados.
Para abreviar, essas propriedades serão referidas como ParamA e ParamB,
respeitivamente.

- Por padrão, isso está definido como NoInput. Isso para o motor completamente.
- Para Constante, 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.BottomSurfaceInput

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


Essa propriedade determina a cor de uma parte. Se a parte tiver um
`Class.BasePart.Material|Material`, isso também determina a cor usada
quando renderizando a textura do material. Para mais controle sobre a cor, a
propriedade `Class.BasePart.Color|Color` pode ser usada e essa propriedade irá
usar o `BrickColor` mais próximo.

Outras propriedades visuais de uma parte são determinadas por
`Class.BasePart.Transparency|Transparency` e
`Class.BasePart.Reflectance|Reflectance`.


BasePart.BrickColor

Este exemplo de código demonstra a configuração do CFrame de uma parte de várias maneiras diferentes.
Ele mostra como criar e compor valores de CFrame. Ele faz referência a uma parte irmã
chamada "OtherPart" para demonstrar posicionamento relativo.

A propriedade `CFrame` determina tanto a posição quanto a orientação do
`Class.BasePart` no mundo. Ela atua como uma localização de referência arbitrária
na geometria, mas `Class.BasePart.ExtentsCFrame|ExtentsCFrame`
representa o `Datatype.CFrame` real de seu centro físico.

Ao definir `CFrame` em uma parte, outras partes unidas também são movidas
relativas à parte, mas é recomendado que você use
`Class.PVInstance:PivotTo()` para mover um modelo inteiro, como quando
teletransportando o personagem de um jogador.

Ao contrário de definir `Class.BasePart.Position`, definir `CFrame` sempre
moverá a parte para o `Datatype.CFrame` exato dado; em outras palavras: **nenhuma
verificação de sobreposição é feita** e o solucionador de física tentará resolver
qualquer sobreposição a menos que ambas as partes estejam `Class.BasePart.Anchored|Anchored`.

Para acompanhar as posições relativas ao `Datatype.CFrame` de uma parte, um
`Class.Attachment` pode ser útil.


BasePart.CFrame

Determina a posição e orientação do `Class.BasePart` no mundo.


Este exemplo de código mostra como uma peça pode desaparecer quando tocada por um Humanoid
e então reaparecer um momento depois para criar uma porta passável.

`CanCollide` determina se uma parte interagirá fisicamente com outras
partes. Quando desativado, outras partes podem passar pela parte sem
interrupções. Partes usadas para **decoração** geralmente têm `CanCollide`
desativado, pois não precisam ser consideradas pelo motor de física.

Se uma parte não estiver `Class.BasePart.Anchored|Anchored` e tiver `CanCollide`
desativado, ela pode cair do mundo e eventualmente ser destruída por
`Class.Workspace.FallenPartsDestroyHeight`.

Quando `CanCollide` está desativado, partes ainda podem disparar o
evento `Class.BasePart.Touched|Touched` (assim como as outras partes que as tocam).
Você pode desativar isso com `Class.BasePart.CanTouch|CanTouch`.

Para mais informações sobre colisões, veja
[Colisões](/workspace/collisions).


BasePart.CanCollide

Determina se uma parte pode colidir com outras partes.


Esta propriedade determina se a parte é considerada durante consultas
espaciais, como
`Class.WorldRoot:GetPartBoundsInBox()|GetPartBoundsInBox` ou
`Class.WorldRoot:Raycast()|Raycast`. Note que
`Class.BasePart.CanCollide|CanCollide` deve ser desativado para que `CanQuery`\ tenhas efeito, e funções de consulta espacial nunca incluirão partes com
`CanQuery` definido como `false`.

Além desta propriedade, também é possível excluir partes que são
decendentes de uma lista específica de partes usando um objeto
`Datatype.OverlapParams` ou `Datatype.RaycastParams` ao chamar as funções
de consulta espacial.


BasePart.CanQuery

Determina se a parte é considerada durante operações de consulta espacial.


Esta propriedade determina se `Class.BasePart.Touched|Touched` e
`Class.BasePart.TouchEnded|TouchEnded` eventos disparam na parte. Se `true`,
outros partes que tocam também devem ter `CanTouch` definido como `true` para eventos de toque dispararem. Se `false`, eventos de toque não podem ser configurados para a parte e
procurar fazê-lo gerará um erro. Da mesma forma, se a propriedade for definida
como `false` após um evento de toque estar conectado, o evento será
desconectado e o `Class.TouchTransmitter` removido.

Note que essa lógica de colisão pode ser definida para respeitar
grupos de colisão através da propriedade `Class.Workspace.TouchesUseCollisionGroups`. Se
`true`, partes em grupos não colidindo ignorarão tanto colisões **quanto**
eventos de toque, tornando essa propriedade irrelevante.

#### Performance

Há um pequeno ganho de desempenho em partes que têm tanto `CanTouch` quanto
`Class.BasePart.CanCollide|CanCollide` definidos como `false`, pois essas partes
nunca precisarão calcular qualquer tipo de colisões entre partes. No entanto, ainda
podem ser atingidas por `Class.WorldRoot:Raycast()|Raycasts` e consultas
`Datatype.OverlapParams`.


BasePart.CanTouch

Determina se `Class.BasePart.Touched|Touched` e
`Class.BasePart.TouchEnded|TouchEnded` eventos disparam na parte.


Determina se uma parte projeta sombra. Desabilitar esta propriedade
para uma parte dada pode causar artefatos visuais nas sombras projetadas sobre
essa parte.

Esta propriedade não é projetada para melhoria de desempenho, mas em cenas complexas,
desabilitá-la estrategicamente em certas partes pode melhorar
o desempenho. Devido à possibilidade de artefatos visuais, recomendamos
mantê-la habilitada em todas as partes na maioria das situações.


BasePart.CastShadow

Determina se uma parte projeta sombra ou não.


A propriedade `CenterOfMass` descreve a posição **local** do centro de massa de uma parte. Se isso for um conjunto de uma única parte, este é o
`Class.BasePart.AssemblyCenterOfMass|AssemblyCenterOfMass` convertido do espaço do mundo para o local. Em partes simples `Class.Part|Parts`, o centro de massa
é sempre `(0, 0, 0)`, mas pode variar para `Class.WedgePart` ou
`Class.MeshPart`.


BasePart.CenterOfMass

Descreve a posição no mundo onde o centro de massa de uma parte está localizado.


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


/reference/engine/classes/FormFactorPart.yaml