Los objetos de Asiento de vehículo soldan un jugador al asiento cuando el jugador toca el asiento.Luego envía las teclas de movimiento a cualquier junta motora conectada, permitiendo el control de un vehículo.

  Si bien los asientos de vehículos son geniales para hacer vehículos simples, tienen algunas limitaciones.El control de movimiento solo detectará motores conectados directamente al asiento del vehículo o a través de otra conexión rígida.Esto significa que si tienes una rueda conectada a un rayo que luego se solda al asiento, funcionará bien, sin embargo, si tienes la rueda conectada a una parte, que está conectada por bisagra al resto del automóvil, no funcionará.

Obliga al personaje con el especificado `Class.Humanoid` a sentarse en el asiento del vehículo.

VehicleSeat:Sit

humanoid

El humanoide obligado a sentarse en el asiento del vehículo.

VehicleSeat

Muestra cuántas bisagras son detectadas por el asiento del vehículo. Útil para depurar diseños de vehículos.

VehicleSeat.AreHingesDetected

Alterna si el `Class.VehicleSeat` está activo o no.Si el asiento está deshabilitado, entonces no se soldará automáticamente un personaje a él al colisionar y no permitirá que un personaje controle el vehículo conectado.

VehicleSeat.Disabled

Alterna si el `Class.VehicleSeat` está activo o no.

Si es verdad, una barra de velocidad elegante se mostrará en la pantalla que te dice a qué velocidad se mueve el vehículo.

VehicleSeat.HeadsUpDisplay

La velocidad máxima que se puede alcanzar.

VehicleSeat.MaxSpeed

El humanoide que está sentado en el asiento

VehicleSeat.Occupant

El humanoide que está sentado en el asiento.

La dirección de movimiento, atada a las teclas A y D.Debe ser uno de 1 (derecha), 0 (recto) o -1 (izquierda).Se actualizará de nuevo a 0 a menos que se establecerconstantemente.

VehicleSeat.Steer

Funciona de forma idéntica a `Class.VehicleSeat.Steer`, pero el valor no es un entero.

VehicleSeat.SteerFloat

La dirección de movimiento, atada a las teclas W y S.Debe ser un entero 1 (adelante) 0 (nulo) o -1 (inversa).Se actualizará de nuevo a 0 a menos que se establecerconstantemente.

VehicleSeat.Throttle

Funciona de forma idéntica a `Class.VehicleSeat.Throttle`, pero el valor no es un entero.

VehicleSeat.ThrottleFloat

Cuán rápido los vehículos podrán alcanzar `Class.VehicleSeat.MaxSpeed`. Cuanto mayor sea el número, más rápido alcanzará la velocidad máxima.

VehicleSeat.Torque

La velocidad a la que girará el vehículo. Los números más altos pueden causar problemas y no necesariamente son mejores.

VehicleSeat.TurnSpeed

Un objeto de asiento que se puede utilizar para controlar un vehículo.

`Class.BasePart` es una clase base abstracta para objetos en el mundo que se renderizan y se simulan físicamente mientras están en el `Class.Workspace`.Hay varias implementaciones de `Class.BasePart` , la más común siendo `Class.Part` y `Class.MeshPart` .Otros incluyen `Class.WedgePart` , `Class.SpawnLocation` , y el objeto singleton `Class.Terrain` .Generalmente, cuando la documentación se refiere a una "parte", la mayoría de las implementaciones `Class.BasePart` trabajarán y no solo `Class.Part` .

  Para obtener información sobre cómo se agrupan `Class.BasePart|BaseParts` en cuerpos rígidos simulados, consulte [ensamblajes](/physics/assemblies) .

  Hay muchos objetos diferentes que interactúan con `Class.BasePart` (diferentes a `Class.Terrain` ), incluyendo:

  *   Varios `Class.BasePart|BaseParts` pueden agruparse dentro de un `Class.Model` y moverse al mismo tiempo usando `Class.PVInstance:PivotTo()` . Ver [modelos](/parts/models) .
  *   Un `Class.Decal` aplica una textura de imagen estirada a las caras de un `Class.BasePart` , mientras que un `Class.Texture` aplica una textura de imagen azulejada a las caras.Vea [Texturas y decoraciones](/parts/textures-decals).
  *   Un `Class.SurfaceGui` renderiza `Class.GuiObject|GuiObjects` en la cara de una parte. Ver [Contenedores de interfaz de usuario en experiencia](/ui/in-experience-containers) .
  *   `Class.Attachment|Attachments` se puede agregar a un `Class.BasePart` para especificar `Datatype.CFrame|CFrames` relativo a la parte.Estos se utilizan a menudo por objetos físicos `Class.Constraint` como se describe en [Con restricciones mecánicas](/physics/mechanical-constraints) y [Con restricciones de movimiento](/physics/mover-constraints).
  *   `Class.ParticleEmitter` objetos emiten partículas de manera uniforme en el volumen del `Class.BasePart` al que están asociados. Ver [Emisores de partículas](/effects/particle-emitters) .
  *   Los objetos ligeros como `Class.PointLight` emiten luz desde el centro de un `Class.BasePart` como se ilustra en [Fuentes de luz](/effects/light-sources) .
  *   Si se padre a un `Class.Tool` y se le da el nombre **Handle** , un `Class.BasePart` puede ser mantenido por los personajes. Vea [Herramientas en la experiencia](/players/tools) .

