Die Flagge ist eine Einheit, die mit einem `Class.FlagStand`-Objekt gespawnt wird und
wird respawnen, wenn sie erobert wird. Wenn ein Spieler den Griff dieses Objekts berührt,
das ein Kind des Flaggenobjekts sein muss, das ein Teil namens "Handle" ist, wird die Flagge
zum Rucksack des Spielers hinzugefügt und in seiner Hand erscheinen. Ein Spieler kann kein
anderes Waffen auswählen, während er eine Flagge trägt, und kann die Flagge jederzeit
fallen lassen, indem er "Backspace" auf der Tastatur drückt. Wenn der Spieler, der eine Flagge trägt,
auf einen anderen FlagStand einer anderen Teamfarbe tritt, wird die Flagge aus dem Rucksack des\Spielers entfernt und ein Punkt wird zu den Leaderstats des Nutzers hinzugefügt, falls bereitgestellt.
Die Flagge wird dann an ihrem Ursprungs-Flagstand regeneriert.


Flag

Die `Class.Team`, für die diese Flagge ist. Entspricht den TeamColors im
`Class.Teams`-Dienst.

Die `Class.Flag`- und `Class.FlagStand`-Objekte wurden erstellt, um Entwicklern zu ermöglichen,
Spiele im Stil von 'Capture the Flag' schnell zu erstellen.


Flag.TeamColor

Die `Class.Team`, für die diese Flagge ist. Entspricht den TeamColors im
`Class.Teams`-Dienst.


Das Flaggenobjekt hilft Ihnen, Spiele im Stil von 'Capture the Flag' zu erstellen.


Dieser Code soll in einem Skript innerhalb eines Werkzeugs platziert werden. Er ermöglicht einem Spieler,
Explosionen zu erzeugen, indem er das Werkzeug ausstattet und auf den Boden klickt. Dies geschieht,
indem eine Funktion, `explode`, definiert wird, die eine nicht tödliche Explosion an einem angegebenen Punkt erzeugt.
Dann wird eine Funktion, `onActivated`, definiert, die ausgeführt wird, wenn das Werkzeug aktiviert wird.
Schließlich wird das Activated-Ereignis des Werkzeugs mit der Funktion `onActivated` verbunden.

Um diesen Code auszuprobieren, versuche ein Werkzeug zu erstellen und ein Teil darin zu platzieren. Nenne das
Teil "Griff". Lege als Nächstes ein Skript im Werkzeug ab und füge den Code dort ein.
Schließlich lege das Werkzeug in den StarterPack.

Dieses Codebeispiel ist für ein Werkzeugobjekt mit einem Teil namens Handle. Es erkennt
wenn Humanoiden, die nicht der aktuelle Träger sind, den Griff berühren und fügt ihnen
Schaden zu. Darüber hinaus, wenn das Werkzeug aktiviert wird, wird eine Schnitt-
Animation in den Standard-Charakteranimationsskripten ausgelöst. Probieren Sie dieses Skript aus,
indem Sie ein Werkzeugobjekt im StarterPack erstellen. Legen Sie ein Teil darin ab und
nennen Sie es Handle. Fügen Sie diesen Code in ein Skript innerhalb des Werkzeugs ein, und versuchen Sie dann, auf einen
anderen Humanoiden zu schlagen!

Ein `Tool` ist ein Objekt, das ein `Class.Humanoid`-Objekt ausrüsten kann. Für Spieler
werden sie in einem `Class.Backpack`-Objekt gespeichert, das zu einem `Class.Player`
Objekt gehört. Im Spiel können Spieler mehrere Werkzeuge haben, die als Symbole
am unteren Bildschirmrand erscheinen. Das Ausrüsten eines Werkzeugs bewegt es aus dem
`Class.Backpack` in ein `Class.Player.Character`-Modell im
`Class.Workspace`. Standardmäßig werden Werkzeuge in der rechten Hand gehalten und haben
einen Griff, der ein `Class.BasePart` namens `Handle` enthält (obwohl
kein Griff erforderlich ist, wenn `Class.Tool.RequiresHandle` auf `false` gesetzt ist). Werkzeuge, die
für (Wieder)spawnende Spieler bereitgestellt werden sollen, sollten im
`Class.StarterPack` gespeichert werden.


Dieses Ereignis wird ausgelöst, wenn der Spieler klickt, während das `Class.Tool`
ausgerüstet ist. Es wird **nicht** ausgelöst, wenn die <kbd>Ctrl</kbd>-Taste während
des Klicks gedrückt wird.

Dieses Ereignis wird typischerweise verwendet, um eine Aktion auszuführen, wenn der Spieler das
Werkzeug verwendet, zum Beispiel um eine Rakete aus einem Raketenwerfer-Werkzeug zu starten.

Der folgende Code, der in einem `Class.LocalScript` platziert wird, erstellt ein Werkzeug im
`Class.Backpack` des lokalen Spielers und gibt "Werkzeug aktiviert" aus, wenn der
Spieler klickt, während das erstellte Werkzeug ausgerüstet ist.

```lua
local Players = game:GetService("Players")

local tool = Instance.new("Tool")
tool.RequiresHandle = false
tool.Parent = Players.LocalPlayer.Backpack

function onActivation()
	print("Werkzeug aktiviert")
end

tool.Activated:Connect(onActivation)
```


Tool.Activated

Wird ausgelöst, wenn der Spieler klickt, während das Werkzeug ausgerüstet ist.


Dieses Ereignis wird ausgelöst, wenn der Spieler seinen Klick loslässt, während das
`Class.Tool` ausgerüstet und aktiviert ist. Es wird typischerweise verwendet, um eine
Aktion auszuführen, wenn der Spieler aufhört, ein Werkzeug zu verwenden.

Der folgende Code, der in einem `Class.LocalScript` platziert wird, erstellt ein Werkzeug im
`Class.Backpack` des lokalen Spielers und gibt "Werkzeug deaktiviert" aus, wenn der
Spieler seinen Klick loslässt, während das Werkzeug ausgerüstet und aktiviert ist.

```lua
local Players = game:GetService("Players")

local tool = Instance.new("Tool")
tool.RequiresHandle = false
tool.Parent = Players.LocalPlayer.Backpack

function toolDeactivated()
	print("Werkzeug deaktiviert")
end

tool.Deactivated:Connect(toolDeactivated)
```


Tool.Deactivated

Wird ausgelöst, wenn der Spieler seinen Klick loslässt, während das Werkzeug ausgestattet und aktiviert ist.


Das untenstehende Beispiel druckt "Ein Werkzeug wurde angelegt", wann immer das Werkzeug vom Spieler angelegt wird. Bitte beachten Sie, dass das untenstehende Beispiel davon ausgeht, dass Sie bereits definiert haben, was "Werkzeug" ist.

Dieses Ereignis wird ausgelöst, wenn ein Spieler das `Class.Tool` ausstattet (es aus dem
`Class.Backpack` herausnimmt).

Das Gegenteil dieses Ereignisses, `Class.Tool.Unequipped`, kann verwendet werden, um zu
bestimmen, wann der Spieler das Werkzeug ablegt, indem er es in seinen
Rucksack legt.

Beachten Sie, dass dieses Ereignis **nicht** ausgelöst wird, wenn `Class.Tool.RequiresHandle`
eingeschaltet ist und kein Griff vorhanden ist.


Tool.Equipped

mouse

Wird ausgelöst, wenn das Werkzeug ausgestattet wird.


Dieses Ereignis wird ausgelöst, wenn ein Spieler das `Class.Tool` ablegt (es in seinen
`Class.Backpack` legt).

