Un SkateboardPlatform peut être utilisé pour créer un skateboard. Lorsque les personnages montent
sur un skateboard, ils y sont attachés jusqu'à ce qu'ils appuient sur la touche échap. Jusque-là,
le personnage utilise des animations de skateboard et se déplace plus vite qu'un
personnage en marche.

Déclenché lorsque le skateboard est équipé.

SkateboardPlatform.Equipped

humanoid

Le `Class.Humanoid` associé au personnage qui équipe le
skateboard.

skateboardController

SkateboardPlatform.equipped

Déclenché lorsque le `Class.SkateboardPlatform.ControllingHumanoid` de la SkateboardPlatform
change la force utilisée sur la SkateboardPlatform.


SkateboardPlatform.MoveStateChanged

newState

oldState

Déclenché chaque fois que le skateboard est déséquipé.


SkateboardPlatform.Unequipped

Le `Class.Humanoid` associé au personnage qui a déséquipé le
skateboard.


SkateboardPlatform.unequipped

Ajoute ''impulseWorld'' à la vélocité de
`Class.BasePart.Velocity` du SkateboardPlatform.

SkateboardPlatform:ApplySpecificImpulse

impulseWorld

SkateboardPlatform

Le SkateboardController actif du SkateboardPlatform.

SkateboardPlatform.Controller

Le `Class.Humanoid` qui contrôle le SkateboardPlatform.

SkateboardPlatform.ControllingHumanoid

La direction du mouvement, liée aux touches A et D. Doit être 1 (droite), 0
(droit), ou -1 (gauche). Revenant à 0 sauf s'il est constamment réglé.

SkateboardPlatform.Steer

Si vrai, les roues ne rouleront pas sans input de l'utilisateur.

SkateboardPlatform.StickyWheels

La direction du mouvement, liée aux touches W et S. Doit être un entier 1
(avant), 0 (nul), ou -1 (arrière). Revenant à 0 sauf s'il est constamment réglé.

SkateboardPlatform.Throttle

Le script ci-dessous génère une nouvelle instance de `Part` et définit plusieurs de ses
propriétés.

Plus particulièrement, le script définit la propriété `Class.Part.Shape` à
`Enum.PartType.Ball`. Il nomme également la partie _JurassicPart_, la fixe, en fait
un enfant de _Workspace_, et définit sa couleur sur blanc.

L'objet Part est un type de `Class.BasePart`. Il existe en cinq formes primitives
 différentes : Boule, Bloc, Cylindre, Coin et CoinWedge.


Part

La propriété Shape définit la forme générale de l'objet comme l'une des
formes intégrées prédéterminées.

L'énumération `Enum.PartType` contrôle la valeur de la forme et a cinq
formes possibles :

| Forme/Valeur | Description                             |
| ------------ | --------------------------------------- |
| Boule       | Une forme sphérique.                   |
| Bloc        | Une forme de bloc.                     |
| Cylindre    | Une forme de cylindre.                 |
| Coin        | Une forme de wedge avec une pente d'un côté. |
| CoinWedge   | Une forme de wedge avec des pentes des deux côtés. |

`Class.MeshPart` et [modélisation solide](/parts/solid-modeling)
peuvent être utilisés pour obtenir des formes de pièce totalement personnalisées.

Les collisions entre les boules, les blocs, et les wedges, et les coins sont exactes,
 alors que les collisions entre le terrain, les cylindres, les TriangleMeshes, et d'autres
types de géométrie sont des approximations. Cela signifie que la forme de boule peut être
utile pour créer des colliders stables pour les roues de voiture.


Part.Shape

Définit la forme générale de l'objet.


Un type commun de `Class.BasePart` qui existe sous différentes formes primitives.


La classe FormFactorPart est une classe abstraite. Elle hérite de la classe
`Class.BasePart` et ajoute la propriété `Class.FormFactorPart.FormFactor` aux classes qui en héritent.


FormFactorPart

Cela spécifiait auparavant une contrainte de grille de la taille de la pièce. Ne fait plus rien.


FormFactorPart.FormFactor

Détermine comment une pièce se comporte lors du redimensionnement et les valeurs que sa taille peut prendre.


FormFactorPart.formFactor

La classe FormFactorPart est une classe abstraite. Elle hérite de la classe BasePart et ajoute la propriété FormFactor aux classes qui en héritent.


Crée une pièce bleue et une pièce cible rouge. La pièce bleue essaiera d'atteindre
en douceur la pièce cible rouge. Déplacez et faites pivoter la cible pour voir le comportement.
Modifier le smoothTime entraînera une vitesse de lissage différente.


`Class.BasePart` est une classe de base abstraite pour les objets dans le monde qui se rendent
et sont simulés physiquement pendant qu'ils sont dans `Class.Workspace`. Il existe plusieurs
implémentations de `Class.BasePart`, les plus courantes étant `Class.Part` et
`Class.MeshPart`. D'autres incluent `Class.WedgePart`, `Class.SpawnLocation`, et
l'objet singleton `Class.Terrain`. En général, quand la documentation fait référence à
un "part", la plupart des implémentations de `Class.BasePart` fonctionneront et pas seulement
`Class.Part`.

