BasePart

La propriété Anchored détermine si la partie sera immobile par la physique.Lorsqu'il est activé, une partie ne changera jamais de position en raison de la gravité, des collisions d'autres parties, du chevauchement d'autres parties ou de toute autre cause liée à la physique.Par resultats, deux parties ancrées ne déclencheront jamais l'événement Touched l'une sur l'autre.

Une partie ancrée peut toujours être déplacée en modifiant son CFrame ou Position , et elle peut toujours avoir un non zéro AssemblyLinearVelocity et AssemblyAngularVelocity .

Enfin, si une partie non ancrée est jointe à une partie ancrée via un objet comme un Weld, elle agira également ancrée.Si une telle jointure se brise, la partie peut à nouveau être affectée par la physique.Voir Assemblages pour plus de détails.

La propriété réseau ne peut pas être définie sur des parties ancrées.Si le statut d'ancrage d'une partie change sur le serveur, la propriété réseau de cette partie sera affectée.

local part = script.Parent

-- Create a ClickDetector so we can tell when the part is clicked
local cd = Instance.new("ClickDetector", part)

-- This function updates how the part looks based on its Anchored state
local function updateVisuals()
	if part.Anchored then
		-- When the part is anchored...
		part.BrickColor = BrickColor.new("Bright red")
		part.Material = Enum.Material.DiamondPlate
	else
		-- When the part is unanchored...
		part.BrickColor = BrickColor.new("Bright yellow")
		part.Material = Enum.Material.Wood
	end
end

local function onToggle()
	-- Toggle the anchored property
	part.Anchored = not part.Anchored

	-- Update visual state of the brick
	updateVisuals()
end

-- Update, then start listening for clicks
updateVisuals()
cd.MouseClick:Connect(onToggle)

Le vecteur de vitesse angulaire de l'assemblage de cette partie. C'est le taux de changement d'orientation en radians par seconde.

La vitesse angulaire est la même à chaque point de l'assemblage.

Définir la vitesse directement peut entraîner un mouvement irréaliste.L'utilisation de Torque ou AngularVelocity contrainte est préférée, ou utilisez ApplyAngularImpulse() si vous voulez un changement instantané de vitesse.

Si la partie est possédée par le serveur, cette propriété doit être modifiée à partir d'un serveur Script (pas d'un LocalScript ou d'un Script avec RunContext défini sur Enum.RunContext.Client ).Si la partie est possédée par un client via la propriété automatique de possession, cette propriété peut être modifiée à partir d'un script client ou d'un script serveur ; changer la propriété d'un script client pour une partie appartenant à un serveur n'aura aucun effet.

Une position calculée via les Mass et Position de toutes les parties de l'assemblage.

Si l'assemblage a une partie ancrée, le centre de masse de cette partie sera le centre de masse de l'assemblage et l'assemblage aura une masse infinie.

Connaître le centre de masse peut aider l'assemblage à maintenir sa stabilité.Une force appliquée au centre de masse ne provoquera pas d'accélération angulaire, seulement linéaire.Une assemblage avec un centre de masse bas aura un meilleur temps de maintien debout sous l'effet de la gravité.

Le vecteur de vitesse linéaire de l'assemblage de cette partie. C'est le taux de changement de position de AssemblyCenterOfMass en studs par seconde.

Si vous voulez connaître la vitesse à un point autre que le centre de masse de l'assemblage, utilisez GetVelocityAtPosition() .

Définir la vitesse directement peut entraîner un mouvement irréaliste.L'utilisation d'une contrainte VectorForce est préférée, ou utilisez ApplyImpulse() si vous voulez un changement instantané de vitesse.

Si la partie est possédée par le serveur, cette propriété doit être modifiée à partir d'un serveur Script (pas d'un LocalScript ou d'un Script avec RunContext défini sur Enum.RunContext.Client ).Si la partie est possédée par un client via la propriété automatique de possession, cette propriété peut être modifiée à partir d'un script client ou d'un script serveur ; changer la propriété d'un script client pour une partie appartenant à un serveur n'aura aucun effet.

La somme de la masse de tout le BaseParts dans l'assemblage de cette partie.Les parties qui sont Massless et qui ne sont pas la partie racine de l'assemblage ne contribueront pas au AssemblyMass.

Si l'assemblage a une partie ancrée, la masse de l'assemblage est considérée comme infinie.Les contraintes et autres interactions physiques entre assemblages non ancrés avec une grande différence de masse peuvent provoquer des instabilités.

Cette propriété indique la BasePart automatiquement choisie pour représenter la partie racine de l'assemblage.C'est la même partie qui est retournée lorsque les développeurs appellent GetRootPart() .

La partie racine peut être modifiée en modifiant le RootPriority des parties dans l'assemblage.

Les parties qui partagent toutes la même AssemblyRootPart sont dans la même assemblée.

Pour plus d'informations sur les parties racines, voir Assemblages.

AudioCanCollide détermine si la partie interagira physiquement avec la simulation audio, similaire à CastShadow pour l'éclairage.

Lorsqu'il est désactivé, l'audio passe à travers la partie ; il n'est pas obstrué ou réfléchi.

La propriété BackSurface détermine le type de surface utilisé pour la direction positive Z d'une partie.Lorsque les faces de deux parties sont placées côte à côte, elles peuvent créer une jointure entre elles.

La propriété BottomSurface détermine le type de surface utilisé pour la direction négative Y d'une partie.Lorsque les faces de deux parties sont placées côte à côte, elles peuvent créer une jointure entre elles.

Cette propriété détermine la couleur d'une partie.Si la partie a un Material, cela détermine également la couleur utilisée lors de la rendition de la texture du matériau.Pour plus de contrôle sur la couleur, la propriété Color peut être utilisée et cette propriété utilisera la plus proche BrickColor.

D'autres propriétés visuelles d'une partie sont déterminées par Transparency et Reflectance .

La propriété CFrame détermine à la fois la position et l'orientation du BasePart dans le monde.Il agit comme un emplacement de référence arbitraire sur la géométrie, mais ExtentsCFrame représente le véritable CFrame de son centre physique.

Lorsque vous définissez CFrame sur une partie, d'autres parties jointes sont également déplacées par rapport à la partie, mais il est recommandé d'utiliser PVInstance:PivotTo() pour déplacer un modèlisationentier, comme lors du téléportation du personnage d'un joueur.

