Una SkateboardPlatform se puede usar para crear una tabla de skate. Cuando los personajes se suben a una tabla de skate, quedan pegados a ella hasta que presionan la tecla de escape. Hasta entonces, el personaje usa animaciones de tabla de skate y viaja más rápido que un personaje caminando.

Se dispara cuando se equipa la tabla de skate.

SkateboardPlatform.Equipped

humanoid

El `Class.Humanoid` asociado con el personaje que equipa la tabla de skate.

skateboardController

SkateboardPlatform.equipped

Se activa cuando el `Class.SkateboardPlatform.ControllingHumanoid` de la SkateboardPlatform
cambia la fuerza que se está utilizando en la SkateboardPlatform.


SkateboardPlatform.MoveStateChanged

newState

oldState

Se activa siempre que se desequipé la patineta.


SkateboardPlatform.Unequipped

El `Class.Humanoid` asociado con el personaje que desequipó la
patineta.


SkateboardPlatform.unequipped

Agrega ''impulseWorld'' a la `Class.BasePart.Velocity` de la SkateboardPlatform.

SkateboardPlatform:ApplySpecificImpulse

impulseWorld

SkateboardPlatform

El SkateboardController activo de la SkateboardPlatform.

SkateboardPlatform.Controller

El `Class.Humanoid` que está controlando la SkateboardPlatform.

SkateboardPlatform.ControllingHumanoid

La dirección del movimiento, vinculada a las teclas A y D. Debe ser 1 (derecha), 0 (recto) o -1 (izquierda). Se restablecerá a 0 a menos que se establezca constantemente.

SkateboardPlatform.Steer

Si es verdadero, las ruedas no rodarán sin la entrada del usuario.

SkateboardPlatform.StickyWheels

La dirección del movimiento, vinculada a las teclas W y S. Debe ser un entero 1 (adelante), 0 (nulo) o -1 (reversa). Se restablecerá a 0 a menos que se establezca constantemente.

SkateboardPlatform.Throttle

El script a continuación genera una nueva instancia de `Part` y establece varias de las propiedades de la parte.
Más notablemente, el script establece la propiedad `Class.Part.Shape` a
`Enum.PartType.Ball`. También nombra la parte _JurassicPart_, la ancla, la convierte
en un hijo de _Workspace_, y establece su color a blanco.

El objeto Part es un tipo de `Class.BasePart`. Viene en cinco formas primitivas diferentes: Bola, Bloque, Cilindro, Cuña y Cuña de esquina.


Part

La propiedad Shape establece la forma general del objeto en una de una lista predeterminada de formas integradas.

El enum `Enum.PartType` controla el valor de la forma, y tiene cinco formas posibles:

| Forma/Valor | Descripción                               |
| ----------- | ----------------------------------------- |
| Bola        | Una forma esférica.                      |
| Bloque      | Una forma de bloque.                     |
| Cilindro    | Una forma de cilindro.                   |
| Cuña        | Una forma de cuña con una inclinación en un lado. |
| Cuña de esquina | Una forma de cuña con inclinaciones en dos lados. |

`Class.MeshPart` y [modelado sólido](/parts/solid-modeling)
se pueden utilizar para obtener formas de parte completamente personalizadas.

Las colisiones entre bolas, bloques y cuñas, y cuñas de esquina son exactas,
mientras que las colisiones entre terreno, cilindros, TriangleMeshes y otros
tipos de geometría son aproximaciones. Esto significa que la forma de bola puede ser
útil para crear colisionadores estables para ruedas de coche.


Part.Shape

Un tipo común de `Class.BasePart` que viene en diferentes formas primitivas.


La clase FormFactorPart es una clase abstracta. Hereda de la
`Class.BasePart` y añade la propiedad `Class.FormFactorPart.FormFactor`
a las clases que heredan de ella.


FormFactorPart

Esto solía especificar una restricción de cuadrícula del tamaño de la parte. Ya no
hace nada.


FormFactorPart.FormFactor

Determina cómo actúa una parte al ser redimensionada y los valores que su tamaño
puede tomar.


