Lorsqu'il est parenté à un `Class.ViewportFrame`, `WorldModel` étend la physique limitée
pour ses enfants sur ce `Class.ViewportFrame`. Par exemple,
les `Class.BasePart|BaseParts` qui sont parentés au `WorldModel` peuvent être
animés et interrogés spatialement (par exemple par des raycasts) mais ces parties ne sont
**pas** simulées. De plus, vous pouvez mettre des personnages `Class.Humanoid` dans le
`WorldModel` et leurs articulations seront correctement configurées pour l'animation.

`WorldModel` expose également la
`Class.WorldModel.UseWorkspaceCollisionGroups|UseWorkspaceCollisionGroups`
propriété pour déterminer s'il utilise les groupes de collision `Class.Workspace` ou
ses propres groupes de collision indépendants pour les requêtes.

Pour éviter d'éventuels problèmes de performance, assurez-vous de ne créer des `WorldModels`
que lorsque vous souhaitez les afficher et de supprimer les `WorldModels` qui ne sont actuellement pas
utilisés.


WorldModel

Lorsque `false` (par défaut), ce `WorldModel` utilise ses propres groupes de collision
pour tout comportement lié à la collision.

Lorsque `true`, ce `WorldModel` utilise les groupes de collision `Class.Workspace`.
De plus, l'état du groupe de collision de ce `WorldModel` peut continuer
a être modifié.


WorldModel.UseWorkspaceCollisionGroups

Détermine si ce `WorldModel` utilise les groupes de collision `Class.Workspace`
ou ses propres groupes de collision indépendants pour les requêtes.


Étend la physique limitée à ses enfants.


Cette classe de base fournit une API pour toute instance destinée à gérer les requêtes spatiales 3D et la simulation, telles que `Class.Workspace` et `Class.WorldModel`.

Le bloc de code ci-dessous démontre comment utiliser
`Class.WorldRoot:ArePartsTouchingOthers()` pour vérifier si les pièces d'une liste sont
en contact avec des pièces dans l'espace de travail qui ne sont pas dans la liste.

Tout d'abord, le script crée deux pièces carrées qui se chevauchent de 1 stud, `Part1` et
`Part2`. Ensuite, il imprime la valeur retournée par ArePartsTouchingOthers() lorsque
Part1 est passé dans `partList` avec trois valeurs de chevauchement différentes : `0`, `0.999`,
et `1`. Les deux premières fois qu'ArePartsTouchingOthers() est appelé retournent `false`
puisque les valeurs de chevauchement sont inférieures à la distance que Part1 et Part2
se chevauchent. Le troisième appel retourne `true` car la valeur de chevauchement est égale à
la distance à laquelle les pièces se chevauchent.

**ArePartsTouchingOthers** renvoie vrai si au moins l'un des `Class.BasePart` donnés touche d'autres parties. Deux parties sont considérées comme « touchant » si elles sont dans le seuil de distance, `overlapIgnored`.

Si aucune partie n'est fournie, false est renvoyé.

WorldRoot:ArePartsTouchingOthers

partList

Une liste de parties qui vérifie si l'une des parties de la liste touche des parties qui ne sont pas dans la liste.

overlapIgnored

Le seuil de chevauchement des parties en studs qui est ignoré avant que les parties ne soient considérées comme touchant.

Vrai si et seulement si l'une des `Class.Part|parts` dans `partList` touche d'autres parties (parties qui ne sont pas dans le partList). Faux si aucune partie n'est passée.

Retourne vrai si l'un des `Class.BasePart` donnés touche d'autres parties.

Lance un bloc et renvoie la première collision avec un `Class.BasePart` ou
`Class.Terrain`. Imprime les propriétés du RaycastResult si un résultat a été
frappé.


Projette une forme en bloc dans une direction donnée et renvoie la première collision avec un `Class.BasePart` ou une cellule `Class.Terrain`. Cela est analogue à la façon dont `Class.WorldRoot:Raycast()` projette un rayon linéaire dans une direction pour trouver une collision, mais utilise une forme 3D au lieu d'un rayon.

Contrairement à `Class.WorldRoot:GetPartsInPart()`, cette méthode ne détecte pas les `Class.BasePart|BaseParts` qui **s'intersectent initialement** avec la forme.

Si un coup est détecté, un `Datatype.RaycastResult` est renvoyé contenant les informations de coup. La propriété `Datatype.RaycastResult.Distance|Distance` représente la distance que la forme doit parcourir pour trouver un coup, et la propriété `Datatype.RaycastResult.Position|Position` représente le point d'intersection qui cause le coup.

Cette méthode génère une erreur si elle reçoit un `Datatype.CFrame`, une taille ou des directions invalides.

WorldRoot:Blockcast

cframe

La position initiale et la rotation de la forme en bloc projetée.

size

La taille de la forme en bloc projetée en studs. La taille maximale est de 512 studs.

direction

Direction de la projection de la forme, avec la magnitude représentant la distance maximale que la forme peut parcourir. La distance maximale est de 1024 studs.

params

Un objet utilisé pour spécifier l'éligibilité des impacts dans l'opération de shapecast.
Si non fourni, des valeurs par défaut sont utilisées où toutes les parties sont
considérées et l'eau de `Class.Terrain` n'est pas ignorée.