Contrairement à la définition de BasePart.Position , la définition de CFrame déplacera toujours la partie à l'exactement donné CFrame ; en d'autres termes : aucun contrôle de chevauchement n'est effectué et le solveur de physique tentera de résoudre tout chevauchement à moins que les deux parties ne soient Anchored .

Pour suivre les positions relatives à une partie de CFrame, un Attachment peut être utile.

local part = script.Parent:WaitForChild("Part")
local otherPart = script.Parent:WaitForChild("OtherPart")

-- Reset the part's CFrame to (0, 0, 0) with no rotation.
-- This is sometimes called the "identity" CFrame
part.CFrame = CFrame.new()

-- Set to a specific position (X, Y, Z)
part.CFrame = CFrame.new(0, 25, 10)

-- Same as above, but use a Vector3 instead
local point = Vector3.new(0, 25, 10)
part.CFrame = CFrame.new(point)

-- Set the part's CFrame to be at one point, looking at another
local lookAtPoint = Vector3.new(0, 20, 15)
part.CFrame = CFrame.lookAt(point, lookAtPoint)

-- Rotate the part's CFrame by pi/2 radians on local X axis
part.CFrame = part.CFrame * CFrame.Angles(math.pi / 2, 0, 0)
-- Rotate the part's CFrame by 45 degrees on local Y axis
part.CFrame = part.CFrame * CFrame.Angles(0, math.rad(45), 0)
-- Rotate the part's CFrame by 180 degrees on global Z axis (note the order!)
part.CFrame = CFrame.Angles(0, 0, math.pi) * part.CFrame -- Pi radians is equal to 180 degrees

-- Composing two CFrames is done using * (the multiplication operator)
part.CFrame = CFrame.new(2, 3, 4) * CFrame.new(4, 5, 6) --> equal to CFrame.new(6, 8, 10)

-- Unlike algebraic multiplication, CFrame composition is NOT communitative: a * b is not necessarily b * a!
-- Imagine * as an ORDERED series of actions. For example, the following lines produce different CFrames:
-- 1) Slide the part 5 units on X.
-- 2) Rotate the part 45 degrees around its Y axis.
part.CFrame = CFrame.new(5, 0, 0) * CFrame.Angles(0, math.rad(45), 0)
-- 1) Rotate the part 45 degrees around its Y axis.
-- 2) Slide the part 5 units on X.
part.CFrame = CFrame.Angles(0, math.rad(45), 0) * CFrame.new(5, 0, 0)

-- There is no "CFrame division", but instead simply "doing the inverse operation".
part.CFrame = CFrame.new(4, 5, 6) * CFrame.new(4, 5, 6):Inverse() --> is equal to CFrame.new(0, 0, 0)
part.CFrame = CFrame.Angles(0, 0, math.pi) * CFrame.Angles(0, 0, math.pi):Inverse() --> equal to CFrame.Angles(0, 0, 0)

-- Position a part relative to another (in this case, put our part on top of otherPart)
part.CFrame = otherPart.CFrame * CFrame.new(0, part.Size.Y / 2 + otherPart.Size.Y / 2, 0)

CanCollide détermine si une partie va interagir physiquement avec d'autres parties.Lorsqu'il est désactivé, d'autres parties peuvent passer à travers la partie sans interruption.Les parties utilisées pour la décoration ont généralement CanCollide, car elles n'ont pas besoin d'être prises en compte par le moteur de physique.

Si une partie n'est pas Anchored et a CanCollide désactivé, elle peut tomber du monde pour être finalement détruite par Workspace.FallenPartsDestroyHeight .

Lorsque CanCollide est désactivé, les parties peuvent toujours déclencher l'événement Touched (ainsi que les autres parties qui les touchent).Vous pouvez désactiver cela avec CanTouch .

Pour plus d'informations sur les collisions, voir Collisions.

-- Paste into a Script inside a tall part
local part = script.Parent

local OPEN_TIME = 1

-- Can the door be opened at the moment?
local debounce = false

local function open()
	part.CanCollide = false
	part.Transparency = 0.7
	part.BrickColor = BrickColor.new("Black")
end

local function close()
	part.CanCollide = true
	part.Transparency = 0
	part.BrickColor = BrickColor.new("Bright blue")
end

local function onTouch(otherPart)
	-- If the door was already open, do nothing
	if debounce then
		print("D")
		return
	end

	-- Check if touched by a Humanoid
	local human = otherPart.Parent:FindFirstChildOfClass("Humanoid")
	if not human then
		print("not human")
		return
	end

	-- Perform the door opening sequence
	debounce = true
	open()
	task.wait(OPEN_TIME)
	close()
	debounce = false
end

part.Touched:Connect(onTouch)
close()

Cette propriété détermine si la partie est prise en compte lors des opérations de requête spatiales, telles que GetPartBoundsInBox ou Raycast .Notez que CanCollide doit être désactivé pour que CanQuery ait lieu, et les fonctions de requête spatiale n'incluront jamais de parties avec CanQuery de false.

Au-delà de cette propriété, il est également possible d'exclure des parties qui sont des descendantes d'une liste donnée de parties en utilisant un objet OverlapParams ou RaycastParams lors de l'appel des fonctions de requête spatiales.

Cette propriété détermine si Touched et TouchEnded événements se déclenchent sur la partie.Si true , d'autres parties sensibles doivent également avoir CanTouch défini à true pour que les événements de toucher se lancer.Si false , les événements de touchage ne peuvent pas être configurés pour la partie et tenter de le faire provoquera une erreur.De même, si la propriété est définie à false après qu'un événement de touch ait été connecté, l'événement sera déconnecté et la TouchTransmitter supprimée.

Notez que cette logique de collision peut être définie pour respecter les groupes de collision à travers la propriété Workspace.TouchesUseCollisionGroups.Si true , les parties des groupes non collisibles ignoreront les collisions et des événements de contact, ce qui rend cette propriété inutile.

Pérformance

Il y a un léger gain de performance sur les parties qui ont à la fois CanTouch et CanCollide définies à false, car ces parties n'auront jamais besoin de calculer aucune collision de partie à partie.Cependant, ils peuvent toujours être frappés par Raycasts et OverlapParams requêtes.

