Das Flag ist eine Einheit, die mit einem `Class.FlagStand`-Objekt gespawnt wird und wird
wieder erscheinen, wenn es gefangen wird. Wenn ein Spieler diesen Objektgriff berührt, der ein
Kind des Flag-Objekts sein muss, das ein Teil namens "Handle" ist, wird die Flagge
zum Rucksack des Spielers hinzugefügt und erscheint in dessen Hand. Ein Spieler kann keine
anderen Waffen wä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
vom Rucksack des Spielers entfernt und ein Punkt wird den leaderstats des Benutzers hinzugefügt,
sofern vorgesehen. Die Flagge regeneriert sich dann am ursprünglichen Flaggenstand.

Flag

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

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 gedacht ist. Entspricht den TeamColors im
`Class.Teams`-Service.

Das Flag-Objekt 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 einem `Class.Player`-Objekt zugeordnet ist. Im Erlebnis können Spieler mehrere Werkzeuge haben, die als Symbole am unteren Bildschirmrand angezeigt werden. Das Ausrüsten eines Werkzeugs bewegt es vom `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` darin hat (obwohl keiner erforderlich ist, wenn `Class.Tool.RequiresHandle` auf `false` gesetzt ist). Werkzeuge, die (Re)Spielern zur Verfügung gestellt 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 durchzuführen, wenn der Spieler das Werkzeug verwendet, beispielsweise um eine Rakete aus einem Raketengewehr-Werkzeug abzufeuern.

Der folgende Code, wenn er 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 durchzuführen, wenn der Spieler aufhört, ein Werkzeug zu verwenden.

Der folgende Code, wenn er 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 ausgerüstet 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` ausrüstet (es aus seinem `Class.Backpack` nimmt).

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` aktiviert ist und kein Griff vorhanden ist.


Tool.Equipped

mouse

Wird ausgelöst, wenn das Werkzeug ausgerüstet 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 ausrüstet, indem er es aus seinem Rucksack nimmt.

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


Tool.Unequipped

Wird ausgelöst, wenn das Werkzeug abgelegt 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 CanBeDropped-Eigenschaft steuert, ob der Spieler das `Class.Tool` fallen lassen kann.

Wenn wahr, wird das Werkzeug, wenn die Rücktaste gedrückt wird, im `Class.Workspace` zugeordnet und aus dem `Class.Backpack` des Spielers entfernt. Wenn falsch, passiert nichts, wenn die Rücktaste gedrückt wird, und das Werkzeug bleibt ausgerüstet.


Tool.CanBeDropped

Steuert, ob der Spieler das Werkzeug fallen lassen 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 wollen.

Wenn auf `true` gesetzt, kann der Spieler das Werkzeug verwenden. Wenn auf `false` gesetzt, ist das Werkzeug deaktiviert und der Spieler kann es nicht verwenden; dies verhindert, dass das Werkzeug durch die 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 einen einzigen `Datatype.CFrame`. Diese Eigenschaften positionieren, wie der Spieler das Werkzeug hält, und umfassen `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 einen `Datatype.CFrame`.


Eine der Eigenschaften, die die Ausrichtung eines Werkzeugs in der Hand eines Charakters spezifiziert. Dies stellt die `R02`, `R12` und `R22`-Werte der Grip-`Datatype.CFrame`-Rotationsmatrix dar.

Andere Eigenschaften von Werkzeugen, die steuern, wie ein Charakter ein Werkzeug hält, umfassen `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

Stellt die `R02`, `R12` und `R22`-Werte der Grip-`Datatype.CFrame`-Rotationsmatrix dar.


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, umfassen `Class.Tool.GripUp`, `Class.Tool.GripRight` und `Class.Tool.GripForward`. Alle diese Eigenschaften werden 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 spezifiziert. Dies stellt die `R00`, `R10` und `R20`-Werte der Grip-`Datatype.CFrame`-Rotationsmatrix dar.

