Le Flag est une unité spawnée avec un objet `Class.FlagStand`, et sera réapparu
lorsqu'il est capturé. Lorsqu'un joueur touche la Poignée de cet objet, qui doit être un
enfant de l'objet Flag, qui est une Partie nommée "Handle", le drapeau sera
ajouté au sac à dos du joueur et apparaîtra dans sa main. Un joueur ne peut pas
sélectionner d'autres armes tout en portant un drapeau, et peut abandonner le drapeau à tout moment
en appuyant sur "Backspace" sur le clavier. Si le joueur portant un drapeau met
les pieds sur un autre FlagStand d'une couleur d'équipe différente, le drapeau sera retiré
du sac à dos du joueur et un point sera ajouté aux leaderstats de l'utilisateur,
s'il y en a. Le drapeau se régénérera alors au stand de drapeau d'origine.


Flag

L'`Class.Team` pour lequel ce drapeau est destiné. Correspond aux TeamColors dans le
service `Class.Teams`.

Les objets `Class.Flag` et `Class.FlagStand` ont été créés pour permettre
aux développeurs de créer rapidement des jeux de style 'capture le drapeau'.


Flag.TeamColor

L'`Class.Team` pour lequel ce drapeau est destiné. Correspond aux TeamColors dans le
service `Class.Teams`.


L'objet Flag vous aide à créer des jeux de style 'capture le drapeau'.


Ce code doit être placé dans un Script au sein d'un Outil. Il permet à un joueur
de faire apparaître des explosions en équipant l'outil et en cliquant sur le sol. Il le fait
en définissant une fonction, `explode`, qui crée une explosion non mortelle à
un point donné. Ensuite, il définit une fonction, `onActivated`, qui s'exécute lorsque l'
outil est activé. Enfin, il connecte l'événement Activated de l'outil à la
fonction `onActivated`.

Pour tester ce code, essayez de créer un Outil et de mettre une Partie à l'intérieur. Nommez la
Partie "Handle". Ensuite, mettez un Script à l'intérieur de l'Outil et collez le code à l'intérieur.
Enfin, mettez l'Outil dans le StarterPack.

Cet exemple de code est pour un objet Outil avec une Partie nommée Poignée. Il détecte
quand des Humanoïdes autres que le détenteur actuel touchent la poignée, et leur inflige
quelques dégâts. De plus, lorsque l'Outil est activé, il déclenche une animation de coup
dans les scripts d'animation par défaut du personnage. Essayez ce script en
créant un objet Outil dans le StarterPack. Mettez une Partie à l'intérieur, et nommez-la
Poignée. Collez ce code dans un Script à l'intérieur de l'Outil, puis essayez de frapper
un autre Humanoïde !

Un `Tool` est un objet qu'un objet `Class.Humanoid` peut équiper. Pour les joueurs,
il est stocké dans un objet `Class.Backpack` parenté à un objet `Class.Player`
. Dans l'expérience, les joueurs peuvent avoir plusieurs outils qui apparaissent comme des icônes
en bas de l'écran. Équiper un outil le déplace du
`Class.Backpack` dans un modèle `Class.Player.Character` dans le
`Class.Workspace`. Par défaut, les outils sont tenus dans la main droite et ont un
manche en eux, qui est une `Class.BasePart` nommée `Handle` à l'intérieur (bien qu'
'un ne soit pas requis si `Class.Tool.RequiresHandle` est `false`). Les outils à fournir aux
joueurs (ré)apparaissants doivent être stockés dans le
`Class.StarterPack`.


Cet événement se déclenche lorsque le joueur clique alors que le `Class.Tool` est
equipé. Il **n'est pas** déclenché si la touche <kbd>Ctrl</kbd> est pressée lors
du clic.

Cet événement est généralement utilisé pour effectuer une action lorsque le joueur utilise l'outil, par exemple pour lancer une fusée depuis un outil d'arme de lance-roquettes.

Le code ci-dessous, lorsqu'il est placé dans un `Class.LocalScript`, crée un outil dans
le `Class.Backpack` du joueur local et imprime "Outil activé" lorsque le
joueur clique alors que l'outil créé est équipé.

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

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

function onActivation()
	print("Outil activé")
end

tool.Activated:Connect(onActivation)
```


Tool.Activated

Se déclenche lorsque le joueur clique alors que l'outil est équipé.


Cet événement se déclenche lorsque le joueur relâche son clic alors que le
`Class.Tool` est équipé et activé. Il est généralement utilisé pour effectuer une
action lorsque le joueur cesse d'utiliser un outil.

Le code ci-dessous, lorsqu'il est placé dans un `Class.LocalScript`, crée un outil dans
le `Class.Backpack` du joueur local et imprime "Outil désactivé" lorsque le
joueur relâche son clic alors que l'outil est équipé et activé.

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

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

function toolDeactivated()
	print("Outil désactivé")
end

tool.Deactivated:Connect(toolDeactivated)
```


Tool.Deactivated

Se déclenche lorsque le joueur relâche son clic alors que l'outil est équipé et
activé.


L'exemple montré ci-dessous imprimera "Un outil a été équipé" chaque fois que l'outil est
equipé par le joueur. Veuillez noter que l'exemple ci-dessous suppose que vous avez
déjà défini ce qu'est "Outil".

Cet événement se déclenche lorsqu'un joueur équipe le `Class.Tool` (le sort de
tableau `Class.Backpack`).

L'opposé de cet événement, `Class.Tool.Unequipped`, peut être utilisé pour
déterminer quand le joueur déséquipe l'outil en le remettant dans son
backpack.

Notez que cet événement ne se déclenche **pas** lorsque `Class.Tool.RequiresHandle` est
enabled et qu'aucun manche n'est présent.


Tool.Equipped

mouse

Se déclenche lorsque l'outil est équipé.


Cet événement se déclenche lorsqu'un joueur déséquipe le `Class.Tool` (le remet dans son
`Class.Backpack`).

L'opposé de cet événement, `Class.Tool.Equipped`, peut être utilisé pour
déterminer quand le joueur équipe l'outil en le sortant de son
backpack.

Notez que cet événement ne se déclenche **pas** lorsque `Class.Tool.RequiresHandle` est
enabled et qu'aucun manche n'est présent.


Tool.Unequipped

Se déclenche lorsque l'outil est déséquipé.


Le code ci-dessous crée un `Class.Tool` dans le `Class.Backpack` du joueur local
qui rend le joueur invisible lorsqu'il est activé et visible lorsqu'il est désactivé.