Détermine si oui ou non une partie lance une ombre.La désactivation de cette propriété pour une partie donnée peut provoquer des artefacts visuels sur les ombres projetées sur cette partie.

Cette propriété n'est pas conçue pour améliorer les performances, mais dans des scènes complexes, la désactivation stratégique de certaines parties peut améliorer les performances.En raison de la possibilité d'artefacts visuels, nous recommandons de le laisser activé sur toutes les parties dans la plupart des situations.

La propriété CenterOfMass décrit la position locale du centre de masse de une partie.Si c'est une assemblage de pièces individuelles, c'est le AssemblyCenterOfMass converti de l'espace mondial en local.Sur un simple Parts , le centre de masse est toujours (0, 0, 0) , mais il peut varier pour WedgePart ou MeshPart .

La propriété CollisionGroup décrit le nom du groupe de collision de la partie (maximum de 100 caractères).Les parties commencent dans le groupe par défaut dont le nom est "Default" .Cette valeur ne peut pas être vide.

Bien que cette propriété elle-même ne soit pas répliquée, le moteur réplique internement la valeur à travers une autre propriété privée pour résoudre les problèmes de compatibilité arrière.

local PhysicsService = game:GetService("PhysicsService")

local collisionGroupBall = "CollisionGroupBall"
local collisionGroupDoor = "CollisionGroupDoor"

-- Register collision groups
PhysicsService:RegisterCollisionGroup(collisionGroupBall)
PhysicsService:RegisterCollisionGroup(collisionGroupDoor)

-- Assign parts to collision groups
script.Parent.BallPart.CollisionGroup = collisionGroupBall
script.Parent.DoorPart.CollisionGroup = collisionGroupDoor

-- Set groups as non-collidable with each other and check the result
PhysicsService:CollisionGroupSetCollidable(collisionGroupBall, collisionGroupDoor, false)
print(PhysicsService:CollisionGroupsAreCollidable(collisionGroupBall, collisionGroupDoor)) --> false

La propriété Color détermine la couleur d'une partie.Si la partie a un Material, cela détermine également la couleur utilisée lors de la rendition de la texture du matériau.

Si cette propriété est configurer, BrickColor utilisera le match le plus proche de cette valeur Color.

D'autres propriétés visuelles d'une partie sont déterminées par Transparency et Reflectance .

-- Paste into a Script within StarterCharacterScripts
-- Then play the game, and fiddle with your character's health
local char = script.Parent
local human = char.Humanoid

local colorHealthy = Color3.new(0.4, 1, 0.2)
local colorUnhealthy = Color3.new(1, 0.4, 0.2)

local function setColor(color)
	for _, child in pairs(char:GetChildren()) do
		if child:IsA("BasePart") then
			child.Color = color
			while child:FindFirstChildOfClass("Decal") do
				child:FindFirstChildOfClass("Decal"):Destroy()
			end
		elseif child:IsA("Accessory") then
			child.Handle.Color = color
			local mesh = child.Handle:FindFirstChildOfClass("SpecialMesh")
			if mesh then
				mesh.TextureId = ""
			end
		elseif child:IsA("Shirt") or child:IsA("Pants") then
			child:Destroy()
		end
	end
end

local function update()
	local percentage = human.Health / human.MaxHealth

	-- Create a color by tweening based on the percentage of your health
	-- The color goes from colorHealthy (100%) ----- > colorUnhealthy (0%)
	local color = Color3.new(
		colorHealthy.R * percentage + colorUnhealthy.r * (1 - percentage),
		colorHealthy.G * percentage + colorUnhealthy.g * (1 - percentage),
		colorHealthy.B * percentage + colorUnhealthy.b * (1 - percentage)
	)
	setColor(color)
end

update()
human.HealthChanged:Connect(update)

CurrentPhysicalProperties indique les propriétés physiques actuelles de la pièce.Vous pouvez définir des valeurs personnalisées pour les propriétés physiques par partie, matériau personnalisé , et l'remplacerdu matériau.Le moteur Roblox priorise les définitions plus granulaires lors de la détermination des propriétés physiques efficaces d'une pièce.Les valeurs de la liste suivante sont dans l'ordre de la plus haute à la plus faible priorité :

• Propriétés physiques personnalisées de la pièce
• Propriétés physiques personnalisées du matériau personnalisé de la pièce
• Propriétés physiques personnalisées de l'annulation du matériau de la partie du matériau
• Propriétés physiques par défaut du matériau de la pièce

CustomPhysicalProperties vous permet de personnaliser divers aspects physiques d'une partie, tels que sa densité, sa friction et son élasticité.

Si cette propriété est activée, cette propriété vous permet de configurer ces propriétés physiques.Si désactivé, ces propriétés physiques sont déterminées par le Material de la partie.

local part = script.Parent

-- This will make the part light and bouncy!
local DENSITY = 0.3
local FRICTION = 0.1
local ELASTICITY = 1
local FRICTION_WEIGHT = 1
local ELASTICITY_WEIGHT = 1

local physProperties = PhysicalProperties.new(DENSITY, FRICTION, ELASTICITY, FRICTION_WEIGHT, ELASTICITY_WEIGHT)
part.CustomPhysicalProperties = physProperties

Lorsque true et lorsque Workspace.FluidForces est activé, cela fait en sorte que le moteur de physique calcule les forces aérodynamiques sur ce BasePart .

Le CFrame de l'extensión physique de la BasePart, représentant son centre physique.

La taille physique réelle du BasePart telle que perçue par le moteur de physique, par exemple dans détection de collision .

La propriété FrontSurface détermine le type de surface utilisé pour la direction négative Z d'une partie.Lorsque les faces de deux parties sont placées côte à côte, elles peuvent créer une jointure entre elles.

La propriété LeftSurface détermine le type de surface utilisé pour la direction négative X d'une pièce.Lorsque les faces de deux parties sont placées côte à côte, elles peuvent créer une jointure entre elles.

La propriété LocalTransparencyModifier est un multiplicateur de Transparency qui n'est visible que pour le client local.Il ne se réplique pas du client au serveur et est utile lorsqu'une partie ne doit pas être rendue pour un client spécifique, comme lorsque le joueur ne voit pas les parties du corps de son personnage lorsqu'il passe en mode première personne.