Das Gegenteil dieses Ereignisses, `Class.Tool.Equipped`, kann verwendet werden, um zu
bestimmen, wann der Spieler das Werkzeug ausstattet, indem er es aus seinem
Rucksack nimmt.

Beachten Sie, dass dieses Ereignis **nicht** ausgelöst wird, wenn `Class.Tool.RequiresHandle`
eingeschaltet ist und kein Griff vorhanden ist.


Tool.Unequipped

Wird ausgelöst, wenn das Werkzeug abgelehnt wird.


Der untenstehende Code erstellt ein `Class.Tool` im `Class.Backpack` des lokalen Spielers,
das den Spieler unsichtbar macht, wenn es aktiviert wird, und sichtbar, wenn es deaktiviert wird.

Wenn es ausgestattet ist, simuliert das Skript die Aktivierung des Werkzeugs und macht den
Spieler für 3 Sekunden unsichtbar, bevor es die Deaktivierung des Werkzeugs simuliert.
Das Halten der linken Maustaste macht den Spieler bis zu 3
Sekunden lang unsichtbar, mit einer Abklingzeit von 1 Sekunde, oder bis der Spieler seine
linke Maustaste loslässt.

Diese Funktion simuliert die Aktivierung des `Class.Tool`. Das Werkzeug muss
ausgerüstet sein, damit diese Funktion funktioniert.


Tool:Activate

Simuliert die Aktivierung des `Class.Tool`.


Diese Funktion simuliert die Deaktivierung des `Class.Tool`. Das Werkzeug muss
ausgerüstet sein, damit diese Funktion funktioniert.


Tool:Deactivate

Simuliert die Deaktivierung des `Class.Tool`.


Tool

Die Eigenschaft CanBeDropped steuert, ob der Spieler das
`Class.Tool` ablegen kann.

Wenn wahr, wird das Werkzeug beim Drücken der Rücktaste an `Class.Workspace` angehängt
und aus dem `Class.Backpack` des Spielers entfernt. Wenn
falsch, passiert beim Drücken der Rücktaste nichts, und das Werkzeug bleibt
ausgerüstet.


Tool.CanBeDropped

Steuert, ob der Spieler das Werkzeug ablegen kann.


Der untenstehende Code-Sample erstellt `Class.Tool` im Rucksack des lokalen Spielers
`Class.Backpack`, der deren `Class.Humanoid.JumpPower|JumpPower`
von `50` auf `150` für 5 Sekunden erhöht.

Dieses Beispiel verwendet die `Class.Tool.Enabled`-Eigenschaft des Werkzeugs als
Debounce, indem die Eigenschaft beim Springen des Spielers auf `true` und
nach der 5-sekündigen Dauer wieder auf `false` gesetzt wird.

Das Ablegen des Werkzeugs stoppt auch das Super-Jumpen des Spielers, indem die
`Class.Humanoid.JumpPower|JumpPower` zurück auf `50` geändert wird.

Die **Enabled**-Eigenschaft bezieht sich darauf, ob das `Class.Tool` verwendet werden kann. Dies
ist nützlich, wenn Sie verhindern möchten, dass ein Spieler ein Werkzeug verwendet,
aber es nicht aus seinem `Class.Backpack` entfernen möchten.

Wenn auf `true` gesetzt, kann der Spieler das Werkzeug verwenden. Wenn auf `false`
gestellt, ist das Werkzeug deaktiviert und der Spieler kann es nicht verwenden; dies verhindert, dass das Werkzeug
von den Methoden `Class.Tool:Activate()` und
`Class.Tool:Deactivate()` aktiviert oder deaktiviert wird, und es verhindert, dass die
Ereignisse `Class.Tool.Activated` und `Class.Tool.Deactivated` ausgelöst werden.


Tool.Enabled

Bezieht sich darauf, ob das Werkzeug verwendet werden kann oder nicht.


Der folgende Code fügt ein `Class.Tool` mit dem Namen **Stick** in den lokalen Spieler's
`Class.BackPack` ein. Wenn der Spieler das Werkzeug aktiviert, gibt der Code die
Werte der Griff Eigenschaften des Werkzeugs aus.

Die `Grip`-Eigenschaft speichert die "Grip"-Eigenschaften des Werkzeugs als ein einzelnes
`Datatype.CFrame`. Diese Eigenschaften bestimmen, wie der Spieler das Werkzeug
hält, und beinhalten `Class.Tool.GripUp|GripUp`, `Class.Tool.GripRight|GripRight`,
`Class.Tool.GripForward|GripForward` und `Class.Tool.GripPos|GripPos`.


Tool.Grip

Speichert die "Grip"-Eigenschaften des Werkzeugs als ein `Datatype.CFrame`.


Eine der Eigenschaften, die die Ausrichtung eines Werkzeugs in der Hand eines Charakters
spezifizieren. Dies repräsentiert die Werte `R02`, `R12` und `R22` der Griff-
`Datatype.CFrame`-Rotationsmatrix.

Andere Werkzeug-Eigenschaften, die steuern, wie ein Charakter ein Werkzeug hält, sind
`Class.Tool.GripUp`, `Class.Tool.GripRight` und `Class.Tool.GripPos`. Alle
diese Eigenschaften werden in einem einzigen `Datatype.CFrame` in der
`Class.Tool.Grip`-Eigenschaft gespeichert.


Tool.GripForward

Repräsentiert die Werte `R02`, `R12` und `R22` der Griff-
`Datatype.CFrame`-Rotationsmatrix.


Diese Eigenschaft steuert den Positionsoffset der Schweißmatrix des Werkzeugs. Es
ist eine von mehreren Eigenschaften, die verwendet werden, um zu positionieren, wie der Spielercharakter
das Werkzeug hält.

Andere Eigenschaften, die steuern, wie ein Charakter ein Werkzeug hält, sind
`Class.Tool.GripUp`, `Class.Tool.GripRight` und `Class.Tool.GripForward`.
Alle diese Eigenschaften sind in einem einzigen `Datatype.CFrame` in der
`Class.Tool.Grip`-Eigenschaft gespeichert.


Tool.GripPos

Der Positionsoffset der Schweißmatrix des Werkzeugs.


Eine der Eigenschaften, die die Ausrichtung eines Werkzeugs in der Hand eines Charakters
spezifizieren. Dies repräsentiert die Werte `R00`, `R10` und `R20` der Griff-
`Datatype.CFrame`-Rotationsmatrix.

Andere Werkzeug-Eigenschaften, die steuern, wie ein Charakter ein Werkzeug hält, sind
`Class.Tool.GripUp`, `Class.Tool.GripForward` und `Class.Tool.GripPos`.
Alle diese Eigenschaften werden in einem einzigen `Datatype.CFrame` in der
`Class.Tool.Grip`-Eigenschaft gespeichert.


Tool.GripRight

Repräsentiert die Werte `R00`, `R10` und `R20` der Griff-
`Datatype.CFrame`-Rotationsmatrix.


Eine der Eigenschaften, die die Ausrichtung eines Werkzeugs in der Hand eines Charakters
spezifizieren. Dies repräsentiert die Werte `R01`, `R11` und `R21` der Griff-
`Datatype.CFrame`-Rotationsmatrix.

Andere Werkzeug-Eigenschaften, die steuern, wie ein Charakter ein Werkzeug hält, sind
`Class.Tool.GripRight`, `Class.Tool.GripForward` und
`Class.Tool.GripPos`. Alle diese Eigenschaften sind in einem einzigen
`Datatype.CFrame` in der `Class.Tool.Grip`-Eigenschaft gespeichert.


Tool.GripUp