Lorsqu'il est équipé, le script simule l'activation de l'outil et rend le
joueur invisible pendant 3 secondes, puis simule la désactivation de l'outil.
Maintenir le bouton gauche de la souris enfoncé rend le joueur invisible jusqu'à 3
secondes, avec une période de recharge de 1 seconde, ou jusqu'à ce que le joueur relâche
tu le bouton gauche de la souris.

Cette fonction simule l'activation du `Class.Tool`. L'outil doit être
équipé pour que cette fonction fonctionne.


Tool:Activate

Cette fonction simule la désactivation du `Class.Tool`. L'outil doit être
équipé pour que cette fonction fonctionne.


Tool:Deactivate

Simule la désactivation du `Class.Tool`.


Tool

La propriété CanBeDropped contrôle si le joueur peut lâcher le
`Class.Tool`.

Si vrai, lorsque la touche de retour arrière est pressée, l'outil sera parenté
à `Class.Workspace` et retiré du `Class.Backpack` du joueur. Si
faux, rien ne se passera lorsque la touche de retour arrière est pressée, et l'outil
resterait équipé.


Tool.CanBeDropped

Contrôle si le joueur peut lâcher l'outil.


Le code ci-dessous crée `Class.Tool` dans le `Class.Backpack` du joueur local
qui augmente son `Class.Humanoid.JumpPower|JumpPower`
de `50` à `150` pendant 5 secondes.

Cet exemple utilise la propriété `Class.Tool.Enabled` de l'outil comme un débounce en
mettant la propriété à `true` lorsque le joueur saute et à `false` après
la durée de 5 secondes.

Déséquiper l'outil empêche également le joueur de faire un super saut en ramenant le
`Class.Humanoid.JumpPower|JumpPower` à `50`.

La propriété **Enabled** est relative à savoir si le `Class.Tool` peut être
utilisé. Cela est utile si vous souhaitez empêcher un joueur d'utiliser un outil,
mais ne souhaitez pas le retirer de son `Class.Backpack`.

Lorsqu'elle est définie sur `true`, le joueur peut utiliser l'outil. Lorsqu'elle est définie sur `false`, l'outil est désactivé et le joueur ne peut pas l'utiliser ; cela empêche l'outil d'
être activé ou désactivé par les méthodes `Class.Tool:Activate()` et
`Class.Tool:Deactivate()`, et cela empêche les événements
`Class.Tool.Activated` et `Class.Tool.Deactivated` de se déclencher.


Tool.Enabled

Relatif à savoir si l'outil peut être utilisé ou non.


Le code ci-dessous insère un `Class.Tool` nommé **Stick** dans le `Class.BackPack` du
joueur local. Lorsque le joueur active l'outil, le code imprime les
valeurs des propriétés de prise de l'outil.

La propriété `Grip` stocke les propriétés de "prise" de l'outil sous un
`Datatype.CFrame`. Ces propriétés déterminent comment le joueur tient l'outil
et incluent `Class.Tool.GripUp|GripUp`, `Class.Tool.GripRight|GripRight`,
`Class.Tool.GripForward|GripForward`, et `Class.Tool.GripPos|GripPos`.


Tool.Grip

Stocke les propriétés de "prise" de l'outil sous un `Datatype.CFrame`.


Une des propriétés qui spécifie l'orientation d'un outil dans la main d'un
personnage. Cela représente les valeurs `R02`, `R12` et `R22` de la matrice de rotation
`Datatype.CFrame` de la prise.

D'autres propriétés d'outil qui contrôlent comment un personnage tient un outil incluent
`Class.Tool.GripUp`, `Class.Tool.GripRight`, et `Class.Tool.GripPos`. Toutes
ces propriétés sont stockées dans un seul `Datatype.CFrame` dans la
propriété `Class.Tool.Grip`.


Tool.GripForward

Représente les valeurs `R02`, `R12` et `R22` de la matrice de rotation
`Datatype.CFrame` de la prise.


Cette propriété contrôle le décalage positionnel de la matrice de soudure de l'outil. Il
s'agit de l'une des plusieurs propriétés utilisées pour positionner comment le personnage du joueur
tient l'outil.

D'autres propriétés qui contrôlent comment un personnage tient un outil incluent
`Class.Tool.GripUp`, `Class.Tool.GripRight`, et `Class.Tool.GripForward`.
Toutes ces propriétés sont stockées dans un seul `Datatype.CFrame` dans la
propriété `Class.Tool.Grip`.


Tool.GripPos

Le décalage positionnel de la matrice de soudure de l'outil.


Une des propriétés qui spécifie l'orientation d'un outil dans la main d'un
personnage. Cela représente les valeurs `R00`, `R10` et `R20` de la matrice de rotation
`Datatype.CFrame` de la prise.

D'autres propriétés d'outil qui contrôlent comment un personnage tient un outil incluent
`Class.Tool.GripUp`, `Class.Tool.GripForward`, et `Class.Tool.GripPos`.
Toutes ces propriétés sont stockées dans un seul `Datatype.CFrame` dans la
propriété `Class.Tool.Grip`.


Tool.GripRight

Représente les valeurs `R00`, `R10` et `R20` de la matrice de rotation
`Datatype.CFrame` de la prise.


Une des propriétés qui spécifie l'orientation d'un outil dans la main d'un
personnage. Cela représente les valeurs `R01`, `R11` et `R21` de la matrice de rotation
`Datatype.CFrame` de la prise.

D'autres propriétés d'outil qui contrôlent comment un personnage tient un outil incluent
`Class.Tool.GripRight`, `Class.Tool.GripForward`, et
`Class.Tool.GripPos`. Toutes ces propriétés sont stockées dans un seul
`Datatype.CFrame` dans la propriété `Class.Tool.Grip`.


Tool.GripUp

Représente les valeurs `R01`, `R11` et `R21` de la matrice de rotation
`Datatype.CFrame` de la prise.


L'exemple de code ci-dessous crée `Class.Tool` dans le `Class.Backpack` du joueur local
qui augmente sa `Class.Humanoid.Walkspeed|WalkSpeed`
de `16` à `30` pendant 5 secondes.

Cet exemple utilise la propriété `Class.Tool.ManualActivationOnly` de l'outil comme un
déclencheur en définissant la propriété sur `true` lorsque le joueur commence à sprinter
et sur `false` lorsque le joueur arrête de sprinter. En conséquence, lorsque le joueur
est en train de sprinter, l'outil ne peut pas être réactivé.