Pour des informations sur la façon dont `Class.BasePart|BaseParts` sont regroupés en corps rigides simulés,
voyez voir [Assemblies](/physics/assemblies).

Il existe de nombreux objets qui interagissent avec `Class.BasePart` (en dehors de `Class.Terrain`), y compris :

- Plusieurs `Class.BasePart|BaseParts` peuvent être regroupés dans un `Class.Model` et
  déplacés en même temps en utilisant `Class.PVInstance:PivotTo()`. Voir
  [Models](/parts/models).
- Un `Class.Decal` applique une texture d'image étirée aux faces d'un
  `Class.BasePart`, tandis qu'un `Class.Texture` applique une texture d'image carrelée aux
  faces. Voir [Textures et Décalcomanies](/parts/textures-decals).
- Un `Class.SurfaceGui` rend des `Class.GuiObject|GuiObjects` sur la face d'une
  pièce. Voir
  [Conteneurs UI en Expérience](/ui/in-experience-containers).
- `Class.Attachment|Attachments` peut être ajouté à un `Class.BasePart` pour spécifier
  des `Datatype.CFrame|CFrames` relatifs à la pièce. Ceux-ci sont souvent utilisés par
  les objets physiques `Class.Constraint` comme indiqué dans
  [Contraintes Mécaniques](/physics/mechanical-constraints) et
  [Contraintes de Déplacement](/physics/mover-constraints).
- Les objets `Class.ParticleEmitter` émettent des particules uniformément dans le volume du
  `Class.BasePart` auquel ils sont parentés. Voir
  [Émetteurs de Particules](/effects/particle-emitters).
- Les objets de lumière comme `Class.PointLight` émettent de la lumière depuis le centre d'un
  `Class.BasePart` comme illustré dans
  [Sources de Lumière](/effects/light-sources).
- S'ils sont parentés à un `Class.Tool` et portés le nom **Handle**, un
  `Class.BasePart` peut être tenu par des personnages. Voir
  [Outils en Expérience](/players/tools).

Déclenché lorsque qu'une autre pièce entre en contact avec un autre objet. Cet événement
n'envoie que des données au client pour l'informer que deux pièces ont collidé,
alors que `Class.BasePart.Touched` envoie des données au serveur.

BasePart.LocalSimulationTouched

part

Déclenché si l'apparence de la pièce est affectée par la classe `Class.Shirt`.

BasePart.OutfitChanged

BasePart.StoppedTouching

otherPart

Cet exemple de code crée un BillboardGui sur une pièce qui affiche le nombre de
pièces actuellement en contact avec elle.


Cet exemple de code montre comment connecter l'événement `Class.BasePart.Touched`
d'un grand nombre de pièces dans un `Class.Model` à une seule fonction.


L'événement **Touched** se déclenche lorsqu'une pièce entre en contact avec une autre
pièce. Par exemple, si **PartA** heurte **PartB**, alors
`Class.BasePart.Touched|PartA.Touched` se déclenche avec **PartB**, et
`Class.BasePart.Touched|PartB.Touched` se déclenche avec **PartA**.

Cet événement ne se déclenche que suite à un mouvement physique, donc il ne se déclenchera pas
si la propriété `Class.BasePart.CFrame|CFrame` a été modifiée de manière à ce que
la pièce chevauche une autre pièce. Cela signifie aussi qu'au moins une des
pièces impliquées ne doit **pas** être `Class.BasePart.Anchored|Ancrée` au moment de la collision.