Andere Eigenschaften von Werkzeugen, die steuern, wie ein Charakter ein Werkzeug hält, umfassen `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

Stellt die `R00`, `R10` und `R20`-Werte der Grip-`Datatype.CFrame`-Rotationsmatrix dar.


Eine der Eigenschaften, die die Ausrichtung eines Werkzeugs in der Hand eines Charakters spezifiziert. Dies stellt die `R01`, `R11` und `R21`-Werte der Grip-`Datatype.CFrame`-Rotationsmatrix dar.

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


Tool.GripUp

Stellt die `R01`, `R11` und `R21`-Werte der Grip-`Datatype.CFrame`-Rotationsmatrix dar.


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 auslösen, wenn `Class.Tool:Activate()` aufgerufen wird. Dies unterdrückt auch die Funktion `Class.ContextActionService:BindActivate()`.

Wenn auf `false` gesetzt, wird ein Mausklick (wenn das Werkzeug ausgerüstet ist) ebenfalls `Class.Tool.Activated` auslösen.


Tool.ManualActivationOnly

Steuert, ob das `Class.Tool` ohne Ausführung von `Class.Tool:Activate()` aktiviert werden kann.


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 in der Regel, dass der Spieler sie ausrüstet, um ein Objekt zu halten, um sie zu verwenden, zum Beispiel Waffen. Werkzeuge ohne Griffe erfordern in der Regel nicht, dass der Spieler sie ausrüstet, um irgendetwas zu halten, um sie zu verwenden, 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 Griff.


Tool.RequiresHandle

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


Die ToolTip-Eigenschaft steuert die Nachricht, die angezeigt wird, wenn die `Class.Mouse` des Spielers über das `Class.Tool` in ihrem `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 den ToolTip wie folgt setzen:

```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 ihrem Rucksack schwebt.


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


BackpackItem ist eine abstrakte Klasse für Rucksackobjekte wie HopperBins und
Tools.


BackpackItem

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

Dieses Property sollte auf die Inhalts-ID eines Bildes gesetzt werden, das auf die
Roblox-Website hochgeladen wurde. Nur Asset-URIs werden für dieses Property unterstützt.

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


BackpackItem.TextureContent

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


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

Dieses Property sollte auf die Inhalts-ID eines Bildes gesetzt werden, das auf die
Roblox-Website hochgeladen wurde.

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


BackpackItem.TextureId

Das Texturoikon, 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 Container-Objekte, was bedeutet, dass sie Objekte zusammenfassen. Sie werden
am besten verwendet, um Sammlungen von `Class.BasePart|BaseParts` zu halten und verfügen über eine Reihe
von Funktionen, die ihre Funktionalität erweitern.

Modelle sind dazu gedacht, **geometrische** Gruppierungen darzustellen. Wenn Ihre Gruppierung keine
geometrische Interpretation hat, beispielsweise 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`, da dies angibt, welches Teil innerhalb

des Modells der Drehpunkt und die Begrenzungsbox „folgen“ werden, während sich das Modell bewegt. Statische
Modelle, die an einem Ort bleiben, profitieren nicht davon, ein primäres Teil zu haben.

Modelle haben eine Vielzahl von Anwendungen, einschließlich der Charaktere von Roblox-Spielern.
Sie weisen auch eine Reihe einzigartiger Verhaltensweisen auf, die wichtig sind, um sie im
Auge zu behalten:

- Wenn ein `Class.Humanoid` und ein `Class.Part` mit dem Namen **Head** unter
  einem Modell verankert sind, wird ein Name/Gesundheits-GUI über dem Modell angezeigt; siehe
  [Charaktername/Gesundheitsanzeige](/characters/name-health-display)
  für Details.
- Wenn die Position eines Teils auf der **Y**-Achse den Wert
  `Class.Workspace.FallenPartsDestroyHeight` erreicht, und es das letzte Objekt
  innerhalb eines `Class.Model` war, wird auch das Modell zerstört.