Disparado cuando otra parte entra en contacto con otro objeto.Este evento solo envía datos al cliente notificándole que dos partes se han colisionado, mientras que `Class.BasePart.Touched` envía datos al servidor.

BasePart.LocalSimulationTouched

part

Despedido si la apariencia de la parte es afectada por la clase `Class.Shirt`.

BasePart.OutfitChanged

BasePart.StoppedTouching

otherPart

This code sample creates a BillboardGui on a part that displays the number of
parts presently touching it.

Se enciende cuando una parte deja de tocar a otra parte en condiciones similares a las de `Class.BasePart.Touched` .

  Este evento funciona en conjunción con `Class.Workspace.TouchesUseCollisionGroups` para especificar si [grupos de colisión](/workspace/collisions#collision-filtering) se reconocen para la detección

BasePart.TouchEnded

Se enciende cuando una parte deja de tocar a otra parte como resultado de un movimiento físico.

This code sample demonstrates how to connect the `Class.BasePart.Touched` event of multiple parts in a `Class.Model` to one function.

El evento **Tocado** se activa cuando una parte entra en contacto con otra parte.Por instancia, si **ParteA** se choca con **ParteB** , entonces `Class.BasePart.Touched|PartA.Touched` dispara con **ParteB** , y `Class.BasePart.Touched|PartB.Touched` dispara con **ParteA** .

  Este evento solo se activa como resultado de un movimiento físico, por lo que no se activará si la propiedad `Class.BasePart.CFrame|CFrame` cambia para que la parte se sobreponga a otra parte.Esto también significa que al menos una de las partes involucradas debe **no** estar `Class.BasePart.Anchored|Anchored` en el momento de la colisión

  Este evento funciona en conjunción con `Class.Workspace.TouchesUseCollisionGroups` para especificar si [grupos de colisión](/workspace/collisions#collision-filtering) se reconocen para la detección

BasePart.Touched

La otra parte que entró en contacto con la parte dada.

Se enciende cuando una parte toca a otra parte como resultado de un movimiento físico.

BasePart:AngularAccelerationToTorque

angAcceleration

angVelocity

Aplica un impulso de fuerza ángular instantáneo a la montura de esta parte, lo que hace que la montura gire.

  La velocidad ángular resultante del impulso depende de la `Class.BasePart.AssemblyMass|mass` de la montura.Así que se requiere un impulso más alto para mover ensambles más masivos.Los impulsos son útiles para casos en los que se desea aplicar una fuerza de forma instantánea, como una explosión o colisión.

  Si la parte es [propiedad](/physics/network-ownership) del servidor, esta función debe llamarse desde un servidor `Class.Script` (no desde un `Class.LocalScript` o un `Class.Script` con `Class.BaseScript.RunContext|RunContext` configurado para `Enum.RunContext.Client` ).Si la parte es propiedad de un cliente a través de **propiedad automática** , esta función se puede llamar desde un script de cliente **o** un script del servidor; llamarla desde un script de cliente para una parte propiedad del servidor no tendrá efecto.

BasePart:ApplyAngularImpulse

impulse

Un vector de impulso ángulo para aplicar a la montura.

Esta función aplica un impulso de fuerza instantáneo a la montura de esta parte.

  La fuerza se aplica en la reunión de `Class.BasePart.AssemblyCenterOfMass|center of mass`, por lo que el movimiento resultante solo será lineal.

  La velocidad resultante del impulso depende de la `Class.BasePart.AssemblyMass|mass` de la montura.Así que se requiere un impulso más alto para mover ensambles más masivos.Los impulsos son útiles para casos en los que se desea aplicar una fuerza de forma instantánea, como una explosión o colisión.

  Si la parte es [propiedad](/physics/network-ownership) del servidor, esta función debe llamarse desde un servidor `Class.Script` (no desde un `Class.LocalScript` o un `Class.Script` con `Class.BaseScript.RunContext|RunContext` configurado para `Enum.RunContext.Client` ).Si la parte es propiedad de un cliente a través de **propiedad automática** , esta función se puede llamar desde un script de cliente **o** un script del servidor; llamarla desde un script de cliente para una parte propiedad del servidor no tendrá efecto.

BasePart:ApplyImpulse

Un vector de impulso lineal para aplicar a la montura.

Aplica un impulso a la asamblea en la asamblea `Class.BasePart.AssemblyCenterOfMass|center of mass` .

Esta función aplica un impulso de fuerza instantáneo a la montura de esta parte, en la posición especificada en el espacio mundial.

  Si la posición no está en la `Class.BasePart.AssemblyCenterOfMass|center of mass` del montaje, el impulso causará un movimiento posicional y rotatorio.

  La velocidad resultante del impulso depende de la `Class.BasePart.AssemblyMass|mass` de la montura.Así que se requiere un impulso más alto para mover ensambles más masivos.Los impulsos son útiles para casos en los que los desarrolladores quieren una fuerza aplicada instantáneamente, como una explosión o colisión.

  Si la parte es [propiedad](/physics/network-ownership) del servidor, esta función debe llamarse desde un servidor `Class.Script` (no desde un `Class.LocalScript` o un `Class.Script` con `Class.BaseScript.RunContext|RunContext` configurado para `Enum.RunContext.Client` ).Si la parte es propiedad de un cliente a través de **propiedad automática** , esta función se puede llamar desde un script de cliente **o** un script del servidor; llamarla desde un script de cliente para una parte propiedad del servidor no tendrá efecto.

BasePart:ApplyImpulseAtPosition

Un vector de impulso para aplicar a la montura.

position

La posición, en el espacio mundial, para aplicar el impulso.

Aplica un impulso a la montura en la posición especificada.

Rompe cualquier conexión de superficie con cualquier parte adyacente, incluida `Class.Weld` y otras `Class.JointInstance`.

BasePart:BreakJoints

Devuelve si las partes pueden chocar entre sí o no.Esta función tiene en cuenta los grupos de colisión de las dos partes.Esta función fallará si la parte especificada no es una BasePart.

BasePart:CanCollideWith

La parte especificada que se está verificando por posibles colisiones.

Devuelve si las partes pueden chocar entre sí.

Este ejemplo comprueba si el propietario de la red del primer `BasePart` llamado *Parte* en el `Workspace` se puede establecer o no.

La función CanSetNetworkOwnership comprueba si puedes establecer la propiedad de red de una parte.

  El valor de devolución de la función verifica si puedes llamar `Class.BasePart:SetNetworkOwner()` o `Class.BasePart:SetNetworkOwnershipAuto()` sin encontrar un error.Devuelve verdadero si puedes modificar/leer la propiedad de la red o devuelve falso y la razón por la que no puedes, como una cadena.

BasePart:CanSetNetworkOwnership

Si puedes modificar o leer la propiedad de la red y la razón.

Comprueba si puedes establecer la propiedad de red de una parte.

BasePart:GetClosestPointOnSurface

Devuelve una tabla de partes conectadas al objeto por cualquier tipo de articulaciónrígida.

  Si `recursive` es verdadera, esta función devolverá todas las partes en la ensambladora conectadas rípidamente a la BasePart.

  #### Juntas rígidas

  Cuando una junta conecta dos partes juntas `(Part0 → Part1)` , una junta es **rígida** si la física de `Part1` está completamente bloqueada por `Part0` .Esto solo se aplica a los siguientes tipos conjuntos:

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

BasePart:GetConnectedParts

recursive

Una tabla de partes conectadas al objeto por cualquier tipo de `Class.JointInstance|joint` .

Devuelve una tabla de partes conectadas al objeto por cualquier tipo de articulaciónrígida.

Devuelve todas las juntas o restricciones que estén conectadas a esta parte.

BasePart:GetJoints

Un array de todas las juntas o restricciones conectadas a la parte.

Este ejemplo crea una nueva parte, myPart, en el espacio de trabajo del juego, con dimensiones de 4x6x4 tacos. La parte también está anclada.

  Entonces, myMass se establece para igualar la masa de la nueva parte. La masa de la parte se imprime al final de la declaración de impresión:

  > La masa de mi parte es...

**GetMass** devuelve el valor de la propiedad de solo lectura `Class.BasePart.Mass|Mass`.

  Esta función precede a la propiedad de masa. Sigue siendo compatible para la compatibilidad con versiones anteriores; debe usar la propiedad de masa directamente.

BasePart:GetMass

Devuelve el valor de la propiedad `Class.BasePart.Mass|Mass` .

Devuelve al jugador actual que es el propietario de la red de esta parte, o `nil` en caso del servidor.

BasePart:GetNetworkOwner

El jugador actual que es el propietario de la red de esta parte, o `nil` en caso del servidor.

Devuelve verdadero si el motor de juegos decide automáticamente al propietario de la red para esta parte.

BasePart:GetNetworkOwnershipAuto

Si el motor de juegos decide automáticamente al propietario de la red para esta parte.

BasePart:GetNoCollisionConstraints

Esta función solía ser relevante cuando la interpolación de partes de compensación de lag de Roblox en línea era interna.La interpolación ahora se aplica directamente al `Datatype.CFrame` .

BasePart:GetRenderCFrame

OBSOBETE. Devuelve un marco C que describe dónde se está renderizando la parte.

Devuelve la parte base de una asamblea.Al mover una asamblea de piezas usando un `Datatype.CFrame` .es importante mover esta parte base (esto moverá todas las otras partes conectadas a ella de acuerdo).Más información está disponible en el artículo [Ensamblajes](/physics/assemblies).

  Esta función precede a la propiedad `Class.BasePart.AssemblyRootPart|AssemblyRootPart` . Se mantiene admitida para la compatibilidad con versiones anteriores, pero deberías usar `Class.BasePart.AssemblyRootPart|AssemblyRootPart` directamente.

BasePart:GetRootPart

La parte base de una ensamblación (una colección de partes conectadas entre sí).

Devuelve la parte base de una colección de partes.

Devuelve una tabla de todas las partes que interactúan físicamente con esta parte.Si la propia parte tiene CanCollide establecido en falso, entonces esta función devuelve una tabla vacía a menos que la parte tenga un objeto `Class.TouchTransmitter|TouchInterest` asociado a ella (lo que significa que algo está conectado a su evento Tocado).Las piezas que son adyacentes pero no se intersectan no se consideran que tocan.Esta función precede a la función `Class.WorldRoot:GetPartsInPart()` que proporciona más flexibilidad y evita las reglas especiales `Class.TouchTransmitter|TouchInterest` descritas anteriormente.Usa `Class.WorldRoot:GetPartsInPart()` en lugar.

BasePart:GetTouchingParts

Una tabla de todas las partes que se intersectan y pueden chocar con esta parte.

Devuelve una tabla de todas las `Class.BasePart.CanCollide` piezas verdaderas que se intersectan con esta parte.

Devuelve la velocidad lineal de la montura de la pieza en la posición dada con respecto a esta pieza.Se puede utilizar para identificar la velocidad lineal de las piezas en una ensambladora diferente a la pieza raíz.Si la asamblea no tiene velocidad ángular, entonces la velocidad lineal siempre será la misma para cada posición.

BasePart:GetVelocityAtPosition

Devuelve la velocidad lineal de la montura de la pieza en la posición dada con respecto a esta pieza.

Devuelve verdadero si el objeto está conectado a una parte que lo mantendrá en su lugar (por ejemplo, una parte `Class.BasePart.Anchored|Anchored`), de lo contrario devuelve falso.En una asamblea que tiene una parte `Class.BasePart.Anchored|Anchored` parte, todas las demás partes están ancladas.

BasePart:IsGrounded

Si el objeto está conectado a una parte que lo mantendrá en su lugar.

Devuelve verdadero si el objeto está conectado a una parte que lo mantendrá en su lugar (por ejemplo, una parte `Class.BasePart.Anchored|Anchored`), de lo contrario devuelve falso.

Crea una soldadura en cualquier lado del `Class.BasePart|Part` que tenga una `Enum.SurfaceType` que pueda crear una soldadura que creará con cualquier parte adyacente.

  Se crearán juntas entre los lados y cualquier superficie de contacto plana, dependiendo de las superficies de los lados.

  *   Las superficies lisas no crearán articulaciones
  *   Las superficies adhesivas crearán una articulación`Class.Glue`
  *   Weld creará una junta `Class.Weld` con cualquier superficie excepto Unjoinable
  *   Studs, Inlet o Universal crearán cada uno una junta `Class.Snap` con cualquiera de las otras dos superficies (por ejemplo, Studs con Inlet y Universal)
  *   Las superficies bisagra y motor crean instancias compartidas `Class.Rotate` y `Class.RotateV`

  A diferencia de `Class.Model:MakeJoints()`, esta función requiere un array de partes como parámetro. Este array se da como sigue:

  ```
  part:MakeJoints({part1, part2, part3})
  ```

  Las articulaciones se rompen si se aplica suficiente fuerza a ellas debido a un `Class.Explosion` , a menos que se asigne un objeto `Class.ForceField` a la `Class.BasePart` o al ancestro `Class.Model` .Por esta razón, a menudo se utilizan para hacer edificios destructibles simples y otros modelos.

BasePart:MakeJoints

Crea una junta en cualquier lado del objeto que tenga una identificación de superficie que pueda hacer una articulación.

Cambia el tamaño de un objeto al igual que usando la herramienta de redimensionamiento de Studio.

BasePart:Resize

normalId

deltaAmount

Cuánto crecer/encogerse en el lado especificado.

Establece al jugador dado como propietario de la red para esto y todas las piezas conectadas.Cuando playerInstance es `nil`, el servidor será el propietario en lugar de un jugador.

BasePart:SetNetworkOwner

playerInstance

El jugador que recibe la propiedad de red de la parte.

Establece al jugador dado como propietario de la red para esto y todas las piezas conectadas.

Permite que el motor de juegos decida dinámicamente quién manejará la física de la parte (uno de los clientes o el servidor).

BasePart:SetNetworkOwnershipAuto

BasePart:TorqueToAngularAcceleration

torque

BasePart:breakJoints

BasePart:getMass

BasePart:makeJoints

BasePart:resize

Crea un nuevo `Class.IntersectOperation` de la geometría interseccionada de la pieza y de las otras piezas en el matriz/listadado.Solo se admiten `Class.Part|Parts` , no `Class.Terrain` o `Class.MeshPart|MeshParts` .Al igual que `Class.Instance:Clone()|Clone()` , el objeto devuelto no tiene ningún set `Class.Instance.Parent|Parent` .

  Las siguientes propiedades de la parte llamante se aplican al resultante `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`

  En la siguiente comparación de imágenes, `Class.BasePart:IntersectAsync()|IntersectAsync()` se llama al bloque púrpura usando una tabla que contiene el bloquesazul.El resultante `Class.IntersectOperation` se resuelve en una forma de la geometría interseccional de ambas partes.

  <figure>
    <img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Intersect.jpg" width="720" alt="Two block parts overlapping" />

    <figcaption>Separar piezas</figcaption>
  </figure>

  <figure>
    <img src="../../../assets/modeling/solid-modeling/Intersect-Result.jpg" width="720" alt="Parts intersected into a new solid model" />

    <figcaption>Resultando <code>Clase.IntersectOperation</code></figcaption>
  </figure>

  #### Notas

  *   Las piezas originales se mantienen intactas después de una operación de intersección exitosa.En la mayoría de los casos, deberías `Class.Instance.Destroy|Destroy()` todas las piezas originales y padre al lugar de devolución `Class.IntersectOperation` al mismo lugar que la llamada `Class.BasePart` .
  *   Por defecto, los colores de la cara de la intersección resultante se toman de la propiedad `Class.BasePart.Color|Color` de las partes originales.Para cambiar toda la intersección a un color específico, establece su propiedad `Class.PartOperation.UsePartColor|UsePartColor` a `true`.
  *   Si una operación de intersección resultara en una parte con más de 20,000 triángulos, se simplificará a 20,000 triángulos.

BasePart:IntersectAsync

parts

Los objetos que participan en la intersección.

collisionfidelity

El valor `Enum.CollisionFidelity` para el resultante `Class.IntersectOperation`.

renderFidelity

El valor `Enum.RenderFidelity` de la resultante `Class.PartOperation`.

Resultando `Class.IntersectOperation` con el nombre predeterminado **Intersect** .

Crea un nuevo `Class.IntersectOperation` de la geometría superpuesta de la pieza y de las otras piezas en el matriz/listadado.

Este ejemplo muestra cómo restar parte(s) de otro `Class.BasePart` para formar un negado `Class.UnionOperation` .

Crea un nuevo `Class.UnionOperation` de la parte, menos la geometría ocupada por las piezas en el matriz/listadado.Solo se admiten `Class.Part|Parts` , no `Class.Terrain` o `Class.MeshPart|MeshParts` .Al igual que `Class.Instance:Clone()|Clone()` , el objeto devuelto no tiene ningún set `Class.Instance.Parent|Parent` .

  Tenga en cuenta que la unión resultante no puede estar vacía debido a las restas. Si la operación resultara en una geometría completamente vacía, fallará.

  En la siguiente comparación de imágenes, `Class.BasePart:SubtractAsync()|SubtractAsync()` se llama al cilindro azul usando una tabla que contiene el bloquespúrpura.El resultante `Class.UnionOperation` resuelve en una forma que omite la geometría del bloquesde la del cilindro.

  <figure>
    <img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Subtract.jpg" width="720" alt="Longer block overlapping a cylinder" />

    <figcaption>Separar piezas</figcaption>
  </figure>

  <figure>
    <img src="../../../assets/modeling/solid-modeling/Negate-Result.jpg" width="720" alt="Block part subtracted from cylinder" />

    <figcaption>Resultando <code>Class.UnionOperation</code></figcaption>
  </figure>

BasePart:SubtractAsync

Los objetos que participan en la restitución.

El valor `Enum.CollisionFidelity` para el resultante `Class.UnionOperation`.

Resultando `Class.UnionOperation` con el nombre predeterminado **Unión** .

Crea un nuevo `Class.UnionOperation` de la parte, menos la geometría ocupada por las piezas en el matriz/listadado.

This example demonstrates how to combine the geometry of one `Class.BasePart`
with the geometry of other part(s) to form a `Class.UnionOperation`.

Crea un nuevo `Class.UnionOperation` de la parte, más la geometría ocupada por las piezas en el matriz/listadado.Solo se admiten `Class.Part|Parts` , no `Class.Terrain` o `Class.MeshPart|MeshParts` .Al igual que `Class.Instance:Clone()|Clone()` , el objeto devuelto no tiene ningún set `Class.Instance.Parent|Parent` .

  Las siguientes propiedades de la parte llamante se aplican al resultante `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`

  En la siguiente comparación de imágenes, `Class.BasePart:UnionAsync()|UnionAsync()` se llama al bloque azul usando una tabla que contiene el cilindro púrpura.El resultante `Class.UnionOperation` se resuelve en una forma de la geometría combinada de ambas partes.

  <figure>
    <img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Union.jpg" width="720" alt="Block and cylinder parts overlapping" />

    <figcaption>Separar piezas</figcaption>
  </figure>

  <figure>
    <img src="../../../assets/modeling/solid-modeling/Union-Result.jpg" width="720" alt="Parts joined together into a single solid union" />

    <figcaption>Resultando <code>Class.UnionOperation</code></figcaption>
  </figure>

  #### Notas

  *   Las piezas originales se mantienen intactas después de una operación de unión exitosa.En la mayoría de los casos, deberías `Class.Instance.Destroy|Destroy()` todas las piezas originales y padre al lugar de devolución `Class.UnionOperation` al mismo lugar que la llamada `Class.BasePart` .
  *   Por defecto, la unión resultante respeta la propiedad `Class.BasePart.Color|Color` de cada una de sus partes.Para cambiar toda la unión a un color específico, establece su propiedad `Class.PartOperation.UsePartColor|UsePartColor` a `true`.
  *   Si una operación de unión resultara en una parte con más de 20,000 triángulos, se simplificará a 20,000 triángulos.

BasePart:UnionAsync

Los objetos que participan en la unión con la parte llamante.

Crea un nuevo `Class.UnionOperation` de la parte, más la geometría ocupada por las piezas en el matriz/listadado.

BasePart

This code sample will allow a part to be clicked to toggle its anchored property. When toggled, the visual appearance of the part is updated (red means anchored, yellow means free).

La propiedad `Anchored` determina si la parte será inmóvil por la física.Cuando está habilitado, una parte nunca cambiará de posición debido a la gravedad, a colisiones de otras partes, a superposición de otras partes o a cualquier otra causa relacionada con la física.Como resultado, dos partes ancladas nunca dispararán el evento `Class.BasePart.Touched|Touched` el uno al otro.

  Una parte anclada aún puede moverse cambiando su `Class.BasePart.CFrame|CFrame` o `Class.BasePart.Position|Position` , y aún puede tener un no cero `Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity` y `Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity` .

  Por último, si una parte sin anclar se une a una parte anclada a través de un objeto como un `Class.Weld`, también actuará anclada.Si se rompe tal junta, la parte puede ser afectada por la física nuevamente.Vea [ensamblajes](/physics/assemblies) para más detalles.

  La propiedad de la red no se puede establecer en partes ancladas.Si el estado de anclaje de una parte cambia en el servidor, se verá afectada la propiedad de red de esa parte.

BasePart.Anchored

Determina si una parte es inmóvil por la física.

El vector de velocidad angular de la montura de esta parte. Es la velocidad de cambio de orientación en radios por segundo.

  La velocidad ángular es la misma en cada punto de la montura.

  Establecer la velocidad directamente puede conducir a un movimiento poco realista.Se prefiere usar `Class.Torque` o `Class.AngularVelocity` la restricción, o usar `Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()` si desea cambios instantáneos en la velocidad.

  Si la parte es [propiedad](/physics/network-ownership) del servidor, esta propiedad debe cambiarse desde un servidor `Class.Script` (no desde un `Class.LocalScript` o un `Class.Script` con `Class.BaseScript.RunContext|RunContext` configurado para `Enum.RunContext.Client`).Si la parte es propiedad de un cliente a través de **propiedad automática** , esta propiedad se puede cambiar desde un script de cliente **o** un script del servidor; cambiarlo desde un script de cliente para una parte propiedad del servidor no tendrá efecto.

BasePart.AssemblyAngularVelocity

La velocidad angular de la montura de la pieza.

Una posición calculada a través de la `Class.BasePart.Mass|Mass` y `Class.BasePart.Position|Position` de todas las piezas en la asamblea.

  Si la ensambladora tiene una parte anclada, el centro de masa de esa parte será el centro de masa de la ensambladora y la ensambladora tendrá masa infinita.

  Conocer el centro de masa puede ayudar a mantener la estabilidad de la montura.Una fuerza aplicada al centro de masa no causará aceleración angular, solo lineal.Una asamblea con un centro de masa bajo tendrá un mejor tiempo de permanencia en pie bajo el efecto de la gravedad.

BasePart.AssemblyCenterOfMass

El centro de masa de la montura de la parte en el espacio mundial.

El vector de velocidad lineal de la montura de esta parte. Es la velocidad de cambio en la posición de `Class.BasePart.AssemblyCenterOfMass|AssemblyCenterOfMass` en studs por segundo.

  Si quieres conocer la velocidad en un punto diferente al centro de masa de la montura, usa `Class.BasePart:GetVelocityAtPosition()|GetVelocityAtPosition()`.

  Establecer la velocidad directamente puede conducir a un movimiento poco realista.Se prefiere usar una restricción `Class.VectorForce` o usar `Class.BasePart:ApplyImpulse()|ApplyImpulse()` si desea cambios instantáneos en la velocidad.

  Si la parte es [propiedad](/physics/network-ownership) del servidor, esta propiedad debe cambiarse desde un servidor `Class.Script` (no desde un `Class.LocalScript` o un `Class.Script` con `Class.BaseScript.RunContext|RunContext` configurado para `Enum.RunContext.Client`).Si la parte es propiedad de un cliente a través de **propiedad automática** , esta propiedad se puede cambiar desde un script de cliente **o** un script del servidor; cambiarlo desde un script de cliente para una parte propiedad del servidor no tendrá efecto.

BasePart.AssemblyLinearVelocity

La velocidad lineal de la montura de la pieza.

La suma de la masa de todos los `Class.BasePart|BaseParts` en la montaje de esta parte.Las piezas que son `Class.BasePart.Massless|Massless` y no son la parte raíz de la montura no contribuirán al `AssemblyMass`.

  Si la ensambladora tiene una parte anclada, se considera que la masa de la ensambladora es infinita.Las restricciones y otras interacciones físicas entre ensamblajes sin anclar con una gran diferencia de masa pueden causar inestabilidades.

BasePart.AssemblyMass

Esta propiedad indica el `Class.BasePart` automáticamente elegido para representar la parte raíz de la instalación.Es la misma parte que se devuelve cuando los desarrolladores llaman `Class.BasePart:GetRootPart()|GetRootPart()` .

  La parte raíz se puede cambiar cambiando el `Class.BasePart.RootPriority|RootPriority` de las partes en la asamblea.

  Las piezas que todas comparten el mismo `AssemblyRootPart` están en la misma ensambladora.

  Para obtener más información sobre partes raíz, vea [Ensamblajes](/physics/assemblies).

BasePart.AssemblyRootPart

Una referencia a la parte raíz de la asamblea.

`AudioCanCollide` determina si la parte interactuará físicamente con la simulación de audio, similar a `Class.BasePart.CastShadow|CastShadow` para iluminación.

  Cuando está desactivado, el audio pasa a través de la parte; no está oculto o reflejado.

BasePart.AudioCanCollide

Determina si la parte interactuará físicamente con la simulación de audio, similar a `Class.BasePart.CastShadow|CastShadow` para iluminación.

This code sample demonstrates how surface properties can be set using only a
NormalId (Top, Front, etc). It switches a motor's -SurfaceInput from NoInput,
Constant and Sin to show how each work using -ParamA and -ParamB properties.

La propiedad `BackParamA` es relevante cuando la parte `Class.BasePart.BackSurface` está configurada como Motor o SteppingMotor y `Class.BasePart.BackSurfaceInput` se configura como Sin.Determina la **amplitud** de la velocidad de rotación del motor.

BasePart.BackParamA

Determina el primer parámetro para el tipo de superficie en la cara trasera de una pieza.

La propiedad es relevante cuando la parte está configurada como Motor o SteppingMotor y está configurada como Constante o Sin.Para Constant, determina la velocidad de rotación constante del motor.Para el pecado, determina la **frecuencia** de la velocidad de rotación del motor.

BasePart.BackParamB

Determina el segundo parámetro para el tipo de superficie en la cara trasera de una pieza.

La propiedad `BackSurface` determina el tipo de superficie utilizada para la dirección positiva **Z** de una parte.Cuando las caras de dos partes se colocan una al lado de la otra, pueden crear una junta entre ellas.

BasePart.BackSurface

Determina el tipo de superficie para la cara trasera de una pieza.

La propiedad `BackSurfaceInput` determina el tipo de entrada proporcionada a la salida de una parte `Class.BasePart.BackSurface`.Esto solo es relevante para los tipos de superficie de Motor o SteppingMotor.Esta propiedad determina cómo se usan `Class.BasePart.BackParamA` y `Class.BasePart.BackParamB`.Para brevedad, estas propiedades se referirán como ParamA y ParamB, respectivamente.

  *   Por defecto, esto se establece en NoInput. Esto detiene el motor por completo.
  *   Para Constant, el motor gira a una velocidad constante igual a `ParamB` .
  *   Para el pecado, el motor gira a una velocidad igual a `ParamA * math.sin(workspace.DistributedGameTime * ParamB)` . Ver `Class.Workspace.DistributedGameTime` .

BasePart.BackSurfaceInput

Determina el tipo de entrada para la cara trasera de una parte.

La propiedad `BottomParamA` es relevante cuando la parte `Class.BasePart.BottomSurface` está configurada como Motor o SteppingMotor y `Class.BasePart.BottomSurfaceInput` se configura como Sin.Determina la **amplitud** de la velocidad de rotación del motor.

BasePart.BottomParamA

Determina el primer parámetro para el tipo de superficie en la cara inferior de una parte.

BasePart.BottomParamB

Determina el segundo parámetro para el tipo de superficie en la cara inferior de una parte.

La propiedad `BottomSurface` determina el tipo de superficie utilizada para la dirección negativa **Y** de una parte.Cuando las caras de dos partes se colocan una al lado de la otra, pueden crear una junta entre ellas.

BasePart.BottomSurface

Determina el tipo de superficie para la cara inferior de una parte.

La propiedad `BottomSurfaceInput` determina el tipo de entrada proporcionada a la salida de una parte `Class.BasePart.BottomSurface`.Esto solo es relevante para los tipos de superficie de Motor o SteppingMotor.Esta propiedad determina cómo se usan `Class.BasePart.BottomParamA` y `Class.BasePart.BottomParamB`.Para brevedad, estas propiedades se referirán como ParamA y ParamB, respectivamente.

  *   Por defecto, esto se establece en NoInput. Esto detiene el motor por completo.
  *   Para Constant, el motor gira a una velocidad constante igual a `ParamB` .
  *   Para el pecado, el motor gira a una velocidad igual a `ParamA * math.sin(workspace.DistributedGameTime * ParamB)` . Ver `Class.Workspace.DistributedGameTime` .

BasePart.BottomSurfaceInput

Determina el tipo de entrada para la cara inferior de una parte.

La clase base abstracta para objetos en el mundo que interactúan físicamente.

/reference/engine/classes/VehicleSeat.yaml