Déquiper l'outil empêche également le joueur de sprinter en changeant le
`Class.Humanoid.Walkspeed|WalkSpeed` à `16`.

Cette propriété contrôle si le `Class.Tool` peut être activé sans
exécuter explicitement `Class.Tool:Activate()` dans un script.

Lorsqu'elle est définie sur `true`, l'outil ne déclenchera `Class.Tool.Activated` que lorsque
`Class.Tool:Activate()` est appelé. Cela supprime également la
fonction `Class.ContextActionService:BindActivate()`.

Lorsqu'elle est définie sur `false`, les clics de souris (lorsque l'outil est équipé) déclencheront également
`Class.Tool.Activated`.


Tool.ManualActivationOnly

Contrôle si le `Class.Tool` peut être activé sans exécuter
`Class.Tool:Activate()`.


Cette propriété détermine si un `Class.Tool` fonctionne sans un
manche.

Un outil a un manche lorsqu'il contient une pièce enfant nommée **Handle**. Les outils
avec des manches nécessitent généralement que le joueur qui les équipe tient un objet
pour les utiliser, par exemple des armes. Les outils sans manches ne nécessitent généralement pas que le joueur
les équipe pour tenir quoi que ce soit pour les utiliser, par
exemple des outils "fly" ou "summon".

Lorsqu'elle est définie sur `true`, l'outil fonctionnera uniquement avec un manche. Lorsqu'elle est
définie sur `false`, l'outil fonctionnera même sans manche.


Tool.RequiresHandle

Détermine si un `Class.Tool` fonctionne sans un manche.


La propriété ToolTip contrôle le message qui sera affiché lorsque la
`Class.Mouse` du joueur survole le `Class.Tool` dans son
`Class.Backpack`.

En général, la valeur de cette propriété doit décrire ce qu'est
l'outil ou son utilisation. Par exemple, pour un outil de pelle, vous pouvez choisir de définir le
ToolTip sur :

```lua
tool.ToolTip = "Pelle"
```
ou

```lua
tool.ToolTip = "Utiliser pour creuser"
```
ou

```lua
tool.ToolTip = "Pelle - Utiliser pour creuser"
```


Tool.ToolTip

Contrôle le message affiché lorsque la souris du joueur survole l'outil dans son
backpack.


Un objet, tel qu'une arme, qui peut être équipé par un `Class.Humanoid`.


BackpackItem est une classe abstraite pour les objets de sac à dos tels que HopperBins et
Outils.


BackpackItem

L'icône de texture qui est affichée pour un outil dans le sac à dos du joueur.

Cette propriété doit être définie sur l'ID de contenu d'une image téléchargée sur le
site Web de Roblox. Seules les URI d'actif sont prises en charge pour cette propriété.

Si cette propriété est laissée vide, le GUI `Class.Backpack` affichera le
nom de l'outil à la place.


BackpackItem.TextureContent

L'icône de texture qui est affichée pour un outil dans le sac à dos du joueur.
Ne prend en charge que les URI d'actif.


L'icône de texture qui est affichée pour un outil dans le sac à dos du joueur.

Cette propriété doit être définie sur l'ID de contenu d'une image téléchargée sur le
site Web de Roblox.

Si cette propriété est laissée vide, le GUI `Class.Backpack` affichera le
nom de l'outil à la place.


BackpackItem.TextureId

L'icône de texture qui est affichée pour un outil dans le sac à dos du joueur.


L'exemple suivant comprend une fonction de base qui prend une table d'objets
et les parenté dans un nouveau modèle, retournant ce modèle.

Les modèles sont des objets conteneurs, ce qui signifie qu'ils regroupent des objets. Ils sont
meilleures utilisées pour contenir des collections de `Class.BasePart|BaseParts` et disposent d'un certain
nombre de fonctions qui étendent leur fonctionnalité.

Les modèles sont destinés à représenter des regroupements **géométriques**. Si votre regroupement n'a
aucune interprétation géométrique, par exemple une collection de
`Class.Script|Scripts`, utilisez un `Class.Folder` à la place.

Les modèles dont les parties constitutives sont reliées entre elles par des joints (si bien qu'elles
peuvent se déplacer ou être détruites via la simulation physique) ont généralement un
`Class.Model.PrimaryPart|PrimaryPart` défini, car il spécifie quelle partie à l'intérieur
modèle le pivot et la boîte de délimitation suivront » alors que le modèle se déplace. Les modèles
statique qui restent au même endroit ne bénéficient pas d'une partie principale définie.

Les modèles ont une large gamme d'applications, y compris les personnages de joueur Roblox.
Ils ont également un certain nombre de comportements uniques qu'il est important de garder à l'esprit :

- Lorsque `Class.Humanoid` et une `Class.Part` nommée **Head** sont parentés sous
  un modèle, un GUI de nom/santé apparaîtra au-dessus du modèle ; voir
  [Affichage du Nom/Santé du Personnage](/characters/name-health-display)
  pour plus de détails.
- Si la position d'une partie sur l'axe **Y** atteint la
  valeur `Class.Workspace.FallenPartsDestroyHeight`, et que c'était le dernier objet
  à l'intérieur d'un `Class.Model`, le modèle sera également détruit.
- Lorsqu'il est utilisé dans un endroit avec `Class.Workspace.StreamingEnabled` défini sur vrai,
  la valeur de `Class.Model.ModelStreamingMode|ModelStreamingMode` contrôle
  divers comportements concernant la façon dont le modèle et les descendants sont répliqués
  et/ou retirés des clients. De plus, la valeur de
  `Class.Model.LevelOfDetail|LevelOfDetail` impacte le rendu du modèle.

Comme pour tous les types `Class.Instance`, le fait qu'un parent `Class.Model` soit
répliqué sur un client ne garantit pas que tous ses enfants soient
répliqués. Ceci est particulièrement important si ces instances sont accessibles par un code s'exécutant sur le client, comme dans un `Class.LocalScript`.
Utiliser `Class.Model.ModelStreamingMode|ModelStreamingMode` avec des valeurs telles que
`Enum.ModelStreamingMode|Atomic` peut garantir que le modèle entier et tous ses descendants sont présents si le modèle parent existe sur le client, ou vous
pouvez utiliser `Class.Instance:WaitForChild()|WaitForChild()` lorsque l'atomicité n'est pas
souhaitée.

Rend ce modèle persistant pour le joueur spécifié. Les modèles persistants
restent présents pour le joueur indépendamment des paramètres ou conditions de streaming.

`Class.Model.ModelStreamingMode|ModelStreamingMode` doit être défini sur
`Enum.ModelStreamingMode|PersistentPerPlayer` pour que le comportement change
suite à l'ajout.