Repräsentiert die Werte `R01`, `R11` und `R21` der Griff-
`Datatype.CFrame`-Rotationsmatrix.


Das Codebeispiel unten erstellt `Class.Tool` im Rucksack des lokalen Spielers
`Class.Backpack`, das seine `Class.Humanoid.Walkspeed|WalkSpeed`
von `16` auf `30` für 5 Sekunden erhöht.

Dieses Beispiel verwendet die Eigenschaft `Class.Tool.ManualActivationOnly` des Werkzeugs als
Debounce, indem die Eigenschaft auf `true` gesetzt wird, wenn der Spieler mit dem Sprinten beginnt,
und auf `false`, wenn der Spieler mit dem Sprinten aufhört. Dadurch kann das Werkzeug,
während der Spieler sprintet, nicht erneut aktiviert werden.

Das Ablegen des Werkzeugs stoppt den Spieler ebenfalls beim Sprinten, indem es die
`Class.Humanoid.Walkspeed|WalkSpeed` auf `16` ändert.

Diese Eigenschaft steuert, ob das `Class.Tool` aktiviert werden kann,
ohne `Class.Tool:Activate()` explizit in einem Skript auszuführen.

Wenn auf `true` gesetzt, wird das Werkzeug nur `Class.Tool.Activated` auslösen, wenn
`Class.Tool:Activate()` aufgerufen wird. Dies unterdrückt auch die
`Class.ContextActionService:BindActivate()`-Funktion.

Wenn auf `false` gesetzt, lösen Maus-Klicks (wenn das Werkzeug ausgerüstet ist) auch
`Class.Tool.Activated` aus.


Tool.ManualActivationOnly

Steuert, ob das `Class.Tool` aktiviert werden kann, ohne
`Class.Tool:Activate()` auszuführen.


Diese Eigenschaft bestimmt, ob ein `Class.Tool` ohne einen
Griff funktioniert.

Ein Werkzeug hat einen Griff, wenn es ein Kindteil mit dem Namen **Handle** enthält. Werkzeuge
mit Griffen erfordern typischerweise, dass der Spieler sie ausrüstet, um ein Objekt
to verwenden, wie zum Beispiel Waffen. Werkzeuge ohne Griffe erfordern typischerweise nicht,
dass der Spieler sie ausrüstet, um irgendetwas zu halten, um sie zu verwenden, wie
zum Beispiel "fliegen" oder "beschwören"-Werkzeuge.

Wenn auf `true` gesetzt, funktioniert das Werkzeug nur mit einem Griff. Wenn auf
`false` gesetzt, funktioniert das Werkzeug auch ohne einen Griff.


Tool.RequiresHandle

Bestimmt, ob ein `Class.Tool` ohne Griff funktioniert.


Die ToolTip-Eigenschaft steuert die Nachricht, die angezeigt wird, wenn die
`Class.Mouse` des Spielers über das `Class.Tool` in seinem
`Class.Backpack` schwebt.

Im Allgemeinen sollte der Wert dieser Eigenschaft beschreiben, was das Werkzeug ist
oder wie es verwendet wird. Zum Beispiel, für ein Schaufelwerkzeug könnten Sie wählen, den
ToolTip auf:

```lua
tool.ToolTip = "Schaufel"
```
oder

```lua
tool.ToolTip = "Verwenden, um zu graben"
```
oder

```lua
tool.ToolTip = "Schaufel - Verwenden, um zu graben"
```


Tool.ToolTip

Steuert die Nachricht, die angezeigt wird, wenn die Maus des Spielers über das
Werkzeug in seinem Rucksack schwebt.


Ein Objekt, wie eine Waffe, das von einem `Class.Humanoid` ausgestattet werden kann.


BackpackItem ist eine abstrakte Klasse für Rucksackgegenstände wie HopperBins und
Werkzeuge.


BackpackItem

Das Textursymbol, das für ein Werkzeug im Rucksack des Spielers angezeigt wird.

Dieses Property sollte auf die Content-ID eines auf der
Roblox-Website hochgeladenen Bildes gesetzt werden. Für dieses Property werden nur Asset-URIs unterstützt.

Wenn dieses Property leer gelassen wird, zeigt die `Class.Backpack` GUI den
Namen des Werkzeugs stattdessen an.


BackpackItem.TextureContent

Das Textursymbol, das für ein Werkzeug im Rucksack des Spielers angezeigt wird.
Unterstützt nur Asset-URIs.


Das Textursymbol, das für ein Werkzeug im Rucksack des Spielers angezeigt wird.

Dieses Property sollte auf die Content-ID eines auf der
Roblox-Website hochgeladenen Bildes gesetzt werden.

Wenn dieses Property leer gelassen wird, zeigt die `Class.Backpack` GUI den
Namen des Werkzeugs stattdessen an.


BackpackItem.TextureId

Das Textursymbol, das für ein Werkzeug im Rucksack des Spielers angezeigt wird.


Das folgende Beispiel enthält eine grundlegende Funktion, die eine Tabelle von Objekten
entgegennimmt und sie in ein neues Modell einfügt, wobei dieses Modell zurückgegeben wird.

Modelle sind Containerobjekte, was bedeutet, dass sie Objekte zusammenfassen. Sie sind
am besten geeignet, um Sammlungen von `Class.BasePart|BaseParts` zu halten und verfügen über eine Reihe
von Funktionen, die ihre Funktionalität erweitern.

Modelle sollen **geometrische** Gruppierungen darstellen. Wenn Ihre Gruppierung keine geometrische
Interpretation hat, zum Beispiel eine Sammlung von `Class.Script|Scripts`, verwenden Sie stattdessen einen
`Class.Folder`.

Modelle, deren Bestandteile durch Gelenke verbunden sind (sodass sie sich bewegen oder durch
Physiksimulation zerstört werden können), haben normalerweise eine `Class.Model.PrimaryPart|PrimaryPart`
festgelegt, da dies angibt, welches Teil innerhalb des Modells der Pivot und die
Umrandungsbox während der Bewegung des Modells "folgen" wird. Statische
Modelle, die an einem Ort bleiben, profitieren nicht von der Festlegung eines primären Teils.

Modelle haben eine Vielzahl von Anwendungen, einschließlich Roblox-Spielercharaktere.
Sie haben auch eine Reihe von einzigartigen Verhaltensweisen, die wichtig sind zu beachten:

- Wenn ein `Class.Humanoid` und ein `Class.Part` mit dem Namen **Head** unter
  einem Modell übergeordnet sind, wird eine Name/Gesundheits-GUI über dem Modell angezeigt; siehe
  [Charaktername/Gesundheitsanzeige](/characters/name-health-display)
  für Einzelheiten.
- Wenn die Position eines Teils auf der **Y**-Achse den Wert von
  `Class.Workspace.FallenPartsDestroyHeight` erreicht und es das letzte Objekt
  innerhalb eines `Class.Model` war, wird das Modell ebenfalls zerstört.
- Wenn es an einem Ort mit `Class.Workspace.StreamingEnabled` verwendet wird,
  kontrolliert der Wert von `Class.Model.ModelStreamingMode|ModelStreamingMode`
  verschiedene Verhaltensweisen hinsichtlich der Replikation und/oder der Entfernung des Modells
  und aller Nachkommen von Clients. Darüber hinaus beeinflusst der Wert von
  `Class.Model.LevelOfDetail|LevelOfDetail` die Darstellung des Modells.

