Das folgende Skript erzeugt eine neue `Part`-Instanz und setzt mehrere der Eigenschaften des Teils.

Besonders bemerkenswert ist, dass das Skript die `Class.Part.Shape`-Eigenschaft auf
`Enum.PartType.Ball` setzt. Es benennt das Teil außerdem _JurassicPart_, verankert es, macht
es zu einem Kind von _Workspace_ und setzt seine Farbe auf weiß.

Das Part-Objekt ist eine Art von `Class.BasePart`. Es kommt in fünf verschiedenen primitiven Formen: Ball, Block, Zylinder, Keil und Eckkeil.


Part

Die Shape-Eigenschaft legt die allgemeine Form des Objekts auf eine der vordefinierten Listen von integrierten Formen fest.

Das `Enum.PartType`-Enum steuert den Formwert und hat fünf mögliche Formen:

| Form/Wert   | Beschreibung                             |
| ----------- | --------------------------------------- |
| Ball        | Eine sphärische Form.                   |
| Block       | Eine Blockform.                         |
| Zylinder    | Eine Zylinderform.                      |
| Keil        | Eine Keilform mit einer Neigung auf einer Seite. |
| Eckkeil     | Eine Keilform mit Neigungen auf zwei Seiten. |

`Class.MeshPart` und [solide Modellierung](/parts/solid-modeling)
können verwendet werden, um vollständig maßgeschneiderte Teilformen zu erhalten.

Kollisionen zwischen Bällen, Blöcken und Keilen sowie Eckkeilen sind exakt,
während Kollisionen zwischen Terrain, Zylindern, TriangleMeshes und anderen Geometrietypen Näherungen sind. Das bedeutet, dass die Ballform nützlich sein kann, um stabile Collider für Autoreifen zu erstellen.


Part.Shape

Bestimmt die allgemeine Form des Objekts.


Eine häufige Art von `Class.BasePart`, die in verschiedenen primitiven Formen erhältlich ist.


Die FormFactorPart-Klasse ist eine abstrakte Klasse. Sie erbt von der
`Class.BasePart` Klasse und fügt die `Class.FormFactorPart.FormFactor` Eigenschaft
zu Klassen hinzu, die von ihr erben.


FormFactorPart

Dies wurde verwendet, um eine Rasterbeschränkung der Größe des Teils anzugeben. Macht jetzt nichts mehr.


FormFactorPart.FormFactor

Bestimmt, wie ein Teil beim Größenänderung reagiert und welche Werte seine Größe
annehmen kann.


FormFactorPart.formFactor

Die FormFactorPart-Klasse ist eine abstrakte Klasse. Sie erbt von der BasePart
Klasse und fügt den FormFactor-Eigenschaft zu Klassen hinzu, die von ihr erben.


Erstellt ein blaues Teil und ein rotes Zielteil. Das blaue Teil wird versuchen, sanft
zum roten Zielteil zu gelangen. Bewege und drehe das Ziel, um das Verhalten zu sehen.
Die Änderung der smoothTime führt zu unterschiedlichen Geschwindigkeiten der Glättung.


`Class.BasePart` ist eine abstrakte Basisklasse für In-World-Objekte, die im `Class.Workspace` gerendert und physisch simuliert werden. Es gibt mehrere Implementierungen von `Class.BasePart`, wobei die häufigsten `Class.Part` und `Class.MeshPart` sind. Weitere umfassen `Class.WedgePart`, `Class.SpawnLocation` und das Singleton-Objekt `Class.Terrain`. Im Allgemeinen funktioniert, wenn die Dokumentation von einem "Teil" spricht, die meisten Implementierungen von `Class.BasePart` und nicht nur `Class.Part`.

Für Informationen darüber, wie `Class.BasePart|BaseParts` in simulierte starre Körper gruppiert werden, siehe [Assemblies](/physics/assemblies).

Es gibt viele verschiedene Objekte, die mit `Class.BasePart` interagieren (außer `Class.Terrain`), einschließlich:

- Mehrere `Class.BasePart|BaseParts` können innerhalb eines `Class.Model` gruppiert und zur selben Zeit mit `Class.PVInstance:PivotTo()` bewegt werden. Siehe [Models](/parts/models).
- Ein `Class.Decal` wendet eine gestreckte Bildtextur auf die Flächen eines `Class.BasePart` an, während ein `Class.Texture` eine geflieste Bildtextur auf die Flächen anwendet. Siehe [Textures and Decals](/parts/textures-decals).
- Ein `Class.SurfaceGui` rendert `Class.GuiObject|GuiObjects` auf der Fläche eines Teils. Siehe [In-Experience UI Containers](/ui/in-experience-containers).
- `Class.Attachment|Attachments` können zu einem `Class.BasePart` hinzugefügt werden, um `Datatype.CFrame|CFrames` relativ zum Teil zu spezifizieren. Diese werden häufig von physikalischen `Class.Constraint`-Objekten verwendet, wie in [Mechanical Constraints](/physics/mechanical-constraints) und [Mover Constraints](/physics/mover-constraints) beschrieben.
- `Class.ParticleEmitter`-Objekte emittieren Partikel gleichmäßig im Volumen des `Class.BasePart`, dem sie zugeordnet sind. Siehe [Particle Emitters](/effects/particle-emitters).
- Lichtobjekte wie `Class.PointLight` strahlen Licht vom Zentrum eines `Class.BasePart` aus, wie in [Light Sources](/effects/light-sources) dargestellt.
- Wenn es zu einem `Class.Tool` zugeordnet ist und den Namen **Handle** erhält, kann ein `Class.BasePart` von Charakteren gehalten werden. Siehe [In-Experience Tools](/players/tools).

Wird ausgelöst, wenn ein anderes Teil mit einem anderen Objekt in Kontakt kommt. Dieses Ereignis
sendet nur Daten an den Klienten, die ihn benachrichtigen, dass zwei Teile kollidiert sind,
während `Class.BasePart.Touched` Daten an den Server sendet.

BasePart.LocalSimulationTouched

part

Wird ausgelöst, wenn das Erscheinungsbild des Teils durch die Klasse `Class.Shirt` betroffen ist.

BasePart.OutfitChanged

BasePart.StoppedTouching

otherPart

Dieses Beispiel erstellt ein BillboardGui auf einem Teil, das die Anzahl der
Teile anzeigt, die derzeit damit in Kontakt sind.