Cette propriété modifie la transparence de la partie locale à travers la formule suivante, avec des valeurs résultantes comprises entre 0 et 1.

1 - (( 1 - Transparency ) × ( 1 - LocalTransparencyModifier ))

<th><code>Modifieur de transparence locale</code></th>

    <th>Côté serveur</th>

    <th>Côté client</th>
  </tr>
</thead>

<tbody>
  <tr>
    <td><code>0.5</code></td>

    <td><code>0</code></td>

    <td><code>0.5</code></td>

    <td><code>0.5</code></td>
  </tr>

  <tr>
    <td><code>0.5</code></td>

    <td><code>0.25</code></td>

    <td><code>0.5</code></td>

    <td><code>0.625</code></td>
  </tr>

  <tr>
    <td><code>0.5</code></td>

    <td><code>0.5</code></td>

    <td><code>0.5</code></td>

    <td><code>0.75</code></td>
  </tr>

  <tr>
    <td><code>0.5</code></td>

    <td><code>0.75</code></td>

    <td><code>0.5</code></td>

    <td><code>0.875</code></td>
  </tr>

  <tr>
    <td><code>0.5</code></td>

    <td><code>1</code></td>

    <td><code>0.5</code></td>

    <td><code>1</code></td>
  </tr>
</tbody>

La propriété Locked détermine si une partie (ou un Model il est inclus) peut être sélectionné dans Studio en cliquant dessus.Cette propriété est le plus souvent activée sur les parties des modèles d'environnement qui ne sont pas en cours d'édition en ce moment.

-- Paste into a Script within a Model you want to unlock
local model = script.Parent

-- This function recurses through a model's heirarchy and unlocks
-- every part that it encounters.
local function recursiveUnlock(object)
	if object:IsA("BasePart") then
		object.Locked = false
	end

	-- Call the same function on the children of the object
	-- The recursive process stops if an object has no children
	for _, child in pairs(object:GetChildren()) do
		recursiveUnlock(child)
	end
end

recursiveUnlock(model)

Mass est une propriété de lecture qui décrit le produit du volume et de la densité d'une partie. Elle est retournée par la fonction GetMass().

• Le volume d'une partie est déterminé par son Size et son Shape, qui varie en fonction du type de BasePart utilisé, comme WedgePart.
• La densité d'une partie est déterminée par son Material ou CustomPhysicalProperties, si spécifié.

Si cette propriété est activée, la partie ne contribuera pas à la masse totale ou à l'inertie de son assemblage tant qu'elle est soudée à une autre partie qui a de la masse.

Si la partie est sa propre partie racine selon AssemblyRootPart, cela sera ignoré pour cette partie et elle contribuera toujours à son assemblage comme une partie normale.Les parties qui ne sont pas massives ne doivent jamais devenir une partie racine d'assemblage à moins que toutes les autres parties de l'assemblage ne soient également sans masse.

Cela pourrait être utile pour des choses comme des accessoires optionnels sur les véhicules que vous ne voulez pas affecter la manipulation de la voiture ou un maillage de rendu sans masse soudé à un maillage de collision plus simple.

Voir aussi Assemblages , un article qui décrit ce que sont les parties racines et comment les utiliser.

La propriété Material permet de définir la texture et les propriétés physiques par défaut d'une partie (dans le cas où CustomPhysicalProperties n'est pas défini).Le matériau par défaut Plastic a une texture très légère, tandis que le matériau SmoothPlastic n'a pas de texture du tout.Certaines textures matérielles comme DiamondPlate et Granite ont des textures très visibles.La texture de chaque matériau reflète la lumière du soleil différemment, notamment Foil .

Définir cette propriété puis activer CustomPhysicalProperties utilisera les propriétés physiques par défaut d'un matériau.Par instance, DiamondPlate est un matériau très dense alors que Wood est très léger.La densité d'une pièce détermine si elle flotte dans l'eau du terrain.

Les modifications de matériel Glass rendent le comportement du rendu sur les graphiques modérés en appliquant un peu de réflectivité (similaire à Reflectance ) et de distorsion de perspective.L'effet est particulièrement prononcé sur les pièces en forme de sphère.Les parties semi-transparentes derrière Glass parties ne sont pas visibles.

Le système recherche l'instance avec le nom et le taperspécifiés.Si elle trouve avec succès une instance correspondante MaterialVariant, elle utilise cette instance pour remplacer le matériau par défaut.Le matériau par défaut peut être le matériau intégré ou une annulation MaterialVariant spécifiée dans MaterialService .

La propriété Orientation décrit la rotation de la partie en degrés autour des axes X , Y et Z en utilisant un Vector3.Les rotations sont appliquées dans l'ordre Y X Z .Cela diffère des angles Euler appropriés et est plutôt des angles Tait-Bryan qui décrivent yaw , pitch et roll .

Il est également intéressant de noter comment cette propriété diffère du constructeur CFrame.Angles() qui applique des rotations dans un ordre différent ( Z ⟩ Y ⟩ X ).Pour un meilleur contrôle de la rotation d'une pièce, il est recommandé de définir CFrame à la place.

Lors de la définition de cette propriété, tout Welds ou Motor6Ds connecté à cette partie aura la propriété correspondante C0 ou C1 mise à jour pour permettre à la partie de se déplacer par rapport à toute autre partie à laquelle elle est jointe.WeldConstraints sera également temporairement désactivé et réactivé pendant le mouvement.

local part = script.Parent

local INCREMENT = 360 / 20

-- Faire pivoter la pièce en continu
while true do
	for degrees = 0, 360, INCREMENT do
		-- Définir uniquement la rotation de l'axe Y
		part.Rotation = Vector3.new(0, degrees, 0)
		-- Un meilleur moyen de le faire serait de définir CFrame
		--part.CFrame = CFrame. nouveau(part.Position) * CFrame.Angles(0, math.rad(degrés), 0)
		task.wait()
	end
end

Cette propriété spécifie le décalage du pivot de la partie par rapport à son CFrame , qui est BasePart:GetPivot() est le même que BasePart.CFrame multiplié par BasePart.PivotOffset .

Cela est pratique pour définir le pivot à un emplacement dans l'espace local , mais définir le pivot d'une partie à un emplacement dans l'espace du monde peut se faire comme suit :

local Workspace = game:GetService("Workspace")