Wie bei allen `Class.Instance`-Typen garantiert die Tatsache, dass ein übergeordnetes `Class.Model`
zu einem Client repliziert wird, nicht, dass alle seine Kinder ebenfalls repliziert werden.
Dies ist besonders wichtig, wenn auf diese Instanzen von Code zugegriffen wird, der auf dem Client
ausgeführt wird, wie in einem `Class.LocalScript`.
Die Verwendung von `Class.Model.ModelStreamingMode|ModelStreamingMode` mit Werten wie
`Enum.ModelStreamingMode|Atomic` kann sicherstellen, dass das gesamte Modell und alle
seiner Nachkommen vorhanden sind, wenn das übergeordnete Modell auf dem Client existiert, oder Sie
können `Class.Instance:WaitForChild()|WaitForChild()` verwenden, wenn Atomizität nicht gewünscht ist.

Setzt dieses Modell für den angegebenen Spieler persistent. Persistente
Modelle bleiben für den Spieler vorhanden, unabhängig von Streaming-Einstellungen oder
bedingungen.

`Class.Model.ModelStreamingMode|ModelStreamingMode` muss auf
`Enum.ModelStreamingMode|PersistentPerPlayer` eingestellt sein,
um jede Verhaltensänderung als Folge der Hinzufügung zu bewirken.

Model:AddPersistentPlayer

playerInstance

Der `Class.Player`, für den dieses Modell persistent gemacht werden soll.

Setzt dieses Modell für den angegebenen Spieler persistent.
`Class.Model.ModelStreamingMode|ModelStreamingMode` muss auf
`Enum.ModelStreamingMode|PersistentPerPlayer` eingestellt sein,
um Verhaltensänderungen als Folge der Hinzufügung zu bewirken.

In diesem Beispiel werden die Gelenke in jedem hinzugefügten Spielercharaktermodell
3 Sekunden nach dem Spawn gebrochen. Das Brechen dieser Gelenke führt dazu, dass der Humanoid
tot ist.

Dieses Codebeispiel demonstriert die manuelle Erstellung von Gelenken auf zwei Teilen, die
Geschwister des Skripts sind (PartA und PartB). Es erstellt Gelenke auf zwei berührenden
Teilen mit kompatiblen Oberflächentypen (Stifte und Einlass).

Bricht Verbindungen zwischen `BaseParts`, einschließlich Oberflächenverbindungen mit
irgendwelchen benachbarten Teilen, `Class.WeldConstraint|WeldConstraints` und allen
`Class.Weld|Welds` und anderen `Class.JointInstance|JointInstances`.

Wenn BreakJoints bei einem Spielercharakter `Class.Model` verwendet wird, wird
`Class.Humanoid` des Charakters sterben, da es auf dem Nacken-Gelenk basiert.

Beachten Sie, dass, obwohl Gelenke, die durch Oberflächenverbindungen mit benachbarten
Teilen erzeugt werden, technisch mit `Class.Model:MakeJoints()` wiederhergestellt werden können,
werden nur Gelenke wiederhergestellt, die durch Oberflächen erzeugt werden. Entwickler sollten
sich darauf nicht verlassen, da nach dem Brechen der Gelenke die Teile möglicherweise nicht
mehr miteinander in Kontakt stehen.

Model:BreakJoints

Bricht Verbindungen zwischen `BaseParts`, einschließlich Oberflächenverbindungen mit
irgendwelchen benachbarten Teilen, `Class.WeldConstraint|WeldConstraints` und allen
`Class.Weld|Welds` und anderen `Class.JointInstance|JointInstances`.

Model:breakJoints

Diese Funktion gibt eine Beschreibung eines Volumens zurück, das alle
`Class.BasePart`-Kinder innerhalb eines `Class.Model` enthält. Die Orientierung des Volumens
beruht auf der Orientierung des `Class.Model.PrimaryPart|PrimaryPart` und entspricht dem
Auswahlfeld, das im Studio gerendert wird, wenn das Modell ausgewählt ist. In Übereinstimmung mit dem Verhalten von
`Class.Terrain:FillBlock()` gibt es ein `Datatype.CFrame`, das das Zentrum dieser Umrandungsbox
repräsentiert, und ein `Datatype.Vector3`, das dessen Größe darstellt. Die Größe kann zur Laufzeit
ungenau sein, wenn physikalische Einschränkungen auf die Teile innerhalb des `Class.Model`
wirken.

Die Orientierung der Umrandungsbox entspricht der Orientierung des
`Class.PVInstance.GetPivot|Pivot` - entweder dem Pivot des
`Class.Model.PrimaryPart|PrimaryPart` (falls vorhanden) oder dem
`Class.Model.WorldPivot|WorldPivot` des Modells.

```lua
local Workspace = game:GetService("Workspace")

local model = Workspace.Model
local part = Workspace.Part
local orientation, size = model:GetBoundingBox()

-- Größe und Position des Teils gleich der Umrandungsbox des Modells anpassen
part.Size = size
part.CFrame = orientation
```

Model:GetBoundingBox

Ein `Datatype.CFrame`, das die Orientierung des Volumens darstellt,
gefolgt von einem `Datatype.Vector3`, das die Größe des Volumens darstellt.

Gibt eine Beschreibung eines Volumens zurück, das alle Teile eines Modells enthält.

Das folgende Codebeispiel zeigt, wie Model.GetExtentsSize verwendet werden kann, um
die Größe des Begrenzungsrahmens zu erhalten, der die Teile enthält.

Gibt die Größe der kleinsten Umrandungsbox zurück, die alle
`Class.BasePart|BaseParts` im `Class.Model` enthält. Die Orientierung entspricht
der Orientierung des `Class.PVInstance.GetPivot|Pivot` - entweder dem
Pivot des `Class.Model.PrimaryPart|PrimaryPart` (falls vorhanden) oder dem
`Class.Model.WorldPivot|WorldPivot` des Modells.

Beachten Sie, dass diese Funktion nur die Größe der kleinsten Umrandungsbox zurückgibt, und
dass der Entwickler seine eigene Methode verwenden muss, um die Position der
Umrandungsbox zu ermitteln.

Model:GetExtentsSize

Die Größe der `Datatype.Vector3`-Extents des `Class.Model`.

Gibt die Größe der kleinsten Umrandungsbox zurück, die alle
`Class.BasePart|BaseParts` im `Class.Model` enthält, ausgerichtet mit der
`Class.Model.PrimaryPart`, sofern festgelegt.

Dieser Wert gab historisch das CFrame einer zentralen Position im
Modell zurück.

Model:GetModelCFrame

Dieser Code würde ein Modell erstellen, einige Teile hineinlegen, sie zufällig positionieren,
und dann die Größe ausgeben:


Die GetModelSize-Funktion gibt die `Datatype.Vector3`-Größe des
`Class.Model` zurück.

Model:GetModelSize

Gibt die Vector3-Größe des Modells zurück.

Wenn diese Methode von einem `Class.Script` aufgerufen wird, gibt sie alle
`Class.Player`-Objekte zurück, für die dieses Modell persistent ist. Wenn sie von
einem `Class.LocalScript` aufgerufen wird, prüft diese Methode nur, ob dieses Modell
persistent für den `Class.Players.LocalPlayer|LocalPlayer` ist.

Model:GetPersistentPlayers

Eine Tabelle mit allen `Class.Player`-Objekten, für die dieses Modell-Objekt
persistent ist.

Gibt alle `Class.Player`-Objekte zurück, für die dieses Modell-Objekt
persistent ist. Das Verhalten variiert je nachdem, ob diese Methode von einem
`Class.Script` oder einem `Class.LocalScript` aufgerufen wird.

Der folgende Code demonstriert, wie GetPrimaryPartCFrame und
SetPrimaryPartCFrame verwendet werden können, um ein Modell zu drehen.