- Wenn es in einem Ort mit aktivierten `Class.Workspace.StreamingEnabled` verwendet wird,
  steuert der Wert von `Class.Model.ModelStreamingMode|ModelStreamingMode`
  verschiedene Verhaltensweisen, wie das Modell und alle Nachkommen repliziert
  und/oder entfernt werden. Darüber hinaus beeinflusst der Wert von
  `Class.Model.LevelOfDetail|LevelOfDetail` das Rendering des Modells.

Wie bei allen `Class.Instance`-Typen garantiert die Tatsache, dass ein übergeordnetes `Class.Model`
zu einem Client repliziert wird, nicht, dass auch alle seine Kinder repliziert werden. Dies ist
besonders wichtig, wenn diese Instanzen von Code, der auf dem Client ausgeführt wird, verwendet werden,
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 vorhanden ist, oder Sie
können `Class.Instance:WaitForChild()|WaitForChild()` verwenden, wenn Atomicität nicht
gewünscht ist.

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

`Class.Model.ModelStreamingMode|ModelStreamingMode` muss auf
`Enum.ModelStreamingMode|PersistentPerPlayer` gesetzt werden, damit das Verhalten
sich infolge der Hinzufügung ändert.

Model:AddPersistentPlayer

playerInstance

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

Setzt dieses Modell so, dass es für den angegebenen Spieler persistent ist.
`Class.Model.ModelStreamingMode|ModelStreamingMode` muss auf
`Enum.ModelStreamingMode|PersistentPerPlayer` gesetzt werden, damit das Verhalten
sich infolge der Hinzufügung ändert.

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).

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

Wenn BreakJoints bei einem Player-Charakter-`Class.Model` verwendet wird, wird der
Humanoid des Charakters sterben, da er von dem Nacken-Gelenk abhängt.

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

Model:BreakJoints

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

Diese Funktion gibt eine Beschreibung eines Volumens zurück, das alle
`Class.BasePart`-Kinder innerhalb eines `Class.Model` enthält. Die Ausrichtung des Volumens
beruht auf der Ausrichtung des `Class.Model.PrimaryPart|PrimaryPart` und entspricht
auch dem Auswahlfeld, das im Studio angezeigt wird, wenn das Modell
ausgewählt ist. Ähnlich wie bei der Funktion `Class.Terrain:FillBlock()` gibt sie
ein `Datatype.CFrame` zurück, das das Zentrum dieses Begrenzungsfeldes darstellt,
und ein `Datatype.Vector3`, das seine Größe darstellt. Die Größe kann zur Laufzeit ungenau
sein, wenn physikalische Einschränkungen auf die Teile innerhalb des
`Class.Model` wirken.

Wenn es kein `Class.Model.PrimaryPart|PrimaryPart` für das Modell gibt, wird das
Begrenzungsfeld an den Weltachsen ausgerichtet.

```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 an das Begrenzungsfeld des Modells anpassen
part.Size = size
part.CFrame = orientation
```

Model:GetBoundingBox

Ein `Datatype.CFrame`, der die Orientierung des Volumens darstellt,
gefolgt von einem `Datatype.Vector3`, der 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 Begrenzungsbox zurück, die alle
`Class.BasePart|BaseParts` im `Class.Model` enthält. Wenn
`Class.Model.PrimaryPart` vorhanden ist, wird die Begrenzungsbox auf
dieses Teil ausgerichtet. Wenn kein primäres Teil gesetzt wurde, wählt die Funktion ein Teil im Modell aus, um
 die Begrenzungsbox auszurichten. Da die Auswahl dieses Teils nicht deterministisch ist, wird empfohlen, ein
`Class.Model.PrimaryPart` zu setzen, um konsistente Ergebnisse mit dieser Funktion zu erhalten.

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

Model:GetExtentsSize

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

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

Dieser Wert gab historisch den 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 aus einem `Class.Script` aufgerufen wird, gibt sie alle
`Class.Player`-Objekte zurück, für die dieses Modell persistent ist. Wenn sie aus einem
`Class.LocalScript` aufgerufen wird, überprüft diese Methode nur, ob dieses Modell persistent
ist für den `Class.Players.LocalPlayer|LocalPlayer`.

Model:GetPersistentPlayers

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