Cet événement fonctionne en conjonction avec
`Class.Workspace.TouchesUseCollisionGroups` pour spécifier si
[les groupes de collision](/workspace/collisions#collision-filtering)
sont reconnus pour la détection.

BasePart.Touched

L'autre pièce qui est entrée en contact avec la pièce donnée.

Déclenche lorsque qu'une pièce touche une autre pièce en raison d'un mouvement physique.

Déclenche lorsque qu'une pièce cesse de toucher une autre pièce dans des conditions similaires à celles de `Class.BasePart.Touched`.

Cet événement fonctionne en conjonction avec
`Class.Workspace.TouchesUseCollisionGroups` pour spécifier si
[les groupes de collision](/workspace/collisions#collision-filtering)
sont reconnus pour la détection.

BasePart.TouchEnded

Déclenche lorsque qu'une pièce cesse de toucher une autre pièce en raison d'un mouvement physique.

Renvoie le vecteur de couple dans l'espace mondial qui doit être appliqué à l'assemblage de la pièce pour atteindre l'accélération angulaire spécifiée. Ce résultat peut être
utilisé pour déterminer le couple qui devrait être appliqué via une instance de `Class.Torque`
ou `Class.BasePart:ApplyAngularImpulse()`.

Le calcul utilise l'équation de rotation d'Euler où _I_ est le tenseur d'inertie dans l'espace mondial de l'assemblage, _α_ est l'accélération angulaire désirée, et
_ω_ est la vitesse angulaire.

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

Si la pièce n'est pas un descendant de `Class.Workspace`, cette méthode renvoie
un vecteur d'infini. Si l'assemblage est ancré, elle renvoie également un
vecteur d'infini.

#### Effets gyroscopiques

Lorsqu'un assemblage en rotation a un tenseur d'inertie asymétrique, le couple
nécessaire pour atteindre une accélération angulaire spécifiée est augmenté en raison
de l'orientation changeante du corps. Le paramètre optionnel `angVelocity`
prend en compte ces effets gyroscopiques. S'il est omis, ces effets gyroscopiques
sont omis du calcul.

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

-- Calculer le couple nécessaire pour atteindre l'accélération désirée
local torque = part:AngularAccelerationToTorque(desiredAcceleration, angularVelocity)
```

BasePart:AngularAccelerationToTorque

angAcceleration

Le vecteur d'accélération angulaire désiré dans l'espace mondial.

angVelocity

La vitesse angulaire actuelle de l'assemblage dans l'espace mondial. Par défaut
de `(0, 0, 0)`. Fournissez la vitesse angulaire de l'assemblage pour tenir compte des
générations gyroscopiques.

Un `Datatype.Vector3` représentant le couple requis dans l'espace mondial pour
produire l'accélération angulaire spécifiée.

Renvoie le couple nécessaire pour atteindre une accélération angulaire donnée sur l'assemblage de cette pièce, en tenant éventuellement compte des effets gyroscopiques.

Applique une force angulaire instantanée à l'assemblage de cette pièce, causant
de l'assemblage à tourner.

La vitesse angulaire résultant de l'impulsion dépend de la
`Class.BasePart.AssemblyMass|masse` de l'assemblage. Donc une impulsion plus importante est requise pour
mouvoir des assemblages plus massifs. Les impulsions sont utiles dans les cas où vous souhaitez
appliquer une force instantanément, comme une explosion ou une collision.

Si la pièce est [possédée](/physics/network-ownership) par le
serveur, cette fonction doit être appelée depuis un `Class.Script` serveur (pas
depuis un `Class.LocalScript` ou un `Class.Script` avec
`Class.BaseScript.RunContext|RunContext` réglé sur `Enum.RunContext.Client`).
Si la pièce est possédée par un client par le biais d'une propriété **automatique**, cette
fonction peut être appelée depuis un script client **ou** un script serveur ;
l'appeler depuis un script client pour une pièce détenue par le serveur n'aura aucun
impact.

BasePart:ApplyAngularImpulse

impulse

Un vecteur d'impulsion angulaire à appliquer à l'assemblage.

Applique un impulsion angulaire à l'assemblage.

Cette fonction applique une force d'impulsion instantanée à l'assemblage de cette pièce.

La force est appliquée au centre de masse de l'assemblage,
`Class.BasePart.AssemblyCenterOfMass|centre de masse`, donc le mouvement résultant ne sera que linéaire.

La vitesse résultante de l'impulsion dépend de la
`Class.BasePart.AssemblyMass|masse` de l'assemblage. Donc une impulsion plus importante est requise pour
mouvoir des assemblages plus massifs. Les impulsions sont utiles dans les cas où vous souhaitez
appliquer une force instantanément, comme une explosion ou une collision.

Si la pièce est [possédée](/physics/network-ownership) par le
serveur, cette fonction doit être appelée depuis un `Class.Script` serveur (pas
depuis un `Class.LocalScript` ou un `Class.Script` avec
`Class.BaseScript.RunContext|RunContext` réglé sur `Enum.RunContext.Client`).
Si la pièce est possédée par un client par le biais d'une propriété **automatique**, cette
fonction peut être appelée depuis un script client **ou** un script serveur ;
l'appeler depuis un script client pour une pièce détenue par le serveur n'aura aucun
impact.

BasePart:ApplyImpulse

Un vecteur d'impulsion linéaire à appliquer à l'assemblage.

Applique une impulsion à l'assemblage au centre de masse de l'assemblage
`Class.BasePart.AssemblyCenterOfMass|centre de masse`.

Cette fonction applique une force d'impulsion instantanée à l'assemblage de cette pièce, à la
position spécifiée dans l'espace mondial.

Si la position n'est pas au centre de masse de l'assemblage,
`Class.BasePart.AssemblyCenterOfMass|centre de masse`, l'impulsion
causera un mouvement positionnel et rotationnel.

La vitesse résultante de l'impulsion dépend de la
`Class.BasePart.AssemblyMass|masse` de l'assemblage. Donc une impulsion plus importante est requise pour
mouvoir des assemblages plus massifs. Les impulsions sont utiles dans les cas où
des développeurs souhaitent appliquer une force instantanément, comme une explosion ou
une collision.

Si la pièce est [possédée](/physics/network-ownership) par le
serveur, cette fonction doit être appelée depuis un `Class.Script` serveur (pas
depuis un `Class.LocalScript` ou un `Class.Script` avec
`Class.BaseScript.RunContext|RunContext` réglé sur `Enum.RunContext.Client`).
Si la pièce est possédée par un client par le biais d'une propriété **automatique**, cette
fonction peut être appelée depuis un script client **ou** un script serveur ;
l'appeler depuis un script client pour une pièce détenue par le serveur n'aura aucun
impact.

BasePart:ApplyImpulseAtPosition

Un vecteur d'impulsion à appliquer à l'assemblage.

position

La position, dans l'espace mondial, pour appliquer l'impulsion.

Applique une impulsion à l'assemblage à la position spécifiée.

Brise toute connexion de surface avec toute pièce adjacente, y compris
`Class.Weld` et autre `Class.JointInstance`.

BasePart:BreakJoints

BasePart:breakJoints

Renvoie si les pièces peuvent entrer en collision les unes avec les autres ou non. Cette
fonction prend en compte les groupes de collision des deux pièces. Cette
fonction produira une erreur si la pièce spécifiée n'est pas un BasePart.

BasePart:CanCollideWith

La pièce spécifiée pour laquelle on vérifie la possibilité de collision.

Si les pièces peuvent entrer en collision les unes avec les autres.

Renvoie si les pièces peuvent entrer en collision les unes avec les autres.

Cet exemple vérifie si la propriété d'appartenance réseau de la première
`BasePart` nommée _Part_ dans le `Workspace` peut être définie.

La fonction CanSetNetworkOwnership vérifie si vous pouvez définir la propriété de réseau d'une pièce.

La valeur de retour de la fonction confirme si vous pouvez ou non appeler
`Class.BasePart:SetNetworkOwner()` ou
`Class.BasePart:SetNetworkOwnershipAuto()` sans rencontrer d'erreur.
Elle renvoie vrai si vous pouvez modifier/lire la propriété de réseau, ou renvoie
faux et la raison pour laquelle vous ne pouvez pas, sous forme de chaîne.

BasePart:CanSetNetworkOwnership

Si vous pouvez modifier ou lire la propriété de réseau et la raison.

Vérifie si vous pouvez définir la propriété de réseau d'une pièce.

Renvoie le point le plus proche à la surface de la pièce par rapport à la position dans l'espace mondial donnée. Si la position fournie est à l'intérieur de la pièce, elle est renvoyée
telle quelle.

Pour `Class.MeshPart` et `Class.PartOperation` instances, cette méthode
respecte la valeur `Enum.CollisionFidelity` de la pièce. Les valeurs de retour peuvent
varier en fonction de la manière dont le maillage est traité : comme une boîte, un coque ou une
forme plus complexe.

BasePart:GetClosestPointOnSurface

Le point dans l'espace mondial pour lequel trouver le point de surface le plus proche.

Le point le plus proche à la surface de la pièce dans l'espace mondial.

Renvoie le point le plus proche à la surface de la pièce par rapport au point donné.

Renvoie une table de pièces connectées à l'objet par n'importe quel type de joint rigide.

Si `recursive` est vrai, cette fonction renverra toutes les pièces dans l'ensemble rigide connectées au BasePart.

#### Joints Rigides

Lorsqu'un joint connecte deux pièces ensemble `(Part0 → Part1)`, un joint est
**rigide** si la physique de `Part1` est complètement verrouillée par `Part0`.
Ceci s'applique uniquement aux types de joints suivants :

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

BasePart:GetConnectedParts

recursive

Une table de pièces connectées à l'objet par n'importe quel type de
`Class.JointInstance|joint`.

Renvoie une table de pièces connectées à l'objet par n'importe quel type de joint rigide.

Retourne tous les Joints ou Contraintes qui sont connectés à cette Partie.

BasePart:GetJoints

Un tableau de tous les Joints ou Contraintes connectés à la Partie.

Cet exemple crée une nouvelle pièce, myPart, dans l'espace de travail du jeu, avec
dimensions 4x6x4 studs. La pièce est également ancrée.

Ensuite, myMass est défini pour égaler la masse de la nouvelle pièce. La masse de la pièce est
imprimée à la fin de l'instruction d'impression:

> La masse de ma pièce est ...

**GetMass** renvoie la valeur de la propriété en lecture seule `Class.BasePart.Mass|Mass`.

Cette fonction précède la propriété Mass. Elle reste supportée pour
la compatibilité rétroactive ; vous devriez utiliser la propriété Mass directement.

BasePart:GetMass

Renvoie la valeur de la propriété `Class.BasePart.Mass|Mass`.

BasePart:getMass

Renvoie le joueur actuel qui est le propriétaire du réseau de cette pièce, ou `nil`
en cas de serveur.

BasePart:GetNetworkOwner

Le joueur actuel qui est le propriétaire du réseau de cette pièce, ou `nil` dans
le cas du serveur.

Renvoie vrai si le moteur de jeu décide automatiquement du propriétaire du réseau
pour cette pièce.

BasePart:GetNetworkOwnershipAuto

Si le moteur de jeu décide automatiquement du propriétaire du réseau pour
cette pièce.

BasePart:GetNoCollisionConstraints

Cette fonction était pertinente lorsque l'interpolation compensant le décalage de Roblox
était interne. L'interpolation est maintenant appliquée directement au
`Datatype.CFrame`.

BasePart:GetRenderCFrame

OBSOLETE. Renvoie un CFrame décrivant où la pièce est rendue.

Renvoie la pièce de base d'un assemblage. Lors de l'assemblage de pièces
avec un `Datatype.CFrame`, il est important de déplacer cette pièce de base (cela
déplacera toutes les autres pièces connectées en conséquence). Plus d'informations
sont disponibles dans l'article [Assemblages](/physics/assemblies).

Cette fonction précède la propriété
`Class.BasePart.AssemblyRootPart|AssemblyRootPart`. Elle reste
supportée pour la compatibilité rétroactive, mais vous devriez utiliser
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` directement.

BasePart:GetRootPart

La pièce de base d'un assemblage (une collection de pièces connectées ensemble).

Renvoie la pièce de base d'un assemblage de pièces.

Renvoie une table de toutes les pièces qui interagissent physiquement avec cette
pièce. Si la pièce elle-même a CanCollide réglé sur faux, alors cette fonction
renvoie une table vide, sauf si la pièce a un
`Class.TouchTransmitter|TouchInterest` objet parenté. Les pièces qui sont adjacentes mais
non intersectantes ne sont pas considérées comme touchant. Cette fonction précède la
fonction `Class.WorldRoot:GetPartsInPart()`, qui offre plus de flexibilité et évite les règles spéciales
de `Class.TouchTransmitter|TouchInterest` décrites ci-dessus. Utilisez `Class.WorldRoot:GetPartsInPart()` à la place.

BasePart:GetTouchingParts

Une table de toutes les pièces qui s'entrecroisent et peuvent entrer en collision avec cette pièce.

Renvoie une table de tous les `Class.BasePart.CanCollide` parties qui
s'intersectent avec cette pièce.

Renvoie la vitesse linéaire de l'assemblage de la pièce à la position donnée
relativement à cette pièce. Elle peut être utilisée pour identifier la vitesse linéaire des
pièces dans un assemblage autre que la pièce racine. Si l'assemblage n'a pas de
vitesse angulaire, alors la vitesse linéaire sera toujours la même pour
chaque position.

BasePart:GetVelocityAtPosition

Renvoie la vitesse linéaire de l'assemblage de la pièce à la position donnée
relativement à cette pièce.

Crée une nouvelle `Class.IntersectOperation` à partir de la géométrie intersectante de
la pièce et des autres pièces dans le tableau donné. Seules les `Class.Part|Parts`
sont prises en charge, pas `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semblable à
`Class.Instance:Clone()|Clone()`, l'objet retourné n'a pas de `Class.Instance.Parent|Parent` défini.

Les propriétés suivantes de la pièce appelante sont appliquées à la
`Class.IntersectOperation` résultante :

- `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`

Dans la comparaison d'image suivante,
`Class.BasePart:IntersectAsync()|IntersectAsync()` est appelé sur le bloc violet en utilisant un tableau contenant le bloc bleu. Le
`Class.IntersectOperation` résultant se résout en une forme de la géométrie
intersectante des deux pièces.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Intersect.jpg"
width="720" alt="Deux pièces en blocs se chevauchant" />
<figcaption>Pièces séparées</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Intersect-Result.jpg"
width="720"
alt="Pièces intersectées en un nouveau modèle solide" />
<figcaption>Résultat <code>Class.IntersectOperation</code></figcaption>
</figure>

#### Remarques

- Les pièces originales restent intactes après une opération d'intersection réussie. Dans la plupart des cas, vous devriez `Class.Instance.Destroy|Destroy()`
  toutes les pièces originales et parenté la `Class.IntersectOperation` retournée au même endroit que la pièce appelante.
- Par défaut, les couleurs de face de l'intersection résultante sont empruntées
  à la propriété `Class.BasePart.Color|Color` des pièces originales. Pour
  changer l'ensemble de l'intersection en une couleur spécifique, réglez sa
  propriété `Class.PartOperation.UsePartColor|UsePartColor` sur `true`.
- Si une opération d'intersection donnerait une pièce avec plus de 20 000
  triangles, elle sera simplifiée à 20 000 triangles.

BasePart:IntersectAsync

parts

Les objets participant à l'intersection.

collisionfidelity

La valeur `Enum.CollisionFidelity` pour le
`Class.IntersectOperation` résultant.

renderFidelity

La valeur `Enum.RenderFidelity` du
`Class.PartOperation` résultant.

Résultant `Class.IntersectOperation` avec le nom par défaut **Intersect**.

Remarque : il est fortement recommandé d'utiliser le nouveau
`Class.GeometryService:IntersectAsync` à la place de cette fonction. En plus
d'avoir de meilleures performances et plus de fonctionnalités, la nouvelle fonction diffère
comme suit :

- La sortie est un tableau d'instances plutôt qu'une seule instance.
- Les pièces d'entrée n'ont pas besoin d'être parentées à la scène, permettant des
  opérations en arrière-plan.
- Lorsque l'option `SplitApart` est réglée sur `true` (par défaut), chaque corps distinct
  sera renvoyé dans son propre `Class.PartOperation`.
- Toutes les pièces retournées sont dans l'espace de coordonnées de la pièce principale, donc
  leurs positions `Class.PVInstance.Origin` sont les mêmes que celle de la pièce principale.
  Cela garde les sommets du maillage dans la même position
  par rapport à l'objet qu'auparavant, mais cela signifie également que
  le `(0, 0, 0)` d'une pièce retournée n'est pas nécessairement au centre de
  son corps.

  Crée une nouvelle `Class.IntersectOperation` à partir de la géométrie qui se chevauche
  de la pièce et des autres pièces dans le tableau donné.

Renvoie vrai si l'objet est connecté à une pièce qui le maintiendra en place
(par exemple une pièce `Class.BasePart.Anchored|Ancrée`), sinon renvoie
faux. Dans un assemblage qui a une pièce `Class.BasePart.Anchored|Ancrée`,
toute autre pièce est ancrée.

BasePart:IsGrounded

Si l'objet est connecté à une pièce qui le maintiendra en place.

Renvoie vrai si l'objet est connecté à une pièce qui le maintiendra en place
(par exemple une pièce `Class.BasePart.Anchored|Ancrée`), sinon renvoie
faux.

Crée un joint sur n'importe quel côté de la `Class.BasePart|Part` qui a un
`Enum.SurfaceType` qui peut créer un joint, il créera un joint avec toutes
les pièces adjacentes.

Des joints seront créés entre les côtés et toutes les surfaces planes qui se touchent,
selon les surfaces des côtés.

- Les surfaces lisses ne créeront pas de joints
- Les surfaces gluantes créeront un joint `Class.Glue`
- Les soudures créeront un joint `Class.Weld` avec n'importe quelle surface sauf pour
  Unjoinable
- Les Studs, Inlet ou Universal créeront respectivement un joint `Class.Snap` avec
  l'une des deux autres surfaces (par exemple, Studs avec Inlet et
  Universal)
- Les surfaces Hinge et Motor créent des instances de joint `Class.Rotate` et
  `Class.RotateV`

Contrairement à `Class.Model:MakeJoints()`, cette fonction nécessite un tableau de
pièces comme paramètre. Ce tableau est donné comme suit :

```
part:MakeJoints({part1, part2, part3})
```
Les joints sont cassés si une force suffisante est appliquée dessus à cause d'une
`Class.Explosion`, à moins qu'un objet `Class.ForceField` soit parenté à la
`Class.BasePart` ou à un ancêtre `Class.Model`. Pour cette raison, ils sont
souvent utilisés pour créer des bâtiments destructibles simples et d'autres modèles.

BasePart:MakeJoints

Crée un joint sur n'importe quel côté de l'objet ayant un ID de surface qui peut
créer un joint.

BasePart:makeJoints

Change la taille d'un objet tout comme utiliser l'outil de redimensionnement du Studio.

BasePart:Resize

normalId

deltaAmount

De combien croître/réduire sur le côté spécifié.

BasePart:resize

Définit le joueur donné comme propriétaire du réseau pour cette pièce et toutes les pièces connectées.
Lorsque playerInstance est `nil`, le serveur sera le propriétaire au lieu d'un
joueur.

BasePart:SetNetworkOwner

playerInstance

Le joueur qui obtient la propriété du réseau de la pièce.

Définit le joueur donné comme propriétaire du réseau pour cette pièce et toutes les pièces connectées.

Permet au moteur de jeu de décider dynamiquement qui gérera la physique de la pièce
(l'un des clients ou le serveur).

BasePart:SetNetworkOwnershipAuto

Cet exemple démontre comment soustraire une ou plusieurs pièces d'une autre
`Class.BasePart` pour former une `Class.UnionOperation` négative.

Crée une nouvelle `Class.UnionOperation` à partir de la pièce, moins la géométrie
occupée par les pièces dans le tableau donné. Seules les `Class.Part|Parts` sont
soutenus, pas `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semblable à
`Class.Instance:Clone()|Clone()`, l'objet retourné n'a pas de `Class.Instance.Parent|Parent` défini.

Notez que la union résultante ne peut pas être vide en raison des soustractions. Si
l'opération entraînerait une géométrie complètement vide, elle échouera.

Dans la comparaison d'image suivante,
`Class.BasePart:SubtractAsync()|SubtractAsync()` est appelé sur le cylindre bleu
utilisant un tableau contenant le bloc violet. Le résultat
`Class.UnionOperation` se résout en une forme qui omet la géométrie du bloc.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Subtract.jpg"
width="720" alt="Bloc plus long chevauchant un cylindre" />
<figcaption>Pièces séparées</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Negate-Result.jpg" width="720"
alt="Bloque partie soustraite du cylindre" />
<figcaption>Résultat <code>Class.UnionOperation</code></figcaption>
</figure>

BasePart:SubtractAsync

Les objets participant à la soustraction.

La valeur `Enum.CollisionFidelity` pour le résultat
`Class.UnionOperation`.

La valeur `Enum.RenderFidelity` du résultat
`Class.PartOperation`.

Résultant `Class.UnionOperation` avec le nom par défaut **Union**.

Remarque : il est fortement recommandé d'utiliser le nouveau
`Class.GeometryService:UnionAsync` à la place de cette fonction. En plus
d'avoir de meilleures performances et plus de fonctionnalités, la nouvelle fonction diffère comme
suit :

- La sortie est un tableau d'instances plutôt qu'une seule instance.
- Les pièces d'entrée n'ont pas besoin d'être parentées à la scène, ce qui permet
  des opérations en arrière-plan.
- Lorsque l'option `SplitApart` est réglée sur `true` (par défaut), chaque corps distinct
  sera renvoyé dans son propre `Class.PartOperation`.
- Toutes les pièces retournées sont dans l'espace de coordonnées de la pièce principale, donc
  leurs positions `Class.PVInstance.Origin` sont les mêmes que celles de la pièce principale.
  Cela garde les sommets du maillage dans la même position par rapport à l'objet qu'auparavant, mais cela signifie aussi que
  le `(0, 0, 0)` d'une pièce retournée n'est pas nécessairement au centre de son corps.

  Crée une nouvelle `Class.UnionOperation` à partir de la pièce, moins la géométrie
  occupée par les pièces dans le tableau donné.

Renvoie l'accélération angulaire dans l'espace mondial qui résulterait de
l'application du couple spécifié à l'assemblage de la pièce, en prenant éventuellement
en compte les effets gyroscopiques.

C'est l'inverse de `Class.BasePart:AngularAccelerationToTorque()`. C'est
utile pour prédire comment un assemblage réagira à un couple appliqué.

Le calcul utilise :

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

où **I** est le tenseur d'inertie dans l'espace mondial de l'assemblage, **τ** est le
couple appliqué, et **ω** est la vitesse angulaire.

Si la pièce n'est pas un descendant de `Class.Workspace`, renvoie `(0, 0, 0)`.
Si l'assemblage est ancré, renvoie `(0, 0, 0)`.

#### Effets gyroscopiques

Lorsqu'un assemblage en rotation a un tenseur d'inertie asymétrique, l'accélération
résultant d'un couple appliqué dépend également de la vitesse angulaire actuelle.
Le paramètre `angVelocity` prend en compte ces effets
gyroscopiques. S'il est omis (par défaut zéro), le résultat néglige
cette contribution du résultat.

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

-- Prédire l'accélération angulaire à partir de ce couple
local angAccel = part:TorqueToAngularAcceleration(appliedTorque, angularVelocity)
```

BasePart:TorqueToAngularAcceleration

torque

Le vecteur de couple appliqué à l'assemblage dans l'espace mondial.

La vitesse angulaire actuelle de l'assemblage dans l'espace mondial. Par défaut
à `(0, 0, 0)`. Fournissez la vitesse angulaire de l'assemblage pour tenir compte des
générations gyroscopiques.

Un `Datatype.Vector3` représentant l'accélération angulaire résultante
dans l'espace mondial.

Renvoie l'accélération angulaire qui résulterait de l'application d'un couple donné à l'assemblage de cette pièce, en tenant éventuellement compte des effets gyroscopiques.

Cet exemple démontre comment combiner la géométrie d'un `Class.BasePart`
avec la géométrie d'autre(s) pièce(s) pour former une `Class.UnionOperation`.

Crée une nouvelle `Class.UnionOperation` à partir de la pièce, ainsi que la géométrie
occupée par les pièces dans le tableau donné. Seules les `Class.Part|Parts` sont
soutenus, pas `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semblable à
`Class.Instance:Clone()|Clone()`, l'objet retourné n'a pas de `Class.Instance.Parent|Parent` défini.

Les propriétés suivantes de la pièce appelante sont appliquées à l'
résultante `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`

Dans la comparaison d'image suivante,
`Class.BasePart:UnionAsync()|UnionAsync()` est appelé sur le bloc bleu
utilisant un tableau contenant le cylindre violet. Le résultat
`Class.UnionOperation` se résout en une forme de la géométrie combinée des
deux pièces.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Union.jpg"
width="720" alt="Pièces de bloc et de cylindre se chevauchant" />
<figcaption>Pièces séparées</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Union-Result.jpg" width="720"
alt="Pièces jointes ensemble en une seule union solide" />
<figcaption>Résultant <code>Class.UnionOperation</code></figcaption>
</figure>

#### Remarques

- Les pièces originales restent intactes après une opération de union réussie.
  Dans la plupart des cas, vous devriez `Class.Instance.Destroy|Destroy()` toutes les
  pièces originales et parenté le `Class.UnionOperation` retourné au même endroit que la
  pièce appelante.
- Par défaut, le union résultant respecte la
  propriété `Class.BasePart.Color|Color` de chacune de ses pièces. Pour changer
  l'ensemble de l'union en une couleur spécifique, réglez sa propriété
  `Class.PartOperation.UsePartColor|UsePartColor` sur `true`.
- Si une opération de union donnerait une pièce avec plus de 20 000
  triangles, elle sera simplifiée à 20 000 triangles.

BasePart:UnionAsync

Les objets participant à l'union avec la pièce appelante.

La valeur `Enum.CollisionFidelity` pour le
`Class.UnionOperation` résultant.

Remarque : il est fortement recommandé d'utiliser le nouveau
`Class.GeometryService:UnionAsync` à la place de cette fonction. En plus
d'avoir de meilleures performances et plus de fonctionnalités, la nouvelle fonction diffère comme
suit :

- La sortie est un tableau d'instances plutôt qu'une seule instance.
- Les pièces d'entrée n'ont pas besoin d'être parentées à la scène, ce qui permet
  des opérations en arrière-plan.
- Lorsque l'option `SplitApart` est réglée sur `true` (par défaut), chaque distinct
  corps sera renvoyé dans son propre `Class.PartOperation`.
- Toutes les pièces retournées sont dans l'espace de coordonnées de la pièce principale, donc
  leurs positions `Class.PVInstance.Origin` sont les mêmes que celles de la pièce principale.
  Cela garde les sommets du maillage dans la même position par rapport à l'objet qu'auparavant, mais cela signifie aussi que
  le `(0, 0, 0)` d'une pièce retournée n'est pas nécessairement au centre de son corps.

        Crée une nouvelle `Class.UnionOperation` à partir de la pièce, ainsi que la géométrie

  occupée par les pièces dans le tableau donné.

BasePart

Cet exemple de code permettra de cliquer sur une pièce pour basculer sa propriété ancrée.
Lorsque c'est basculé, l'apparence visuelle de la pièce est mise à jour (rouge
signifie ancré, jaune signifie libre).


La propriété `Anchored` détermine si la pièce sera immuable par
la physique. Lorsqu'elle est activée, une pièce ne changera jamais de position en raison de
la gravité, des collisions avec d'autres pièces, du chevauchement d'autres pièces, ou de toute autre
cause liée à la physique. En conséquence, deux parties ancrées ne déclencheront jamais
l'événement `Class.BasePart.Touched|Touched` l'une sur l'autre.

Une pièce ancrée peut toutefois être déplacée en changeant son
`Class.BasePart.CFrame|CFrame` ou `Class.BasePart.Position|Position`, et
elle peut toujours avoir une
`Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity` et
`Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity` non nulles.

Enfin, si une pièce non ancrée est jointe à une pièce ancrée via un
objet comme un `Class.Weld`, celle-ci agira également comme ancrée. Si un tel joint
se casse, la pièce peut à nouveau être affectée par la physique. Voir
[Assemblies](/physics/assemblies) pour plus de détails.

La propriété de propriété réseau ne peut pas être définie sur des pièces ancrées. Si le statut ancré d'une pièce change sur le serveur, la propriété réseau de cette pièce sera
affectée.

BasePart.Anchored

Détermine si une pièce est immuable par la physique.

Le vecteur de vitesse angulaire de l'assemblage de cette pièce. C'est le taux de
changement d'orientation en radians par seconde.

La vitesse angulaire est la même à chaque point de l'assemblage.

Définir directement la vitesse peut entraîner un mouvement irréaliste. Il est préférable d'utiliser
un `Class.Torque` ou une contrainte `Class.AngularVelocity`, ou d'utiliser
`Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()` si vous voulez
un changement instantané de la vitesse.

Si la pièce est [propriétaire](/physics/network-ownership) du
serveur, cette propriété doit être modifiée par un `Class.Script` serveur (pas
à partir d'un `Class.LocalScript` ou d'un `Class.Script` avec
`Class.BaseScript.RunContext|RunContext` défini sur `Enum.RunContext.Client`).
Si la pièce est possédée par un client par **propriété automatique**, cette
propriété peut être changée à partir d'un script client **ou** d'un script
serveur; changer cela à partir d'un script client pour une pièce possédée par le serveur n'aura
aucun effet.

BasePart.AssemblyAngularVelocity

La vitesse angulaire de l'assemblage de la pièce.

Une position calculée via la `Class.BasePart.Mass|Mass` et
`Class.BasePart.Position|Position` de toutes les pièces de l'assemblage.

Si l'assemblage a une pièce ancrée, le centre de masse de cette pièce sera
le centre de masse de l'assemblage, et l'assemblage aura une masse infinie.

Connaître le centre de masse peut aider l'assemblage à maintenir la stabilité. Une
force appliquée au centre de masse ne causera pas d'accélération angulaire,
seulement linéaire. Un assemblage avec un centre de masse bas sera mieux en mesure
de rester debout sous l'effet de la gravité.

BasePart.AssemblyCenterOfMass

Le centre de masse de l'assemblage de la pièce dans l'espace monde.

Le vecteur de vitesse linéaire de cet assemblage de pièce. C'est le taux de
changement de position de
`Class.BasePart.AssemblyCenterOfMass|AssemblyCenterOfMass` en studs par
seconde.

Si vous voulez connaître la vitesse à un point autre que le centre de masse de l'assemblage,
utilisez
`Class.BasePart:GetVelocityAtPosition()|GetVelocityAtPosition()`.

Définir directement la vitesse peut provoquer un mouvement irréaliste. Utiliser une
contrainte `Class.VectorForce` est préférable, ou utilisez
`Class.BasePart:ApplyImpulse()|ApplyImpulse()` si vous souhaitez un changement instantané
de vitesse.

Si la partie est [propriétaire](/physics/network-ownership) du
serveur, cette propriété doit être changée depuis un `Class.Script` serveur (non
à partir d'un `Class.LocalScript` ou d'un `Class.Script` avec
`Class.BaseScript.RunContext|RunContext` défini sur `Enum.RunContext.Client`).
Si la pièce est possédée par un client par **propriété automatique**, cette
propriété peut être changée à partir d'un script client **ou** d'un script
serveur; changer cela à partir d'un script client pour une pièce possédée par le serveur n'aura
aucun effet.

BasePart.AssemblyLinearVelocity

La vitesse linéaire de l'assemblage de la pièce.

La classe de base abstraite pour les objets dans le monde qui interagissent physiquement.

/reference/engine/classes/SkateboardPlatform.yaml