Ein einfaches Modell wird im Workspace erstellt und eine Schleife wird gestartet, die das Modell
alle 0,2 Sekunden um 10 Grad um die Y-Achse dreht.

Diese Funktion wurde durch `Class.PVInstance:GetPivot()` ersetzt, die
als Ersatz dient und das Verhalten Ihres Codes nicht ändert. Verwenden Sie
`Class.PVInstance:GetPivot()` für neue Arbeiten und migrieren Sie Ihre vorhandenen
`Class.Model:GetPrimaryPartCFrame()`-Aufrufe, wenn es Ihnen passt.

Gibt das `Datatype.CFrame` des `Class.Model.PrimaryPart` des Modells zurück.

Diese Funktion ist äquivalent zu:

    Model.PrimaryPart.CFrame

Beachten Sie, dass diese Funktion einen Fehler auslöst, wenn kein primärer Teil für das
`Class.Model` vorhanden ist. Dieses Verhalten kann Probleme verursachen, wenn z. B.
der primäre Teil niemals festgelegt wurde oder zerstört wurde.

Model:GetPrimaryPartCFrame

Gibt das `Datatype.CFrame` des `Class.Model.PrimaryPart` des Modells zurück.
Diese Funktion wirft einen Fehler, wenn kein primärer Teil für das
`Class.Model` vorhanden ist.

Dieses Codebeispiel demonstriert, wie man einen Ersatz für alle Kopien
 eines Baummodells mit `Class.Model:PivotTo()` und `Class.Model:ScaleTo()` einspringt. Der
Pivot und die Größe der Modelle werden als Referenz verwendet, um sicherzustellen, dass die
relativen Größen und Positionen der Ersatzmodelle mit denen der
Originale übereinstimmen.


Modelle enthalten einen persistierenden kanonischen Skalierungsfaktor, der für neu
erstellte Modelle bei 1 beginnt und sich ändert, während das Modell durch
Aufrufen von `Class.Model:ScaleTo()` skaliert wird. Diese Funktion gibt den aktuellen
kanonischen Skalierungsfaktor des Modells zurück.

Der aktuelle Skalierungsfaktor wirkt sich _direkt_ nicht auf die Größe von Instanzen
unter dem Modell aus. Er wird für die Inhaltserstellung und Skriptingzwecke verwendet,
um zu speichern, wie das Modell relativ zu seiner ursprünglichen Größe skaliert wurde.

Innerhalb einer bestimmten Sitzung speichert das Modell die präzisen Informationen der ursprünglichen
Größe der Nachkomme-Instanzen nach dem ersten Aufruf von
`Class.Model:ScaleTo()`. Das bedeutet, dass das Aufrufen von
`Class.Model:ScaleTo()|ScaleTo(x)` gefolgt von
`Class.Model:ScaleTo()|ScaleTo(1)` Sie _genau_ zur ursprünglichen Konfiguration des Modells
mit keinem Gleitfehler zurückbringt. Das Vermeiden von Gleitfehler ist der Grund, warum
es eine Scale**To**-Funktion und keine Scale**By**-Funktion gibt.

Der Skalierungsfaktor beeinflusst das Verhalten der Engine in einem Punkt:
Der Skalierungsfaktor eines Modells wird auf Gelenkversätze von `Class.Animation|Animations`
angewendet, die auf einem `Class.AnimationController` unter diesem Modell abgespielt werden,
so dass animierte Rigs Animationen korrekt wiedergeben, selbst wenn sie skaliert sind.

Model:GetScale

Der aktuelle kanonische Skalierungsfaktor des Modells.

Gibt die kanonische Skalierung des Modells zurück, die standardmäßig für neu
erstellte Modelle 1 beträgt und sich ändert, während es über
`Class.Model:ScaleTo()` skaliert wird.

Dieses Codebeispiel zeigt, wie Verbindungen mit der
Model:MakeJoints-Funktion erstellt werden können.

Ein Modell wird instanziiert, mit zwei Teilen übereinander. Der obere Teil ist
verankert und der untere Teil nicht. Normalerweise würde der untere Teil, wenn er im Workspace verankert ist,
auf die Basisplatte fallen.

Da die TopSurface-Eigenschaft des unteren Teils auf
Enum.SurfaceType.Weld gesetzt ist, bedeutet dies, dass bei der Ausführung von Model:MakeJoints eine
Verbindung zwischen ihnen hergestellt wird.

Daher fällt der untere Teil nicht, bis die Verbindungen im Modell
gebrochen werden. Dies geschieht oft mit Model:BreakJoints, aber in diesem Beispiel wird die
Verbindung mit einer Explosion zerbrochen.

Dieses Codebeispiel demonstriert die Erstellung von Gelenken an zwei Teilen, die
Geschwister des Skripts sind (PartA und PartB). Es verwendet MakeJoints auf zwei berührenden
Teilen mit kompakten Oberflächentypen (Studs und Inlet).

Das Zusammenfügen basierend auf SurfaceType ist veraltet. Verwenden Sie nicht MakeJoints für neue
Projekte. Verwenden Sie stattdessen `Class.WeldConstraint|WeldConstraints` und
`Class.HingeConstraint|HingeConstraints`.

Durchläuft alle `Class.BasePart|Parts` im `Class.Model` und erstellt
Gelenke zwischen den angegebenen Teilen und allen planaren Berührungsoberflächen,
abhängig von den Oberflächen der Teile.

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

Diese Funktion funktioniert nicht, wenn das Teil nicht ein Nachkomme von
`Class.Workspace` ist. Daher müssen Sie zunächst sicherstellen, dass das Modell auf dem
Workspace verankert ist, bevor Sie MakeJoints verwenden.

Model:MakeJoints

Durchläuft alle `Class.BasePart|BaseParts` im `Class.Model`. Wenn eine Seite eines Teils eine SurfaceType hat, die ein Gelenk erstellen kann,
wird ein Gelenk mit irgendwelchen benachbarten Teilen erstellt.

Model:makeJoints

Model:move

location

Dieses Beispiel zeigt, wie `Class.Model:MoveTo()` Kollisionen vermeidet.

Ein einfaches zwei-teiliges `Class.Model` wird erstellt, und sein `Class.Model.PrimaryPart`
wird festgelegt. Ein großes Hindernis wird daneben platziert.

Nach 5 Sekunden wird `Class.Model:MoveTo()` verwendet, um das Modell zu bewegen
innerhalb des Hindernisses. Da MoveTo jedoch ein Modell nicht in ein
Hindernis bewegen kann, wird das `Class.Model` auf der Y-Achse nach oben verschoben und über
das Hindernis platziert.


Bewegt das `Class.Model.PrimaryPart|PrimaryPart` an die angegebene Position. Wenn
kein primärer Teil angegeben wurde, wird der Wurzelteil des Modells verwendet, aber der Wurzelteil
ist nicht deterministisch und es wird empfohlen, immer einen primären Teil festzulegen, wenn Sie
`Class.Model:MoveTo()|MoveTo()` verwenden.

Wenn es irgendwelche Hindernisse gibt, wo das Modell bewegt werden soll, wie `Class.Terrain`
oder andere `Class.BasePart|BaseParts`, wird das Modell vertikal nach oben bewegt, bis
es keine Hindernisse mehr gibt. Wenn dieses Verhalten nicht gewünscht ist, sollte stattdessen
`Class.PVInstance:PivotTo()` verwendet werden.

Beachten Sie, dass die Drehung beim Bewegen eines Modells mit
`Class.Model:MoveTo()|MoveTo()` nicht beibehalten wird. Es wird empfohlen, entweder
`Class.Model:TranslateBy()|TranslateBy()` oder `Class.PVInstance:PivotTo()` zu verwenden,
wenn die aktuelle Drehung des Modells beibehalten werden muss.