Gibt alle `Class.Player`-Objekte zurück, für die dieses Modellobjekt persistent ist.
Das Verhalten variiert je nachdem, ob diese Methode aus 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 fungiert 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 bei Gelegenheit.

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

Diese Funktion entspricht Folgendem:

    Model.PrimaryPart.CFrame

Beachten Sie, dass diese Funktion einen Fehler auslösen wird, wenn kein
primäres Teil für das `Class.Model` existiert. Wenn dieses Verhalten nicht gewünscht ist, können Entwickler
folgendes tun, was gleichwertig zu `nil` ist, wenn kein primäres Teil vorhanden ist.

    local cFrame = Model.PrimaryPart and Model.PrimaryPart.CFrame

Model:GetPrimaryPartCFrame

Gibt den `Datatype.CFrame` des `Class.Model.PrimaryPart` des Modells zurück.
Diese Funktion wird einen Fehler auslösen, wenn kein primäres Teil für das
`Class.Model` existiert.

Dieses Codebeispiel demonstriert den Ersatz eines Modells für alle Kopien eines Baum-Modells mit PivotTo und ScaleTo. Der Pivot und die Skalierung der Modelle werden als Referenz verwendet, um sicherzustellen, dass die relativen Größen und Positionen der Ersetzungsmodelle mit denen der Originals übereinstimmen.

Modelle enthalten einen persistenten kanonischen Skalierungsfaktor, der bei neu
erstellten Modellen zu Beginn auf 1 gesetzt ist und sich ändert, wenn das Modell durch den Aufruf
`Model/ScaleTo` skaliert wird. Diese Funktion gibt den aktuellen kanonischen Skalierungsfaktor
 des Modells zurück.

Der aktuelle Skalierungsfaktor beeinflusst nicht _direkt_ die Größe der Instanzen
unter dem Modell. Er wird für die Inhaltsautorisierung und Skripting-Zwecke verwendet,
um zu merken, wie das Modell relativ zu seiner ursprünglichen Größe skaliert wurde.

Innerhalb einer bestimmten Sitzung wird das Modell die präzisen Informationen zur ursprünglichen Größe
 der Nachkommeninstanzen nach dem ersten `Model/ScaleTo`-Aufruf zwischenspeichern. Das bedeutet, dass
der Aufruf von `ScaleTo(x)`, gefolgt von `ScaleTo(1)` Sie genau zu der ursprünglichen Konfiguration des Modells zurückbringt, ohne
float-Drift. Das Vermeiden von Float-Drift ist die Motivation für die Verwendung einer Scale**To**-Funktion
statt einer Scale**By**-Funktion.

Der Skalierungsfaktor hat in einer Hinsicht einen Einfluss auf das Verhalten der Engine: Der Skalierungsfaktor
 eines Modells wird auf Gelenkverlagerungen von `Class.Animation|animations` angewendet, die auf einem
`Class.AnimationController` unter diesem Modell abgespielt werden, sodass animierte Rigs Animationen korrekt
abspielen, selbst wenn sie skaliert sind.

Model:GetScale

Der aktuelle kanonische Skalierungsfaktor des Modells.

