Collisions

Une collision se produit lorsque deux objets 3D entrent en contact dans le monde 3D. Pour un traitement des collisions personnalisé, BasePart dispose d'un ensemble d'événements de collision et de techniques de filtrage de collision, vous permettant de contrôler quels ensembles physiques entrent en collision avec d'autres.

Événements de collision

Les événements de collision se produisent lorsque deux BaseParts se touchent ou cessent de se toucher dans le monde 3D. Vous pouvez détecter ces collisions via les événements Touched et TouchEnded qui se produisent indépendamment de la valeur de la propriété CanCollide de chaque partie. Lorsque vous envisagez le traitement des collisions sur les parties, notez ce qui suit :

• La propriété CanTouch d'une pièce détermine si elle déclenche des événements de collision. Si elle est définie sur false, ni Touched ni TouchEnded ne se déclencheront.
• La propriété CanCollide d'une pièce affecte si elle sera physiquement en collision avec d'autres pièces et si des forces agiront sur elles. Même si CanCollide est désactivée pour une pièce, vous pouvez détecter le toucher et le non-toucher via les événements Touched et TouchEnded.
• Les événements Touched et TouchEnded ne se déclenchent que par le mouvement physique, et non par des modifications de Position ou CFrame qui entraînent une intersection ou la fin d'une intersection avec une autre pièce.
• La classe de niveau supérieur Terrain hérite de BasePart, vous pouvez donc attribuer un groupe de collision à Terrain pour déterminer si d'autres BaseParts entrent en collision avec des voxels de Terrain.

Touched

L'événement Touched se déclenche lorsqu'un BasePart entre en contact avec un autre, ou avec un voxel de Terrain. Il ne se déclenche que par simulation physique et ne se déclenchera pas lorsque la Position ou CFrame de la pièce est explicitement définie de manière à ce qu'elle intersecte une autre pièce ou un voxel.

Le schéma de code suivant montre comment l'événement Touched peut être connecté à une fonction onTouched() personnalisée. Notez que l'événement envoie l'argument otherPart à la fonction, indiquant l'autre pièce impliquée dans la collision.

local Workspace = game:GetService("Workspace")

local part = Workspace.Part

local function onTouched(otherPart)
	print(part.Name .. " a collidé avec " .. otherPart.Name)
end

part.Touched:Connect(onTouched)

Notez que l'événement Touched peut se déclencher plusieurs fois rapidement en raison de collisions physiques subtiles, par exemple lorsque un objet en mouvement "se stabilise" dans une position de repos ou lorsqu'une collision implique un modèle à plusieurs pièces. Pour éviter de déclencher plus d'événements Touched que nécessaire, vous pouvez mettre en œuvre un simple système de debounce qui impose une période de "cooldown" via un attribut d'instance.

local Workspace = game:GetService("Workspace")

local part = Workspace.Part

local COOLDOWN_TIME = 1

local function onTouched(otherPart)
	if not part:GetAttribute("Touched") then
		print(part.Name .. " a collidé avec " .. otherPart.Name)

		part:SetAttribute("Touched", true)  -- Définir l'attribut sur true
		task.wait(COOLDOWN_TIME)  -- Attendre la durée de cooldown
		part:SetAttribute("Touched", false)  -- Réinitialiser l'attribut
	end
end

part.Touched:Connect(onTouched)

TouchEnded

L'événement TouchEnded se déclenche lorsque l'ensemble des limites de collision d'un BasePart sort des limites d'un autre BasePart ou d'un voxel de Terrain rempli. Il ne se déclenche que par simulation physique et ne se déclenchera pas lorsque la Position ou CFrame de la pièce est explicitement définie de manière à ce qu'elle cesse d'intersecter une autre pièce ou un voxel.

Le schéma de code suivant montre comment l'événement TouchEnded peut être connecté à une fonction onTouchEnded() personnalisée. Comme pour Touched, l'événement envoie l'argument otherPart à la fonction, indiquant l'autre pièce impliquée.

local Workspace = game:GetService("Workspace")

local part = Workspace.Part

local function onTouchEnded(otherPart)
	print(part.Name .. " ne touche plus " .. otherPart.Name)
end

part.TouchEnded:Connect(onTouchEnded)

Filtrage de collision

Le filtrage de collision définit quelles pièces physiques entrent en collision avec d'autres. Vous pouvez configurer le filtrage pour de nombreux objets via des groupes de collision ou contrôler les collisions sur une base part-à-part avec des instances de NoCollisionConstraint.