Model:MoveTo

position

Der `Datatype.Vector3`, auf den das `Class.Model` bewegt wird.

Bewegt das `Class.Model.PrimaryPart|PrimaryPart` an die angegebene Position. Wenn
kein primärer Teil angegeben wurde, wird der Wurzelteil des Modells verwendet.

Model:moveTo

Macht dieses Modell für den angegebenen Spieler nicht mehr persistent. Dies garantiert nicht,
dass das Modell sofort für den Spieler entfernt wird; nach dem Aufrufen dieser Methode wird das
Modell als `Enum.ModelStreamingMode|Atomic` für diesen Spieler behandelt und bleibt vorhanden,
während es sich innerhalb des Ziel-Streaming-Radius befindet.

`Class.Model.ModelStreamingMode|ModelStreamingMode` muss auf
`Enum.ModelStreamingMode|PersistentPerPlayer` eingestellt sein,
um Verhaltensänderungen als Folge der Entfernung zu bewirken.

Model:RemovePersistentPlayer

Der `Class.Player`, für den dieses Modell nicht mehr persistent gemacht werden soll.

Macht dieses Modell für den angegebenen Spieler nicht mehr persistent.
`Class.Model.ModelStreamingMode|ModelStreamingMode` muss auf
`Enum.ModelStreamingMode|PersistentPerPlayer` eingestellt sein,
um Verhaltensänderungen als Folge der Entfernung zu bewirken.

Setzt die Drehung der Teile des Modells auf die zuvor festgelegte Identitätsdrehung,
was über die Methode `Class.Model:SetIdentityOrientation()` erfolgt.

Model:ResetOrientationToIdentity

Modelle enthalten einen persistierenden kanonischen Skalierungsfaktor, der für neu
erstellte Modelle bei 1 beginnt. Diese Funktion skaliert das Modell um den Pivot-Standort,
relativ dazu, wie es bei einem Skalierungsfaktor von 1 aussehen würde. Um dies zu erreichen,
tut es zwei Dinge:

- Setzt den aktuellen Skalierungsfaktor des Modells auf den angegebenen Wert
- Ändert die Größe und die Position aller Nachkommen-Instanzen entsprechend

Die Skalierung der Standorte erfolgt um den Pivot-Standort herum.

Alle "geometrischen" Eigenschaften von Nachkommen-Instanzen werden skaliert. Das
umfasst offensichtlich die Größen von Teilen, aber hier sind einige andere Beispiele für
Eigenschaften, die skaliert werden:

- Die Länge von Gelenken wie `Class.WeldConstraint|WeldConstraints` und
  `Class.RopeConstraint`
- Physikalische Geschwindigkeiten und Kräfte wie `Class.HingeConstraint`
- Visuelle Eigenschaften wie Größen von Partikelemittern
- Andere Längen-Eigenschaften wie `Class.Sound.RollOffMinDistance`

Model:ScaleTo

newScaleFactor

Setzt den Skalierungsfaktor des Modells, passt die Größe und den Standort aller
Nachkommen-Instanzen so an, dass sie diesen Skalierungsfaktor relativ zu ihren
ursprünglichen Größen und Standorten haben, wenn der Skalierungsfaktor 1 war.

Setzt die Identitätsdrehung des angegebenen Modells, sodass Sie später die
Drehung des gesamten Modells über die Verwendung der Methode
`ResetOrientationToIdentity` zurücksetzen können.

Model:SetIdentityOrientation

Diese Funktion wurde durch `Class.PVInstance:PivotTo()` ersetzt, die
als leistungsfähigerer Ersatz dient und das Verhalten Ihres Codes nicht ändert. Verwenden Sie
`Class.PVInstance:PivotTo()` für neue Arbeiten und migrieren Sie Ihre vorhandenen
`Class.Model:SetPrimaryPartCFrame()`-Aufrufe, wenn es Ihnen passt.

Setzt das `Class.BasePart.CFrame` des primären Teils des Modells.
Alle anderen Teile im Modell werden ebenfalls bewegt und behalten ihre
Orientierung und Versatz in Bezug auf das `Class.Model.PrimaryPart`.

Beachten Sie, diese Funktion wirft einen Fehler, wenn kein `Class.Model.PrimaryPart`
für das Modell vorhanden ist. Dies kann Probleme verursachen, wenn z. B.
der primäre Teil nie festgelegt wurde oder zerstört wurde.

Model:SetPrimaryPartCFrame

cframe

Das `Datatype.CFrame`, das festgelegt werden soll.

Setzt das `Class.BasePart.CFrame` des primären Teils des Modells.
Alle anderen Teile im Modell werden ebenfalls bewegt und behalten ihre
Orientierung und Versatz in Bezug auf das `Class.Model.PrimaryPart`.

Dieses Beispiel zeigt, wie `Class.Model:TranslateBy()` Kollisionen ignoriert
und die Ausrichtung des Modells respektiert.

Ein einfaches zwei-teiliges `Class.Model` wird erstellt, um 45 Grad um die Y-Achse gedreht,
und sein `Class.Model.PrimaryPart` wird festgelegt. Ein großes Hindernis-Teil wird daneben platziert.

Nach 5 Sekunden wird `Class.Model:TranslateBy()` verwendet, um das Modell zu
lenken, damit es sich im Hindernis-Teil bewegt. Das Modell wird sich innerhalb des
Hindernisses bewegen und seine aktuelle Ausrichtung beibehalten.


Verschiebt ein `Class.Model` um den angegebenen `Datatype.Vector3`-Versatz und
bewahrt die Orientierung des Modells. Wenn ein weiteres `Class.BasePart` oder
`Class.Terrain` bereits an der neuen Position vorhanden ist, wird das
`Class.Model` mit diesem Objekt überlappen.

Die Verschiebung wird im Weltbereich und nicht im Objektbereich angewendet,
was bedeutet, dass sich das Modell auch dann entlang der Standardachse bewegt,
wenn die Teile des Modells unterschiedlich orientiert sind.

Model:TranslateBy

delta

Der `Datatype.Vector3`, um den das `Class.Model` verschoben wird.

Verschiebt ein `Class.Model` um den angegebenen `Datatype.Vector3`-Versatz und
bewahrt die Orientierung des Modells. Wenn ein weiteres `Class.BasePart` oder
`Class.Terrain` bereits an der neuen Position vorhanden ist, wird das
`Class.Model` mit diesem Objekt überlappen.

Model

Legt das Detailniveau des Modells für Erfahrungen mit aktivierter
[Streaming](/workspace/streaming) fest. Composite- oder
Imposter-Meshes unterstützen keine Physik, Kollisionserkennung oder
Raycasting.

Wenn auf `Enum.ModelLevelOfDetail|StreamingMesh` eingestellt, wird ein
Mesh mit niedrigerer Auflösung, das als "Imposter" bezeichnet wird (farbiges,
grobes Mesh, das alle Kindteile des Modells umschließt), außerhalb des
Streaming-Radius gerendert. Unterstützt keine Texturen.

Wenn auf `Enum.ModelLevelOfDetail|SLIM` eingestellt, wird ein **SLIM**
Modell (Skalierbares Leichtgewichtiges Interaktives Modell) gerendert,
eine Zusammenstellung aller Kindteile in progressiv niedrigeren
Auflösungen je nach Entfernung basierend auf dem Streaming-Radius.
Dies verbessert die visuelle Qualität erheblich im Vergleich zu
`Enum.ModelLevelOfDetail|StreamingMesh`.