Model:AddPersistentPlayer

playerInstance

Le `Class.Player` pour rendre ce modèle persistant.

Rend ce modèle persistant pour le joueur spécifié.
`Class.Model.ModelStreamingMode|ModelStreamingMode` doit être défini sur
`Enum.ModelStreamingMode|PersistentPerPlayer` pour que le comportement change
suite à l'ajout.

Dans cet exemple, les articulations de chaque Modèle de personnage ajouté seront cassées
3 secondes après l'apparition. Casser ces articulations fera mourir le Humanoïde.

Cet exemple de code montre la création manuelle de joints sur deux pièces qui sont
sœurs du script (PartA et PartB). Il crée des joints sur deux pièces touchant
avec des types de surface compatibles (Studs et Inlet).

Brise les connexions entre `BaseParts`, y compris les connexions de surface avec
les parties adjacentes, `Class.WeldConstraint|WeldConstraints`, et toutes
`Class.Weld|Welds` et autres `Class.JointInstance|JointInstances`.

Lorsque BreakJoints est utilisé sur un personnage joueur `Class.Model`, le
`Class.Humanoid` du personnage mourra car il dépend du joint de cou.

Notez que bien que les joints produits par des connexions de surface avec des
parties adjacentes puissent techniquement être recréés en utilisant `Class.Model:MakeJoints()`, cela
ne recréera que les joints produits par des surfaces. Les développeurs ne devraient pas compter
là-dessus car, après la rupture des joints, les parties ne seront peut-être plus en
contact les unes avec les autres.

Model:BreakJoints

Brise les connexions entre `BaseParts`, y compris les connexions de surface avec
les parties adjacentes, `Class.WeldConstraint|WeldConstraints` et toutes
`Class.Weld|Welds` et autres `Class.JointInstance|JointInstances`.

Model:breakJoints

Cette fonction renvoie une description d'un volume qui contient tous
les enfants `Class.BasePart` à l'intérieur d'un `Class.Model`. L'orientation du volume
dépend de l'orientation de la `Class.Model.PrimaryPart|PrimaryPart`,
et correspond à la boîte de sélection rendue dans Studio lorsque le modèle est
sélectionné. Miroitant le comportement de `Class.Terrain:FillBlock()`, elle
renvoie un `Datatype.CFrame` représentant le centre de cette boîte de délimitation
et un `Datatype.Vector3` représentant sa taille. La taille peut être inexacte
au moment de l'exécution si des contraintes physiques agissent sur les parties à l'intérieur du
`Class.Model`.