FormFactorPart.formFactor

La clase FormFactorPart es una clase abstracta. Hereda de la clase BasePart
y añade la propiedad FormFactor a las clases que heredan de ella.


Crea una pieza azul y una pieza objetivo roja. La pieza azul intentará alcanzar suavemente
la pieza objetivo roja. Mueve y rota el objetivo para ver el comportamiento.
Cambiar smoothTime resultará en una velocidad de suavizado diferente.


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

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

Hay muchos objetos diferentes que interactúan con `Class.BasePart` (además
de `Class.Terrain`), incluyendo:

- Varios `Class.BasePart|BaseParts` pueden ser agrupados dentro de un `Class.Model` y
  movidos al mismo tiempo usando `Class.PVInstance:PivotTo()`. Consulta
  [Models](/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 en mosaico a
  las caras. Consulta [Textures and Decals](/parts/textures-decals).
- Un `Class.SurfaceGui` renderiza `Class.GuiObject|GuiObjects` en la cara de una
  parte. Consulta
  [In-Experience UI Containers](/ui/in-experience-containers).
- `Class.Attachment|Attachments` se pueden añadir a un `Class.BasePart` para especificar
  `Datatype.CFrame|CFrames` en relación con la parte. Estos son utilizados frecuentemente por
  objetos de `Class.Constraint` físicos como se describe en
  [Mechanical Constraints](/physics/mechanical-constraints) y
  [Mover Constraints](/physics/mover-constraints).
- Los objetos `Class.ParticleEmitter` emiten partículas uniformemente en el volumen del
  `Class.BasePart` al que están vinculados. Consulta
  [Particle Emitters](/effects/particle-emitters).
- Objetos de luz como `Class.PointLight` emiten luz desde el centro de un
  `Class.BasePart` como se ilustra en
  [Light Sources](/effects/light-sources).
- Si está vinculado a un `Class.Tool` y se le da el nombre **Handle**, un
  `Class.BasePart` puede ser sostenido por personajes. Consulta
  [In-Experience Tools](/players/tools).


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


BasePart.LocalSimulationTouched

part

Se activa si la apariencia de la pieza está afectada por la clase `Class.Shirt`.


BasePart.OutfitChanged

BasePart.StoppedTouching

otherPart

Este ejemplo de código crea un BillboardGui en una parte que muestra el número de
partes que actualmente la están tocando.

Este ejemplo de código demuestra cómo conectar el evento `Class.BasePart.Touched`
de múltiples partes en un `Class.Model` a una función.


El evento **Touched** se activa cuando una pieza entra en contacto con otra
pieza. Por ejemplo, si **PartA** choca con **PartB**, entonces
`Class.BasePart.Touched|PartA.Touched` se activa con **PartB**, y
`Class.BasePart.Touched|PartB.Touched` se activa con **PartA**.

Este evento solo se activa como resultado de movimiento físico, por lo que no
se activará si la propiedad `Class.BasePart.CFrame|CFrame` fue cambiada de tal
modo que la pieza se superpone a otra pieza. Esto también significa que al menos
una de las piezas involucradas no debe ser `Class.BasePart.Anchored|Anclado` en el
tiempo de la colisión.

Este evento funciona en conjunto con
`Class.Workspace.TouchesUseCollisionGroups` para especificar si
[los 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 pieza dada.


Se activa cuando una pieza toca a otra pieza como resultado de movimiento físico.


Se activa cuando una pieza deja de tocar a otra pieza bajo condiciones similares a
las de `Class.BasePart.Touched`.

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


BasePart.TouchEnded

Se activa cuando una pieza deja de tocar a otra pieza como resultado de movimiento físico.


Devuelve el vector de torque en el espacio mundial que debe aplicarse a la
asamblea de la pieza para lograr la aceleración angular especificada. Este resultado se puede
utilizar para determinar el torque que debe aplicarse a través de una
instancia de `Class.Torque` o `Class.BasePart:ApplyAngularImpulse()`.

El cálculo utiliza la ecuación de rotación de Euler donde _I_ es el tensor de
inercia del mundo de la asamblea, _α_ es la aceleración angular deseada, y
_ω_ es la velocidad angular.

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

Si la pieza no es un descendiente de `Class.Workspace`, este método devuelve
un vector de infinito. Si la asamblea está anclada, también devolverá un
vector de infinito.

#### Efectos Giroscópicos

Cuando una asamblea giratoria tiene un tensor de inercia asimétrico, el torque
necesario para lograr una aceleración angular especificada se incrementa debido a
la orientación cambiante del cuerpo. El parámetro opcional `angVelocity`
considera estos efectos giroscópicos. Si se omite, estos efectos giroscópicos
se omiten del cálculo.

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

-- Calcula el torque necesario para lograr la aceleración deseada
local torque = part:AngularAccelerationToTorque(desiredAcceleration, angularVelocity)
```


BasePart:AngularAccelerationToTorque

angAcceleration

El vector de aceleración angular deseada en el espacio mundial.


angVelocity

La velocidad angular actual de la asamblea en el espacio mundial. Por defecto
es `(0, 0, 0)`. Proporciona la velocidad angular de la asamblea para tener en cuenta\los efectos giroscópicos.


Un `Datatype.Vector3` que representa el torque en el espacio mundial requerido para
producir la aceleración angular especificada.


Devuelve el torque necesario para alcanzar una cierta aceleración angular en la
asamblea de esta pieza, teniendo en cuenta opcionalmente los efectos giroscópicos.


Aplica un impulso de fuerza angular instantáneo a la asamblea de esta pieza, causando
a la asamblea que gire.

La velocidad angular resultante del impulso depende de la `Class.BasePart.AssemblyMass|masa` de la asamblea. Por lo tanto, se requiere un impulso mayor para
mover asambleas más masivas. Los impulsos son útiles para casos en los que deseas
aplicar una fuerza instantáneamente, como una explosión o colisión.

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


BasePart:ApplyAngularImpulse

impulse

Un vector de impulso angular que se aplicará a la asamblea.


Aplica un impulso angular a la asamblea.


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

La fuerza se aplica en el `Class.BasePart.AssemblyCenterOfMass|centro de masa` de la asamblea, por lo que el movimiento resultante solo será lineal.

La velocidad resultante del impulso depende de la `Class.BasePart.AssemblyMass|masa` de la asamblea. Por lo tanto, se requiere un impulso mayor para
mover asambleas más masivas. Los impulsos son útiles para casos en los que deseas
aplicar una fuerza instantáneamente, como una explosión o colisión.

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


BasePart:ApplyImpulse

Un vector de impulso lineal que se aplicará a la asamblea.


Aplica un impulso a la asamblea en el `Class.BasePart.AssemblyCenterOfMass|centro de masa` de la asamblea.


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

Si la posición no está en el `Class.BasePart.AssemblyCenterOfMass|centro de masa` de la asamblea, el impulso causará un movimiento posicional y rotacional.

La velocidad resultante del impulso depende de la `Class.BasePart.AssemblyMass|masa` de la asamblea. Por lo tanto, se requiere un impulso mayor para
mover asambleas más masivas. Los impulsos son útiles para casos en los que
los desarrolladores desean aplicar una fuerza instantáneamente, como una explosión o
colisión.

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


BasePart:ApplyImpulseAtPosition

Un vector de impulso que se aplicará a la asamblea.


position

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


Aplica un impulso a la asamblea en una posición especificada.


Rompe cualquier conexión superficial con cualquier pieza adyacente, incluyendo
`Class.Weld` y otros `Class.JointInstance`.


BasePart:BreakJoints

BasePart:breakJoints

Devuelve si las piezas pueden colisionar entre sí o no. Esta
función tiene en cuenta los grupos de colisión de las dos piezas. Esta
función mostrará un error si la pieza especificada no es un BasePart.


BasePart:CanCollideWith

La pieza especificada que se está verificando para colisionabilidad.


Si las piezas pueden colisionar entre sí.


Devuelve si las piezas pueden colisionar entre sí.


Este ejemplo comprueba si se puede establecer o no la propiedad de red de la primera
`BasePart` llamada _Part_ en el `Workspace`.

La función CanSetNetworkOwnership verifica si puedes establecer la propiedad de red de una pieza.

El valor de retorno de la función verifica si puedes llamar a
`Class.BasePart:SetNetworkOwner()` o
`Class.BasePart:SetNetworkOwnershipAuto()` sin encontrar un error.
Devuelve verdadero si puedes modificar/leer la propiedad de 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 red y la razón.


Verifica si puedes establecer la propiedad de red de una pieza.


Devuelve el punto más cercano en la superficie de la pieza a la
posición en el espacio mundial dada. Si la posición proporcionada está
dentro de la pieza, se devuelve tal cual.

Para instancias de `Class.MeshPart` y `Class.PartOperation`, este método
respeta el valor de `Enum.CollisionFidelity` de la pieza. Los valores de retorno pueden
diferir en función de si la malla se está tratando como una caja, un casco, o una
forma más compleja.


BasePart:GetClosestPointOnSurface

El punto en el espacio mundial para encontrar el punto más cercano en la superficie.


El punto más cercano en la superficie de la pieza en el espacio mundial.


Devuelve el punto más cercano en la superficie de la pieza al punto dado.


Devuelve una tabla de piezas conectadas al objeto por cualquier tipo de junta
rígida.

Si `recursive` es verdadero, esta función devolverá todas las piezas en la
asamblea conectadas rígidamente al BasePart.

#### Juntas Rígidas

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

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


BasePart:GetConnectedParts

recursive

Una tabla de piezas conectadas al objeto por cualquier tipo de
`Class.JointInstance|junta`.


Devuelve una tabla de piezas conectadas al objeto por cualquier tipo de junta
rí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 pieza, myPart, en el Workspace del juego, con
dimensiones 4x6x4 studs. La pieza también está anclada.

Luego, myMass se establece para igualar la masa de la nueva pieza. La masa de la pieza se
imprime al final de la declaración print:

> La masa de mi pieza es ...

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

Esta función es anterior a la propiedad Masa. Se sigue soportando por\compatibilidad hacia atrás; debes usar la propiedad Masa directamente.


BasePart:GetMass

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


BasePart:getMass

Devuelve el jugador actual que es el propietario de red de esta pieza, o `nil`
en caso de que sea el servidor.


BasePart:GetNetworkOwner

El jugador actual que es el propietario de red de esta pieza, o `nil` en
caso de que sea el servidor.


Devuelve verdadero si el motor del juego decide automáticamente el propietario de red
para esta pieza.


BasePart:GetNetworkOwnershipAuto

Si el motor del juego decide automáticamente el propietario de red para
esta pieza.


BasePart:GetNoCollisionConstraints

Esta función solía ser relevante cuando la interpolación de partes de Roblox para
compensar el lag estaba interna. La interpolación ahora se aplica al
directamente al `Datatype.CFrame`.


BasePart:GetRenderCFrame

OBSOLETO. Devuelve un CFrame que describe dónde se está renderizando la pieza.


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

Esta función es anterior a la
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` propiedad. Se sigue
soportando por compatibilidad hacia atrás, pero debes usar
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` directamente.


BasePart:GetRootPart

La pieza base de una asamblea (una colección de piezas conectadas
juntas).


Devuelve la pieza base de una asamblea de piezas.


Devuelve una tabla de todas las piezas que están interactuando físicamente con esta
pieza. Si la pieza en sí tiene CanCollide configurado como falso, entonces esta función
devuelve una tabla vacía a menos que la pieza tenga un
`Class.TouchTransmitter|TouchInterest` objeto parentado a ella (lo que significa
que algo está conectado a su evento Touched). Las piezas que son adyacentes pero
no intersectan no se consideran como tocándose. Esta función es anterior a la
función `Class.WorldRoot:GetPartsInPart()`, que proporciona más
flexibilidad y evita las reglas especiales de `Class.TouchTransmitter|TouchInterest`
descritas anteriormente. Usa `Class.WorldRoot:GetPartsInPart()` en su lugar.


BasePart:GetTouchingParts

Una tabla de todas las piezas que intersectan y pueden colisionar con esta pieza.


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


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


BasePart:GetVelocityAtPosition

Devuelve la velocidad lineal de la asamblea de la pieza en la posición dada
relativa a esta pieza.


Crea una nueva `Class.IntersectOperation` a partir de la geometría de intersección de
the pieza y las otras piezas en el array proporcionado. Solo se admiten `Class.Part|Piezas`,
no `Class.Terrain` o `Class.MeshPart|MeshParts`. Similar a
`Class.Instance:Clone()|Clone()`, el objeto devuelto no tiene un `Class.Instance.Parent|Padre` establecido.

Las siguientes propiedades de la pieza que llama se aplican a los
resultados de `Class.IntersectOperation`:

- `Class.BasePart.Color|Color`, `Class.BasePart.Material|Material`,
  `Class.BasePart.MaterialVariant|MaterialVariant`,
  `Class.BasePart.Reflectance|Reflectance`,
  `Class.BasePart.Transparency|Transparencia`
- `Class.BasePart.CanCollide|CanCollide`
- `Class.BasePart.Anchored|Anclado`, `Class.BasePart.Density|Densidad`,
  `Class.BasePart.Elasticity|Elasticidad`,
  `Class.BasePart.ElasticityWeight|PesoElasticidad`,
  `Class.BasePart.Friction|Fricción`,
  `Class.BasePart.FrictionWeight|PesoFricción`

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

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Intersect.jpg"
width="720" alt="Dos bloques de partes superpuestos" />
<figcaption>Partes separadas</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Intersect-Result.jpg"
width="720" alt="Partes intersectadas en un nuevo modelo sólido" />
<figcaption>Resultado <code>Class.IntersectOperation</code></figcaption>
</figure>

#### Notas

- Las partes originales permanecen intactas después de una operación de intersección
exitosa. En la mayoría de los casos, deberías `Class.Instance.Destroy|Destruir()`
  todas las piezas originales y parentar el `Class.IntersectOperation`
devuelto al mismo lugar que la pieza que llamó.
- Por defecto, los colores de las caras de la intersección resultante son tomados
  de la propiedad `Class.BasePart.Color|Color` de las piezas originales. Para
  cambiar toda la intersección a un color específico, establece su
  propiedad `Class.PartOperation.UsePartColor|UsePartColor` en `true`.
- Si una operación de intersección resultara en una pieza 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 `Class.IntersectOperation` resultante.


renderFidelity

El valor `Enum.RenderFidelity` del `Class.PartOperation` resultante.


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


Nota: Se recomienda encarecidamente utilizar la función más nueva
`Class.GeometryService:IntersectAsync` en lugar de esta función. Además de tener un rendimiento mejor y más características, la nueva función difiere de la siguiente manera:

- La salida es un array de instancias en lugar de una sola instancia.
- Las piezas de entrada no necesitan estar parentadas a la escena, permitiendo operaciones en segundo plano.
- Cuando la opción `SplitApart` está configurada en `true` (por defecto), cada cuerpo distinto
devolverá en su propio `Class.PartOperation`.
- Todas las partes devueltas están en el espacio de coordenadas de la pieza principal, por lo que
  sus posiciones `Class.PVInstance.Origin` son las mismas que las de la pieza principal. Esto mantiene los
  vértices de la malla en la misma posición relativa al objeto como antes
  de la operación, pero también significa que el `(0, 0, 0)` de una parte devuelta no está
  necesariamente en el centro de su cuerpo.

  Crea una nueva `Class.IntersectOperation` a partir de la geometría superpuesta
  de la pieza y las otras piezas en el array proporcionado.


Devuelve verdadero si el objeto está conectado a una pieza que lo mantendrá en
su lugar (por ejemplo, una pieza `Class.BasePart.Anchored|Anclado`), de lo contrario devuelve
falso. En una asamblea que tiene una pieza `Class.BasePart.Anchored|Anclado`,
cada otra pieza está en el suelo.


BasePart:IsGrounded

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


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


Crea una junta en cualquier lado del `Class.BasePart|Parte` que tenga un
`Enum.SurfaceType` que pueda hacer una junta, creará una junta con cualquier
pieza adyacente.

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

- Las superficies lisas no crearán juntas
- Las superficies de pegamento crearán una junta de `Class.Glue`
- Las uniones crearán una junta de `Class.Weld` con cualquier superficie excepto por
  Unjoinable
- Los Studs, Inlet o Universal crearán cada uno una junta de `Class.Snap` con
  cualquiera de las otras dos superficies (por ejemplo, Studs con Inlet y
  Universal)
- Las superficies de bisagra y motor crean instancias de junta `Class.Rotate` y `Class.RotateV`

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

```
part:MakeJoints({part1, part2, part3})
```
Las juntas se rompen si se aplica suficiente fuerza a ellas debido a una
`Class.Explosion`, a menos que un objeto `Class.ForceField` esté parentado a la
`Class.BasePart` o ancestro `Class.Model`. Por esta razón, a menudo se utilizan para
hacer edificios simples destructibles y otros modelos.


BasePart:MakeJoints

Crea una junta en cualquier lado del objeto que tenga un ID de superficie que pueda
hacer una junta.


BasePart:makeJoints

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


BasePart:Resize

normalId

deltaAmount

Cuánto crecer/reducir en el lado especificado.


BasePart:resize

Establece al jugador dado como propietario de red para esta 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 se le dará propiedad de red de la pieza.


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


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


BasePart:SetNetworkOwnershipAuto

Este ejemplo demuestra cómo restar parte(s) de otro
`Class.BasePart` para formar una `Class.UnionOperation` negada.

Crea una nueva `Class.UnionOperation` a partir de la parte, menos la geometría
ocupada por las partes en el array proporcionado. Solo se admiten `Class.Part|Piezas`,
no `Class.Terrain` o `Class.MeshPart|MeshParts`. Similar a
`Class.Instance:Clone()|Clone()`, el objeto devuelto no tiene un `Class.Instance.Parent|Padre` establecido.

Ten en cuenta que la unión resultante no puede estar vacía debido a las sustracciones. 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 en el cilindro azul utilizando una tabla que contiene el bloque púrpura. La unión.resultante `Class.UnionOperation` resuelve
en una forma que omite la geometría del bloque de la del cilindro.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Subtract.jpg"
width="720" alt="Bloque más largo superpuesto a un cilindro" />
<figcaption>Partes separadas</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Negate-Result.jpg" width="720"
alt="Parte bloque restado del cilindro" />
<figcaption>Resultado <code>Class.UnionOperation</code></figcaption>
</figure>


BasePart:SubtractAsync

Los objetos que participan en la sustracción.


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


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


Resultado `Class.UnionOperation` con el nombre predeterminado **Union**.


Nota: Se recomienda encarecidamente usar la más nueva
`Class.GeometryService:UnionAsync` en lugar de esta función. Además de tener un rendimiento mejor y más características, la nueva función difiere de la siguiente manera:

- La salida es un array de instancias en lugar de una sola instancia.
- Las partes de entrada no necesitan estar parentadas a la escena, lo que permite
dos operaciones en segundo plano.
- Cuando la opción `SplitApart` está configurada en `true` (por defecto), cada cuerpo distinto
  será devuelto en su propio `Class.PartOperation`.
- Todas las partes devueltas están en el espacio de coordenadas de la parte principal, así que
  sus posiciones `Class.PVInstance.Origin` son las mismas que las de la parte principal. Esto mantiene los vértices de la malla en la misma posición
  relativa al objeto como antes de la operación, pero significa que el `(0, 0, 0)` de una parte devuelta no esté
  necesariamente en el centro de su cuerpo.

  Crea una nueva `Class.UnionOperation` a partir de la pieza, menos la geometría
  ocupada por las partes en el array proporcionado.


Devuelve la aceleración angular en el espacio mundial que resultaría de
aplicar el torque especificado a la asamblea de la pieza, teniendo en cuenta opcionalmente los
efectos giroscópicos.

Esta es la inversa de `Class.BasePart:AngularAccelerationToTorque()`. Es
útil para predecir cómo responderá una asamblea a un torque aplicado.

El cálculo utiliza:

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

donde **I** es el tensor de inercia del espacio mundial de la asamblea, **τ** es el
torque aplicado, y **ω** es la velocidad angular.

Si la pieza no es un descendiente de `Class.Workspace`, devuelve `(0, 0, 0)`.
Si la asamblea está anclada, devuelve `(0, 0, 0)`.

#### Efectos Giroscópicos

Cuando una asamblea giratoria tiene un tensor de inercia asimétrico, la
aceleración resultante de un torque aplicado también depende de la velocidad
angular actual. El parámetro `angVelocity` considera estos efectos
giroscópicos. Si se omite (por defecto a cero), el resultado no tiene en cuenta
esta contribución del resultado.

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

-- Prever la aceleración angular de este torque
local angAccel = part:TorqueToAngularAcceleration(appliedTorque, angularVelocity)
```


BasePart:TorqueToAngularAcceleration

torque

El vector de torque aplicado a la asamblea en el espacio mundial.


La velocidad angular actual de la asamblea en el espacio mundial. Por defecto
es `(0, 0, 0)`. Proporciona la velocidad angular de la asamblea para tener en cuenta
los efectos giroscópicos.


Un `Datatype.Vector3` representando la aceleración angular resultante
en el espacio mundial.


Devuelve la aceleración angular que resultaría al aplicar un dado
torque a la asamblea de esta pieza, teniendo en cuenta opcionalmente los efectos giroscópicos.


Este ejemplo demuestra cómo combinar la geometría de una `Class.BasePart`
con la geometría de otras(s) parte(s) para formar una `Class.UnionOperation`.

Crea una nueva `Class.UnionOperation` a partir de la parte, más la geometría
ocupada por las partes en el array proporcionado. Solo se admiten `Class.Part|Piezas`,
no `Class.Terrain` o `Class.MeshPart|MeshParts`. Similar a
`Class.Instance:Clone()|Clone()`, el objeto devuelto no tiene un `Class.Instance.Parent|Padre` establecido.

Las siguientes propiedades de la pieza que llama se aplican a los
resultados de `Class.UnionOperation`:

- `Class.BasePart.Color|Color`, `Class.BasePart.Material|Material`,
  `Class.BasePart.MaterialVariant|MaterialVariant`,
  `Class.BasePart.Reflectance|Reflectance`,
  `Class.BasePart.Transparency|Transparencia`
- `Class.BasePart.CanCollide|CanCollide`
- `Class.BasePart.Anchored|Anclado`, `Class.BasePart.Density|Densidad`,
  `Class.BasePart.Elasticity|Elasticidad`,
  `Class.BasePart.ElasticityWeight|PesoElasticidad`,
  `Class.BasePart.Friction|Fricción`,
  `Class.BasePart.FrictionWeight|PesoFricción`

En la siguiente comparación de imágenes,
`Class.BasePart:UnionAsync()|UnionAsync()` se llama en el bloque azul
utilizando una tabla que contiene el cilindro púrpura. La unión resultante
d resolverá 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="Partes de bloque y cilindro superpuestas" />
<figcaption>Partes separadas</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Union-Result.jpg" width="720"
alt="Partes unidas en una sola unión sólida" />
<figcaption>Resultado <code>Class.UnionOperation</code></figcaption>
</figure>

#### Notas

- Las partes originales permanecen intactas después de una operación de unión
exitosa. En la mayoría de los casos, deberías `Class.Instance.Destroy|Destruir()` todas las
originales y parentar el `Class.UnionOperation` devuelto al mismo lugar que
de la parte que llamó.
- 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` en `true`.
- Si una operación de unión resultara en una pieza 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 que llama.


Nota: Se recomienda encarecidamente usar la más nueva
`Class.GeometryService:UnionAsync` en lugar de esta función. Además de tener un rendimiento mejor y más características, la nueva función difiere de la siguiente manera:

- La salida es un array de instancias en lugar de una sola instancia.
- Las partes de entrada no necesitan estar parentadas a la escena, lo que permite
  operaciones en segundo plano.
- Cuando la opción `SplitApart` está configurada en `true` (por defecto), cada cuerpo distinto
  será devuelto en su propio `Class.PartOperation`.
- Todas las partes devueltas están en el espacio de coordenadas de la pieza principal, así que
  sus posiciones `Class.PVInstance.Origin` son las mismas que las de la pieza principal. Esto mantiene los vértices de la malla en la misma posición
  relativa al objeto como antes de la operación, pero también significa que el `(0, 0, 0)` de una parte devuelta no esté
  necesariamente en el centro de su cuerpo.

        Crea una nueva `Class.UnionOperation` a partir de la pieza, más la geometría

  ocupada por las partes en el array proporcionado.


BasePart

Este ejemplo de código permitirá que una parte sea clickeada para alternar su propiedad anclada.
Cuando se alterna, la apariencia visual de la parte se actualiza (rojo
significa anclada, amarillo significa libre).


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

Una parte anclada aún puede ser movida cambiando su
`Class.BasePart.CFrame|CFrame` o `Class.BasePart.Position|Position`, y
también puede tener un
`Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity` y
`Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity` no nulos.

Finalmente, si una parte no anclada se une con una parte anclada a través de un
objeto como un `Class.Weld`, también actuará como anclada. Si tal unión
se rompe, la parte puede ser afectada nuevamente por la física. Consulta
[Assemblies](/physics/assemblies) para obtener más detalles.

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


BasePart.Anchored

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


El vector de velocidad angular del ensamblaje de esta parte. Es la tasa de
cambio de orientación en radianes por segundo.

La velocidad angular es la misma en cada punto del ensamblaje.

Configurar la velocidad directamente puede llevar a un movimiento no realista. Es preferible usar
`Class.Torque` o `Class.AngularVelocity` como restricción, o usar
`Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()` si deseas un
cambio instantáneo en la velocidad.

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


BasePart.AssemblyAngularVelocity

La velocidad angular del ensamblaje de la parte.


Una posición calculada mediante la `Class.BasePart.Mass|Mass` y
`Class.BasePart.Position|Position` de todas las partes en el ensamblaje.

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

Conocer el centro de masa puede ayudar al ensamblaje a mantener la estabilidad. Un
fuerza aplicada al centro de masa no causará aceleración angular,
sólo lineal. Un ensamblaje con un bajo centro de masa tendrá mejores posibilidades de mantenerse
erguido bajo el efecto de la gravedad.


BasePart.AssemblyCenterOfMass

El centro de masa del ensamblaje de la parte en el espacio del mundo.


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

Si deseas conocer la velocidad en un punto distinto al centro de masa del ensamblaje,
usa `Class.BasePart:GetVelocityAtPosition()|GetVelocityAtPosition()`.

Configurar la velocidad directamente puede llevar a un movimiento no realista. Usar un
`Class.VectorForce` como restricción es preferible, o usa
`Class.BasePart:ApplyImpulse()|ApplyImpulse()` si deseas un cambio instantáneo
en la velocidad.

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


BasePart.AssemblyLinearVelocity

La velocidad lineal del ensamblaje de la parte.


La suma de la masa de todos los `Class.BasePart|BaseParts` en este
ensamblaje de parte. Las partes que son `Class.BasePart.Massless|Massless` y no
son la raíz del ensamblaje no contribuirán a la `AssemblyMass`.

Si el ensamblaje tiene una parte anclada, la masa del ensamblaje se considera
infinita. Las restricciones y otras interacciones físicas entre ensamblajes no anclados con
una gran diferencia en masa pueden causar inestabilidades.


BasePart.AssemblyMass

La masa total del ensamblaje de la parte.


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


/reference/engine/classes/SkateboardPlatform.yaml