Wenn auf `Enum.ModelLevelOfDetail|Disabled` oder
`Enum.ModelLevelOfDetail|Automatic` eingestellt, werden Meshes mit
niedrigerer Auflösung nicht angezeigt.


Model.LevelOfDetail

Legt die Detailstufe des Modells für Erlebnisse mit aktivem Instanz-Streaming fest.

Steuert, wie `Class.Model|Models` gestreamt werden, wenn das Instanz-
[Streaming](/workspace/streaming) aktiviert ist. Das Verhalten hängt von der
ausgewählten Enumeration ab. Hat keine Auswirkungen, wenn das Streaming nicht aktiviert ist.

Diese Eigenschaft sollte nur im Studio über das Fenster
[Eigenschaften](/studio/properties) geändert werden, wenn das Streaming aktiviert ist, oder in
`Class.Script|Scripts`, aber niemals in `Class.LocalScript|LocalScripts` (das kann zu undefiniertem
Verhalten führen).

Model.ModelStreamingMode

Steuert das Streaming-Verhalten von `Class.Model|Models`, wenn das Instanz-Streaming aktiviert ist.

Dieses Codesample erstellt ein Würfelmodell und wirft es, dann gibt es aus, ob es
mit der blauen Seite nach oben gelandet ist. Wenn `Class.Model.PrimaryPart` nicht gesetzt war,
würde sich der Pivot / die Begrenzungsbox des Würfels drehen, da die Teile darin
physikalisch simuliert werden während des Wurfs.

Verweist auf den primären Teil des `Class.Model`. Der primäre Teil ist der
`Class.BasePart`, der als physischer Bezug für den Pivot des Modells dient. Das bedeutet, dass sich der
Pivot mit dem primären Teil synchron bewegt, wenn Teile innerhalb des Modells aufgrund von physikalischer
Simulation oder anderen Gründen bewegt werden.

Beachten Sie, dass `Class.Model|Models` standardmäßig kein `PrimaryPart` festgelegt haben.
Wenn Sie ein Modell erstellen, das von der Physik beeinflusst werden muss, sollten Sie diese
Eigenschaft manuell im Studio oder innerhalb eines Skripts festlegen. Wenn der primäre Teil **nicht**
eingestellt ist, bleibt der Pivot an derselben Position im Weltbereich, selbst wenn Teile innerhalb des Modells
bewegt werden.

Beachten Sie auch, dass bei der Festlegung dieser Eigenschaft ein `Class.BasePart`
verwendet werden muss, das ein Nachkomme des Modells ist. Wenn Sie versuchen, den
`Class.Model.PrimaryPart` auf ein `Class.BasePart` festzulegen, das **nicht** ein
Nachkomme des Modells ist, wird er auf dieses Teil gesetzt, aber während des nächsten
Simulationsschrittes auf `nil` zurückgesetzt &mdash; dies ist ein veraltetes Verhalten, um
Skripte zu unterstützen, die davon ausgehen, dass sie den primären Teil vorübergehend auf ein
`Class.BasePart` setzen können, das kein Nachkomme des Modells ist.

Die allgemeine Regel für Modelle ist:

- Modelle, deren Teile durch physische Gelenke wie
  `Class.WeldConstraint|WeldConstraints` oder `Class.Motor6D|Motor6Ds`
  verbunden sind, sollten einen primären Teil zugewiesen bekommen. Zum Beispiel, Roblox-Charakter-
  modelle haben ihren `Class.Model.PrimaryPart` standardmäßig auf den
  **HumanoidRootPart** gesetzt.
- Statische (normalerweise `Class.BasePart.Anchored|Anchored`) Modelle, die an einem
  Ort bleiben, es sei denn, ein Skript bewegt sie ausdrücklich, benötigen kein
  `Class.Model.PrimaryPart` und profitieren meist nicht von der Festlegung eines.

Model.PrimaryPart

Der primäre Teil des `Class.Model`, oder `nil`, wenn nicht explizit festgelegt.

Das Festlegen dieser Eigenschaft im Eigenschaftenfenster skaliert das Modell, als
ob `Class.Model:ScaleTo()` aufgerufen würde, und skaliert alle Nachkommen
drinben, wie Materialien, Bilder und die 3D-Geometrie von Teilen, sodass das Modell den
angegebenen Skalierungsfaktor relativ zu seiner ursprünglichen Größe hat.

Diese Eigenschaft ist nur im Studio verfügbar und wirft einen Fehler, wenn sie
in einem `Class.Script` oder `Class.LocalScript` verwendet wird. `Class.Model:ScaleTo()` und
`Class.Model:GetScale()` sollten aus Skripten verwendet werden.

Model.Scale

Editor-exklusive Eigenschaft, die das Modell um seinen Pivot skaliert. Das Festlegen
    dieser Eigenschaft bewegt die Skala, als ob `Class.Model:ScaleTo()` aufgerufen
    würde.

Dieses Codebeispiel zeigt eine benutzerdefinierte Funktion zum Zurücksetzen des Pivots eines Modells
zurück zum Mittelpunkt des umgebenden Rechtecks dieses Modells.

Diese Eigenschaft bestimmt, wo sich der Pivot eines `Class.Model` befindet, wenn
kein `Class.Model.PrimaryPart` festgelegt ist. Wenn das `Class.Model`
**doch** einen `Class.Model.PrimaryPart|PrimaryPart` hat, ist der Pivot des
`Class.Model` gleich dem Pivot dieses primären Teils, und diese
`Class.Model.WorldPivot|WorldPivot`-Eigenschaft wird ignoriert.

Für ein neu erstelltes `Class.Model` wird sein Pivot als das Zentrum
der Umrandungsbox seiner Inhalte behandelt, bis zum **ersten Mal**, dass
seine `Class.Model.WorldPivot`-Eigenschaft festgelegt wird. Sobald der
Weltpivot für das erste Mal festgelegt wird, ist es unmöglich, dieses
ursprüngliche Verhalten wiederherzustellen.

Am häufigsten wird das Modell mit den Studio-Tools oder mit Modellbewegungsfunktionen wie
`Class.PVInstance:PivotTo()` und `Class.Model:MoveTo()` bewegt, was den Weltpivot festlegt und damit
dieses neue Modellverhalten beendet.

Der Zweck dieses Verhaltens ist es, Luau-Code zu ermöglichen, einen
sinnvollen Pivot zu erhalten, indem einfach ein neues Modell erstellt und Objekte daran
gegliedert werden, um zu vermeiden, dass `Class.Model.WorldPivot` jedes Mal explizit
festgelegt werden muss, wenn Sie ein Modell in Code erstellen.

```
local Workspace = game:GetService("Workspace")

local model = Instance.new("Model")
Workspace.BluePart.Parent = model
Workspace.RedPart.Parent = model
model.Parent = Workspace

print(model:GetPivot())  -- Momentan gleich dem Zentrum der Umrandungsbox, die "BluePart" und "RedPart" enthält

model:PivotTo(CFrame.new(0, 10, 0))  -- Das funktioniert, ohne "model.WorldPivot" explizit festzulegen
```

Model.WorldPivot

Bestimmt, wo sich der Pivot eines `Class.Model` befindet, wenn kein
festgelegter `Class.Model.PrimaryPart` vorhanden ist.

Modelle sind Containerobjekte, was bedeutet, dass sie Objekte zusammenfassen. Sie sind
am besten geeignet, um Sammlungen von `Class.BasePart|BaseParts` zu halten und verfügen über eine Reihe
von Funktionen, die ihre Funktionalität erweitern.