local part = Workspace.BluePart
local desiredPivotCFrameInWorldSpace = CFrame.new(0, 10, 0)
part.PivotOffset = part.CFrame:ToObjectSpace(desiredPivotCFrameInWorldSpace)

local function resetPivot(model)
	local boundsCFrame = model:GetBoundingBox()
	if model.PrimaryPart then
		model.PrimaryPart.PivotOffset = model.PrimaryPart.CFrame:ToObjectSpace(boundsCFrame)
	else
		model.WorldPivot = boundsCFrame
	end
end

resetPivot(script.Parent)

local function createHand(length, width, yOffset)
	local part = Instance.new("Part")
	part.Size = Vector3.new(width, 0.1, length)
	part.Material = Enum.Material.Neon
	part.PivotOffset = CFrame.new(0, -(yOffset + 0.1), length / 2)
	part.Anchored = true
	part.Parent = workspace
	return part
end

local function positionHand(hand, fraction)
	hand:PivotTo(CFrame.fromEulerAnglesXYZ(0, -fraction * 2 * math.pi, 0))
end

-- Créer un dial
for i = 0, 11 do
	local dialPart = Instance.new("Part")
	dialPart.Size = Vector3.new(0.2, 0.2, 1)
	dialPart.TopSurface = Enum.SurfaceType.Smooth
	if i == 0 then
		dialPart.Size = Vector3.new(0.2, 0.2, 2)
		dialPart.Color = Color3.new(1, 0, 0)
	end
	dialPart.PivotOffset = CFrame.new(0, -0.1, 10.5)
	dialPart.Anchored = true
	dialPart:PivotTo(CFrame.fromEulerAnglesXYZ(0, (i / 12) * 2 * math.pi, 0))
	dialPart.Parent = workspace
end

-- Créer des mains
local hourHand = createHand(7, 1, 0)
local minuteHand = createHand(10, 0.6, 0.1)
local secondHand = createHand(11, 0.2, 0.2)

-- Exécuter l'horloge
while true do
	local components = os.date("*t")
	positionHand(hourHand, (components.hour + components.min / 60) / 12)
	positionHand(minuteHand, (components.min + components.sec / 60) / 60)
	positionHand(secondHand, components.sec / 60)
	task.wait()
end

La propriété Position décrit les coordonnées d'une partie en utilisant un Vector3.Il reflète la position de la partie CFrame , mais il peut également être configurer.

Lors de la définition de cette propriété, tout Welds ou Motor6Ds connecté à cette partie aura la propriété correspondante C0 ou C1 mise à jour pour permettre à la partie de se déplacer par rapport à toute autre partie à laquelle elle est jointe.WeldConstraints sera également temporairement désactivé et réactivé pendant le mouvement.

Indique le temps en secondes depuis que la physique de la partie a été mise à jour pour la dernière fois sur le client local ou le serveur.Cette valeur sera 0 lorsque la partie n'a pas de physique (Anchored est true).

La propriété Reflectance détermine à quel point une partie reflète le ciel.Une valeur de 0 indique que la partie n'est pas réfléchissante du tout, et une valeur de 1 indique que la partie devrait refléter pleinement.

La réflectance n'est pas affectée par Transparency à moins que la partie soit entièrement transparente, auquel cas la réflectance ne se rendra pas du tout.La réflectance peut ou peut ne pas être ignorée en fonction de la Material de la partie.

La propriété ResizeIncrement est une propriété de lecture seule qui décrit le plus petit changement de taille autorisé par la méthode Resize().Il diffère selon les implémentations de la classe abstraite BasePart ; par instance, Part a ce paramètre à 1 alors que TrussPart a ce paramètre à 2 puisque les sections de treillis individuelles sont de taille 2×2×2.

La propriété ResizeableFaces utilise un objet Faces pour décrire les différents visages sur lesquels une partie peut être redimensionnée.Pour la plupart des implémentations de BasePart , telles que Part et WedgePart , cette propriété inclut tous les visages.Cependant, TrussPart définira son ResizeableFaces ensemble à seulement deux visages puisque ces types de pièces doivent avoir deux Size dimensions de longueur 2 .

Cette propriété est le plus souvent utilisée avec des outils pour construire et manipuler des parties et a peu d'utilité en dehors de ce contexte.La classe peut être utilisée en conjonction avec cette propriété pour afficher uniquement les poignées sur les visages qui peuvent être redimensionnés sur une partie.

-- Put this Script in several kinds of BasePart, like
-- Part, TrussPart, WedgePart, CornerWedgePart, etc.
local part = script.Parent

-- Create a handles object for this part
local handles = Instance.new("Handles")
handles.Adornee = part
handles.Parent = part

-- Manually specify the faces applicable for this handle
handles.Faces = Faces.new(Enum.NormalId.Top, Enum.NormalId.Front, Enum.NormalId.Left)

-- Alternatively, use the faces on which the part can be resized.
-- If part is a TrussPart with only two Size dimensions
-- of length 2, then ResizeableFaces will only have two
-- enabled faces. For other parts, all faces will be enabled.
handles.Faces = part.ResizeableFaces

La propriété RightSurface détermine le type de surface utilisé pour la direction positive X d'une partie.Lorsque les faces de deux parties sont placées côte à côte, elles peuvent créer une jointure entre elles.

Cette propriété est un entier entre -127 et 127 qui a la priorité sur toutes les autres règles pour le trierde la partie racine.Lorsque vous envisagez plusieurs parties qui ne sont pas Anchored et qui partagent la même valeur Massless , une partie avec une valeur plus élevée RootPriority aura la priorité sur celles avec une valeur inférieure RootPriority .

Vous pouvez utiliser cette propriété pour contrôler quelle partie d'une assemblage est la partie racine et maintenir la partie racine stable en cas de modifications de taille.

Voir aussi Assemblages , un article qui décrit ce que sont les parties racines et comment les utiliser.

La rotation de la pièce en degrés pour les trois axes.

Lors de la définition de cette propriété, tout Welds ou Motor6Ds connecté à cette partie aura la propriété correspondante C0 ou C1 mise à jour pour permettre à la partie de se déplacer par rapport à toute autre partie à laquelle elle est jointe.WeldConstraints sera également temporairement désactivé et réactivé pendant le mouvement.