L'orientation de la boîte de délimitation correspond à l'orientation de la
`Class.PVInstance.GetPivot|Pivot` - soit le pivot de la
`Class.Model.PrimaryPart|PrimaryPart` (s'il est présent) ou le
`Class.Model.WorldPivot|WorldPivot` du modèle.

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

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

-- Redimensionnez et positionnez la partie égale à la boîte de délimitation du modèle
part.Size = size
part.CFrame = orientation
```

Model:GetBoundingBox

Un `Datatype.CFrame` représentant l'orientation du volume
suivi d'un `Datatype.Vector3` représentant la taille du volume.

Renvoie une description d'un volume qui contient toutes les parties d'un Modèle.

L'exemple de code ci-dessous démontre comment Model.GetExtentsSize peut être utilisé pour obtenir
la taille de la boîte englobante contenant les pièces.

Renvoie la taille de la plus petite boîte de délimitation qui contient toutes les
`Class.BasePart|BaseParts` dans le `Class.Model`. L'orientation correspond à
l'orientation de la `Class.PVInstance.GetPivot|Pivot` - soit le
pivot de la `Class.Model.PrimaryPart|PrimaryPart` (s'il est présent) ou le
`Class.Model.WorldPivot|WorldPivot` du modèle.

Notez que cette fonction ne renvoie que la taille de la plus petite boîte de délimitation, et
le développeur doit utiliser sa propre méthode pour obtenir la position de la
boîte de délimitation.

Model:GetExtentsSize

Les dimensions `Datatype.Vector3` de la `Class.Model`.

Renvoie la taille de la plus petite boîte de délimitation qui contient toutes les
`Class.BasePart|BaseParts` dans le `Class.Model`, alignée avec le
`Class.Model.PrimaryPart` si celui-ci est défini.

Cette valeur renvoyait historiquement le CFrame d'une position centrale dans le
modèle.

Model:GetModelCFrame

Ce code créerait un modèle, y placerait des pièces, les positionnerait au hasard,
et imprimerait sa taille :

La fonction GetModelSize renvoie la taille `Datatype.Vector3` du
`Class.Model`.

Model:GetModelSize

Lorsque cette méthode est appelée à partir d'un `Class.Script`, elle renvoie tous les
objets `Class.Player` pour lesquels ce modèle est persistant. Lorsqu'elle est appelée à partir d'une
`Class.LocalScript`, cette méthode vérifie uniquement si ce modèle est persistant
pour le `Class.Players.LocalPlayer|LocalPlayer`.

Model:GetPersistentPlayers

Une table avec tous les objets `Class.Player` pour lesquels cet objet modèle est
persistant.

Renvoie tous les objets `Class.Player` pour lesquels cet objet modèle est
persistant. Le comportement varie en fonction de si cette méthode est appelée
à partir d'un `Class.Script` ou d'un `Class.LocalScript`.

Le code suivant démontre comment GetPrimaryPartCFrame et
SetPrimaryPartCFrame peuvent être utilisés pour faire tourner un modèle.

Un modèle simple est créé dans l'Espace de travail et une boucle est lancée qui va
faire tourner le modèle de 10 degrés autour de l'axe Y toutes les 0,2 secondes.

Cette fonction a été remplacée par `Class.PVInstance:GetPivot()` qui
agit comme un remplacement et ne change pas le comportement de votre code. Utilisez
`Class.PVInstance:GetPivot()` pour de nouveaux travaux et migrez vos appels existants
`Class.Model:GetPrimaryPartCFrame()` lorsque cela est possible.

Renvoie le `Datatype.CFrame` de la `Class.Model.PrimaryPart` du modèle.

Cette fonction est équivalente à ce qui suit.

    Model.PrimaryPart.CFrame

Notez que cette fonction renverra une erreur si aucune partie principale n'existe pour le
`Class.Model`. Cela peut causer des problèmes si, par exemple, la partie principale
n'a jamais été définie ou a été détruite.

Model:GetPrimaryPartCFrame

Renvoie le `Datatype.CFrame` de la `Class.Model.PrimaryPart` du modèle.
Cette fonction renverra une erreur si aucune partie principale n'existe pour le
`Class.Model`.

Cet exemple de code démontre comment substituer un remplacement pour toutes les copies
 d'un modèle d'arbre en utilisant `Class.Model:PivotTo()` et `Class.Model:ScaleTo()`. Le
 pivot et l'échelle des modèles sont utilisés comme référence pour garantir que les
 tailles et emplacements relatifs des modèles de remplacement correspondent à ceux des
 originaux.


Les modèles contiennent un facteur d'échelle canonique persistant, qui commence à 1
pour les modèles nouvellement créés et change lorsque le modèle est mis à l'échelle en appelant
`Class.Model:ScaleTo()`. Cette fonction renvoie le facteur d'échelle canonique actuel
du modèle.

Le facteur d'échelle actuel n'impacte pas _directement_ la taille des Instances
sous le modèle. Il est utilisé à des fins d'autorisation de contenu et de scripting
pour se souvenir de la manière dont le modèle a été mis à l'échelle par rapport à sa taille d'origine.

Au cours d'une session donnée, le modèle mettra en cache les informations précises sur la taille
originale des Instances descendantes après le premier
`Class.Model:ScaleTo()` appel. Cela signifie que l'appel
`Class.Model:ScaleTo()|ScaleTo(x)` suivi de
`Class.Model:ScaleTo()|ScaleTo(1)` vous ramènera _exactement_ à la configuration
originale du modèle sans dérive de point flottant. Éviter la dérive de point flottant est la motivation
pour avoir une fonction Scale**To** plutôt qu'une fonction Scale**By**.

Le facteur d'échelle impacte le comportement du moteur d'une manière : le facteur d'échelle
d'un modèle sera appliqué aux décalages de joint des
`Class.Animation|Animations` jouées sur un `Class.AnimationController`
sous ce modèle, de sorte que les rigs animés joueront correctement les
animations même lorsqu'ils sont mis à l'échelle.

Model:GetScale

Le facteur d'échelle canonique actuel du modèle.

Renvoie l'échelle canonique du modèle, qui est par défaut 1 pour les modèles
nouvellement créés et changera lorsqu'il sera mis à l'échelle via
`Class.Model:ScaleTo()`.

Cet exemple de code montre comment des joints peuvent être créés en utilisant la
fonction Model:MakeJoints.

Un modèle est instancié, avec deux parties l'une sur l'autre. La partie supérieure est
ancrée et la partie inférieure ne l'est pas. Normalement, lorsqu'elle est parentée au Workspace,
la partie inférieure tomberait sur la Baseplate.

Cependant, comme la propriété TopSurface de la partie inférieure est définie sur
Enum.SurfaceType.Weld, cela signifie que lorsque Model:MakeJoints est exécuté, une
connexion est faite entre elles.

Par conséquent, la partie inférieure ne tombe pas tant que les joints dans le modèle ne sont
pas cassés. Cela se fait souvent en utilisant Model:BreakJoints, mais dans cet exemple, la
connexion est rompue à l'aide d'une explosion.

Cet exemple de code démontre la création de joints sur deux pièces qui sont
sœurs du script (PartA et PartB). Il utilise MakeJoints sur deux pièces touchant
avec des types de surface compatibles (Studs et Inlet).

L'assemblage basé sur le SurfaceType est obsolète. N'utilisez pas MakeJoints pour de nouveaux
projets. Utilisez plutôt `Class.WeldConstraint|WeldConstraints` et
`Class.HingeConstraint|HingeConstraints`.

Parcours tous les `Class.BasePart|Parts` dans le `Class.Model` et crée des
joints entre les Parties spécifiées et toutes les surfaces planes touchant,
suivant les surfaces des parties.

- Les surfaces lisses ne créeront pas de joints
- Les surfaces autocollantes créeront un joint de `Class.Glue`
- Le Weld créera un joint de `Class.Weld` avec n'importe quelle surface sauf pour
  Unjoinable
- Les Studs, Inlet, ou Universal créeront chacun un joint de `Class.Snap` avec
  l'une ou l'autre des deux autres surfaces (ex. Studs avec Inlet et
  Universelles)
- Les surfaces Hinge et Motor créent des instances de joint `Class.Rotate` et `Class.RotateV`

Cette fonction ne fonctionne pas si la Partie n'est pas un descendant de
`Class.Workspace`. Par conséquent, vous devez d'abord vous assurer que le modèle est parenté
to Workspace avant d'utiliser MakeJoints.

Model:MakeJoints

Parcours tous les `Class.BasePart|BaseParts` dans le `Class.Model`. Si le côté de
une partie a un SurfaceType qui peut créer un joint, il créera un joint
avec toutes les parties adjacentes.

Model:makeJoints

Model:move

location

Cet exemple démontre comment `Class.Model:MoveTo()` évite les collisions.

Un simple `Class.Model` en deux parties est créé, et sa `Class.Model.PrimaryPart`
est définie. Une grande partie d'obstruction est placée à côté.

Après 5 secondes, `Class.Model:MoveTo()` est utilisé pour diriger le modèle à se déplacer
à l'intérieur de la partie d'obstruction. Cependant, comme MoveTo ne déplacera pas un modèle à l'intérieur
 d'une obstruction, le `Class.Model` est déplacé vers le haut sur l'axe Y et placé au-dessus
de l'obstruction.


Déplace la `Class.Model.PrimaryPart|PrimaryPart` à la position donnée. Si
une partie principale n'a pas été spécifiée, la partie racine du modèle sera utilisée, mais la partie racine n'est pas déterministe et il est recommandé que vous
définissiez toujours une partie principale lors de l'utilisation de `Class.Model:MoveTo()|MoveTo()`.

S'il y a des obstructions là où le modèle doit être déplacé, comme
`Class.Terrain` ou d'autres `Class.BasePart|BaseParts`, le modèle sera
déplacé verticalement jusqu'à ce qu'il n'y ait rien sur son chemin. Si ce
comportement n'est pas souhaité, `Class.PVInstance:PivotTo()` devrait être utilisé
à la place.

Notez que la rotation n'est pas préservée lors du déplacement d'un modèle avec
`Class.Model:MoveTo()|MoveTo()`. Il est recommandé d'utiliser soit
`Class.Model:TranslateBy()|TranslateBy()` ou `Class.PVInstance:PivotTo()`
s'il est nécessaire de maintenir la rotation actuelle du modèle.

Model:MoveTo

position

Le `Datatype.Vector3` vers lequel le `Class.Model` est déplacé.

Déplace la `Class.Model.PrimaryPart|PrimaryPart` à la position donnée. Si
une partie principale n'a pas été spécifiée, la partie racine du modèle sera utilisée.

Model:moveTo

Rend ce modèle non persistant pour le joueur spécifié. Cela ne garantit pas que le modèle sera immédiatement
retiré pour le joueur ; après avoir appelé cette méthode, le modèle sera traité comme
`Enum.ModelStreamingMode|Atomic` pour ce joueur et restera présent tant qu'il est
à l'intérieur du rayon de streaming cible.

`Class.Model.ModelStreamingMode|ModelStreamingMode` doit être défini sur
`Enum.ModelStreamingMode|PersistentPerPlayer` pour que le comportement change
suite à la suppression.

Model:RemovePersistentPlayer

Le `Class.Player` pour lequel ce modèle ne sera plus persistant.

Rend ce modèle non persistant pour le joueur spécifié.
`Class.Model.ModelStreamingMode|ModelStreamingMode` doit être défini sur
`Enum.ModelStreamingMode|PersistentPerPlayer` pour que le comportement change
suite à la suppression.

Réinitialise la rotation des parties du modèle à la rotation d'identité précédemment définie,
qui se fait via la méthode `Class.Model:SetIdentityOrientation()`.

Model:ResetOrientationToIdentity

Models contain a persistent canonical scale factor, which starts out at 1
for newly created models. This function scales the model, around the pivot
location, relative to how it would look at a scale factor of 1. To
accomplish this it does two things:

- Sets the current scale factor of the model to the specified value
- Resizes and repositions all descendant Instances accordingly

The scaling of locations is done around the pivot location.

All "geometric" properties of descendant Instances will be scaled. That
obviously includes the sizes of parts, but here are some other examples of
properties which are scaled:

- The length of joints like `Class.WeldConstraint|WeldConstraints`, and
  `Class.RopeConstraint`
- Physical velocities and forces like `Class.HingeConstraint`
- Visual properties like sizes of particle emitters
- Other length properties like `Class.Sound.RollOffMinDistance`


Model:ScaleTo

newScaleFactor

Définit le facteur d'échelle du modèle, ajustant la taille et l'emplacement de
toutes les Instances descendantes de sorte qu'elles aient ce facteur d'échelle par rapport à
leurs tailles et emplacements initiaux lorsque le facteur d'échelle était de 1.

Définit la rotation d'identité du modèle donné, vous permettant de réinitialiser la
rotation de l'ensemble du modèle ultérieurement, grâce à la méthode
`ResetOrientationToIdentity`.

Model:SetIdentityOrientation

Cette fonction a été remplacée par `Class.PVInstance:PivotTo()` qui
agit comme un remplacement plus performant et ne change pas le comportement de votre code. Utilisez
`Class.PVInstance:PivotTo()` pour de nouveaux travaux et migrez vos appels existants
`Class.Model:SetPrimaryPartCFrame()` lorsque cela est possible.

Définit le `Class.BasePart.CFrame` de la `Class.Model.PrimaryPart` du modèle.
Toutes les autres parties du modèle seront également déplacées et maintiendront leur
orientation et leur décalage par rapport à la `Class.Model.PrimaryPart`.

Notez que cette fonction lancera une erreur si aucune `Class.Model.PrimaryPart`
 n'existe pour le modèle. Cela peut causer des problèmes si, par exemple, la partie principale
a jamais été définie ou a été détruite.

Model:SetPrimaryPartCFrame

cframe

Définit le `Class.BasePart.CFrame` de la `Class.Model.PrimaryPart` du modèle.
Toutes les autres parties du modèle seront également déplacées et maintiendront leur
orientation et leur décalage par rapport à la `Class.Model.PrimaryPart`.

Cet exemple démontre comment `Class.Model:TranslateBy()` ignore les collisions
et respecte l'orientation du modèle.

Un simple modèle `Class.Model` à deux parties est créé, tourné de 45 degrés sur l'axe Y,
et sa `Class.Model.PrimaryPart` est définie. Une grande partie d'obstruction est placée
à côté.

Après 5 secondes, `Class.Model:TranslateBy()` est utilisé pour diriger le modèle à
se déplacer à l'intérieur de la partie d'obstruction. Le modèle se déplacera à l'intérieur de
l'obstruction et maintiendra son orientation actuelle.


Déplace un `Class.Model` par le décalage `Datatype.Vector3` donné, préservant
l'orientation du modèle. Si une autre `Class.BasePart` ou `Class.Terrain`
est déjà présente à la nouvelle position, alors le `Class.Model` se chevauchera
avec cet objet.

La translation est appliquée dans l'espace mondial plutôt que dans l'espace objet,
ce qui signifie que même si les parties du modèle sont orientées différemment, elles se déplaceront
le long de l'axe standard.

Model:TranslateBy

delta

Le `Datatype.Vector3` par lequel traduire le `Class.Model`.

Déplace un `Class.Model` par le décalage `Datatype.Vector3` donné, préservant
l'orientation du modèle. Si une autre `Class.BasePart` ou `Class.Terrain`
est déjà présente à la nouvelle position, alors le `Class.Model` se chevauchera
avec cet objet.

Model

Définit le niveau de détail du modèle pour les expériences avec l'
[streaming](/workspace/streaming) activé. Les maillages composites ou
imposteurs ne prennent pas en charge la physique, la détection de collisions ou
la détection de rayons.

Lorsqu'il est défini sur `Enum.ModelLevelOfDetail|StreamingMesh`, un maillage
"imposteur" de résolution inférieure (maillage coloré et grossier qui entoure toutes les
tiges enfants du modèle) est rendu en dehors du rayon de streaming. Ne prend pas en charge
les textures.

Lorsqu'il est défini sur `Enum.ModelLevelOfDetail|SLIM`, un modèle **SLIM** (Modèle
Interactif Légèrement Évolutif) rend une composition de toutes les tiges enfants à
des résolutions progressivement inférieures en fonction des distances basées sur le rayon de
streaming. Cela améliore considérablement la qualité visuelle par rapport à
`Enum.ModelLevelOfDetail|StreamingMesh`.

Lorsqu'il est défini sur `Enum.ModelLevelOfDetail|Disabled` ou
`Enum.ModelLevelOfDetail|Automatic`, les maillages de résolution inférieure ne seront pas
affichés.


Model.LevelOfDetail

Définit le niveau de détail sur le modèle pour les expériences avec le streaming
d'instances activé.

Contrôle comment les `Class.Model|Models` sont diffusés et retirés lorsque le
[streaming](/workspace/streaming) des instances est activé. Le comportement
varie en fonction de l'énumération sélectionnée. N'a aucun effet lorsque le streaming n'est pas activé.

Cette propriété ne devrait être modifiée que dans Studio via la
[fenêtre des Propriétés](/studio/properties) lorsque le streaming est
enregistré, ou dans des `Class.Script|Scripts`, mais jamais dans
`Class.LocalScript|LocalScripts` (le faire peut entraîner un comportement indéfini).

Model.ModelStreamingMode

Contrôle le comportement de streaming du modèle sur `Class.Model|Models` lorsque
le streaming d'instances est activé.

Cet exemple de code crée et lance un modèle de dé, puis indique s'il
est tombé avec le côté bleu face visible. Si `Class.Model.PrimaryPart` n'était pas défini,
le pivot / la boîte de délimitation du dé tournerait, car les parties à l'intérieur de celui-ci
sont simulées physiquement pendant le lancer.

Pointe vers la partie principale du `Class.Model`. La partie principale est le
`Class.BasePart` qui sert de référence physique pour le pivot du
modèle. C'est-à-dire que lorsque des parties à l'intérieur du modèle sont déplacées à cause de la
simulation physique ou d'autres moyens, le pivot se déplacera en synchronisation avec la partie principale.

Notez que les `Class.Model|Models` n'ont pas `PrimaryPart` défini par défaut.
Si vous créez un modèle qui doit être soumis à la physique, vous
devez manuellement définir cette propriété dans Studio ou dans un script. Si la
partie principale **n'est pas** définie, le pivot restera au même endroit dans
espace mondial, même si des parties à l'intérieur du modèle sont déplacées.

Notez également que lors de la définition de cette propriété, il doit s'agir d'un `Class.BasePart`
qui est un descendant du modèle. Si vous essayez de définir
`Class.Model.PrimaryPart` à un `Class.BasePart` qui **n'est pas** un
descendant du modèle, cela sera défini sur cette partie mais réinitialisé à `nil`
lors du prochain étape de simulation &mdash; ce comportement hérité vise à soutenir
les scripts qui supposent pouvoir définir temporairement la partie principale
à un `Class.BasePart` qui n'est pas un descendant du modèle.

La règle générale pour les modèles est la suivante :

- Les modèles dont les parties sont reliées via des joints physiques tels que
  `Class.WeldConstraint|WeldConstraints` ou `Class.Motor6D|Motor6Ds`
  devraient avoir une partie principale assignée. Par exemple, les modèles
  de personnages Roblox ont leur `Class.Model.PrimaryPart` défini sur le
  **HumanoidRootPart** par défaut.
- Les modèles statiques (généralement `Class.BasePart.Anchored|Anchored`) qui restent en
  un endroit à moins qu'un script ne les déplace explicitement n'ont pas besoin d'un
  `Class.Model.PrimaryPart` et tendent à ne pas bénéficier d'en avoir un défini.

Model.PrimaryPart

La partie principale du `Class.Model`, ou `nil` si non explicitement définie.

Définir cette propriété dans la fenêtre Propriétés va mettre à l'échelle le modèle comme
si `Class.Model:ScaleTo()` avait été appelé sur lui, redimensionnant tous les Instances descendantes du modèle,
tels que les matériaux, les images, et la géométrie 3D des
parties, de sorte que le modèle ait le facteur de mise à l'échelle spécifié par rapport à sa
taille d'origine.

Cette propriété n'est disponible que dans Studio et lancera une erreur si elle est utilisée
dans un `Class.Script` ou `Class.LocalScript`. `Class.Model:ScaleTo()` et
`Class.Model:GetScale()` devraient être utilisés depuis les scripts.

Model.Scale

Propriété réservée à l'éditeur utilisée pour mettre à l'échelle le modèle autour de son pivot. Définit
cette propriété déplacera l'échelle comme si `Class.Model:ScaleTo()` avait été
appelé sur elle.

Cet exemple de code montre une fonction personnalisée pour réinitialiser le pivot d'un modèle
à la centre de la boîte englobante de ce modèle.

Cette propriété détermine où se situe le pivot d'un `Class.Model` qui
**n'a pas** de `Class.Model.PrimaryPart` défini. Si le
`Class.Model` **a** un `Class.Model.PrimaryPart|PrimaryPart`, le
pivot du `Class.Model` est égal au pivot de cette partie principale
au lieu de cela, et cette propriété `Class.Model.WorldPivot|WorldPivot` est ignorée.

Pour un `Class.Model` nouvellement créé, son pivot sera traité comme le centre
de la boîte de délimitation de son contenu jusqu'à la **première fois** que sa
propriété `Class.Model.WorldPivot` est définie. Une fois que le pivot du monde est défini pour
la première fois, il est impossible de restaurer ce comportement initial.

Le plus souvent, déplacer le modèle avec les outils Studio, ou avec des fonctions
 de mouvement de modèle telles que `Class.PVInstance:PivotTo()` et
`Class.Model:MoveTo()`, va définir le pivot du monde et ainsi mettre fin à ce nouveau
comportement du modèle.

Le but de ce comportement est de permettre au code Luau d'obtenir un pivot sensé
simplement en créant un nouveau modèle et en parentant des objets à celui-ci, évitant le
d'un paramétrage explicite de `Class.Model.WorldPivot` chaque fois que vous créez un
modèle dans le code.

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

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

print(model:GetPivot())  -- Actuellement égal au centre de la boîte de délimitation contenant "BluePart" et "RedPart"

model:PivotTo(CFrame.new(0, 10, 0))  -- Cela fonctionne sans avoir besoin de définir explicitement "model.WorldPivot"
```

Model.WorldPivot

Détermine où se situe le pivot d'un `Class.Model` qui **n'a pas** de
`Class.Model.PrimaryPart` défini.

Les modèles sont des objets conteneurs, ce qui signifie qu'ils regroupent des objets. Ils sont
meilleures utilisées pour contenir des collections de `Class.BasePart|BaseParts` et disposent d'un certain
nombre de fonctions qui étendent leur fonctionnalité.

Une `Class.PVInstance` est une classe abstraite qui ne peut pas être créée. Elle est la
base de tous les objets ayant une position physique dans le monde.


Cet exemple de code est un script de téléportation simple qui déplace votre personnage
10&nbsp;studs vers l'avant dans la direction dans laquelle vous faites face lorsque vous appuyez
sur la touche <kbd>F</kbd>. Cela se fait en obtenant le pivot actuel avec
`Class.PVInstance:GetPivot()` et en appelant `PVInstance|PivotTo` pour déplacer le
personnage vers l'avant.

Cette fonction obtient le pivot d'une `Class.PVInstance`. Cela est souvent utilisé
avec `Class.PVInstance:PivotTo()` pour déplacer un modèle.

`Class.Model|Models` et `Class.BasePart|BaseParts` sont tous deux
`Class.PVInstance|PVInstances` ("Instances de Vitesse de Position") et donc tous deux
ont cette fonction.


PVInstance:GetPivot

Obtient le pivot d'une `Class.PVInstance`.


Transforme la `Class.PVInstance` ainsi que tous ses descendents
`Class.PVInstance|PVInstances` de sorte que le pivot soit maintenant situé à
la `Datatype.CFrame` spécifiée. C'est la fonction principale qui devrait être
utilisée pour déplacer des `Class.Model|Models` via le scripting.

`Class.BasePart|BaseParts` sont déplacés de cette manière en ayant leur
`Datatype.CFrame` transformé par le décalage nécessaire.
Les `Class.Model|Models` sont déplacés de cette manière en ayant leur
`Class.Model.WorldPivot` transformé par le décalage nécessaire.

Notez que pour des raisons d'efficacité, les événements `Class.Object.Changed` ne sont pas
déclenchés pour la `Class.BasePart.Position|Position` et
`Class.BasePart.Orientation|Orientation` des `Class.BasePart|BaseParts`
déplacés de cette manière ; ils ne sont déclenchés que pour `Datatype.CFrame`.

Lors de l'appel de `Class.PVInstance:PivotTo()|PivotTo` sur des `Class.Model|Models`,
les décalages des pièces et modèles descendants sont mis en cache, de sorte que
les appels subséquents à `Class.PVInstance:PivotTo()|PivotTo` sur le même modèle
ne cumulent pas de dérive en virgule flottante entre les pièces composant le
modèle.

`Class.Model|Models` et `Class.BasePart|BaseParts` sont tous deux
`Class.PVInstance|PVInstances` ("Instances de Vitesse de Position") et donc tous deux
ont cette fonction.


PVInstance:PivotTo

targetCFrame

La `Datatype.CFrame` à laquelle le pivot de `Class.PVInstance` doit être égal
après l'avoir déplacé.


Transforme la `Class.PVInstance` ainsi que tous ses descendents
`Class.PVInstance|PVInstances` de sorte que le pivot soit maintenant situé à
la `Datatype.CFrame` spécifiée.


PVInstance

PVInstance.Origin

PVInstance.Pivot Offset

Classe abstraite pour tous les objets ayant une position physique dans le monde.


`Instance` est la classe de base pour toutes les classes de la hiérarchie des classes Roblox
qui peuvent faire partie de l'arbre `Class.DataModel`.

Il n'est pas possible de créer directement des objets `Instance` racines, mais le constructeur spécial
`Datatype.Instance.new()` crée des objets via le code, prenant le
nom de la classe comme paramètre et retournant l'objet créé.

Démontre la détection des changements dans la descendance d'une instance en se connectant à l'événement
`Class.Instance.AncestryChanged`.

Le Parent de ChangingPart est défini sur différentes valeurs au fil du temps. Le parent de
la pièce est l'ancêtre de la pièce, donc l'événement `Class.Instance.AncestryChanged`
se déclenchera chaque fois qu'il change.


Déclenche lorsque cette instance est re-parentée ou lorsque l'un de ses
ancêtres est re-parenté.

Vous pouvez utiliser cet événement pour suivre la suppression d'une instance
dans Studio, comme une suppression manuelle dans l'Explorateur ou via un
plugin. Si vous devez détecter lorsqu'une instance est détruite à l'aide de
`Class.Instance:Destroy()`, utilisez plutôt l'événement `Class.Instance.Destroying`.

Instance.AncestryChanged

child

L'instance dont la propriété `Class.Instance.Parent|Parent` a changé,
qui peut être cette instance ou un ancêtre plus lointain, **pas**
nécessairement l'instance à laquelle le gestionnaire est connecté.

parent

Déclenche lorsqu'il y a un changement dans la propriété `Class.Instance.Parent`
de cet objet ou de l'un de ses ancêtres.

Cet événement déclenche chaque fois qu'un attribut est modifié sur l'instance,
notamment lorsque l'attribut est défini sur `nil`. Le nom de l'attribut modifié
est passé à la fonction connectée.

Par exemple, le snippet de code suivant connecte la fonction `attributeChanged()`
qui se déclenche chaque fois qu'un des attributs de la pièce change:

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

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "modifié")
end