Eine `Class.PVInstance` ist eine abstrakte Klasse, die nicht erstellt werden kann. Sie ist die
Basis für alle Objekte, die einen physischen Standort in der Welt haben.


Dieses Codebeispiel ist ein einfaches Teleport-Skript, das deinen Charakter
10&nbsp;Studs in die Richtung bewegt, in die du gerade schaust, wenn du die
<kbd>F</kbd>-Taste drückst. Es geschieht, indem der aktuelle Pivot mit
`Class.PVInstance:GetPivot()` abgerufen und `PVInstance|PivotTo` aufgerufen wird, um
das
Charakter vorwärts zu bewegen.

Diese Funktion erhält den Pivot einer `Class.PVInstance`. Dies wird oft
mit `Class.PVInstance:PivotTo()` verwendet, um ein Modell zu bewegen.

`Class.Model|Models` und `Class.BasePart|BaseParts` sind beide
`Class.PVInstance|PVInstances` ("Positionsgeschwindigkeitsinstanzen") und daher haben beide
 diese Funktion.


PVInstance:GetPivot

Erhält den Pivot einer `Class.PVInstance`.


Transformiert die `Class.PVInstance` zusammen mit allen ihren Nachkommen
`Class.PVInstance|PVInstances`, sodass der Pivot jetzt an dem
angegebenen `Datatype.CFrame` liegt. Dies ist die Hauptfunktion, die verwendet werden sollte,
um `Class.Model|Models` über Skripting zu bewegen.

`Class.BasePart|BaseParts` werden auf diese Weise bewegt, indem ihr
`Datatype.CFrame` durch den erforderlichen Offset transformiert wird.
`Class.Model|Models` werden auf diese Weise bewegt, indem ihr
`Class.Model.WorldPivot` durch den erforderlichen Offset transformiert wird.

Beachten Sie, dass aus Effizienzgründen die `Class.Object.Changed`-Ereignisse nicht
für `Class.BasePart.Position|Position` und
`Class.BasePart.Orientation|Orientation` von `Class.BasePart|BaseParts`
, die auf diese Weise bewegt werden, ausgelöst werden; sie werden nur für `Datatype.CFrame` ausgelöst.

Beim Aufrufen von `Class.PVInstance:PivotTo()|PivotTo` auf `Class.Model|Models`
werden die Offsets der nachfolgenden Teile und Modelle zwischengespeichert, sodass
nachfolgende Aufrufe von `Class.PVInstance:PivotTo()|PivotTo` auf demselben Modell
ein Drift der Gleitkommazahlen zwischen den Teilen, die das Modell ausmachen, nicht akkumulieren.

`Class.Model|Models` und `Class.BasePart|BaseParts` sind beide
`Class.PVInstance|PVInstances` ("Positionsgeschwindigkeitsinstanzen") und daher haben beide
 diese Funktion.


PVInstance:PivotTo

targetCFrame

Der `Datatype.CFrame`, dem der Pivot der `Class.PVInstance` nach der Bewegung entsprechen sollte.


Transformiert die `Class.PVInstance` zusammen mit allen ihren Nachkommen
`Class.PVInstance|PVInstances`, sodass der Pivot jetzt an dem
angegebenen `Datatype.CFrame` liegt.


PVInstance

PVInstance.Origin

PVInstance.Pivot Offset

Abstrakte Klasse für alle Objekte, die einen physischen Standort in der Welt haben.


`Instance` ist die Basisklasse für alle Klassen in der Roblox-Klassenhierarchie, die Teil des `Class.DataModel`-Baumes sein können.

Es ist nicht möglich, direkt Root-`Instance`-Objekte zu erstellen, aber der spezielle `Datatype.Instance.new()`-Konstruktor erstellt Objekte über Code, indem er den Namen der Klasse als Parameter entgegennimmt und das erstellte Objekt zurückgibt.

Demonstriert das Erkennen von Änderungen an der Abstammung einer Instanz, indem man sich mit dem
`Class.Instance.AncestryChanged` Ereignis verbindet.

Der Parent des ChangingPart wird im Laufe der Zeit auf verschiedene Werte gesetzt. Der Parent des
Teils ist der Vorfahr des Teils, sodass das `Class.Instance.AncestryChanged` Ereignis
ausgelöst wird, wann immer es sich ändert.


Wird ausgelöst, wenn diese Instanz umgegliedert wird oder wenn einer ihrer Vorfahren
umgegliedert wird.

Sie können dieses Ereignis verwenden, um das Löschen einer Instanz im Studio zu verfolgen,
wie z.B. das manuelle Löschen im Explorer oder über ein Plugin. Wenn Sie erkennen müssen,
wann eine Instanz mit `Class.Instance:Destroy()` gelöscht wird, verwenden Sie stattdessen das
event `Class.Instance.Destroying`.

Instance.AncestryChanged

child

Die Instanz, deren `Class.Instance.Parent|Parent`-Eigenschaft sich geändert hat,
was diese Instanz oder einen weiter entfernten Vorfahren sein kann, **nicht**
unbedingt die Instanz, an die der Handler verbunden ist.

parent

Der neue Elternteil des `child`-Parameters.

Wird ausgelöst, wenn die `Class.Instance.Parent`-Eigenschaft dieses Objekts oder einer
seiner Vorfahren geändert wird.

Dieses Ereignis wird ausgelöst, wenn ein beliebiges Attribut auf der Instanz geändert wird,
auch wenn ein Attribut auf `nil` gesetzt wird. Der Name des geänderten Attributs wird an die
verbundene Funktion übergeben.

Zum Beispiel verbindet der folgende Code-Schnipsel die Funktion `attributeChanged()`
musikalisch, um zu feuern, wenn sich eines der Attribute des Parts ändert:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "geändert")
end

part.AttributeChanged:Connect(attributeChanged)
```
Siehe auch `Class.Instance:GetAttributeChangedSignal()`, das ein Ereignis zurückgibt,
das ausgelöst wird, wenn ein bestimmtes angegebenes Attribut geändert wird.

Instance.AttributeChanged

attribute

Der Name des Attributs, das geändert wurde.

Wird ausgelöst, wenn ein Attribut auf der `Class.Instance` geändert wird.

Dieses Snippet druckt die Namen von Objekten aus, während sie zum Workspace hinzugefügt werden:

Wird ausgelöst, nachdem ein Objekt zu dieser `Class.Instance` hinzugefügt wurde.

Hinweis, beim Verwenden dieser Methode auf einem Client, um Objekte zu erkennen, die vom
Server erstellt wurden, ist es notwendig, `Class.Instance:WaitForChild()` zu verwenden, wenn
man auf die Nachkommen dieses Objekts zugreift. Dies liegt daran, dass das Objekt und seine
Nachkommen nicht garantiert gleichzeitig vom Server zum Client repliziert werden. Zum Beispiel:

```
local Workspace = game:GetService("Workspace")

Workspace.ChildAdded:Connect(function(child)
	-- Verwenden Sie WaitForChild(), da Nachkommen möglicherweise noch nicht repliziert wurden
	local head = child:WaitForChild("Head")
end)
```
Hinweis, dieses Ereignis funktioniert nur für unmittelbare Kinder der `Class.Instance`.
Für ein Ereignis, das alle Nachkommen erfasst, verwenden Sie `Class.Instance.DescendantAdded`.

Siehe auch `Class.Instance.ChildRemoved`.

Instance.ChildAdded

Wird ausgelöst, nachdem ein Objekt zu dieser `Class.Instance` hinzugefügt wurde.

Instance

`Instance` ist die Basisklasse für alle Klassen in der Roblox-Klassenhierarchie, die Teil des `Class.DataModel`-Baumes sein können.