La propriété d'une partie détermine ses dimensions visuelles , tandis que représente la taille réelle utilisée par le moteur de physique, comme dans détection de collision .Les dimensions individuelles (longueur, largeur, hauteur) peuvent être aussi basses que 0.001 et aussi élevées que 2048.Les dimensions de taille en dessous de seront représentées visuellement comme si les dimensions de la pièce étaient .

La partie d'une pièce Size est utilisée de différentes manières supplémentaires :

• Pour influencer sa masse comme donnée par GetMass() .
• Par ParticleEmitter pour déterminer la zone d'où les particules sont générées.
• Par BlockMesh à déterminer partiellement le prisme rectangulaire rendu.
• Par SpecialMesh pour déterminer la taille du maillage rendu pour certains MeshTypes.
• Par SurfaceLight pour déterminer l'espace à éclairer.

local TOWER_BASE_SIZE = 30

local position = Vector3.new(50, 50, 50)

local hue = math.random()
local color0 = Color3.fromHSV(hue, 1, 1)
local color1 = Color3.fromHSV((hue + 0.35) % 1, 1, 1)

local model = Instance.new("Model")
model.Name = "Tower"

for i = TOWER_BASE_SIZE, 1, -2 do
	local part = Instance.new("Part")
	part.Size = Vector3.new(i, 2, i)
	part.Position = position
	part.Anchored = true
	part.Parent = model
	-- Tween from color0 and color1
	local perc = i / TOWER_BASE_SIZE
	part.Color = Color3.new(
		color0.R * perc + color1.R * (1 - perc),
		color0.G * perc + color1.G * (1 - perc),
		color0.B * perc + color1.B * (1 - perc)
	)

	position = position + Vector3.new(0, part.Size.Y, 0)
end
model.Parent = workspace

La propriété TopSurface détermine le type de surface utilisé pour la direction positive Y d'une partie.Lorsque les faces de deux parties sont placées côte à côte, elles peuvent créer une jointure entre elles.

La propriété Transparency contrôle la visibilité d'une partie sur une échelle de 0 à 1 où 0 est complètement visible (opaque) et 1 est complètement invisible (pas rendu du tout).

Bien que les parties entièrement transparentes ne soient pas rendues du tout, les objets partiellement transparents ont des coûts de rendu importants.Avoir de nombreuses parties translucides peut avoir un impact sur les performances.

Lorsque les parties transparentes se chevauchent, l'ordre de rendu peut agir de manière imprévisible, vous devez donc éviter les parties semi-transparentes de se chevaucher.

Voir aussi LocalTransparencyModifier comme multiplicateur de Transparency qui n'est visible que pour le client local.

-- Paste into a Script inside a tall part
local part = script.Parent

local OPEN_TIME = 1

-- Can the door be opened at the moment?
local debounce = false

local function open()
	part.CanCollide = false
	part.Transparency = 0.7
	part.BrickColor = BrickColor.new("Black")
end

local function close()
	part.CanCollide = true
	part.Transparency = 0
	part.BrickColor = BrickColor.new("Bright blue")
end

local function onTouch(otherPart)
	-- If the door was already open, do nothing
	if debounce then
		print("D")
		return
	end

	-- Check if touched by a Humanoid
	local human = otherPart.Parent:FindFirstChildOfClass("Humanoid")
	if not human then
		print("not human")
		return
	end

	-- Perform the door opening sequence
	debounce = true
	open()
	task.wait(OPEN_TIME)
	close()
	debounce = false
end

part.Touched:Connect(onTouch)
close()

Paramètres

Retours

Applique un impulsion de force angulaire instantanée à l'assemblage de cette partie, provoquant son rotation.

La vitesse angulaire résultante de l'impulsion repose sur la mass de l'assemblage.Il est donc nécessaire d'un impulsion plus élevée pour déplacer des assemblages plus massifs.Les impulsions sont utiles dans les cas où vous voulez qu'une force soit appliquée instantanément, comme une explosion ou une collision.

Si la partie est possédée par le serveur, cette fonction doit être appelée à partir d'un serveur Script (pas d'un LocalScript ou d'un Script avec RunContext défini sur Enum.RunContext.Client ).Si la partie est possédée par un client via la propriété automatique , cette fonction peut être appelée à partir d'un script client ou d'un script serveur ; l'appeler à partir d'un script client pour une partie appartenant à un serveur n'aura aucun effet.

Paramètres

Retours

Cette fonction applique un impulsion de force instantanée à l'assemblage de cette partie.

La force est appliquée à l'assemblage de center of mass, donc le mouvement résultant sera seulement linéaire.

La vitesse résultante de l'impulsion repose sur la mass de l'assemblage.Il est donc nécessaire d'un impulsion plus élevée pour déplacer des assemblages plus massifs.Les impulsions sont utiles dans les cas où vous voulez qu'une force soit appliquée instantanément, comme une explosion ou une collision.

Si la partie est possédée par le serveur, cette fonction doit être appelée à partir d'un serveur Script (pas d'un LocalScript ou d'un Script avec RunContext défini sur Enum.RunContext.Client ).Si la partie est possédée par un client via la propriété automatique , cette fonction peut être appelée à partir d'un script client ou d'un script serveur ; l'appeler à partir d'un script client pour une partie appartenant à un serveur n'aura aucun effet.

Paramètres

Retours

Cette fonction applique un impulsion de force instantanée à l'assemblage de cette partie, à la position spécifiée dans l'espace du monde.

Si la position n'est pas à l'assemblage de center of mass, l'impulsion provoquera un mouvement positionnel et rotatif.

La vitesse résultante de l'impulsion repose sur la mass de l'assemblage.Il est donc nécessaire d'un impulsion plus élevée pour déplacer des assemblages plus massifs.Les impulsions sont utiles dans les cas où les développeurs souhaitent appliquer une force instantanément, comme une explosion ou une collision.

Si la partie est possédée par le serveur, cette fonction doit être appelée à partir d'un serveur Script (pas d'un LocalScript ou d'un Script avec RunContext défini sur Enum.RunContext.Client ).Si la partie est possédée par un client via la propriété automatique , cette fonction peut être appelée à partir d'un script client ou d'un script serveur ; l'appeler à partir d'un script client pour une partie appartenant à un serveur n'aura aucun effet.

Paramètres