Gibt den kanonischen Skalierungsfaktor des Modells zurück, der bei neu
erstellten Modellen standardmäßig 1 beträgt und sich ändert, wenn es über
`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).

Die auf SurfaceType basierende Verbindung ist veraltet. Verwenden Sie MakeJoints nicht für neue
Projekte. Nutzen 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 planar berührenden Oberflächen,
abhängig von den Oberflächen der Teile.

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

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

Model:MakeJoints

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

Dieses Beispiel zeigt, wie Model:MoveTo Kollisionen vermeidet.

Ein einfaches, zweigeteiltes Modell wird erstellt und sein PrimaryPart wird gesetzt. Ein großes
Hindernis wird daneben platziert.

Nach 5 Sekunden wird Model:MoveTo verwendet, um das Modell zu bewegen, sodass es in das
Hindernis gelangt. Da MoveTo jedoch ein Modell nicht in ein
Hindernis bewegen kann, wird das Modell entlang der Y-Achse nach oben verschoben und über das
Hindernis platziert.

Bewegt das `Class.Model.PrimaryPart|PrimaryPart` an die angegebene Position. Wenn
 kein primäres Teil angegeben wurde, wird das Wurzelteil des Modells verwendet, aber
 das Wurzelteil ist nicht deterministisch, und es wird empfohlen, immer ein primäres Teil zu setzen,
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 nichts im Weg steht. Wenn dieses
Verhalten nicht gewünscht ist, sollte `Class.PVInstance:PivotTo()` stattdessen verwendet werden.

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

Model:MoveTo

position

Der `Datatype.Vector3`, zu dem das `Class.Model` bewegt wird.

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

Macht dieses Modell für den angegebenen Spieler nicht mehr persistent. Dies garantiert
nicht, dass das Modell sofort für den Spieler entfernt wird; nachdem
Sie diese Methode aufgerufen haben, wird das Modell als
`Enum.ModelStreamingMode|Atomic` für diesen Spieler behandelt und bleibt aktiv,
solang es sich innerhalb des Ziel-Streaming-Radius befindet.

`Class.Model.ModelStreamingMode|ModelStreamingMode` muss auf
`Enum.ModelStreamingMode|PersistentPerPlayer` gesetzt werden, damit sich das Verhalten
 aufgrund der Entfernung ändert.

Model:RemovePersistentPlayer

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

Macht dieses Modell für den angegebenen Spieler nicht mehr persistent.
`Class.Model.ModelStreamingMode|ModelStreamingMode` muss auf
`Enum.ModelStreamingMode|PersistentPerPlayer` gesetzt werden, damit sich das Verhalten
 aufgrund der Entfernung ändert.

Setzt die Drehung der Teile des Modells auf die zuvor festgelegte Identitätsdrehung zurück,
 die durch die `Class.Model:SetIdentityOrientation()`-Methode festgelegt wurde.

Model:ResetOrientationToIdentity

Modelle enthalten einen persistenten kanonischen Skalierungsfaktor, der zu Beginn für neu
erstellte Modelle auf 1 gesetzt ist. Diese Funktion skaliert das Modell um den Drehpunkt,
relativ dazu, wie es bei einem Skalierungsfaktor von 1 aussehen würde. Um dies zu erreichen, tut sie zwei Dinge:

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

Die Skalierung der Positionen erfolgt um den Drehpunkt.

Alle „geometrischen“ Eigenschaften von Nachkommen-Instanzen werden skaliert. Dazu gehören offensichtlich die Größen
von Teilen, aber hier sind einige weitere Beispiele für Eigenschaften, die skaliert werden:

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

Model:ScaleTo

newScaleFactor

Setzt den Skalierungsfaktor des Modells, wodurch die Größe und Position aller Nachkommen-Instanzen
 so angepasst werden, dass sie diesen Skalierungsfaktor relativ zu ihren ursprünglichen Größen und Positionen 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
`ResetOrientationToIdentity`-Methode zurücksetzen können.

Model:SetIdentityOrientation

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

Setzt den `Class.BasePart.CFrame` des primären Teils des Modells.
 Alle anderen Teile im Modell werden ebenfalls verschoben und behalten ihre
Orientierung und Verschiebung relativ zum `Class.Model.PrimaryPart`.

Beachten Sie, dass diese Funktion einen Fehler auslöst, wenn kein `Class.Model.PrimaryPart`
für das Modell vorhanden ist. Dies kann Probleme verursachen, wenn beispielsweise das primäre Teil
nie gesetzt oder zerstört wurde.

Model:SetPrimaryPartCFrame

cframe

Der `Datatype.CFrame`, der gesetzt werden soll.

Setzt den `Class.BasePart.CFrame` des primären Teils des Modells.
 Alle anderen Teile im Modell werden ebenfalls verschoben und behalten ihre
Orientierung und Verschiebung relativ zum `Class.Model.PrimaryPart`.

Dieses Beispiel zeigt, wie Model:TranslateBy Kollisionen ignoriert und die Orientierung des Modells respektiert.

Ein einfaches zweigeteiltes Modell wird erstellt, um 45 Grad entlang der Y-Achse rotiert und sein
PrimaryPart wird festgelegt. Ein großes Hindernis wird daneben platziert.

Nach 5 Sekunden wird Model:TranslateBy verwendet, um das Modell zu bewegen, sodass es in das
Hindernis eindringt. Das Modell wird in das Hindernis hineinbewegt und
beibehält seine aktuelle Orientierung.

Verschiebt ein `Class.Model` um den gegebenen `Datatype.Vector3`-Offset, wobei die
Orientierung des Modells beibehalten wird. Wenn ein anderes `Class.BasePart` oder `Class.Terrain`
bereits an der neuen Position existiert, wird das `Class.Model` über dieses Objekt gelegt.

Die Verschiebung erfolgt im Welt-Space statt im Objekt-Space,
was bedeutet, dass auch wenn die Teile des Modells unterschiedlich orientiert sind, es dennoch entlang den
Standardachsen bewegt wird.

Model:TranslateBy

delta

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

Verschiebt ein `Class.Model` um den angegebenen `Datatype.Vector3`-Offset, wobei die
Orientierung des Modells beibehalten wird. Wenn ein anderes `Class.BasePart` oder `Class.Terrain`
bereits an der neuen Position existiert, wird das `Class.Model` über dieses Objekt gelegt.

Model:breakJoints

Model:makeJoints

Model:move

location

Model:moveTo

Model

Legt das Detailniveau des Modells für Erfahrungen mit aktivierten
[Streaming](/workspace/streaming) fest.

Wenn es auf `Enum.ModelLevelOfDetail|StreamingMesh` gesetzt ist, wird ein
niedrigauflösendes "Imposter"-Mesh (farbiges, grobes Mesh, das alle
Kindteile des Modells umschließt) außerhalb des Streaming-Radius
gerendert.

Wenn es auf `Enum.ModelLevelOfDetail|SLIM` gesetzt ist, wird ein skalierbares,
leichtgewichtiges interaktives Modell oder SLIM-Modell (eine Komponente
aller Kindteile des Modells) in progressiv niedrigeren Auflösungen in
Abhängigkeit vom Streaming-Radius gerendert. Dies verbessert die visuelle
Qualität erheblich im Vergleich zu `StreamingMesh`.

Wenn es auf `Enum.ModelLevelOfDetail|Disabled` oder
`Enum.ModelLevelOfDetail|Automatic` gesetzt ist, werden niedrigauflösende
Meshes nicht angezeigt.


Model.LevelOfDetail

Legt das Detailniveau des Modells für Erlebnisse fest, bei denen das
Instanz-Streaming aktiviert ist.

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

Diese Eigenschaft sollte nur im Studio über das
[Properties](/studio/properties)-Fenster geändert werden, wenn das Streaming aktiv ist,
oder in `Class.Script|Scripts`, jedoch niemals in
`Class.LocalScript|LocalScripts` (so kann undefined behavior entstehen).

Model.ModelStreamingMode

Steuert das Streaming-Verhalten des Modells, wenn
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.

Zeigt auf das primäre Teil des `Class.Model`. Das primäre Teil ist das
`Class.BasePart`, das als physikalische Referenz für den Drehpunkt des Modells fungiert. Das heißt, wenn Teile innerhalb des Modells durch physikalische
Simulation oder andere Mittel bewegt werden, wird sich der Drehpunkt synchron mit dem primären Teil bewegen.

Beachten Sie, dass `Class.Model|Models` standardmäßig keinen `PrimaryPart` gesetzt haben.
Wenn Sie ein Modell erstellen, das durch Physik beeinflusst werden muss, sollten Sie
diese Eigenschaft manuell im Studio oder innerhalb eines Skripts setzen. Wenn das
primäre Teil **nicht** gesetzt ist, bleibt der Drehpunkt an der gleichen Stelle im
Weltraum, selbst wenn Teile innerhalb des Modells bewegt werden.

Beachten Sie auch, dass beim Setzen dieser Eigenschaft, es sich um ein `Class.BasePart`
handeln muss, das ein Nachkomme des Modells ist. Wenn Sie versuchen, `Class.Model.PrimaryPart`
auf ein `Class.BasePart` zu setzen, das **kein** Nachkomme des Modells ist, wird es auf dieses Teil gesetzt, aber beim nächsten Simulationsschritt auf `nil` zurückgesetzt – dies ist ein veraltetes Verhalten, um Skripte zu unterstützen,
die davon ausgehen, dass sie das primäre 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 über physikalische Gelenke wie
  `Class.WeldConstraint|WeldConstraints` oder `Class.Motor6D|Motor6Ds`
  miteinander verbunden sind, sollten ein primäres Teil zugewiesen bekommen. Beispielsweise haben Roblox-Charaktermodelle ihr `Class.Model.PrimaryPart`
  standardmäßig auf das **HumanoidRootPart** gesetzt.
- Statische (normalerweise `Class.BasePart.Anchored|Anchored`) Modelle, die an einem Ort bleiben,
  es sei denn, ein Skript bewegt sie explizit, benötigen kein
  `Class.Model.PrimaryPart` und profitieren in der Regel nicht von einem gesetzten.

Model.PrimaryPart

Das primäre Teil des `Class.Model`, oder `nil`, wenn nicht explizit gesetzt.

Das Setzen dieser Eigenschaft im Eigenschaftenfenster skaliert das Modell,
als ob `Model/ScaleTo` auf es aufgerufen wurde, und skaliert alle Nachkommen-Instanzen
im Modell, wie Materialien, Bilder und die 3D-Geometrie der Teile, 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
`Script` oder `LocalScript` verwendet wird. `Model/ScaleTo` und `Model/GetScale`
sollten aus Skripten verwendet werden.

Model.Scale

Editor-eigenschaft, die verwendet wird, um das Modell um seinen Drehpunkt zu skalieren. Das Setzen
 dieser Eigenschaft bewirkt eine Skalierung, als ob `Model/ScaleTo` auf
 es aufgerufen wurde.

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 der Drehpunkt eines `Class.Model` liegt, das
**nicht** über ein `Class.Model.PrimaryPart` verfügt. Wenn das
`Class.Model` **doch** ein `Class.Model.PrimaryPart|PrimaryPart` hat, ist der
Drehpunkt des `Class.Model` gleich dem Drehpunkt dieses primären Teils,
 und diese `Class.Model.WorldPivot|WorldPivot`-Eigenschaft wird ignoriert.

Für ein neu erstelltes `Class.Model` wird sein Drehpunkt als der Mittelpunkt
 der Begrenzungsbox seines Inhalts betrachtet, bis die **erste** Einstellung seiner
`Class.Model.WorldPivot`-Eigenschaft erfolgt. Sobald der Welt-Drehpunkt zum
ersten Mal gesetzt wurde, ist es unmöglich, dieses ursprüngliche Verhalten wiederherzustellen.

Am häufigsten bewirken das Verschieben des Modells mit den Studio-Tools oder mit Modellbewegungsfunktionen wie
`Class.PVInstance:PivotTo()` und
`Class.Model:MoveTo()`, dass der Welt-Drehpunkt gesetzt wird und somit dieses neue
Modellverhalten endet.

Der Zweck dieses Verhaltens ist es, Luau-Code zu ermöglichen, einen sinnvollen Drehpunkt
einfach zu erhalten, indem man ein neues Modell erstellt und Objekte daran anheftet,
und die Notwendigkeit, jedes Mal, wenn Sie ein Modell im Code erstellen, `Class.Model.WorldPivot`
explizit zu setzen, zu vermeiden.

```
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 Mittelpunkt der Begrenzungsbox, die "BluePart" und "RedPart"
hält