Contient le résultat de l'opération de projection de forme, ou `nil` si aucune `Class.BasePart` ou cellule `Class.Terrain` éligible n'a été touchée.

Projette une forme en bloc dans une direction donnée et renvoie un `Datatype.RaycastResult` si la forme touche un `Class.BasePart` ou une cellule `Class.Terrain`.

Cette fonction déplace un tableau de `Class.BasePart|BaseParts` vers un tableau de
`Datatype.CFrame|CFrames` sans nécessairement déclencher les événements de propriété par défaut
`Class.Object.Changed|Changed`. Cela fournit un moyen très rapide de
déplacer un grand nombre de pièces, car vous n'avez pas à payer le coût de
ensembles de propriétés séparés pour chaque pièce individuelle.

Les tableaux `partList` et `cframeList` sont des tableaux séquentiels (tables Luau avec
indices entiers commençant à 1), pas des dictionnaires. Chaque pièce à l'indice `i`
dans `partList` est déplacée vers le `Datatype.CFrame|CFrame` à l'indice `i` dans
`cframeList`. Les tableaux doivent contenir le même nombre d'entrées.

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

local partList = { Workspace.Part1, Workspace.Part2 }
local cframeList = { CFrame.new(0, 5, 0), CFrame.new(10, 5, 0) }
Workspace:BulkMoveTo(partList, cframeList, Enum.BulkMoveMode.FireCFrameChanged)
```
Le troisième argument vous permet d'optimiser davantage l'opération de mouvement.
Par défaut, l'événement `Class.Object.Changed|Changed` de chaque pièce se déclenche
pour `Class.BasePart.Position|Position`,
`Class.BasePart.Orientation|Orientation`, et
`Class.BasePart.CFrame|CFrame`. Cependant, si vous spécifiez
`Enum.BulkMoveMode|FireCFrameChanged` comme troisième argument, seul l'événement
`Class.Object.Changed|Changed` pour la propriété
`Class.BasePart.CFrame|CFrame` se déclenchera.

Notez que vous ne devez utiliser cette fonction que si vous êtes sûr que le
mouvement des pièces est un goulet d'étranglement dans votre code. Il suffit de définir le
`Class.BasePart.CFrame|CFrame` des pièces individuelles et des modèles soudés, ce qui est suffisamment rapide dans la majorité des cas.

WorldRoot:BulkMoveTo

Un tableau de `Class.BasePart|BaseParts` à déplacer. Chaque entrée est
correspondante par indice à l'entrée correspondante dans `cframeList`.

cframeList

Un tableau de `Datatype.CFrame|CFrames` vers lequel les pièces seront déplacées,
correspondant par indice à `partList`. Les deux tableaux doivent avoir la même longueur.

eventMode

Un énumérateur `Enum.BulkMoveMode` spécifiant quels
événements `Class.Object.Changed|Changed` se déclenchent pendant le déplacement. La valeur par défaut est
`Enum.BulkMoveMode|FireAllEvents`.

Déplace un tableau de `Class.BasePart|BaseParts` vers un tableau de
`Datatype.CFrame|CFrames`.

Renvoie si les deux groupes de collision spécifiés vont entrer en collision dans ce monde. Cette méthode renverra également `true` si l'un des groupes n'est pas enregistré dans ce monde, car le masque de collision par défaut entre en collision avec tous les groupes.


WorldRoot:CollisionGroupsAreCollidable

name1

name2

Renvoie si les deux groupes vont entrer en collision dans ce monde.


Définit le statut de collision entre deux groupes dans ce monde. Cette méthode générera une erreur si l'un des groupes n'est pas enregistré dans ce monde, il est donc recommandé de confirmer l'enregistrement de chaque groupe via `Class.WorldRoot:IsCollisionGroupRegistered()` avant d'effectuer cet appel.


WorldRoot:CollisionGroupSetCollidable

collidable

Définit le statut de collision entre deux groupes dans ce monde.


**FindPartOnRay** utilise [le raycasting](/workspace/raycasting) pour trouver le premier `Class.BasePart` ou cellule `Class.Terrain` intersectant avec un `Datatype.Ray` donné. Cette fonction renvoie le `Class.BasePart` ou la cellule de terrain touchée, le point d'intersection, la normale de surface au point d'intersection, et le `Enum.Material` associé touché.

Si le paramètre `ignoreDescendantsInstance` est fourni, le calcul de raycasting ignorera l'objet donné et tous ses descendants. Il se comporte de manière similaire à la propriété `Class.Mouse.TargetFilter`.

Les paramètres `terrainCellsAreCubes` et `ignoreWater` déterminent si les cellules `Class.Terrain` doivent être traitées comme des cubes ou non, et si l'eau doit être ignorée ou non.

Pour inclure ou exclure plusieurs objets et leurs descendants, utilisez les variantes `Class.WorldRoot:FindPartOnRayWithWhitelist()` et `Class.WorldRoot:FindPartOnRayWithIgnoreList()`.

#### Remarques

- Théoriquement, un rayon s'étend à l'infini dans une direction. Cependant, la longueur maximale du vecteur de direction sur Roblox est de 15000 studs.
- La longueur (magnitude) du vecteur directionnel est importante, car les parties plus éloignées que sa longueur ne seront pas testées.
- Si le rayon n'intersecte rien, les valeurs de retour seront `nil` et le point à l'extrémité du rayon, respectivement.
- Les parties qui se trouvent dans un [groupe de collision](/workspace/collisions#collision-filtering) qui ne collidait pas avec le groupe de collision "Default" sont implicitement ignorées.


WorldRoot:FindPartOnRay

Un `Datatype.Ray` dont l'origine et la direction définissent le raycast.

ignoreDescendantsInstance

Une `Class.Instance` dont les descendants sont ignorés dans le raycast.


terrainCellsAreCubes

Si les cellules de `Class.Terrain` sont traitées comme des cubes pleins lors
du calcul de l'intersection. La valeur par défaut est false.

ignoreWater

Si les cellules d'eau de `Class.Terrain` sont ignorées par le rayon. La valeur par défaut est
false.

Le `Class.BasePart` ou la cellule `Class.Terrain` touchée, le point d'intersection `Datatype.Vector3`, la normale de surface `Datatype.Vector3` au point d'intersection, et le `Enum.Material` du `Class.BasePart` ou de la cellule de terrain touchée.

Renvoie le premier `Class.BasePart` ou cellule `Class.Terrain` intersectant avec le `Datatype.Ray` donné.


WorldRoot:findPartOnRay

Cette fonction est une variante de `Class.WorldRoot:FindPartOnRay()` avec l'ajout d'une liste d'ignorance. Cela vous permet d'ignorer certaines parties ou `Class.Model|Models`.

Ceux qui cherchent à **inclure** un groupe spécifique d'objets devraient plutôt utiliser `Class.WorldRoot:FindPartOnRayWithWhitelist()`.


WorldRoot:FindPartOnRayWithIgnoreList

Un `Datatype.Ray` dont l'origine et la direction définissent le raycast.


ignoreDescendantsTable

Un tableau d'objets dont les descendants sont exclus du raycast.


Indique si les cellules `Class.Terrain` sont traitées comme des cubes complets lors du calcul de l'intersection. Par défaut, c'est faux.


Indique si les cellules d'eau `Class.Terrain` sont ignorées par le rayon. Par défaut, c'est faux.


Le `Class.BasePart` ou la cellule `Class.Terrain` touchée, le point d'intersection `Datatype.Vector3`, la normale de surface `Datatype.Vector3` au point d'intersection, et le `Enum.Material` de la `Class.BasePart` ou de la cellule de terrain touchée.


Renvoie le premier `Class.BasePart` ou cellule `Class.Terrain` intersectant avec le `Datatype.Ray` donné qui n'est pas dans, ni descendant d'un objet dans, la liste d'ignorance donnée.


Cette fonction est une variante de `Class.WorldRoot:FindPartOnRay()` avec l'ajout d'une liste d'inclusion. Cela vous permet de détecter uniquement certaines parties ou `Class.Model|Models` et est particulièrement utile lorsque, par exemple, vous recherchez des points d'intersection entre un rayon et une seule partie.

Si une valeur `nil` est donnée dans la liste d'inclusion, les instances après celle-ci seront ignorées.

Ceux qui cherchent à **exclure** un groupe spécifique d'objets devraient plutôt utiliser `Class.WorldRoot:FindPartOnRayWithIgnoreList()`.


WorldRoot:FindPartOnRayWithWhitelist

whitelistDescendantsTable

Un tableau d'objets dont les descendants sont les seuls candidats considérés dans le raycast.


Renvoie le premier `Class.BasePart` ou cellule `Class.Terrain` intersectant avec le `Datatype.Ray` donné qui est dans, ou descendant d'un objet dans, la liste d'inclusion donnée.


Renvoie un tableau de `Class.BasePart|BaseParts` dans le `Datatype.Region3` donné.

Cette fonction prend un paramètre maxParts optionnel (par défaut 20) qui limite le nombre de `Class.BasePart|BaseParts` pouvant être renvoyés. Une fois ce nombre atteint, la recherche de `Class.BasePart|BaseParts` s'arrêtera. Cela signifie que certaines `Class.BasePart|BaseParts` peuvent ne pas être renvoyées même si elles se trouvent dans le `Datatype.Region3`.

Le paramètre optionnel `ignoreDescendantsInstance` peut être utilisé pour spécifier une instance spécifique pour laquelle elle-même et tous ses descendants doivent être ignorés par cette fonction. Cela peut être utile lorsque, par exemple, vous souhaitez voir si des `Class.BasePart|BaseParts` se trouvent à l'intérieur d'un `Class.BasePart` autre que le `Class.BasePart` lui-même.

```
local min = part.Position - (0.5 * part.Size)
local max = part.Position + (0.5 * part.Size)
local region = Region3.new(min, max)
local parts = worldroot:FindPartsInRegion3(region, part)  -- Ignorer la partie
```
Les variantes `Class.WorldRoot:FindPartsInRegion3WithIgnoreList()` et `Class.WorldRoot:FindPartsInRegion3WithWhiteList()` de cette méthode existent pour fournir des fonctionnalités spécifiques d'exclusion et d'inclusion.

Si aucune `Class.BasePart|BaseParts` n'est trouvée, un tableau vide sera renvoyé.


WorldRoot:FindPartsInRegion3

region

maxParts

Le nombre maximum de `Class.BasePart|BaseParts` à renvoyer.


Un tableau de `Class.BasePart|BaseParts` dans le `Datatype.Region3`.


Renvoie un tableau de `Class.BasePart|BaseParts` dans le `Datatype.Region3` donné.


WorldRoot:findPartsInRegion3

Renvoie un tableau de `Class.BasePart|BaseParts` dans le `Datatype.Region3` donné qui ne sont pas dans, ni descendants d'une entrée dans, la liste d'ignorance donnée.

Si une valeur `nil` est donnée dans la liste d'ignorance, les instances après cette valeur ne seront pas ignorées. Si aucune `Class.BasePart|BaseParts` n'est trouvée, un tableau vide sera renvoyé.

Cette fonction est une variante de `Class.WorldRoot:FindPartsInRegion3()` avec l'ajout d'une liste d'ignorance. Cela permet au développeur d'exclure certaines `Class.BasePart|BaseParts` ou `Class.Model|Models` de la recherche. Ceux qui cherchent à trouver des `Class.BasePart|BaseParts` dans un `Datatype.Region3` en utilisant une liste d'inclusion devraient utiliser `Class.WorldRoot:FindPartsInRegion3WithWhiteList()`.


WorldRoot:FindPartsInRegion3WithIgnoreList

Un tableau de `Class.BasePart|BaseParts` trouvés dans le `Datatype.Region3`.


Renvoie un tableau de `Class.BasePart|BaseParts` dans le `Datatype.Region3` donné qui ne sont pas dans, ni descendants d'une entrée dans, la liste d'ignorance donnée.


Renvoie un tableau de `Class.BasePart|BaseParts` dans le `Datatype.Region3` donné qui sont dans, ou descendants d'une entrée dans, la liste d'inclusion donnée.

Si une valeur `nil` est donnée dans la liste d'inclusion, les instances après cette valeur ne seront pas ignorées. Si aucune `Class.BasePart|BaseParts` n'est trouvée, un tableau vide sera renvoyé.

Cette fonction est une variante de `Class.WorldRoot:FindPartsInRegion3()` avec l'ajout d'une liste d'inclusion. Cela permet au développeur d'inclure uniquement certaines `Class.BasePart|BaseParts` ou `Class.Model|Models` dans la recherche. Ceux qui cherchent à trouver des `Class.BasePart|BaseParts` dans un `Datatype.Region3` en utilisant une liste d'exclusion devraient utiliser `Class.WorldRoot:FindPartsInRegion3WithIgnoreList()`.


WorldRoot:FindPartsInRegion3WithWhiteList

Renvoie un tableau de `Class.BasePart|BaseParts` dans le `Datatype.Region3` donné qui sont dans, ou descendants d'une entrée dans, la liste d'inclusion donnée.


Renvoie le nombre maximum de groupes de collision que le moteur prend en charge par monde. Cette valeur est actuellement de 32.


WorldRoot:GetMaxCollisionGroups

Renvoie le nombre maximum de groupes de collision dans ce monde.


`Class.WorldRoot:GetPartBoundsInBox()` renvoie un tableau de parties dont les **boîtes englobantes** chevauchent une boîte dont le volume est décrit à l'aide du centre donné (`Datatype.CFrame`) et de la taille (`Datatype.Vector3`).

Comme souligné, cette méthode de requête spatiale considère efficacement le volume des boîtes englobantes des parties plutôt que leur volume occupé réel. Cela peut être important lors de la prise en compte de cylindres, de sphères, d'unions et de `Class.MeshPart|MeshParts` qui ont des formes non bloquées. Pour les cas où la précision est particulièrement importante, utilisez `Class.WorldRoot:GetPartsInPart()` à la place, ou filtrez vous-même les résultats de cette méthode.

Cette méthode utilise un objet `Datatype.OverlapParams` pour décrire des portions réutilisables des paramètres de requête spatiale, telles qu'une liste d'inclusion ou d'exclusion, le nombre maximum de parties à interroger, quel [groupe de collision](/workspace/collisions#collision-filtering) utiliser, et si la requête privilégie la valeur `Class.BasePart.CanCollide` d'une partie intersectée par rapport à sa valeur `Class.BasePart.CanQuery`.


WorldRoot:GetPartBoundsInBox

L'emplacement du centre du volume de boîte donné à interroger.


La taille du volume de boîte donné à interroger.


overlapParams

Contient des portions réutilisables des paramètres de requête spatiale.


Un tableau de `Class.BasePart|BaseParts` qui ont correspondu à la requête spatiale.


Renvoie un tableau de parties dont les **boîtes englobantes** chevauchent une boîte donnée.


`Class.WorldRoot:GetPartBoundsInRadius()` renvoie un tableau de parties dont les **boîtes englobantes** chevauchent une sphère dont le volume est décrit à l'aide du centre donné (`Datatype.Vector3`) et du rayon (nombre).

Comme souligné, cette méthode de requête spatiale considère efficacement le volume des boîtes englobantes des parties plutôt que leur volume occupé réel. Cela peut être important lors de la prise en compte de cylindres, de sphères, d'unions et de `Class.MeshPart|MeshParts` qui ont des formes non bloquées. Pour les cas où la précision est particulièrement importante, utilisez `Class.WorldRoot:GetPartsInPart()` à la place, ou filtrez vous-même les résultats de cette méthode.

Cette méthode utilise un objet `Datatype.OverlapParams` pour décrire des portions réutilisables des paramètres de requête spatiale, telles qu'une liste d'inclusion ou d'exclusion, le nombre maximum de parties à interroger, quel [groupe de collision](/workspace/collisions#collision-filtering) utiliser, et si la requête privilégie la valeur `Class.BasePart.CanCollide` d'une partie intersectée par rapport à sa valeur `Class.BasePart.CanQuery`.


WorldRoot:GetPartBoundsInRadius

position

L'emplacement du centre du volume de sphère donné à interroger.


radius

Le rayon du volume de sphère donné à interroger.


Renvoie un tableau de parties dont les **boîtes englobantes** chevauchent une sphère donnée.


`Class.WorldRoot:GetPartsInPart()` renvoie un tableau de parties dont l'espace occupé est partagé avec la partie donnée (qui doit exister dans le même `Class.WorldRoot` que les parties à interroger). Cette méthode peut être utilisée à la place de `Class.BasePart:GetTouchingParts()` et est généralement un meilleur choix.

Comme noté, cette méthode de requête spatiale considère le **volume exact** occupé par la partie donnée en utilisant un contrôle de collision géométrique complet. Par exemple, une partie concave/vide ne correspondra pas aux parties interrogées à l'intérieur à moins qu'elles ne se chevauchent/touchent réellement une telle partie. Pour des volumes plus simples, envisagez d'utiliser `Class.WorldRoot:GetPartBoundsInBox()` ou `Class.WorldRoot:GetPartBoundsInRadius()`, car elles sont moins précises mais fonctionnent plus efficacement.

Cette méthode utilise un objet `Datatype.OverlapParams` pour décrire des portions réutilisables des paramètres de requête spatiale, telles qu'une liste d'inclusion ou d'exclusion, le nombre maximum de parties à interroger, quel [groupe de collision](/workspace/collisions#collision-filtering) utiliser, et si la requête privilégie la valeur `Class.BasePart.CanCollide` d'une partie intersectée par rapport à sa valeur `Class.BasePart.CanQuery`.


WorldRoot:GetPartsInPart

part

La partie dont le volume doit être vérifié par rapport à d'autres parties.


Renvoie un tableau de parties dont l'espace occupé est partagé avec la partie donnée.


Renvoie une table avec des informations sur tous les groupes de collision de ce monde. Chaque valeur dans la table renvoyée est elle-même une table contenant deux membres :

<table>
  <thead>
    <tr>
      <th>Membre</th>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>mask</td>
      <td>integer</td>
      <td>Le masque du groupe de collision ; uniquement pour un usage interne.</td>
    </tr>
    <tr>
      <td>name</td>
      <td>string</td>
      <td>Nom du groupe de collision.</td>
    </tr>
  </tbody>
</table>


WorldRoot:GetRegisteredCollisionGroups

Renvoie une table avec des informations sur tous les groupes de collision de ce monde.


Cette fonction déplace la partie spécifiée à l'emplacement spécifié via [la cinématique inverse](https://en.wikipedia.org/wiki/Inverse_kinematics) plutôt que de la déplacer directement, pour s'assurer que tous les joints, `Class.Constraint|constraints`, ou collisions auxquels cette partie participe restent physiquement satisfaits. Actuellement, cette fonction n'est disponible qu'en Studio pour les `Class.Plugin|plugins`, car elle entre actuellement en conflit avec la physique d'un jeu en cours d'exécution.

**Stiffness de translation** est un nombre entre 0 et 1 spécifiant à quel point il faut correspondre agressivement à la position de la partie à la position de la partie du `CFrame` cible. **Stiffness de rotation** est un nombre entre 0 et 1 spécifiant à quel point il faut correspondre agressivement à la rotation de la partie à la rotation de la partie du `CFrame` cible.

Par exemple :

- Si la stiffness de translation et la stiffness de rotation sont toutes deux égales à 1, alors la partie sera déplacée exactement au `CFrame` cible, peu importe les contraintes physiques qui s'appliquent.
- Si la stiffness de translation et la stiffness de rotation sont toutes deux égales à 0.5, alors la partie essaiera de se déplacer exactement au `CFrame` cible, mais peut être poussée hors du chemin par des contraintes physiques.
- Si la stiffness de translation et la stiffness de rotation sont toutes deux égales à 0, alors le `CFrame` cible sera ignoré et les contraintes physiques seront résolues pour l'objet à la position où il se trouvait.


WorldRoot:IKMoveTo

target

L'emplacement pour déplacer la partie spécifiée.


translateStiffness

Un nombre entre 0 et 1 spécifiant à quel point il faut correspondre agressivement à la position de la partie à la position de la partie du `Datatype.CFrame` cible.


rotateStiffness

Un nombre entre 0 et 1 spécifiant à quel point il faut correspondre agressivement à la rotation de la partie à la rotation de la partie du `Datatype.CFrame` cible.


collisionsMode

Vous permet de spécifier quels objets doivent être affectés par la résolution physique.


Déplace la partie spécifiée à l'emplacement spécifié via la cinématique inverse plutôt que de la déplacer directement, pour s'assurer que tous les joints, contraintes ou collisions auxquels cette partie participe restent physiquement satisfaits.


Vérifie si un groupe de collision est enregistré dans ce monde. Il est recommandé d'appeler cette méthode avant d'appeler des méthodes qui génèrent des erreurs pour des groupes de collision non enregistrés, comme `Class.WorldRoot:CollisionGroupSetCollidable()`.


WorldRoot:IsCollisionGroupRegistered

name

Vérifie si un groupe de collision est enregistré dans ce monde.


**IsRegion3Empty** renvoie un booléen indiquant s'il n'y a pas de `Class.BasePart|BaseParts` dans le `Datatype.Region3` donné.

Le paramètre optionnel `ignoreDescendantsInstance` peut être utilisé pour spécifier une instance spécifique pour laquelle elle-même et tous ses descendants doivent être ignorés par cette fonction. Cela peut être utile lorsque, par exemple, vous souhaitez voir si des `Class.BasePart|BaseParts` se trouvent à l'intérieur d'un `Class.BasePart` autre que le `Class.BasePart` lui-même.

```
local min = part.Position - (0.5 * part.Size)
local max = part.Position + (0.5 * part.Size)
local region = Region3.new(min, max)
local isPartEmpty = worldroot:IsRegion3Empty(region, part)  -- Ignorer la partie
```
Si plus d'un objet et ses descendants doivent être exclus de la recherche, les développeurs devraient utiliser `Class.WorldRoot:IsRegion3EmptyWithIgnoreList()`.

Cette fonction ne renvoie que si une région est vide ou non. Les développeurs cherchant à trouver des `Class.BasePart|BaseParts` dans une région devraient utiliser `Class.WorldRoot:FindPartsInRegion3()`.

#### Comment fonctionnent les vérifications Region3 ?

Vérifier si une partie chevauche un `Datatype.Region3` n'est pas un processus simple. C'est en fait long et compliqué. Au lieu de cela, il vérifie si les parties sont à peu près dans la même zone. Lorsque cette fonction est appelée, elle détermine quels voxels contiennent le `Datatype.Region3`. Elle détermine ensuite quelles parties pourraient se trouver dans ces voxels. Elle le fait en comparant la boîte englobante alignée sur les axes (parfois appelée AABB) de la partie avec les voxels. La boîte englobante alignée sur les axes peut être vue dans Roblox Studio lorsque une partie est sélectionnée.

Cela signifie que la zone inspectée par la fonction peut être plus grande que le `Datatype.Region3`. Pour cette raison, il est recommandé de s'assurer que le `Datatype.Region3` est sur la grille de voxels. Le meilleur moyen de le faire est de définir les coordonnées du `Datatype.Region3` sur des multiples de 4 (puisque les voxels mesurent 4 x 4 x 4 studs).

Cette méthode est un moyen assez rapide et facile de voir si des parties se trouvent dans une zone générale. Si un jeu a besoin de savoir si des parties se trouvent exactement dans une zone, alors `Class.BasePart:GetTouchingParts()` devrait être utilisé. Il y a un coût plus élevé à utiliser `Class.BasePart:GetTouchingParts()` puisque une partie est nécessaire dans le `Class.WorldRoot` et la fonction prend plus de temps à s'exécuter.


WorldRoot:IsRegion3Empty

ignoreDescendentsInstance

Renvoie un booléen indiquant s'il n'y a pas de `Class.BasePart|BaseParts` dans le `Datatype.Region3` donné.


Renvoie un booléen indiquant s'il n'y a pas de `Class.BasePart|BaseParts` dans le `Datatype.Region3` donné, en ignorant les `Class.BasePart|BaseParts` qui sont des descendants des objets dans la liste d'ignorance donnée. Si une valeur `nil` est donnée dans la liste d'ignorance, les instances après cette valeur ne seront pas ignorées.

Cette fonction ne renvoie que si une région est vide ou non. Les développeurs cherchant à trouver des `Class.BasePart|BaseParts` spécifiques dans une région devraient utiliser `Class.WorldRoot:FindPartsInRegion3WithIgnoreList()`.

Cette fonction est une variante de `Class.WorldRoot:IsRegion3Empty()` avec l'ajout d'une liste d'ignorance. Dans les cas où une liste d'inclusion est requise à la place, les développeurs devraient vérifier si des parties sont renvoyées par `Class.WorldRoot:FindPartsinRegion3WithWhitelist()`.


WorldRoot:IsRegion3EmptyWithIgnoreList

ignoreDescendentsTable

Renvoie un booléen indiquant s'il n'y a pas de `Class.BasePart|BaseParts` dans le `Datatype.Region3` donné, en ignorant les `Class.BasePart|BaseParts` qui sont des descendants des objets dans la liste d'ignorance donnée.


Lance un rayon et renvoie la première collision avec un `Class.BasePart` ou
`Class.Terrain`. Imprime les propriétés du RaycastResult si un résultat a été
frappé.


Lance un rayon en utilisant une origine, une direction, et des `Datatype.RaycastParams` optionnels. S'il trouve un `Class.BasePart` ou une cellule `Class.Terrain` éligible, un `Datatype.RaycastResult` est renvoyé contenant les résultats de l'opération. Si aucun objet `Datatype.RaycastParams` n'est fourni, les valeurs par défaut sont utilisées (toutes les parties sont considérées et l'eau `Class.Terrain` n'est pas ignorée).

Notez que la longueur (magnitude) du vecteur directionnel est importante, car les objets/terrains plus éloignés que sa longueur ne seront pas testés. Si vous utilisez un `Datatype.CFrame` pour aider à créer les composants du rayon, envisagez d'utiliser `Datatype.CFrame.LookVector` comme vecteur directionnel et de le multiplier par la longueur désirée comme montré dans l'exemple ci-dessous. La longueur maximale du vecteur de direction est de 15 000 studs.

Cette méthode **n'utilise pas** un objet `Datatype.Ray`, mais ses composants d'origine et de direction peuvent être empruntés à `Datatype.Ray.Origin` et `Datatype.Ray.Direction`.


WorldRoot:Raycast

origin

Le vecteur directionnel du rayon. Notez que la longueur de ce vecteur est importante, car les parties/terrains plus éloignés que sa longueur ne seront pas testés.


raycastParams

Un objet utilisé pour spécifier l'éligibilité des impacts dans l'opération de raycast. Si non fourni, des valeurs par défaut sont utilisées où toutes les autres parties sont considérées et l'eau `Class.Terrain` n'est pas ignorée.


Contient les résultats d'une opération de raycast, ou `nil` si aucun `Class.BasePart` ou cellule `Class.Terrain` éligible n'a été touché.


Lance un rayon en utilisant une origine, une direction, et des `Datatype.RaycastParams` optionnels, puis renvoie un `Datatype.RaycastResult` si un objet ou un terrain éligible intersecte le rayon.


Enregistre un nouveau groupe de collision dans ce monde avec le nom donné. Le nom ne peut pas être `"Default"`.

Notez que cette méthode a un léger surcoût de performance basé sur le nombre de `Class.BasePart|BaseParts` dans le monde, il est donc recommandé d'enregistrer tous les groupes de collision au moment de l'édition via l'[éditeur](/workspace/collisions#collision-groups) de Studio et d'appeler `Class.WorldRoot:UnregisterCollisionGroup()|UnregisterCollisionGroup()` et `Class.WorldRoot:RenameCollisionGroup()|RenameCollisionGroup()` aussi rarement que possible.


WorldRoot:RegisterCollisionGroup

Enregistre un nouveau groupe de collision dans ce monde avec le nom donné.


Renomme le groupe de collision enregistré spécifié dans ce monde, mais ne renomme **pas** la propriété `Class.BasePart.CollisionGroup|CollisionGroup` des parties qui utilisent le groupe. Le premier argument de cette méthode est le nom du groupe à renommer, le deuxième argument est le nouveau nom pour le groupe. Si le groupe spécifié n'existe pas, cette méthode ne fera rien. Les conventions de nommage pour le nouveau nom suivent les mêmes règles que si le groupe était créé avec `Class.WorldRoot:RegisterCollisionGroup()|RegisterCollisionGroup()`.

Cette méthode générera une erreur d'exécution dans les circonstances suivantes :

- Nom invalide ou vide fourni pour l'un des arguments.
- La méthode est appelée depuis un client.

Notez que cette méthode a un léger surcoût de performance basé sur le nombre de `Class.BasePart|BaseParts` dans le monde, il est donc recommandé d'enregistrer tous les groupes de collision au moment de l'édition via l'[éditeur](/workspace/collisions#collision-groups) de Studio et de les renommer aussi rarement que possible.


WorldRoot:RenameCollisionGroup

from

Renomme le groupe de collision spécifié dans ce monde.


Lance la forme du `Class.BasePart` donné dans une direction donnée et renvoie la première collision avec un `Class.BasePart` ou une cellule `Class.Terrain`. Cela est analogue à la façon dont `Class.WorldRoot:Raycast()` lance un rayon linéaire dans une direction pour trouver une collision, mais utilise une forme 3D au lieu d'un rayon. Contrairement à `Class.WorldRoot:Blockcast()` et `Class.WorldRoot:Spherecast()`, qui utilisent une simple boîte ou sphère, cette méthode lance la géométrie réelle de la partie fournie.

Contrairement à `Class.WorldRoot:GetPartsInPart()`, cette méthode ne détecte pas les `Class.BasePart|BaseParts` qui **intersectent initialement** la forme.

Si un impact est détecté, un `Datatype.RaycastResult` est renvoyé contenant les informations d'impact. La propriété `Datatype.RaycastResult.Distance|Distance` représente la distance que la forme doit parcourir pour trouver un impact, et la propriété `Datatype.RaycastResult.Position|Position` représente le point d'intersection qui cause l'impact.

Cette méthode génère une erreur si elle reçoit une partie inexistante, une direction invalide, ou une partie avec une géométrie `Class.Terrain`.


WorldRoot:Shapecast

La partie dont la forme est lancée. Le lancement utilise la géométrie de cette partie (bloc, balle, maillage, etc.) et sa taille ; des parties excessivement grandes peuvent ne pas être prises en charge, et cela ne peut pas être une partie `Class.Terrain`.


Direction du lancement de forme, avec la magnitude représentant la distance maximale que la forme peut parcourir. La distance maximale est de 1024 studs.


Un objet utilisé pour spécifier l'éligibilité des impacts dans l'opération de lancement de forme. Si non fourni, des valeurs par défaut sont utilisées où toutes les autres parties sont considérées et l'eau `Class.Terrain` n'est pas ignorée. La partie lancée est toujours exclue des résultats.


Contient le résultat de l'opération de lancement de forme, ou `nil` si aucun `Class.BasePart` ou cellule `Class.Terrain` éligible n'a été touché.


Lance la forme d'un `Class.BasePart` donné dans une direction et renvoie un `Datatype.RaycastResult` si la forme touche un `Class.BasePart` ou une cellule `Class.Terrain`.


Lance une sphère et renvoie la première collision avec un `Class.BasePart` ou
`Class.Terrain`. Imprime les propriétés du RaycastResult si un résultat a été
 frappé.

Lance une forme sphérique dans une direction donnée et renvoie la première collision avec un `Class.BasePart` ou une cellule `Class.Terrain`. Cela est analogue à la façon dont `Class.WorldRoot:Raycast()` lance un rayon linéaire dans une direction pour trouver une collision, mais utilise une forme 3D au lieu d'un rayon.

Contrairement à `Class.WorldRoot:GetPartsInPart()`, cette méthode ne détecte pas les `Class.BasePart|BaseParts` qui **intersectent initialement** la forme.

Si un impact est détecté, un `Datatype.RaycastResult` est renvoyé contenant les informations d'impact. La propriété `Datatype.RaycastResult.Distance|Distance` représente la distance que la forme doit parcourir pour trouver un impact, et la propriété `Datatype.RaycastResult.Position|Position` représente le point d'intersection qui cause l'impact.

Cette méthode génère une erreur si elle reçoit des entrées de rayon ou de direction invalides.


WorldRoot:Spherecast

La position initiale de la forme sphérique lancée.


Le rayon de la forme sphérique lancée en studs. Le rayon maximum est de 256 studs.


Un objet utilisé pour spécifier l'éligibilité des impacts dans l'opération de lancement de forme. Si non fourni, des valeurs par défaut sont utilisées où toutes les parties sont considérées et l'eau `Class.Terrain` n'est pas ignorée.


Lance une forme sphérique dans une direction donnée et renvoie un `Datatype.RaycastResult` si la forme touche un `Class.BasePart` ou une cellule `Class.Terrain`.


Simule les pièces dans l'espace de travail pendant une période fixe en appelant la
fonction StepPhysics une fois par image jusqu'à ce qu'un temps spécifié se soit écoulé.

Fait avancer la simulation pour les parties dans le monde en fonction d'un incrément de temps spécifié et d'un ensemble optionnel de `Class.BasePart`. Lorsqu'un ensemble de parties est spécifié, seules ces parties seront simulées et toutes les autres parties dans le monde seront traitées comme ancrées. Lorsque cet argument est omis, toutes les parties dans le monde seront incluses dans la simulation. L'incrément de temps spécifié peut être n'importe quel nombre positif, des valeurs plus grandes augmentant le temps d'exécution de la fonction. En fonction de la valeur de l'incrément de temps, le système physique peut le subdiviser en plusieurs étapes individuelles pour maintenir la précision et la stabilité de la simulation. Même si la fonction effectue plusieurs sous-étapes, les résultats de la simulation ne seront visibles qu'une fois la fonction terminée. Pour visualiser les étapes individuelles d'une simulation, la fonction peut être appelée une fois par RenderStep via l'événement `Class.RunService.RenderStepped`.


WorldRoot:StepPhysics

La quantité de temps qui sera simulée. Cet argument doit être un nombre positif. Des valeurs plus grandes augmenteront le temps d'exécution de cette fonction.


parts

Tableau optionnel de parties qui seront simulées. Cet ensemble doit contenir des instances de type `Class.BasePart` ; tout autre type sera ignoré.


Fait avancer la simulation pour les parties dans le monde en fonction d'un incrément de temps spécifié et d'un ensemble optionnel de `Class.BasePart|BaseParts`.


Désenregistre le groupe de collision pour le nom donné dans ce monde, avec les comportements suivants :

- Si un nom invalide est fourni, la méthode ne fera rien.
- Si le nom réservé `"Default"` est fourni **ou** si la méthode est appelée depuis un client, elle générera une erreur.
- Si des parties se trouvent dans le groupe de collision lorsqu'il est supprimé, ces parties conserveront toujours le même nom de groupe de collision. Le comportement physique des parties dans un groupe supprimé est indéfini, il est donc recommandé de déplacer toutes les parties dans un groupe supprimé vers un autre groupe, comme le groupe `"Default"`.

Notez que cette méthode a un léger surcoût de performance basé sur le nombre de `Class.BasePart|BaseParts` dans le monde, il est donc recommandé d'enregistrer tous les groupes de collision au moment de l'édition via l'[éditeur](/workspace/collisions#collision-groups) de Studio et d'appeler cette méthode aussi rarement que possible.


WorldRoot:UnregisterCollisionGroup

Désenregistre le groupe de collision pour le nom donné dans ce monde.


WorldRoot

Classe de base pour gérer la simulation physique et les requêtes spatiales 3D.

L'exemple suivant inclut une fonction de base qui prend une table d'objets
et les parenthèses 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 démontre la création manuelle de joints sur deux parties qui sont
sœurs du script (PartA et PartB). Il crée des joints sur deux parties 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

Démontre `Class.Model:GetBoundingBox()`.


Cette fonction renvoie une description d'un volume qui contient tous les enfants `Class.BasePart` dans un `Class.Model`. L'orientation du volume est basée sur l'orientation du `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 englobante et un `Datatype.Vector3` représentant sa taille. La taille peut être inexacte à l'exécution si des contraintes physiques agissent sur les parties à l'intérieur du `Class.Model`.

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

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

Model

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

/reference/engine/classes/WorldModel.yaml