Groupes de collision

Les groupes de collision vous permettent d'assigner des BaseParts à des groupes dédiés et de spécifier s'ils entrent en collision avec ceux d'autres groupes. Les pièces au sein de groupes non-collidants passent complètement à travers les autres, même si les deux pièces ont leur propriété CanCollide définie sur true.

Vous pouvez facilement configurer des groupes de collision via l'éditeur de Groupes de collision de Studio, accessible via le menu Fenêtre ⟩ 3D de Studio.

L'éditeur fonctionne en mode Liste : qui privilégie le docking sur le côté gauche ou droit de Studio, ou en mode Table plus large, qui privilégie le docking en haut ou en bas.

Enregistrer des groupes

L'éditeur comprend un groupe de collision Par défaut qui ne peut pas être renommé ou supprimé. Tous les BaseParts appartiennent automatiquement à ce groupe par défaut à moins d'être assignés à un autre groupe, ce qui signifie qu'ils entreront en collision avec tous les autres objets du groupe Par défaut.

Pour créer un nouveau groupe de collision :

1. Cliquez sur le bouton Ajouter un groupe en haut du panneau d'éditeur, entrez un nouveau nom de groupe, puis appuyez sur Enter. Le nouveau groupe apparaît dans les deux colonnes de la vue liste, ou dans la colonne de gauche et la rangée supérieure de la vue table.

   Vue ListeVue Table

   

2. Répétez le processus si nécessaire, en choisissant un nom unique et descriptif pour chaque groupe. Notez que vous pouvez modifier le nom d'un groupe pendant le développement en cliquant dans son champ, ou en le sélectionnant et en cliquant sur le bouton renommer.

   

Configurer les collisions de groupe

Dans la configuration par défaut, les objets de tous les groupes entrent en collision les uns avec les autres. Pour empêcher les objets d'un groupe de rentrer en collision avec des objets d'un autre groupe, décocher la case dans la rangée/colonne respective.

Dans l'exemple suivant, les objets du groupe Cubes ne rentreront pas en collision avec les objets du groupe Portes.

Assigner des objets à des groupes

Pour assigner des objets à des groupes que vous avez enregistrés via l'éditeur de Studio :

1. Sélectionnez un ou plusieurs BaseParts qui peuvent faire partie d'un groupe de collision.

2. Assignez-les au groupe en cliquant sur le bouton ⊕ pour sa rangée. Les objets ne peuvent appartenir qu'à un seul groupe de collision à la fois, donc les placer dans un nouveau groupe les retire de leur groupe actuel.

   

Une fois assigné, le nouveau groupe est reflété sous la propriété CollisionGroup de l'objet.

Groupe de collision StudioSelectable

Les outils dans Studio utilisent le système de filtrage de collision pour déterminer quels objets sont des candidats à la sélection lorsqu'on clique dans la vue 3D. Les objets dont le groupe de collision assigné ne collident pas avec StudioSelectable seront ignorés.

Par exemple, si vous avez des points de contrôle dans une expérience de course dont les zones effectives sont définies par de grandes pièces transparentes, vous pouvez les assigner à un groupe de collision Points de contrôle et ensuite faire en sorte que ce groupe soit non-collidable avec StudioSelectable afin qu'ils ne gênent pas lorsque vous éditez la géométrie de carte sous-jacente.

Pour le code de plugin, il est recommandé d'assigner "StudioSelectable" comme filtre de groupe de collision de votre RaycastParams lors de la recherche de pièces sous le curseur. Cela permet à vos plugins de correspondre aux mécanismes de sélection que les créateurs ont appris à attendre des outils intégrés de Studio.

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

local raycastParams = RaycastParams.new()
raycastParams.CollisionGroup = "StudioSelectable"  -- Pour suivre la convention
raycastParams.BruteForceAllSlow = true  -- Pour que les pièces avec CanQuery de "false" puissent être sélectionnées

local mouseLocation = UserInputService:GetMouseLocation()
local mouseRay = Workspace.CurrentCamera:ViewportPointToRay(mouseLocation.X, mouseLocation.Y)
local filteredSelectionHit = Workspace:Raycast(mouseRay.Origin, mouseRay.Direction * 10000, raycastParams)

Filtrage part-à-part

Pour empêcher les collisions entre deux pièces spécifiques sans établir des groupes de collision, par exemple entre la roue d'un véhicule et son châssis, envisagez la contrainte No Collision. Les avantages incluent :