Retours

Renvoie si les parties peuvent se heurter les unes aux autres ou non.Cette fonction tient compte des groupes de collision des deux parties.Cette fonction échouera si la partie spécifiée n'est pas une BasePart.

Paramètres

Retours

La fonction CanSetNetworkOwnership vérifie si vous pouvez définir la propriété réseau d'une partie.

La valeur de retour de la fonction vérifie si vous pouvez ou non appeler BasePart:SetNetworkOwner() ou BasePart:SetNetworkOwnershipAuto() sans rencontrer d'erreur.Il renvoie vrai si vous pouvez modifier/lire la propriété du réseau, ou renvoie faux et la raison pour laquelle vous ne pouvez pas, en tant que chaîne.

Retours

local part = workspace:FindFirstChild("Part")

if part and part:IsA("BasePart") then
	local canSet, errorReason = part:CanSetNetworkOwnership()
	if canSet then
		print(part:GetFullName() .. "'s Network Ownership can be changed!")
	else
		warn("Cannot change the Network Ownership of " .. part:GetFullName() .. " because: " .. errorReason)
	end
end

Paramètres

Retours

Retourne une table de parties connectées à l'objet par tout type de articulationrigide.

Si recursive est vrai, cette fonction retournera toutes les parties de l'assemblage rigoureusement connectées à la BasePart.

Coupeaux rigides

Lorsqu'une jonction connecte deux parties ensemble (Part0 → Part1) , une jonction est rigide si la physique de Part1 est complètement verrouillée par Part0 .Cela ne s'applique qu'aux types joints suivants :

• Weld
• Snap
• ManualWeld
• Motor
• Motor6D
• WeldConstraint

Paramètres

Retours

Renvoie tous les jointures ou contraintes qui sont connectées à cette partie.

Retours

GetMass renvoie la valeur de la propriété de lecture seule Mass .

Cette fonction précède la propriété de masse. Elle reste supportée pour la compatibilité rétrograde ; vous devez utiliser la propriété de masse directement.

Retours

local myPart = Instance.new("Part")
myPart.Size = Vector3.new(4, 6, 4)
myPart.Anchored = true
myPart.Parent = workspace

local myMass = myPart:GetMass()

print("My part's mass is " .. myMass)

Renvoie le joueur actuel qui est le propriétaire du réseau de cette partie, ou nil en cas du serveur.

Retours

Renvoie true si le moteur de jeu décide automatiquement du propriétaire du réseau pour cette partie.

Retours

Retours

Renvoie la partie de base d'une assemblage.Lors du déplacement d'une assemblage de pièces en utilisant un CFrame .il est important de déplacer cette partie de base (ce qui déplacera toutes les autres parties qui lui sont connectées en conséquence).Plus d'informations sont disponibles dans l'article Assemblies.

Cette fonction précède la propriété AssemblyRootPart. Elle reste supportée pour la compatibilité rétrograde, mais vous devez utiliser AssemblyRootPart directement.

Retours

Renvoie une table de toutes les parties qui interagissent physiquement avec cette partie.Si la partie elle-même a CanCollide défini sur false, alors cette fonction renvoie une table vide à moins que la partie ait un objet TouchInterest parenté à elle (ce qui signifie que quelque chose est connecté à son événement Touché).Les parties adjacentes mais non intersectantes ne sont pas considérées comme touchantes.Cette fonction précède la fonction WorldRoot:GetPartsInPart() qui fournit plus de flexibilité et évite les règles spéciales TouchInterest décrites ci-dessus.Utilisez WorldRoot:GetPartsInPart() à la place.

Retours

Renvoie la vitesse linéaire de l'assemblage de la pièce à la position donnée par rapport à cette pièce.Il peut être utilisé pour identifier la vitesse linéaire des parties dans une assemblage autre que la partie racine.Si l'assemblage n'a pas de vitesse angulaire, la vitesse linéaire sera toujours la même pour chaque position.

Paramètres

Retours

Renvoie true si l'objet est connecté à une partie qui le maintiendra en place (par exemple, une partie Anchored), sinon renvoie false.Dans une assemblage qui a une partie Anchored partie, chaque autre partie est ancrée.

Retours

Change la taille d'un objet tout comme l'utilisation de l'outil de redimensionnement de Studio.

Paramètres

Retours

Définit le joueur donné comme propriétaire du réseau pour ceci et toutes les parties connectées.Lorsque playerInstance est nil, le serveur sera le propriétaire au lieu d'un joueur.

Paramètres

Retours