model:PivotTo(CFrame.new(0, 10, 0))  -- Dies funktioniert, ohne "model.WorldPivot" explizit setzen zu müssen
```

Model.WorldPivot

Bestimmt, wo der Drehpunkt eines `Class.Model` liegt, das **nicht** über ein
`Class.Model.PrimaryPart` verfügt.

Modelle sind Container-Objekte, was bedeutet, dass sie Objekte zusammenfassen. Sie werden
am besten verwendet, 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` ("Position Velocity Instances") und 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 nun an der
gespecifizierten `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 ihre
`Datatype.CFrame` durch den notwendigen Offset transformiert wird.
`Class.Model|Models` werden auf diese Weise bewegt, indem ihr
`Class.Model.WorldPivot` durch den notwendigen Offset transformiert wird.

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

Beim Aufrufen von `Class.PVInstance:PivotTo()|PivotTo` auf `Class.Model|Models`
werden die Offsets der Abkömmlinge Teile und Modelle zwischen den Aufrufen
von `Class.PVInstance:PivotTo()|PivotTo` auf dasselbe Modell
nicht mehr angehäuft, sodass kein Abdrift des Floating Point zwischen den
Teilen des Modells auftritt.

`Class.Model|Models` und `Class.BasePart|BaseParts` sind beide
`Class.PVInstance|PVInstances` ("Position Velocity Instances") und haben beide
 diese Funktion.


PVInstance:PivotTo

targetCFrame

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


Transformiert die `Class.PVInstance` zusammen mit allen ihren Nachkommen
`Class.PVInstance|PVInstances`, sodass der Pivot nun an der
gespecifizierten `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,
und kann Teil des `Class.DataModel`-Baums sein.