part.AttributeChanged:Connect(attributeChanged)
```
Voir aussi `Class.Instance:GetAttributeChangedSignal()` qui renvoie un
event qui se déclenche lorsqu'un attribut spécifique donné change.

Instance.AttributeChanged

attribute

Le nom de l'attribut qui a été modifié.

Déclenche chaque fois qu'un attribut est modifié sur la `Class.Instance`.

Ce fragment imprime les noms des objets lorsqu'ils sont ajoutés à l'espace de travail :

Déclenche après qu'un objet a été parenté à cette `Class.Instance`.

Notez que, lors de l'utilisation de cette méthode sur un client pour détecter des objets créés par le
serveur, il est nécessaire d'utiliser `Class.Instance:WaitForChild()` lors
de l'indexation des descendants de ces objets. Cela est dû au fait que l'objet et ses
descendants ne sont pas garantis d'être répliqués du serveur au client
simultanément. Par exemple:

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

Workspace.ChildAdded:Connect(function(child)
	-- Utilisez WaitForChild() car les descendants peuvent ne pas avoir encore été répliqués
	local head = child:WaitForChild("Head")
end)
```
Notez que cet événement ne fonctionne que pour les enfants immédiats de la
`Class.Instance`. Pour un événement qui capture tous les descendants, utilisez
`Class.Instance.DescendantAdded`.

Voir aussi `Class.Instance.ChildRemoved`.

Instance.ChildAdded

La `Class.Instance` qui a été ajoutée.

Déclenche après qu'un objet a été parenté à cette `Class.Instance`.

Instance.childAdded

Instance

`Instance` est la classe de base pour toutes les classes de la hiérarchie des classes Roblox
qui peuvent faire partie de l'arbre `Class.DataModel`.