Permet au moteur de jeu de décider dynamiquement qui gérera la physique de la partie (l'un des clients ou le serveur).

Retours

Paramètres

Retours

Crée une nouvelle IntersectOperation à partir de la géométrie intersectante de la pièce et des autres parties dans l'matricedonné.Seulement Parts sont pris en charge, pas Terrain ou MeshParts.Semblable à Clone() , l'objet retourné n'a pas de set Parent .

Les propriétés suivantes de la partie appelante sont appliquées au résultat IntersectOperation :

• Color , Material , MaterialVariant , Reflectance , Transparency
• CanCollide
• Anchored , Density , Elasticity , ElasticityWeight , Friction , FrictionWeight

Dans la comparaison d'image suivante, IntersectAsync() est appelé sur le bloc violet en utilisant une table contenant le bloc bleu.Le résultat IntersectOperation se résout en une forme de la géométrie interceptante des deux parties.

<figcaption>Pièces séparées</figcaption>

<figcaption>Résultat <code>Class.IntersectOperation</code></figcaption>

Notations

• Les parties originales restent intactes après une opération d'intersection réussie.Dans la plupart des cas, vous devez Destroy() toutes les parties originales et parent le retourné IntersectOperation au même endroit que l'appelant BasePart.
• Par défaut, les couleurs du visage de l'intersection résultante sont empruntées à la propriété Color des parties originales.Pour changer toute l'intersection en une couleur spécifique, définissez sa propriété UsePartColor à true.
• Si une opération d'intersection aboutit à une partie avec plus de 20 000 triangles, elle sera simplifiée à 20 000 triangles.

Paramètres

Retours

Crée un nouveau UnionOperation à partir de la partie, moins la géométrie occupée par les parties dans l'matricedonné.Seulement Parts sont pris en charge, pas Terrain ou MeshParts.Semblable à Clone() , l'objet retourné n'a pas de set Parent .

Notez que l'union résultante ne peut pas être vide en raison de soustractions. Si l'opération aboutirait à une géométrie complètement vide, elle échouerait.

Dans la comparaison d'image suivante, SubtractAsync() est appelé sur le cylindre bleu en utilisant une table contenant le bloc violet.Le résultat UnionOperation se résout en une forme qui omet la géométrie du bloc de celle du cylindre.

<figcaption>Pièces séparées</figcaption>

<figcaption>Résultat <code>Class.UnionOperation</code></figcaption>

Paramètres

Retours

local Workspace = game:GetService("Workspace")

local mainPart = script.Parent.PartA
local otherParts = { script.Parent.PartB, script.Parent.PartC }

-- Effectuer une opération de soustraction
local success, newSubtract = pcall(function()
	return mainPart:SubtractAsync(otherParts)
end)

-- Si l'opération réussit, positionnez-la à la même position et attribuez-la à l'espace de travail
if success and newSubtract then
	newSubtract.Position = mainPart.Position
	newSubtract.Parent = Workspace
end

-- Détruire les parties originales qui restent intactes après l'opération
mainPart:Destroy()
for _, part in otherParts do
	part:Destroy()
end

Crée une nouvelle UnionOperation de la partie, plus la géométrie occupée par les parties dans l'matricedonné.Seulement Parts sont pris en charge, pas Terrain ou MeshParts.Semblable à Clone() , l'objet retourné n'a pas de set Parent .

Les propriétés suivantes de la partie appelante sont appliquées au résultat UnionOperation :

• Color , Material , MaterialVariant , Reflectance , Transparency
• CanCollide
• Anchored , Density , Elasticity , ElasticityWeight , Friction , FrictionWeight

Dans la comparaison d'image suivante, UnionAsync() est appelé sur le bloc bleu en utilisant une table contenant le cylindre violet.Le résultat UnionOperation se résout en une forme de la géométrie combinée des deux parties.

<figcaption>Pièces séparées</figcaption>

<figcaption>Résultat <code>Class.UnionOperation</code></figcaption>

Notations

• Les parties originales restent intactes après une opération d'union réussie.Dans la plupart des cas, vous devez Destroy() toutes les parties originales et parent le retourné UnionOperation au même endroit que l'appelant BasePart.
• Par défaut, l'union résultante respecte la propriété Color de chacune de ses parties.Pour changer l'ensemble de l'union en une couleur spécifique, définissez sa propriété UsePartColor à true.
• Si une opération d'union aboutit à une partie contenant plus de 20 000 triangles, elle sera simplifiée à 20 000 triangles.

Paramètres

Retours

local Workspace = game:GetService("Workspace")

local mainPart = script.Parent.PartA
local otherParts = { script.Parent.PartB, script.Parent.PartC }

-- Perform union operation
local success, newUnion = pcall(function()
	return mainPart:UnionAsync(otherParts)
end)

-- If operation succeeds, position it at the same location and parent it to the workspace
if success and newUnion then
	newUnion.Position = mainPart.Position
	newUnion.Parent = Workspace
end

-- Destroy original parts which remain intact after operation
mainPart:Destroy()
for _, part in otherParts do
	part:Destroy()
end

S'enflamme lorsqu'une partie cesse de toucher une autre partie dans des conditions similaires à celles de BasePart.Touched .

Cet événement fonctionne en conjonction avec Workspace.TouchesUseCollisionGroups pour spécifier si les groupes de collision sont reconnus pour la détection.

Paramètres

local part = script.Parent

local billboardGui = Instance.new("BillboardGui")
billboardGui.Size = UDim2.new(0, 200, 0, 50)
billboardGui.Adornee = part
billboardGui.AlwaysOnTop = true
billboardGui.Parent = part

local tl = Instance.new("TextLabel")
tl.Size = UDim2.new(1, 0, 1, 0)
tl.BackgroundTransparency = 1
tl.Parent = billboardGui

local numTouchingParts = 0

local function onTouch(otherPart)
	print("Touch started: " .. otherPart.Name)
	numTouchingParts = numTouchingParts + 1
	tl.Text = numTouchingParts
end

local function onTouchEnded(otherPart)
	print("Touch ended: " .. otherPart.Name)
	numTouchingParts = numTouchingParts - 1
	tl.Text = numTouchingParts
end

part.Touched:Connect(onTouch)
part.TouchEnded:Connect(onTouchEnded)

L'événement Touché se déclenche lorsqu'une partie entre en contact avec une autre partie.Par instance, si PartA heurte PartB , alors PartA.Touched tire avec PartB et PartB.Touched tire avec PartA .

Cet événement ne se déclenche que lors d'un mouvement physique, il ne se déclenchera donc pas si la propriété CFrame a été modifiée de sorte que la partie se chevauche avec une autre partie.Cela signifie également que au moins une des parties impliquées ne doit pas être à la fois au moment de la collision.

Cet événement fonctionne en conjonction avec Workspace.TouchesUseCollisionGroups pour spécifier si les groupes de collision sont reconnus pour la détection.

Paramètres

local part = script.Parent

local billboardGui = Instance.new("BillboardGui")
billboardGui.Size = UDim2.new(0, 200, 0, 50)
billboardGui.Adornee = part
billboardGui.AlwaysOnTop = true
billboardGui.Parent = part

local tl = Instance.new("TextLabel")
tl.Size = UDim2.new(1, 0, 1, 0)
tl.BackgroundTransparency = 1
tl.Parent = billboardGui

local numTouchingParts = 0

local function onTouch(otherPart)
	print("Touch started: " .. otherPart.Name)
	numTouchingParts = numTouchingParts + 1
	tl.Text = numTouchingParts
end

local function onTouchEnded(otherPart)
	print("Touch ended: " .. otherPart.Name)
	numTouchingParts = numTouchingParts - 1
	tl.Text = numTouchingParts
end

part.Touched:Connect(onTouch)
part.TouchEnded:Connect(onTouchEnded)

local model = script.Parent

local function onTouched(otherPart)
	-- Ignore instances of the model coming in contact with itself
	if otherPart:IsDescendantOf(model) then
		return
	end

	print(model.Name .. " collided with " .. otherPart.Name)
end

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