Es ist nicht möglich, Root-`Instance`-Objekte direkt zu erstellen, aber der spezielle
`Datatype.Instance.new()`-Konstruktor erstellt Objekte über Code, wobei der
Name der Klasse als Parameter übergeben wird und das erstellte Objekt zurückgegeben wird.

Demonstriert die Erkennung von Änderungen in der Abstammung einer Instanz, indem die `Class.Instance.AncestryChanged`-Ereignis verbunden wird.

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

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

Dieses Ereignis enthält zwei Parameter: `child` bezieht sich auf die `Class.Instance`,
dessen `Class.Instance.Parent` tatsächlich geändert wurde, während `parent` sich auf die
e neue `Class.Instance.Parent` bezieht.

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

Instance.AncestryChanged

child

Die `Class.Instance`, deren `Class.Instance.Parent` geändert wurde.

parent

Der neue `Class.Instance.Parent` der `Class.Instance`, deren
`Class.Instance.Parent` geändert wurde.

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

Dieses Ereignis wird ausgelöst, wenn ein beliebiges Attribut an der Instanz geändert wird,
 einschließlich 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()`,
die ausgelöst wird, wenn eines der Attribute des Parts geändert wird:

```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 Attribut geändert wird.

Instance.AttributeChanged

attribute

Der Name des Attributs, das geändert wurde.

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

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

Ausgelöst, nachdem ein Objekt diesem `Class.Instance` zugeordnet wurde.

Beachten Sie, dass es notwendig ist, `Class.Instance:WaitForChild()` zu verwenden, wenn
der Client verwendet wird, um Objekte zu erkennen, die vom Server erstellt wurden,
beim Indizieren der Nachkommen dieser Objekte. Das liegt daran, dass das Objekt und
seine Nachkommen nicht gleichzeitig vom Server an den 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)
```
Beachten Sie, dass dieses Ereignis nur für unmittelbare Kinder der
`Class.Instance` funktioniert. 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 in diese `Class.Instance` eingefügt wird.

Instance

`Instance` ist die Basisklasse für alle Klassen in der Roblox-Klassenhierarchie
und kann Teil des `Class.DataModel`-Baums sein.

Flag

Zusammenfassung

Eigenschaften

Eigenschaften

Eigenschaften

Eigenschaften

Eigenschaften

Methoden

Methoden

Methoden

Methoden

Events

Events

Eigenschaften

Methoden

Events

Auf dieser Seite