Dieses Codebeispiel zeigt, wie man das `Class.BasePart.Touched`
Ereignis mehrerer Teile in einem `Class.Model` mit einer Funktion verbindet.


Das **Touched**-Ereignis wird ausgelöst, wenn ein Teil mit einem anderen
Teil in Kontakt kommt. Zum Beispiel, wenn **PartA** auf **PartB** stößt,
dann wird `Class.BasePart.Touched|PartA.Touched` mit **PartB** ausgelöst, und
`Class.BasePart.Touched|PartB.Touched` wird mit **PartA** ausgelöst.

Dieses Ereignis wird nur als Ergebnis physikalischer Bewegung ausgelöst, sodass es nicht
ausgelöst wird, wenn die `Class.BasePart.CFrame|CFrame`-Eigenschaft so geändert wird,
dass das Teil ein anderes Teil überlappt. Das bedeutet auch, dass mindestens eines der
beteiligten Teile zum Zeitpunkt der Kollision **nicht** `Class.BasePart.Anchored|Anchored` sein muss.

Dieses Ereignis funktioniert in Verbindung mit
`Class.Workspace.TouchesUseCollisionGroups`, um anzugeben, ob
[Collision-Gruppen](/workspace/collisions#collision-filtering)
für die Erkennung anerkannt werden.

BasePart.Touched

Das andere Teil, das mit dem angegebenen Teil in Kontakt gekommen ist.

Wird ausgelöst, wenn ein Teil ein anderes Teil als Ergebnis der physikalischen Bewegung berührt.

Wird ausgelöst, wenn ein Teil aufhört, ein anderes Teil unter ähnlichen Bedingungen wie
`Class.BasePart.Touched` zu berühren.

Dieses Ereignis funktioniert in Verbindung mit
`Class.Workspace.TouchesUseCollisionGroups`, um anzugeben, ob
[Collision-Gruppen](/workspace/collisions#collision-filtering)
für die Erkennung anerkannt werden.

BasePart.TouchEnded

Wird ausgelöst, wenn ein Teil aufhört, ein anderes Teil als Ergebnis der physikalischen
Bewegung zu berühren.

Gibt den Drehmomentvektor im Welt-Raum zurück, der auf die Baugruppe des Teils angewendet werden muss, um die angegebene Winkelbeschleunigung zu erreichen. Dieses Ergebnis kann verwendet werden, um das Drehmoment zu bestimmen, das über eine `Class.Torque`-Instanz oder `Class.BasePart:ApplyAngularImpulse()` angewendet werden sollte.

Die Berechnung verwendet die Rotationsgleichung von Euler, wobei _I_ der Trägheitstensor der Baugruppe im Welt-Raum ist, _α_ die gewünschte Winkelbeschleunigung und _ω_ die Winkelgeschwindigkeit.

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

Wenn das Teil kein Nachkomme von `Class.Workspace` ist, gibt diese Methode einen Vektor der Unendlichkeit zurück. Wenn die Baugruppe verankert ist, gibt sie ebenfalls einen Vektor der Unendlichkeit zurück.

#### Gyroskopische Effekte

Wenn eine rotierende Baugruppe einen asymmetrischen Trägheitstensor hat, wird das erforderliche Drehmoment zur Erreichung einer bestimmten Winkelbeschleunigung aufgrund der sich ändernden Orientierung des Körpers erhöht. Der optionale Parameter `angVelocity` berücksichtigt diese gyroskopischen Effekte. Wenn er weggelassen wird, werden diese gyroskopischen Effekte von der Berechnung ausgeschlossen.

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

-- Berechne das Drehmoment, das benötigt wird, um die gewünschte Beschleunigung zu erreichen
local torque = part:AngularAccelerationToTorque(desiredAcceleration, angularVelocity)
```

BasePart:AngularAccelerationToTorque

angAcceleration

Der gewünschte Winkelbeschleunigungsvektor im Welt-Raum.

angVelocity

Die aktuelle Winkelgeschwindigkeit der Baugruppe im Welt-Raum. Standardmäßig ist sie `(0, 0, 0)`. Geben Sie die Winkelgeschwindigkeit der Baugruppe an, um gyroskopische Effekte zu berücksichtigen.

Ein `Datatype.Vector3`, der das im Welt-Raum erforderliche Drehmoment darstellt, um die angegebene Winkelbeschleunigung zu erzeugen.

Gibt das Drehmoment zurück, das erforderlich ist, um eine gegebene Winkelbeschleunigung für die Baugruppe dieses Teils zu erreichen, wobei optional gyroskopische Effekte berücksichtigt werden.

Wendet einen sofortigen angularen Kraftimpuls auf die Baugruppe dieses Teils an, wodurch
sich die Baugruppe dreht.

Die resultierende Drehgeschwindigkeit aus dem Impuls hängt von der Masse der
Baugruppe ab, `Class.BasePart.AssemblyMass|mass`. Ein höherer Impuls wird benötigt, um
massivere Baugruppen zu bewegen. Impulse sind nützlich für Fälle, in denen Sie
sofort eine Kraft anwenden möchten, wie zum Beispiel bei einer Explosion oder Kollision.

Wenn das Teil [besessen](/physics/network-ownership) wird vom
Server, muss diese Funktion von einem Server-`Class.Script` aufgerufen werden (nicht
von einem `Class.LocalScript` oder einem `Class.Script`, dessen
`Class.BaseScript.RunContext|RunContext` auf `Enum.RunContext.Client` gesetzt ist).
Wenn das Teil von einem Client durch **automatische** Besitzverhältnisse besessen wird,
kann diese Funktion von einem Client-Skript **oder** einem Server-Skript aufgerufen werden;
ein Aufruf von einem Client-Skript für ein server-besessenes Teil hat keine
Auswirkungen.

BasePart:ApplyAngularImpulse

impulse

Ein angularer Impulsvektor, der auf die Baugruppe angewendet werden soll.

Wendet einen angularen Impuls auf die Baugruppe an.

Diese Funktion wendet einen sofortigen Kraftimpuls auf die Baugruppe dieses Teils an.

Die Kraft wird an der Masse der Baugruppe,
`Class.BasePart.AssemblyCenterOfMass|center of mass`, angewendet, sodass die
resultierende Bewegung nur linear sein wird.

Die resultierende Geschwindigkeit aus dem Impuls hängt von der Masse der
Baugruppe ab, `Class.BasePart.AssemblyMass|mass`. Ein höherer Impuls wird benötigt, um
massivere Baugruppen zu bewegen. Impulse sind nützlich für Fälle, in denen Sie
sofort eine Kraft anwenden möchten, wie bei einer Explosion oder Kollision.

Wenn das Teil [besessen](/physics/network-ownership) wird vom
Server, muss diese Funktion von einem Server-`Class.Script` aufgerufen werden (nicht
von einem `Class.LocalScript` oder einem `Class.Script`, dessen
`Class.BaseScript.RunContext|RunContext` auf `Enum.RunContext.Client` gesetzt ist).
Wenn das Teil von einem Client durch **automatische** Besitzverhältnisse besessen wird,
kann diese Funktion von einem Client-Skript **oder** einem Server-Skript aufgerufen werden;
ein Aufruf von einem Client-Skript für ein server-besessenes Teil hat keine
Auswirkungen.

BasePart:ApplyImpulse

Ein linearer Impulsvektor, der auf die Baugruppe angewendet werden soll.

Wendet einen Impuls auf die Baugruppe an, an der
`Class.BasePart.AssemblyCenterOfMass|Masse`.

Diese Funktion wendet einen sofortigen Kraftimpuls auf die Baugruppe dieses Teils an, an
der angegebenen Position im Welt-Raum.

Wenn die Position nicht im Schwerpunkt der Baugruppe,
`Class.BasePart.AssemblyCenterOfMass|center of mass`, ist, verursacht der Impuls
sowohl eine Positions- als auch eine Rotationsbewegung.

Die resultierende Geschwindigkeit aus dem Impuls hängt von der Masse der
Baugruppe ab, `Class.BasePart.AssemblyMass|mass`. Ein höherer Impuls wird benötigt, um
massivere Baugruppen zu bewegen. Impulse sind nützlich für Fälle, in denen
die Entwickler eine Kraft sofort anwenden möchten, wie bei einer Explosion oder
Kollision.

Wenn das Teil [besessen](/physics/network-ownership) wird vom
Server, muss diese Funktion von einem Server-`Class.Script` aufgerufen werden (nicht
von einem `Class.LocalScript` oder einem `Class.Script`, dessen
`Class.BaseScript.RunContext|RunContext` auf `Enum.RunContext.Client` gesetzt ist).
Wenn das Teil von einem Client durch **automatische** Besitzverhältnisse besessen wird,
kann diese Funktion von einem Client-Skript **oder** einem Server-Skript aufgerufen werden;
ein Aufruf von einem Client-Skript für ein server-besessenes Teil hat keine
Auswirkungen.

BasePart:ApplyImpulseAtPosition

Ein Impulsvektor, der auf die Baugruppe angewendet werden soll.

position

Die Position im Welt-Raum, an der der Impuls angewendet werden soll.

Wendet einen Impuls an die Baugruppe an an einer bestimmten Position.

Zerbricht jegliche Oberflächenverbindung mit angrenzenden Teilen, einschließlich
`Class.Weld` und anderen `Class.JointInstance`.

BasePart:BreakJoints

BasePart:breakJoints

Gibt zurück, ob die Teile miteinander kollidieren können oder nicht. Diese
Funktion berücksichtigt die Kollisionsgruppen der beiden Teile. Diese
Funktion wird einen Fehler ausgeben, wenn das angegebene Teil kein BasePart ist.

BasePart:CanCollideWith

Das angegebene Teil, das auf Kollidierbarkeit geprüft wird.

Ob die Teile miteinander kollidieren können.

Gibt zurück, ob die Teile miteinander kollidieren können.

Dieses Beispiel überprüft, ob der Netzwerkbesitz des ersten
`BasePart` mit dem Namen _Part_ im `Workspace` festgelegt werden kann.

Die CanSetNetworkOwnership-Funktion überprüft, ob Sie das Netzwerkbesitz eines Teils
setzen können.

Der Rückgabewert der Funktion überprüft, ob Sie `Class.BasePart:SetNetworkOwner()` oder
`Class.BasePart:SetNetworkOwnershipAuto()` ohne Fehler aufrufen können. Es gibt `true` zurück, wenn Sie das Netzwerkbesitz ändern/lesen können, oder gibt `false` zurück
und den Grund, warum das nicht geht, als String zurück.

BasePart:CanSetNetworkOwnership

Ob Sie das Netzwerkbesitz ändern oder lesen können und der Grund.

Überprüft, ob Sie das Netzwerkbesitz eines Teils setzen können.

Gibt den nächstgelegenen Punkt auf der Oberfläche des Teils zur angegebenen Weltposition zurück.
Wenn sich die angegebene Position im Inneren des Teils befindet, wird sie unverändert zurückgegeben.

Für `Class.MeshPart`- und `Class.PartOperation`-Instanzen berücksichtigt diese Methode den `Enum.CollisionFidelity`-Wert des Teils. Die Rückgabewerte können variieren, je nachdem, ob das Mesh als Kasten, Hülle oder komplexere Form behandelt wird.

BasePart:GetClosestPointOnSurface

Der Punkt im Weltbereich, zu dem der nächstgelegene Oberflächenpunkt gefunden werden soll.

Der nächstgelegene Punkt auf der Oberfläche des Teils im Weltbereich.

Gibt den nächstgelegenen Punkt auf der Oberfläche des Teils zum angegebenen Punkt zurück.

Gibt eine Tabelle von Teilen zurück, die durch irgendeine Art von starr
verbindender Gelenke mit dem Objekt verbunden sind.

Wenn `recursive` wahr ist, wird diese Funktion alle Teile im
Bau zusammen mit dem BasePart zurückgeben, die starr verbunden sind.

#### Starrverbinden

Wenn ein Gelenk zwei Teile miteinander verbindet `(Part0 → Part1)`, ist ein Gelenk
**starr**, wenn die Physik von `Part1` vollständig von `Part0`
blockiert ist. Dies gilt nur für die folgenden Gelenktypen:

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

BasePart:GetConnectedParts

recursive

Eine Tabelle von Teilen, die durch irgendein
`Class.JointInstance|Joint` verbunden sind.

Gibt eine Tabelle von Teilen zurück, die durch irgendeine Art von starr
verbindender Gelenke mit dem Objekt verbunden sind.

Gibt alle Gelenke oder Beschränkungen zurück, die mit diesem Teil verbunden sind.

BasePart:GetJoints

Ein Array aller Gelenke oder Beschränkungen, die mit dem Teil verbunden sind.

Dieses Beispiel erstellt ein neues Teil, myPart, im Workspace des Spiels, mit
dimensionen 4x6x4 Studs. Das Teil ist ebenfalls verankert.

Dann wird myMass auf die Masse des neuen Teils gesetzt. Die Masse des Teils wird
am Ende der Druckanweisung ausgegeben:

> Die Masse meines Teils ist ...

**GetMass** gibt den Wert der schreibgeschützten `Class.BasePart.Mass|Mass`
Eigenschaft zurück.

Diese Funktion entstand vor der Masse-Eigenschaft. Sie bleibt
für die Rückwärtskompatibilität unterstützt; Sie sollten die Masse-Eigenschaft
direkt verwenden.

BasePart:GetMass

Gibt den Wert der `Class.BasePart.Mass|Mass`-Eigenschaft zurück.

BasePart:getMass

Gibt den aktuellen Spieler zurück, der der Netzwerkbesitzer dieses Teils ist, oder `nil`
 im Falle des Servers.

BasePart:GetNetworkOwner

Der aktuelle Spieler, der der Netzwerkbesitzer dieses Teils ist, oder `nil` im
Falle des Servers.

Gibt `true` zurück, wenn die Spiel-Engine automatisch den Netzwerkbesitz
für dieses Teil bestimmt.

BasePart:GetNetworkOwnershipAuto

Ob die Spiel-Engine automatisch den Netzwerkbesitz für
dieses Teil bestimmt.

Gibt `true` zurück, wenn die Spiel-Engine automatisch den Netzwerkbesitz
für dieses Teil festlegt.

BasePart:GetNoCollisionConstraints

Diese Funktion war früher relevant, als die lagkompensierende
Interpolation von Teilen online intern war. Die Interpolation wird jetzt
direkt auf das `Datatype.CFrame` angewendet.

BasePart:GetRenderCFrame

OBSOLET. Gibt ein CFrame zurück, das beschreibt, wo das Teil gerendert wird.

Gibt das Basisstück einer Baugruppe zurück. Wenn Sie eine Baugruppe von Teilen bewegen,
bestimmt durch ein `Datatype.CFrame`, ist es wichtig, dieses Basisteil zu bewegen (dies
bewegt dann alle anderen Teile, die mit ihm verbunden sind, entsprechend). Weitere Informationen
gibt es im Artikel [Assemblies](/physics/assemblies).

Diese Funktion entstand vor der
`Class.BasePart.AssemblyRootPart|AssemblyRootPart`-Eigenschaft. Sie bleibt
für die Rückwärtskompatibilität unterstützt, aber Sie sollten direkt die
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` verwenden.

BasePart:GetRootPart

Das Basisstück einer Baugruppe (eine Sammlung von Teilen, die miteinander verbunden sind).

Gibt das Basisstück einer Baugruppe von Teilen zurück.

Gibt eine Tabelle aller Teile zurück, die physisch mit diesem
Teil interagieren. Wenn das Teil selbst `CanCollide` auf false gesetzt hat, gibt diese Funktion
 eine leere Tabelle zurück, es sei denn, das Teil hat ein
`Class.TouchTransmitter|TouchInterest`-Objekt, das mit ihm verbunden ist (was bedeutet,
dass etwas mit seinem Berührt-Ereignis verbunden ist). Teile, die angrenzen, aber
nicht schneiden, werden nicht als berührend betrachtet. Diese Funktion entstand vor der
`Class.WorldRoot:GetPartsInPart()`-Funktion, die mehr Flexibilität bietet und die speziellen
`Class.TouchTransmitter|TouchInterest`-Regeln oben vermeidet. Verwenden Sie stattdessen `Class.WorldRoot:GetPartsInPart()`.

BasePart:GetTouchingParts

Eine Tabelle aller Teile, die schneiden und mit diesem Teil kollidieren können.

Gibt eine Tabelle aller `Class.BasePart.CanCollide`-Wahrteile zurück, die
 mit diesem Teil schneiden.

Gibt die lineare Geschwindigkeit der Baugruppe des Teils an der gegebenen Position
relativ zu diesem Teil zurück. Damit kann die lineare Geschwindigkeit von
Teilen in einer Baugruppe identifiziert werden, die nicht das Basisteil sind. Wenn die Baugruppe keine
angulare Geschwindigkeit hat, bleibt die lineare Geschwindigkeit immer die gleiche für
jede Position.

BasePart:GetVelocityAtPosition

Gibt die lineare Geschwindigkeit der Baugruppe des Teils an der gegebenen Position
relativ zu diesem Teil zurück.

Erstellt eine neue `Class.IntersectOperation` aus der überlappenden Geometrie des
Teils und den anderen Teilen im gegebenen Array. Nur `Class.Part|Parts`
sind unterstützt, nicht `Class.Terrain` oder `Class.MeshPart|MeshParts`. Ähnlich
wie `Class.Instance:Clone()|Clone()`, hat das zurückgegebene Objekt kein festgelegtes
`Class.Instance.Parent|Parent`.

Die folgenden Eigenschaften des aufrufenden Teils werden auf die
resultierende `Class.IntersectOperation` angewendet:

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

In dem folgenden Bildvergleich,
wird `Class.BasePart:IntersectAsync()|IntersectAsync()` auf dem lila
Block aufgerufen, wobei ein Array, das den blauen Block enthält, verwendet wird. Das Ergebnis
`Class.IntersectOperation` löst sich in eine Form der überlappenden
Geometrie beider Teile auf.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Intersect.jpg"
width="720" alt="Zwei blockierte Teile überlappen" />
<figcaption>Getrennte Teile</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Intersect-Result.jpg"
width="720" alt="Teile in ein neues festes Modell überlagert" />
<figcaption>Ergebnis <code>Class.IntersectOperation</code></figcaption>
</figure>

#### Hinweise

- Die ursprünglichen Teile bleiben nach einem erfolgreichen Schnitt-
  Vorgang intakt. In den meisten Fällen sollten Sie `Class.Instance.Destroy|Destroy()`
  alle ursprünglichen Teile und das zurückgegebene
  `Class.IntersectOperation` an den gleichen Ort wie das aufrufende
  `Class.BasePart` anhängen.
- Standardmäßig werden die Gesichtsfarben der resultierenden Schnittmenge von der `Class.BasePart.Color|Color`-Eigenschaft der ursprünglichen Teile entlehnt. Um
  die gesamte Schnittfläche in eine bestimmte Farbe zu ändern, setzen Sie die
  `Class.PartOperation.UsePartColor|UsePartColor`-Eigenschaft auf `true`.
- Wenn ein Schnittvorgang Teile mit mehr als 20.000
  Dreiecken ergibt, wird es auf 20.000 Dreiecke vereinfacht.

BasePart:IntersectAsync

parts

Die Objekte, die an der Schnittmenge teilnehmen.

collisionfidelity

Der `Enum.CollisionFidelity`-Wert für die resultierende
`Class.IntersectOperation`.

renderFidelity

Der `Enum.RenderFidelity`-Wert der resultierenden
`Class.PartOperation`.

Resultierende `Class.IntersectOperation` mit dem Standardnamen **Intersect**.

Hinweis: Es wird dringend empfohlen, die neuere
`Class.GeometryService:IntersectAsync` anstelle dieser Funktion zu verwenden. Neben einer besseren Leistung und mehr Funktionen unterscheidet sich die neue Funktion wie folgt:

- Die Ausgabe ist ein Array von Instanzen statt einer einzelnen Instanz.
- Die Eingabeteile müssen nicht im Szenenbaum angeordnet sein, was Hintergrundoperationen ermöglicht.
- Wenn die Option `SplitApart` auf `true` (Standard) gesetzt ist, wird jeder einzelne Körper in seiner eigenen `Class.PartOperation` zurückgegeben.
- Alle zurückgegebenen Teile befinden sich im Koordinatenraum des Hauptteils, sodass ihre `Class.PVInstance.Origin`-Positionen die gleichen sind wie die des Hauptteils. Dies hält die Vertizes des Meshs in der gleichen Position relativ zum Objekt wie vor der Operation, bedeutet jedoch auch, dass das `(0, 0, 0)` eines zurückgegebenen Teils nicht unbedingt im Zentrum seines Körpers liegt.

  Erstellt eine neue `Class.IntersectOperation` aus der überlappenden Geometrie
  des Teils und der anderen Teile im angegebenen Array.

Gibt `true` zurück, wenn das Objekt mit einem Teil verbunden ist, das es an seinem Platz hält (zum Beispiel ein `Class.BasePart.Anchored|Anchored`-Teil), andernfalls gibt `false` zurück. In einer\Baugruppe, die ein `Class.BasePart.Anchored|Anchored`-Teil hat, sind alle anderen Teile
gestützt.

BasePart:IsGrounded

Ob das Objekt mit einem Teil verbunden ist, das es an seinem Platz hält.

Gibt `true` zurück, wenn das Objekt mit einem Teil verbunden ist, das es an seinem Platz hält (zum Beispiel ein `Class.BasePart.Anchored|Anchored`-Teil), andernfalls gibt `false` zurück.

Erstellt ein Gelenk an jeder Seite des `Class.BasePart|Part`, das einen
`Enum.SurfaceType` hat, der ein Gelenk erstellen kann und ein Gelenk mit allen angrenzenden Teilen herstellen wird.

Gelenke werden zwischen den Seiten und allen planar berührenden Oberflächen hergestellt,
abhängig von den Oberflächen der Seiten.

- Glatte Oberflächen erzeugen keine Gelenke
- Klebeoberflächen erzeugen ein `Class.Glue`-Gelenk
- Schweißen erzeugen ein `Class.Weld`-Gelenk mit jeder Oberfläche, außer
  Unjoinable
- Stifte, Einlass oder Universal erzeugen jeweils ein `Class.Snap`-Gelenk mit
  einer der beiden anderen Oberflächen (z.B. Stifte mit Einlass und
  Universal)
- Scharnier- und Motoroberflächen erzeugen `Class.Rotate` und `Class.RotateV`-Gelenkinstanzen

Im Gegensatz zu `Class.Model:MakeJoints()` benötigt diese Funktion ein Array von
Teilen als Parameter. Dieses Array wird wie folgt bereitgestellt:

```
part:MakeJoints({part1, part2, part3})
```
Gelenke brechen, wenn ausreichend Kraft auf sie ausgeübt wird, es sei denn, ein
`Class.Explosion` wird hinzugefügt, es sei denn, ein `Class.ForceField`-Objekt ist mit der
`Class.BasePart` oder dem übergeordneten `Class.Model` verbunden. Aus diesem Grund werden sie
häufig verwendet, um einfache zerstörbare Gebäude und andere Modelle zu erstellen.

BasePart:MakeJoints

Erstellt ein Gelenk an irgendeiner Seite des Objekts, das eine Oberflächen-ID hat, die ein Gelenk herstellen kann.

BasePart:makeJoints

Ändert die Größe eines Objekts, genau wie bei der Verwendung des Studio-Resize-Tools.

BasePart:Resize

normalId

deltaAmount

Wie viel auf der angegebenen Seite wachsen/schrumpfen soll.

Ändert die Größe eines Objekts, genau wie die Verwendung des Studio-Resize-Tools.

BasePart:resize

Setzt den angegebenen Spieler als Netzwerkbesitzer für dieses und alle verbundenen Teile.
Wenn playerInstance `nil` ist, wird der Server der Besitzer anstelle eines Spielers sein.

BasePart:SetNetworkOwner

playerInstance

Der Spieler, der die Netzwerkbesitzrechte für das Teil erhält.

Setzt den angegebenen Spieler als Netzwerkbesitzer für dieses und alle verbundenen Teile.

Lässt die Spielengine dynamisch entscheiden, wer die Physik des Teils handhaben wird
(einer der Clients oder der Server).

BasePart:SetNetworkOwnershipAuto

Dieses Beispiel zeigt, wie man Teile von einem anderen
`Class.BasePart` abzieht, um eine negierte `Class.UnionOperation` zu bilden.

Erstellt eine neue `Class.UnionOperation` aus dem Teil, minus der Geometrie
, die von den Teilen in dem angegebenen Array eingenommen wird. Nur `Class.Part|Parts` sind
unterstützt, nicht `Class.Terrain` oder `Class.MeshPart|MeshParts`. Ähnlich wie
`Class.Instance:Clone()|Clone()`, hat das zurückgegebene Objekt kein festgelegtes
`Class.Instance.Parent|Parent`.

Beachten Sie, dass die resultierende Union aufgrund von Subtraktionen nicht leer sein kann. Wenn die
Operation zu vollständig leerer Geometrie führen würde, schlägt sie fehl.

In der folgenden Bildverarbeitung,
wird `Class.BasePart:SubtractAsync()|SubtractAsync()` auf dem blauen
Zylinder mit einer Tabelle aufgerufen, die den lila Block enthält. Die resultierende
`Class.UnionOperation` ergibt eine Form, die die Geometrie des Blocks vom Zylinder
auslässt.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Subtract.jpg"
width="720" alt="Längerer Block überlappt einen Zylinder" />
<figcaption>Getrennte Teile</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Negate-Result.jpg" width="720"
alt="Blockteil von Zylinder subtrahiert" />
<figcaption>Resultierende <code>Class.UnionOperation</code></figcaption>
</figure>

BasePart:SubtractAsync

Die Objekte, die an der Subtraktion teilnehmen.

Der `Enum.CollisionFidelity`-Wert für die resultierende
`Class.UnionOperation`.

Resultierende `Class.UnionOperation` mit dem Standardnamen **Union**.

Hinweis: Es wird dringend empfohlen, die neuere
`Class.GeometryService:UnionAsync` anstelle dieser Funktion zu verwenden. Neben einer besseren Leistung und mehr Funktionen unterscheidet sich die neue Funktion wie folgt:

- Die Ausgabe ist ein Array von Instanzen statt einer einzelnen Instanz.
- Die Eingabeteile müssen nicht im Szenenbaum angeordnet sein, was Hintergrundoperationen ermöglicht.
- Wenn die Option `SplitApart` auf `true` (Standard) gesetzt ist, wird jeder einzelne Körper in seiner eigenen `Class.PartOperation` zurückgegeben.
- Alle zurückgegebenen Teile befinden sich im Koordinatenraum des Hauptteils, sodass ihre `Class.PVInstance.Origin`-Positionen die gleichen sind wie die des Hauptteils. Dies hält die Vertizes des Meshs in der gleichen Position relativ zum Objekt wie vor der Operation, bedeutet jedoch auch, dass das `(0, 0, 0)` eines zurückgegebenen Teils nicht unbedingt im Zentrum seines Körpers liegt.

  Erstellt eine neue `Class.UnionOperation` aus dem Teil, minus der Geometrie,
  die von den Teilen im angegebenen Array eingenommen wird.

Gibt die Winkelbeschleunigung im Welt-Raum zurück, die aus der Anwendung des angegebenen Drehmoments auf die Baugruppe des Teils resultiert, wobei optional gyroskopische Effekte berücksichtigt werden.

Dies ist das Inverse von `Class.BasePart:AngularAccelerationToTorque()`. Es ist nützlich, um vorherzusagen, wie eine Baugruppe auf ein angewendetes Drehmoment reagieren wird.

Die Berechnung verwendet:

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

wobei **I** der Trägheitstensor der Baugruppe im Welt-Raum ist, **τ** das angelegte Drehmoment und **ω** die Winkelgeschwindigkeit.

Wenn das Teil kein Nachkomme von `Class.Workspace` ist, gibt es `(0, 0, 0)` zurück. Wenn die Baugruppe verankert ist, gibt sie `(0, 0, 0)` zurück.

#### Gyroskopische Effekte

Wenn eine rotierende Baugruppe einen asymmetrischen Trägheitstensor hat, hängt die Beschleunigung, die aus einem angewendeten Drehmoment resultiert, auch von der aktuellen Winkelgeschwindigkeit ab. Der Parameter `angVelocity` berücksichtigt diese gyroskopischen Effekte. Wenn er weggelassen wird (Standardmäßig null), wird dieser Beitrag von dem Ergebnis ausgeschlossen.

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

-- Prognostiziere die Winkelbeschleunigung aus diesem Drehmoment
local angAccel = part:TorqueToAngularAcceleration(appliedTorque, angularVelocity)
```

BasePart:TorqueToAngularAcceleration

torque

Der Drehmomentvektor, der im Welt-Raum auf die Baugruppe angewendet wird.

Ein `Datatype.Vector3`, der die resultierende Winkelbeschleunigung im Welt-Raum darstellt.

Gibt die Winkelbeschleunigung zurück, die aus der Anwendung eines bestimmten Drehmoments auf die Baugruppe dieses Teils resultieren würde, wobei optional gyroskopische Effekte berücksichtigt werden.

Dieses Beispiel zeigt, wie man die Geometrie eines `Class.BasePart`
mit der Geometrie anderer Teile kombiniert, um eine `Class.UnionOperation` zu bilden.

Erstellt eine neue `Class.UnionOperation` aus dem Teil, plus der Geometrie
, die von den Teilen in dem angegebenen Array eingenommen wird. Nur `Class.Part|Parts` sind
unterstützt, nicht `Class.Terrain` oder `Class.MeshPart|MeshParts`. Ähnlich wie
`Class.Instance:Clone()|Clone()`, hat das zurückgegebene Objekt kein festgelegtes
`Class.Instance.Parent|Parent`.

Die folgenden Eigenschaften des aufrufenden Teils werden auf die
resultierende `Class.UnionOperation` angewendet:

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

In der folgenden Bildverarbeitung,
wird `Class.BasePart:UnionAsync()|UnionAsync()` auf den blauen Block
mit einer Tabelle aufgerufen, die den lila Zylinder enthält. Die resultierende
`Class.UnionOperation` ergibt eine Form der kombinierten Geometrie
beider Teile.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Union.jpg"
width="720" alt="Block- und Zylinderteile überlappen" />
<figcaption>Getrennte Teile</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Union-Result.jpg" width="720"
alt="Teile zu einer einzigen soliden Union verbunden" />
<figcaption>Resultierende <code>Class.UnionOperation</code></figcaption>
</figure>

#### Anmerkungen

- Die ursprünglichen Teile bleiben nach einer erfolgreichen Union-Operation intakt.
  In den meisten Fällen sollten Sie alle ursprünglichen Teile `Class.Instance.Destroy|Destroy()` und die zurückgegebene `Class.UnionOperation` an denselben Ort wie das aufrufende `Class.BasePart` anfügen.
- Standardmäßig respektiert die resultierende Union die
  `Class.BasePart.Color|Color`-Eigenschaft jedes Teils. Um die gesamte Union in einer bestimmten Farbe zu ändern, setzen Sie ihre
  `Class.PartOperation.UsePartColor|UsePartColor`-Eigenschaft auf `true`.
- Wenn eine Union-Operation zu einem Teil mit mehr als 20.000
  Dreiecken führen würde, wird es auf 20.000 Dreiecke vereinfacht.

BasePart:UnionAsync

Die Objekte, die an der Union mit dem aufrufenden Teil teilnehmen.

Hinweis: Es wird dringend empfohlen, die neuere
`Class.GeometryService:UnionAsync` anstelle dieser Funktion zu verwenden. Neben einer besseren Leistung und mehr Funktionen unterscheidet sich die neue Funktion wie folgt:

- Die Ausgabe ist ein Array von Instanzen statt einer einzelnen Instanz.
- Die Eingabeteile müssen nicht im Szenenbaum angeordnet sein, was Hintergrundoperationen ermöglicht.
- Wenn die Option `SplitApart` auf `true` (Standard) gesetzt ist, wird jeder einzelne Körper in seiner eigenen `Class.PartOperation` zurückgegeben.
- Alle zurückgegebenen Teile befinden sich im Koordinatenraum des Hauptteils, sodass ihre `Class.PVInstance.Origin`-Positionen die gleichen sind wie die des Hauptteils. Dies hält die Vertizes des Meshs in der gleichen Position relativ zum Objekt wie vor der Operation, bedeutet jedoch auch, dass das `(0, 0, 0)` eines zurückgegebenen Teils nicht unbedingt im Zentrum seines Körpers liegt.

        Erstellt eine neue `Class.UnionOperation` aus dem Teil, plus der Geometrie

  die von den Teilen im angegebenen Array eingenommen wird.

BasePart

Dieses Codebeispiel ermöglicht es, ein Teil anzuklicken, um seine festgelegte
Eigenschaft umzuschalten. Wenn umgeschaltet, wird das visuelle Erscheinungsbild des Teils aktualisiert (rot
bedeutet festgelegt, gelb bedeutet frei).


Die `Anchored`-Eigenschaft bestimmt, ob das Teil von der Physik unbeweglich sein wird. Wenn aktiviert, wird ein Teil niemals seine Position aufgrund von Gravitation, Kollisionen mit anderen Teilen, Überlappungen mit anderen Teilen oder anderen physikbedingten Ursachen ändern. Daher werden zwei verankerte Teile niemals das `Class.BasePart.Touched|Touched`-Ereignis gegenseitig auslösen.

Ein verankertes Teil kann dennoch bewegt werden, indem sein `Class.BasePart.CFrame|CFrame` oder `Class.BasePart.Position|Position` geändert wird, und es kann immer noch eine von Null verschiedene `Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity` und `Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity` haben.

Schließlich, wenn ein unverankertes Teil mit einem verankerten Teil durch ein Objekt wie einen `Class.Weld` verbunden ist, verhält es sich ebenfalls wie ein verankertes Teil. Wenn eine solche Verbindung bricht, kann das Teil erneut von der Physik beeinflusst werden. Siehe [Assemblies](/physics/assemblies) für weitere Details.

Die Netzwerkzugehörigkeit kann für verankerte Teile nicht festgelegt werden. Wenn sich der Ankerstatus eines Teils auf dem Server ändert, wird die Netzwerkzugehörigkeit dieses Teils betroffen sein.

BasePart.Anchored

Bestimmt, ob ein Teil von der Physik unbeweglich ist.

Der Winkelgeschwindigkeitsvektor dieser Baugruppe. Es ist die Rate der Änderung der Orientierung in Radianten pro Sekunde.

Die Winkelgeschwindigkeit ist an jedem Punkt der Baugruppe gleich.

Eine direkte Einstellung der Geschwindigkeit kann zu unrealistischer Bewegung führen. Die Verwendung von `Class.Torque` oder `Class.AngularVelocity`-Constraints wird bevorzugt, oder verwenden Sie `Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()`, wenn Sie eine sofortige Änderung der Geschwindigkeit wünschen.

Wenn das Teil [besitzt](/physics/network-ownership) wird von dem Server, muss diese Eigenschaft von einem Server-`Class.Script` geändert werden (nicht von einem `Class.LocalScript` oder einem `Class.Script`, dessen `Class.BaseScript.RunContext|RunContext` auf `Enum.RunContext.Client` festgelegt ist). Wenn das Teil über **automatische** Zugehörigkeit von einem Client besessen wird, kann diese Eigenschaft von einem Clientskript **oder** einem Serverskript geändert werden; die Änderung von einem Clientskript für ein serverbesessenes Teil hat keine Auswirkungen.

BasePart.AssemblyAngularVelocity

Die Winkelgeschwindigkeit der Baugruppe des Teils.

Eine Position, die durch die `Class.BasePart.Mass|Mass` und `Class.BasePart.Position|Position` aller Teile in der Baugruppe berechnet wird.

Wenn die Baugruppe ein verankertes Teil hat, wird der Schwerpunkt dieses Teils der Schwerpunkt der Baugruppe sein, und die Baugruppe wird eine unendliche Masse haben.

Das Wissen um den Schwerpunkt kann der Baugruppe helfen, Stabilität zu bewahren. Eine auf den Schwerpunkt ausgeübte Kraft verursacht keine Winkelbeschleunigung, sondern nur lineare. Eine Baugruppe mit einem niedrigen Schwerpunkt wird es einfacher haben, unter dem Einfluss der Schwerkraft aufrecht zu bleiben.

BasePart.AssemblyCenterOfMass

Der Schwerpunkt der Baugruppe des Teils im Weltraum.

Der lineare Geschwindigkeitsvektor dieser Baugruppe. Es ist die Rate der Positionsänderung des `Class.BasePart.AssemblyCenterOfMass|AssemblyCenterOfMass` in Studs pro Sekunde.

Wenn Sie die Geschwindigkeit an einem anderen Punkt als dem Schwerpunkt der Baugruppe wissen möchten, verwenden Sie `Class.BasePart:GetVelocityAtPosition()|GetVelocityAtPosition()`.

Eine direkte Einstellung der Geschwindigkeit kann zu unrealistischer Bewegung führen. Die Verwendung eines `Class.VectorForce`-Constraints wird bevorzugt, oder verwenden Sie `Class.BasePart:ApplyImpulse()|ApplyImpulse()`, wenn Sie eine sofortige Änderung der Geschwindigkeit wünschen.

Wenn das Teil [besitzt](/physics/network-ownership) wird von dem Server, muss diese Eigenschaft von einem Server-`Class.Script` geändert werden (nicht von einem `Class.LocalScript` oder einem `Class.Script`, dessen `Class.BaseScript.RunContext|RunContext` auf `Enum.RunContext.Client` festgelegt ist). Wenn das Teil über **automatische** Zugehörigkeit von einem Client besessen wird, kann diese Eigenschaft von einem Clientskript **oder** einem Serverskript geändert werden; die Änderung von einem Clientskript für ein serverbesessenes Teil hat keine Auswirkungen.

BasePart.AssemblyLinearVelocity

Die lineare Geschwindigkeit der Baugruppe des Teils.

Die Summe der Masse aller `Class.BasePart|BaseParts` in dieser Baugruppe des Teils. Teile, die `Class.BasePart.Massless|Massless` sind und nicht das Wurzelteil der Baugruppe sind, tragen nicht zur `AssemblyMass` bei.

Wenn die Baugruppe ein verankertes Teil hat, wird die Masse der Baugruppe als unendlich betrachtet. Einschränkungen und andere physikalische Wechselwirkungen zwischen unverankerten Baugruppen mit großen Unterschied in der Masse können Instabilitäten verursachen.

BasePart.AssemblyMass

Die gesamte Masse der Baugruppe des Teils.

Diese Eigenschaft zeigt das `Class.BasePart` an, das automatisch ausgewählt wurde, um das Wurzelteil der Baugruppe darzustellen. Wenn das Teil nicht mit dem `Class.Workspace` verbunden ist, wird diese Eigenschaft `nil` sein.

Das Wurzelteil kann geändert werden, indem die `Class.BasePart.RootPriority|RootPriority` der Teile in der Baugruppe geändert wird.

Teile, die alle dasselbe `AssemblyRootPart` teilen, gehören zur selben Baugruppe.

Für weitere Informationen zu Wurzeltail, siehe [Assemblies](/physics/assemblies).

BasePart.AssemblyRootPart

Eine Referenz auf das Wurzelteil der Baugruppe.

`AudioCanCollide` bestimmt, ob das Teil physisch mit der Audiosimulation interagiert, ähnlich wie `Class.BasePart.CastShadow|CastShadow` für Beleuchtung.

Wenn deaktiviert, dringt Audio durch das Teil; es wird nicht verdeckt oder reflektiert.

BasePart.AudioCanCollide

Bestimmt, ob das Teil physisch mit der Audio-Simulation interagiert, ähnlich wie `Class.BasePart.CastShadow|CastShadow` für Beleuchtung.

Dieses Codebeispiel zeigt, wie Oberflächeneigenschaften nur mit einem
NormalId (Oben, Vorne, usw.) festgelegt werden können. Es wechselt die -SurfaceInput des Motors von NoInput,
Constant und Sin, um zu zeigen, wie jede mit den -ParamA und -ParamB-Eigenschaften funktioniert.

Die `BackParamA`-Eigenschaft ist relevant, wenn `Class.BasePart.BackSurface` auf Motor oder SteppingMotor gesetzt ist und `Class.BasePart.BackSurfaceInput` auf Sin. Sie bestimmt die **Amplitude** der Rotationsgeschwindigkeit des Motors.

BasePart.BackParamA

Bestimmt den ersten Parameter für den SurfaceType der Rückseite eines Teils.

Die `BackParamB`-Eigenschaft ist relevant, wenn `Class.BasePart.BackSurface` auf Motor oder SteppingMotor gesetzt ist und `Class.BasePart.BackSurfaceInput` auf konstant oder Sin. Für konstant bestimmt sie die konstante Rotationsgeschwindigkeit des Motors. Für Sin bestimmt sie die **Frequenz** der Rotationsgeschwindigkeit des Motors.

BasePart.BackParamB

Bestimmt den zweiten Parameter für den SurfaceType der Rückseite eines Teils.

Die `BackSurface`-Eigenschaft bestimmt die Art der Oberfläche, die für die positive **Z**-Richtung eines Teils verwendet wird. Wenn die Flächen von zwei Teilen nebeneinander platziert werden, können sie eine Verbindung zwischen ihnen herstellen.

BasePart.BackSurface

Bestimmt die Art der Oberfläche für die Rückseite eines Teils.

Die `BackSurfaceInput`-Eigenschaft bestimmt die Art der Eingabe, die einem Teil's `Class.BasePart.BackSurface` bereitgestellt wird. Dies ist nur relevant für Motor- oder SteppingMotor-SurfaceTypes. Diese Eigenschaft bestimmt, wie `Class.BasePart.BackParamA` und `Class.BasePart.BackParamB` verwendet werden. Aus Gründen der Kürze werden diese Eigenschaften als ParamA und ParamB bezeichnet.

- Standardmäßig ist dies auf NoInput festgelegt. Dies stoppt den Motor vollständig.
- Für konstant rotiert der Motor mit einer konstanten Geschwindigkeit gleich `ParamB`.
- Für Sin rotiert der Motor mit einer Geschwindigkeit gleich `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. Siehe `Class.Workspace.DistributedGameTime`.

BasePart.BackSurfaceInput

Bestimmt die Art der Eingabe für die Rückseite eines Teils.

Die `BottomParamA`-Eigenschaft ist relevant, wenn ein Teil's `Class.BasePart.BottomSurface` auf Motor oder SteppingMotor gesetzt ist und `Class.BasePart.BottomSurfaceInput` auf Sin gesetzt ist. Sie bestimmt die **Amplitude** der Rotationsgeschwindigkeit des Motors.

BasePart.BottomParamA

Bestimmt den ersten Parameter für den SurfaceType der Unterseite eines Teils.

Die `BottomParamB`-Eigenschaft ist relevant, wenn ein Teil's `Class.BasePart.BottomSurface` auf Motor oder SteppingMotor gesetzt ist und `Class.BasePart.BottomSurfaceInput` auf konstant oder Sin gesetzt ist. Für konstant bestimmt sie die konstante Rotationsgeschwindigkeit des Motors. Für Sin bestimmt sie die **Frequenz** der Rotationsgeschwindigkeit des Motors.

BasePart.BottomParamB

Bestimmt den zweiten Parameter für den SurfaceType der Unterseite eines Teils.

Die `BottomSurface`-Eigenschaft bestimmt die Art der Oberfläche, die für die negative **Y**-Richtung eines Teils verwendet wird. Wenn die Flächen von zwei Teilen nebeneinander platziert werden, können sie eine Verbindung zwischen ihnen herstellen.

BasePart.BottomSurface

Bestimmt die Art der Oberfläche für die Unterseite eines Teils.

Die abstrakte Basisklasse für In-World-Objekte, die physisch interagieren.