• Les groupes de collision et/ou les scripts de configuration ne sont pas requis, vous permettant de créer et de partager facilement des modèles avec un filtrage de collision personnalisé.
• Les pièces connectées ne collident pas entre elles, mais elles peuvent toujours entrer en collision avec d'autres objets.

Désactiver les collisions de personnage

Les personnages des joueurs Roblox entrent en collision les uns avec les autres par défaut. Cela peut entraîner un gameplay intéressant mais non intentionnel, tel que des personnages sautant sur les uns sur les autres pour atteindre des zones spécifiques. Si ce comportement est indésirable, vous pouvez l'empêcher via le script suivant dans le ServerScriptService.

local PhysicsService = game:GetService("PhysicsService")
local Players = game:GetService("Players")

PhysicsService:RegisterCollisionGroup("Personnages")
PhysicsService:CollisionGroupSetCollidable("Personnages", "Personnages", false)

local function onDescendantAdded(descendant)
	-- Définir le groupe de collision pour toute partie descendante
	if descendant:IsA("BasePart") then
		descendant.CollisionGroup = "Personnages"
	end
end

local function onCharacterAdded(character)
	-- Traiter les descendants existants et nouveaux pour la configuration physique
	for _, descendant in character:GetDescendants() do
		onDescendantAdded(descendant)
	end
	character.DescendantAdded:Connect(onDescendantAdded)
end

Players.PlayerAdded:Connect(function(player)
	-- Détecter quand le personnage du joueur est ajouté
	player.CharacterAdded:Connect(onCharacterAdded)
end)

Collisions de modèle

Les objets Model sont des conteneurs pour des pièces plutôt que d'hériter de BasePart, donc ils ne peuvent pas se connecter directement aux événements BasePart.Touched ou BasePart.TouchEnded. Pour déterminer si un modèle déclenche des événements de collision, vous devez boucler à travers ses enfants et connecter les fonctions onTouched() et onTouchEnded() personnalisées à chaque BasePart.

L'échantillon de code suivant connecte toutes les BaseParts d'un modèle à plusieurs pièces aux événements de collision et suit le nombre total de collisions avec d'autres pièces.

local model = script.Parent

local numTouchingParts = 0

local function onTouched(otherPart)
	-- Ignorer les instances du modèle s'intersectant elles-mêmes
	if otherPart:IsDescendantOf(model) then return end
	-- Augmenter le nombre de parties du modèle en contact
	numTouchingParts += 1

	print(model.Name, "intersecté avec", otherPart.Name, "| Pièces du modèle en contact :", numTouchingParts)
end

local function onTouchEnded(otherPart)
	-- Ignorer les instances du modèle se désintersectant elles-mêmes
	if otherPart:IsDescendantOf(model) then return end
	-- Diminuer le nombre de parties du modèle en contact
	numTouchingParts -= 1

	print(model.Name, "ne s'intersecte plus", otherPart.Name, "| Pièces du modèle en contact :", numTouchingParts)
end

for _, child in model:GetChildren() do
	if child:IsA("BasePart") then
		child.Touched:Connect(onTouched)
		child.TouchEnded:Connect(onTouchEnded)
	end
end

Collisions entre maillage et modélisation solide

Les MeshPart et PartOperation (pièces jointes par modélisation solide) sont des sous-classes de BasePart, donc les maillages et les parties modélisées solides héritent des mêmes événements de collision et options de filtrage de collision que les parties normales. Cependant, étant donné que les maillages et les parties à modélisation solide ont généralement des géométries plus complexes, elles possèdent une propriété distinctive CollisionFidelity qui détermine à quel point les limites physiques s'alignent précisément avec la représentation visuelle pour le traitement des collisions.

La propriété CollisionFidelity a les options suivantes, par ordre de fidélité et d'impact sur les performances du plus bas au plus élevé :

• Boîte — Crée une boîte de collision englobante, idéale pour les objets petits ou non interactifs.
• Coque — Génère une coque convexe, adaptée aux objets avec moins d'indentations ou de cavités prononcées.
• Par défaut — Produit une forme de collision approximative qui supporte la concavité, adaptée aux objets complexes ayant des besoins d'interaction semi-détaillés.
• DécompositionConvexePrécise — Offre la plus grande précision, mais pas encore une représentation 1:1 de l'élément visuel. Cette option a le coût de performance le plus élevé et nécessite plus de temps pour que le moteur le calcule.

Pour plus d'informations sur l'impact sur les performances des options de fidélité de collision et comment les atténuer, consultez Optimisation des performances.