BasePart

La propriété Anchored détermine si une partie sera immovable physiquement. Lorsqu'elle est activée, une partie ne changera jamais de position en raison de la gravité, d'autres collisions de parties, d'une superposition d'autres parties ou de n'importe quelle autre cause physique. Par resultats, deux parties ancrées ne déclencheront jamais l'événement BasePart.Touched sur l'une l'autre.

Une partie ancrée peut toujours être déplacée en modifiant son CFrame ou Position, et il peut toujours avoir une valeur non zéro AssemblyLinearVelocity et 1> Class.BasePart.RotationAngularVelocity|RotationAngularVelocity1>.

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

La propriété du réseau ne peut pas être définie sur les parties ancrées. Si le statut d'ancrage d'une partie change sur le serveur, la propriété du 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)

Vecteur de vitesse angulaire de cette partie de l'assemblage. 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 une rotation in réaliste. L'utilisation de Torque ou AngularVelocity contraintes est préférée, ou utiliser BasePart:ApplyAngularImpulse() si vous voulez un changement instantané dans la vitesse.

Si la partie est possédée par le serveur, cette propriété doit être modifiée à partir d'un script du client sur un serveur Script (

Une position calculée via le mass et le 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 la stabilité. Une force appliquée au centre de masse ne provoquera pas l'accélération angulaire, seulement linéaire. Un assemblage avec un faible centre de masse aura un meilleur temps restant debout sous l'effet de la gravité.

Le vélocité linéaire de l'assemblage de cette partie. Il s'agit du taux de changement de position de l'assemblage de la center of mass en studs par seconde.

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

Définir la vitesse directement peut entraîner une moto réaliste. L'utilisation d'une contrainte VectorForce est préférée, ou utilisez BasePart: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 script du client sur un serveur Script (

La somme de la masse de tous les parts dans cette partie d'assemblage. Les parties qui sont Massless et ne sont pas la partie racine de l'assemblage ne contribueront pas à l'AssemblyMass.

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

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

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

Les parties qui partagent toutes la même racine d'assemblage sont dans la même assemblée.

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

La propriété BackSurface détermine le type de surface utilisé pour la direction +Z d'une partie. Lorsque les deux parties sont placées côté à côté, elles peuvent créer une jonction entre elles. Si défini sur Moteur, l'entrée BasePart.BackSurfaceInput détermine comment une jonction de moteur devrait se comporter.

La plupart des types de surface rendent une texture sur le visage de la pièce si le BasePart.Material est réglé sur Plastique. Certains types de surface - hinge, moteur et steppermotor - rendront un adornement 3D à la place. Si cette propriété est sélectionnée dans la fenêtre propriétés, elle sera soulignée dans le monde de jeu similaire à celle d'un SurfaceSelection .

local demoPart = script.Parent

-- Create a billboard gui to display what the current surface type is
local billboard = Instance.new("BillboardGui")
billboard.AlwaysOnTop = true
billboard.Size = UDim2.new(0, 200, 0, 50)
billboard.Adornee = demoPart
local textLabel = Instance.new("TextLabel")
textLabel.Size = UDim2.new(0, 200, 0, 50)
textLabel.BackgroundTransparency = 1
textLabel.TextStrokeTransparency = 0
textLabel.TextColor3 = Color3.new(1, 1, 1) -- White
textLabel.Parent = billboard
billboard.Parent = demoPart

local function setAllSurfaces(part, surfaceType)
	part.TopSurface = surfaceType
	part.BottomSurface = surfaceType
	part.LeftSurface = surfaceType
	part.RightSurface = surfaceType
	part.FrontSurface = surfaceType
	part.BackSurface = surfaceType
end

while true do
	-- Iterate through the different SurfaceTypes
	for _, enum in pairs(Enum.SurfaceType:GetEnumItems()) do
		textLabel.Text = enum.Name
		setAllSurfaces(demoPart, enum)
		task.wait(1)
	end
end

La propriété BottomSurface détermine le type de surface utilisé pour la direction -Y d'une partie. Lorsque les deux parties' visages sont placés côté à côté, ils peuvent créer un joint entre elles. Si set to Motor, the BasePart.BottomSurfaceInput détermine comment un joint moteur devrait se comporter.

La plupart des types de surface rendent une texture sur le visage de la pièce si le BasePart.Material est réglé sur Plastique. Certains types de surface - hinge, moteur et steppermotor - rendront un adornement 3D à la place. Si cette propriété est sélectionnée dans la fenêtre propriétés, elle sera soulignée dans le monde de jeu similaire à celle d'un SurfaceSelection .

local demoPart = script.Parent

-- Create a billboard gui to display what the current surface type is
local billboard = Instance.new("BillboardGui")
billboard.AlwaysOnTop = true
billboard.Size = UDim2.new(0, 200, 0, 50)
billboard.Adornee = demoPart
local textLabel = Instance.new("TextLabel")
textLabel.Size = UDim2.new(0, 200, 0, 50)
textLabel.BackgroundTransparency = 1
textLabel.TextStrokeTransparency = 0
textLabel.TextColor3 = Color3.new(1, 1, 1) -- White
textLabel.Parent = billboard
billboard.Parent = demoPart

local function setAllSurfaces(part, surfaceType)
	part.TopSurface = surfaceType
	part.BottomSurface = surfaceType
	part.LeftSurface = surfaceType
	part.RightSurface = surfaceType
	part.FrontSurface = surfaceType
	part.BackSurface = surfaceType
end

while true do
	-- Iterate through the different SurfaceTypes
	for _, enum in pairs(Enum.SurfaceType:GetEnumItems()) do
		textLabel.Text = enum.Name
		setAllSurfaces(demoPart, enum)
		task.wait(1)
	end
end

La propriété BrickColor détermine la couleur d'une partie. Si la partie a un BasePart.Material, cela détermine également la couleur utilisée lors du rendu de la texture du matériau. Pour plus de contrôle sur la couleur, la propriété BasePart.Color peut être utilisée (elle est une variante de couleur de Color3). Si la couleur est configurer, cette propriété utilisera la couleur la plus proche.

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

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)

La propriété CFrame détermine à la fois la position et l'orientation de la BasePart dans le monde. Elle agit comme un lieu de référence arbitraire sur la géométrie, mais ExtentsCFrame représente la vraie 1> Datatype.CFrame1> de son centre physique.

Lorsque vous configurez 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 lorsque vous téléportez le personnage d'un joueur.

Contrairement à la valeur de BasePart.Position, la valeur de BasePart.CFrame déplacerait toujours la partie à l'endroit exact donné CFrame ; en d'autres termes : 1> aucune vérification d'emplacement n'est effectuée1> et le solvant de physique tentera de résoudre tout

Pour suivre les positions par rapport à un élément 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 physiquement interagira avec d'autres parties. Lorsqu'il est désactivé, d'autres parties peuvent passer à travers la brique non modifiée. Les parties utilisées pour la décoration sont généralement désactivées, car elles ne doivent pas être prises en compte par le moteur de physique.

Si une partie n'est pas BasePart.Anchored et a désactivé CanCollide, 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 BasePart.Touched (comme les autres parties les touchant). Vous pouvez désactiver cela avec BasePart.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()

CanQuery détermine si la partie est considérée pendant les opérations de recherche spatiale, telles que GetPartBoundsInBox ou Raycast. CanCollide doit également être désactivé lors de la désactivation de CanQuery. Ces fonctions ne incluront jamais de parties dont le CanRender et

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

Cette propriété détermine si Class.BasePart.Touched|Touched</

Notez que cette logique de collision peut être configurée pour respecter les groupes de collision via la propriété Workspace.TouchesUseCollisionGroups. Si true, les parties dans les groupes non collisionnés ignoreront à la fois les collisions 1>et1> les événements de touche, ce qui rendra cette propriété inutile.

Performance

Il y a une petite performance gagnée sur les parties qui ont à la fois CanTouch et CanCollide défini sur false, car ces parties ne nécessitent jamais de calculer de sorte que les collisions de pièces. C

Détermine si oui ou non une partie lance une ombre.

Notez que cette fonctionnalité n'est pas conçue pour l'amélioration des performances. Il ne devrait être désactivé que sur les parties où vous voulez cacher les ombres que la partie cast. Désactiver cette propriété pour une partie donnée peut causer des artefacts visuels sur les ombres cast sur cette partie.

La propriété CenterOfMass décrit la position locale de la position du centre de masse d'une partie. Si ceci est une simple assemblage de partie, ceci est le AssemblyCenterOfMass converti de l'espace mondial en l'espace local. Sur simple Parts, le centre de masse est toujours (0,0,

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" . Ce 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é couleur détermine la couleur d'une partie. Si la partie a un BasePart.Material, cela détermine également la couleur utilisée lors du rendu de la texture du matériau. Si cette propriété est configurer, BasePart.BrickColor utilise la couleur la plus proche de la valeur Couleur3.

D'autres propriétés visuelles d'une partie sont déterminées par BasePart.Transparency et BasePart.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)

Les propriétés physiques actuelles indiquent les propriétés physiques actuelles de la partie. Vous pouvez définir des valeurs personnalisées pour les propriétés physiques par partie, matériau personnalisé et couverture remplacer. Le moteur priorise plus de définitions granulaires lors de la détermination des propriétés physiques effektives d'une partie. Les valeurs dans la liste suivante sont en ordre du plus élevé au plus bas :

• Propriétés physiques personnalisées de la partie
• Propriétés physiques personnalisées du matériau de la partie
• Les propriétés physiques personnalisées de la matière d'overture de la partie
• Propriétés physiques par défaut du matériau de la partie

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

Si vous l'activez, cette propriété vous permet de configurer ces propriétés physiques. Si vous la désactivez, ces propriétés physiques sont déterminées par le BasePart.Material de la partie. La page pour Enum.Material contient la liste des différents matériaux 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 vrai, et quand Workspace.FluidForces est activé, cause le moteur de physique à calculer les forces aéroynamiques sur cette BasePart .

Le CFrame des parties physiques de la BasePart, représentant son centre physique.

La taille physique réelle de la BasePart comme vue par le moteur de physique, par exemple dans la détection de collision.

La propriété FrontSurface détermine le type de surface utilisé pour la direction -Z d'une partie. Lorsque les deux parties sont placées côté à côté, elles peuvent créer un joint entre elles. Si défini sur Moteur, le BasePart.FrontSurfaceInput détermine comment un joint moteur devrait se comporter.

La plupart des types de surface rendent une texture sur le visage de la pièce si le BasePart.Material est réglé sur Plastique. Certains types de surface, y compris Hinge, Motor et SteppingMotor, rendent un adornement 3D à la place. Si cette propriété est sélectionnée dans la fenêtre propriétés, elle sera soulignée dans le monde de jeu, similaire à celle d'un SurfaceSelection .

local demoPart = script.Parent

-- Create a billboard gui to display what the current surface type is
local billboard = Instance.new("BillboardGui")
billboard.AlwaysOnTop = true
billboard.Size = UDim2.new(0, 200, 0, 50)
billboard.Adornee = demoPart
local textLabel = Instance.new("TextLabel")
textLabel.Size = UDim2.new(0, 200, 0, 50)
textLabel.BackgroundTransparency = 1
textLabel.TextStrokeTransparency = 0
textLabel.TextColor3 = Color3.new(1, 1, 1) -- White
textLabel.Parent = billboard
billboard.Parent = demoPart

local function setAllSurfaces(part, surfaceType)
	part.TopSurface = surfaceType
	part.BottomSurface = surfaceType
	part.LeftSurface = surfaceType
	part.RightSurface = surfaceType
	part.FrontSurface = surfaceType
	part.BackSurface = surfaceType
end

while true do
	-- Iterate through the different SurfaceTypes
	for _, enum in pairs(Enum.SurfaceType:GetEnumItems()) do
		textLabel.Text = enum.Name
		setAllSurfaces(demoPart, enum)
		task.wait(1)
	end
end

La propriété LeftSurface détermine le type de surface utilisé pour la direction -X d'une partie. Lorsque les deux parties sont placées côté à côté, elles peuvent créer une jonction entre elles. Si défini sur Moteur, le BasePart.LeftSurfaceInput détermine comment une jonction moteur devrait se comporter.

La plupart des types de surface rendent une texture sur le visage de la pièce si le BasePart.Material est réglé sur Plastique. Certains types de surface, y compris Hinge, Motor et SteppingMotor, rendent un adornement 3D à la place. Si cette propriété est sélectionnée dans la fenêtre propriétés, elle sera soulignée dans le monde de jeu, similaire à celle d'un SurfaceSelection .

local demoPart = script.Parent

-- Create a billboard gui to display what the current surface type is
local billboard = Instance.new("BillboardGui")
billboard.AlwaysOnTop = true
billboard.Size = UDim2.new(0, 200, 0, 50)
billboard.Adornee = demoPart
local textLabel = Instance.new("TextLabel")
textLabel.Size = UDim2.new(0, 200, 0, 50)
textLabel.BackgroundTransparency = 1
textLabel.TextStrokeTransparency = 0
textLabel.TextColor3 = Color3.new(1, 1, 1) -- White
textLabel.Parent = billboard
billboard.Parent = demoPart

local function setAllSurfaces(part, surfaceType)
	part.TopSurface = surfaceType
	part.BottomSurface = surfaceType
	part.LeftSurface = surfaceType
	part.RightSurface = surfaceType
	part.FrontSurface = surfaceType
	part.BackSurface = surfaceType
end

while true do
	-- Iterate through the different SurfaceTypes
	for _, enum in pairs(Enum.SurfaceType:GetEnumItems()) do
		textLabel.Text = enum.Name
		setAllSurfaces(demoPart, enum)
		task.wait(1)
	end
end

La propriété LocalTransparencyModifier est un multiplicateur de BasePart.Transparency qui n'est visible que pour le client local. Il ne se réplique pas du client au serveur et est utile pour quand une partie ne devrait pas rendre pour un client spécifique, comme le fait le joueur de ne pas voir ses parties du corps quand il passe en mode première personne.

Cette propriété modifie la transparence de la partie locale à l'aide de la formule suivante, ce qui donne des valeurs de clôture entre 0 et 1.

clientTransparency = 1 - ((1 - part.Transparency) * (1 - part.LocalTransparencyModifier))

<tbody>
  <tr>
    <td>0.5</td>
    <td>0</td>
    <td>0.5</td>
    <td>0.5</td>
  </tr>

  <tr>
    <td>0.5</td>
    <td>0.25</td>
    <td>0.5</td>
    <td>0,625</td>
  </tr>

  <tr>
    <td>0.5</td>
    <td>0.5</td>
    <td>0.5</td>
    <td>0.75</td>
  </tr>

  <tr>
    <td>0.5</td>
    <td>0.75</td>
    <td>0.5</td>
    <td>0.875</td>
  </tr>

  <tr>
    <td>0.5</td>
    <td>1</td>
    <td>0.5</td>
    <td>1</td>
  </tr>
</tbody>

La propriété Verrouillée détermine si un part (ou un model qu'il contient) peut être sélectionné dans Roblox Studio en cliquant dessus. Cette propriété est la plus souvent activée sur les parties dans les modèles d'environnement qui ne sont pas en cours d'édition en ce moment. Roblox Studio a un outil Verrouiller/Déverrouiller Tout qui peut act

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

Masse est une propriété de lecture unique qui décrit la production du volume et de la densité d'une partie. Il est renvoyé par la fonction GetMass.

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

Si cette propriété est activée, la BasePart ne contribuera pas à la masse ou à l'inertie totale de son assemblage tant qu'elle est soudeuré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 à la masse et à l'inertie de son assemblage comme une partie normale. Les parties qui ne sont pas massives ne devraient jamais devenir une partie racine d'assemblage à moins que toutes les autres parties de l'assemblage ne soient également massives.

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 massif souduit à un maillage de collision plus simple.

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

La propriété Matériau permet à un constructeur de définir la texture et les propriétés physiques d'une partie (dans le cas où BasePart.CustomPhysicalProperties n'est pas configuré). Le matériau Plastique par défaut a une texture très claire, et le matériau SmoothPlastic n'a pas de texture du tout. Certaines textures de matériau comme DiamondPlate et Granite ont des textures très visibles. La texture de chaque matériau reflète la lumière du sole

En activant cette propriété, l'utilisation de BasePart.CustomPhysicalProperties utilisera les propriétés physiques par défaut d'un matériau. Par instance, le diamant est un matériau très dense alors que le bois est très léger. La densité d'une partie détermine si elle flotte dans l'eau du terrain.

Le matériau Verre change le comportement de rendu sur les paramètres graphiques modérés. Il applique un peu de réflexion (similaire à BasePart.Reflectance ) et de perspective. L'effet est particulièrement prononcé sur les objets de forme sphérique (set BasePart.Shape à Ball). Les objets semi- transparents et les objets de verre derrière les vitres ne sont pas visibles.

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 système recherche l'instance MaterialVariant avec le nom spécifié MaterialVariant et le taperBasePart.Material. Si il trouve avec succès une instance MaterialVariant correspondante, il utilise cette instance MaterialVariant pour remplacer le matériau par défaut. Le matériau par défaut peut être le matériau intégré ou un type de matériau spécifié 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. Ce diffère

Lorsque vous avez configuré cette propriété n'importe lequel Welds ou Class.Motor6D|Motor6Ds connecté à cette partie aura la propriété correspondante Motor6Ds ou C0 mise à jour et permettra à la partie de

Les contraintes de soudures seront également temporairement désactivées et réactivées pendant le mouvement.

local part = script.Parent

local INCREMENT = 360 / 20

-- Rotate the part continually
while true do
	for degrees = 0, 360, INCREMENT do
		-- Set only the Y axis rotation
		part.Rotation = Vector3.new(0, degrees, 0)
		-- A better way to do this would be setting CFrame
		--part.CFrame = CFrame.new(part.Position) * CFrame.Angles(0, math.rad(degrees), 0)
		task.wait()
	end
end

Cette propriété spécifie l'Offset de la partie de son pivot, CFrame, qui est part:GetPivot() , qui est la même que part.CFrame * part.PivotOffset.

Ceci est pratique pour définir le pivot à un endroit dans l'espace local , mais définir le pivot d'une partie dans l'espace du monde peut être fait comme suivant :

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

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

-- Create hands
local hourHand = createHand(7, 1, 0)
local minuteHand = createHand(10, 0.6, 0.1)
local secondHand = createHand(11, 0.2, 0.2)

-- Run clock
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'un part à l'aide d'un Vector3. Il reflète la position de la partie's BasePart.CFrame, mais il peut également être configurer.

Lorsque vous avez configuré cette propriété n'importe lequel Welds ou Class.Motor6D|Motor6Ds connecté à cette partie aura la propriété correspondante Motor6Ds ou C0 mise à jour et permettra à la partie de

Les contraintes de soudures seront également temporairement désactivées et réactivées pendant le mouvement.

Cela renvoie le temps en secondes depuis la dernière mise à jour de la physique du partage sur le client local (ou le serveur). Renvoie 0 lorsque la partie n'a pas de physique (ancrée)

La propriété réflectance détermine la quantité d'un part qui reflète la skybox. Une valeur de 0 indique que la partie n'est pas réfléctive du tout, et une valeur de 1 indique que la partie devrait être complètement réfléctive.

La réflectance n'est pas affectée par BasePart.Transparency, à moins que la partie ne soit complètement transparente, dans ce cas la réflectance ne rendra pas du tout. La réflectance peut ou non être ignorée en fonction du BasePart.Material de la partie.

local part = script.Parent

local pointLight = Instance.new("PointLight")
pointLight.Brightness = 0
pointLight.Range = 12
pointLight.Parent = part

local touchNo = 0
local function blink()
	-- Advance touchNo to tell other blink() calls to stop early
	touchNo = touchNo + 1
	-- Save touchNo locally so we can tell when it changes globally
	local myTouchNo = touchNo
	for i = 1, 0, -0.1 do
		-- Stop early if another blink started
		if touchNo ~= myTouchNo then
			break
		end
		-- Update the blink animation
		part.Reflectance = i
		pointLight.Brightness = i * 2
		task.wait(0.05)
	end
end

part.Touched:Connect(blink)

La propriété RedimensionnerIncrément est une propriété de lecture unique qui décrit la plus petite modification de taille autorisée par la méthode BasePart:Resize(). Elle diffère entre les implémentations de la BasePart classe abstraite. Par instance, Part a ce paramètre à 1 et 1>

-- 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é ResizeableFaces (avec un e , pas ResizableFaces) décrit l'utilisation d'un objet Faces pour afficher les différents visages sur lesquels une partie peut être redimensionnée. Pour la pl

-- 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 +X d'une partie. Lorsque les deux parties sont placées côté à côté, elles peuvent créer une jonction entre elles. Si défini sur Moteur, la BasePart.RightSurfaceInput détermine comment une jonction moteur devrait se comporter.

La plupart des types de surface rendent une texture sur le visage de la pièce si le BasePart.Material est réglé sur Plastique. Certains types de surface, y compris Hinge, Motor et SteppingMotor, rendent une adornement 3D à la place. Si cette propriété est sélectionnée dans la fenêtre propriétés, elle sera soulignée dans le monde de jeu, similaire à celle d'un SurfaceSelection .

local demoPart = script.Parent

-- Create a billboard gui to display what the current surface type is
local billboard = Instance.new("BillboardGui")
billboard.AlwaysOnTop = true
billboard.Size = UDim2.new(0, 200, 0, 50)
billboard.Adornee = demoPart
local textLabel = Instance.new("TextLabel")
textLabel.Size = UDim2.new(0, 200, 0, 50)
textLabel.BackgroundTransparency = 1
textLabel.TextStrokeTransparency = 0
textLabel.TextColor3 = Color3.new(1, 1, 1) -- White
textLabel.Parent = billboard
billboard.Parent = demoPart

local function setAllSurfaces(part, surfaceType)
	part.TopSurface = surfaceType
	part.BottomSurface = surfaceType
	part.LeftSurface = surfaceType
	part.RightSurface = surfaceType
	part.FrontSurface = surfaceType
	part.BackSurface = surfaceType
end

while true do
	-- Iterate through the different SurfaceTypes
	for _, enum in pairs(Enum.SurfaceType:GetEnumItems()) do
		textLabel.Text = enum.Name
		setAllSurfaces(demoPart, enum)
		task.wait(1)
	end
end

Cette propriété est un nombre entre -127 et 127 qui prend la priorité sur toutes les autres règles pour le tri des parties de trier. Lors de la考ération de plusieurs parties qui ne sont pas Anchored et qui partagent la même valeur Massless, une partie avec une plus grande valeur RootPriority prendra la

Vous pouvez utiliser cette propriété pour contrôler quelle partie d'une assemblage est la partie racine et garder la partie racine stable si la taille change.

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

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

Lorsque vous avez configuré cette propriété n'importe lequel Welds ou Class.Motor6D|Motor6Ds connecté à cette partie aura la propriété correspondante Motor6Ds ou C0 mise à jour et permettra à la partie de

Les contraintes de soudures seront également temporairement désactivées et réactivées pendant le mouvement.

La propriété Size d'une partie détermine ses dimensions visuelles, tandis que Class.BasePart.ExtentsSize|ExtentsSize représente la taille réelle utilisée par le moteur de physique, telle que dans dé

La taille de la partie détermine sa masse qui est donnée par BasePart:GetMass(). Un élément de Size est utilisé par une variété d'autres objets :

• ParticleEmitter pour déterminer la zone dans laquelle les particules sont générées.
• BlockMesh pour déterminer partiellement le prisme rectangulaire rendu.
• SpecialMesh pour certains MeshTypes , pour déterminer la taille du maillage rendu.
• SurfaceLight pour déterminer l'espace à illuminer.

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 +Y d'une pièce. Lorsque les deux parties' visages sont placés côté à côté, ils peuvent créer un joint entre elles. Si défini sur Moteur, la BasePart.TopSurfaceInput détermine comment un joint moteur devrait se comporter.

La plupart des types de surface rendent une texture sur le visage de la pièce si le BasePart.Material est réglé sur Plastique. Certains types de surface - hinge, moteur et steppermotor - rendront un adornement 3D à la place. Si cette propriété est sélectionnée dans la fenêtre propriétés, elle sera soulignée dans le monde de jeu similaire à celle d'un SurfaceSelection .

local demoPart = script.Parent

-- Create a billboard gui to display what the current surface type is
local billboard = Instance.new("BillboardGui")
billboard.AlwaysOnTop = true
billboard.Size = UDim2.new(0, 200, 0, 50)
billboard.Adornee = demoPart
local textLabel = Instance.new("TextLabel")
textLabel.Size = UDim2.new(0, 200, 0, 50)
textLabel.BackgroundTransparency = 1
textLabel.TextStrokeTransparency = 0
textLabel.TextColor3 = Color3.new(1, 1, 1) -- White
textLabel.Parent = billboard
billboard.Parent = demoPart

local function setAllSurfaces(part, surfaceType)
	part.TopSurface = surfaceType
	part.BottomSurface = surfaceType
	part.LeftSurface = surfaceType
	part.RightSurface = surfaceType
	part.FrontSurface = surfaceType
	part.BackSurface = surfaceType
end

while true do
	-- Iterate through the different SurfaceTypes
	for _, enum in pairs(Enum.SurfaceType:GetEnumItems()) do
		textLabel.Text = enum.Name
		setAllSurfaces(demoPart, enum)
		task.wait(1)
	end
end

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

BasePart.Reflectance peut réduire la transparence globale d'un brique si elle est réglée sur une valeur proche de 1.

Bien que les parties complètement transparentes ne soient rendues à tout moment, les objets partiellement transparents ont des coûts de rendu significatifs. Avoir de nombreuses parties translucides peut ralentir les performances du jeu.

Lorsque les parties transparentes se chevauchent, l'ordre de rendu peut agir imprévisible - essayez de garder les parties semi- transparentes de se chevaucher pour éviter cela.

Le BasePart.LocalTransparencyModifier est un multiplicateur de Transparence 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()

local function makeXRayPart(part)
	-- LocalTransparencyModifier will make parts see-through but only for the local
	-- client, and it won't replicate to the server
	part.LocalTransparencyModifier = 0.5
end

-- This function uses recursion to search for parts in the game
local function recurseForParts(object)
	if object:IsA("BasePart") then
		makeXRayPart(object)
	end

	-- Stop if this object has a Humanoid - we don't want to see-through players!
	if object:FindFirstChildOfClass("Humanoid") then
		return
	end

	-- Check the object's children for more parts
	for _, child in pairs(object:GetChildren()) do
		recurseForParts(child)
	end
end

recurseForParts(workspace)

Paramètres

Retours

Applique une impulsion de force angulaire instantanée à l'assemblage de cette partie, ce qui fait tourner l'assemblage.

La vitesse angulaire résultante de l'impulsion repose sur la mass de l'assemblage. Ainsi, un impulsion plus élevée est requise pour déplacer des assemblages plus massifs. Les impulsions sont utiles dans les cas où vous souhaitez 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 (non pas à partir d'un

Paramètres

Retours

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

La force est appliquée au centre d'assemblage, center of mass, ce qui signifie que le mouvement résultant ne sera linéaire que.

La vélocité résultante de l'impulsion repose sur la masse d'assemblage de mass. Ainsi, un impulsion plus élevée est requise pour déplacer des assemblages plus massifs. Les impulsions sont utiles dans les cas où vous souhaitez appliquer une force instantanément, telle qu'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 (non pas à partir d'un

Paramètres

Retours

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

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

La vélocité résultante de l'impulsion repose sur la masse d'assemblage de mass. Ainsi, un impulsion plus élevée est requise pour déplacer des assemblages plus massifs. Les impulsions sont utiles dans les cas où les développeurs veulent 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 (non pas à partir d'un

Paramètres

Retours

Renvoie si les parties peuvent se heurter ou non. Cette fonction tient compte des groupes de collision des deux parties. Cette fonction se produira une erreur 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é du réseau d'une partie.

La valeur de retour de la fonction vérifie si oui ou non vous pouvez appeler BasePart:SetNetworkOwner() ou BasePart:SetNetworkOwnershipAuto() sans rencontrer une 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

Renvoie une table de pièces connectées à l'objet par n'importe quel type de articulationrigide.

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

Joints rigides

Lorsqu'un joint connecte deux parties ensemble (Part0 → Part1) , un joint est rigide si les physiques de Part1 sont complètement verrouillées par 1> Part01>. Cela ne s'applique qu'aux types de joint suivants :

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

Paramètres

Retours

Retournez toutes les Jointures ou Contraintes qui sont connectées à cette partie.

Retours

ObtenezMass renvoie la valeur de la propriété de lecture unique Mass.

Cette fonction est prédéfinie par la propriété Masse. Elle reste prise en charge pour la compatibilité avec les versions antérieures ; vous devriez utiliser la propriété 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 zéro dans le cas du serveur.

Retours

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

Retours

Retours

Renvoie la partie de base d'une assemblage. Lorsque vous déplacez une assemblage de parties en utilisant un CFrame . il est important de déplacer cette partie de base (cela déplacera toutes les autres parties connectées à elle). Plus d'informations sont disponibles dans l'article Assemblages.

Cette fonction est prédéfinie par la propriété AssemblyRootPart. Elle est toujours prise en charge pour la compatibilité avec les versions antérieures, mais vous devriez utiliser AssemblyRootPart directement.

Retours

Renvoie une table de toutes les parties qui interagissent physiquement avec cette partie. Si la partie elle-même a le paramètre CanCollide défini sur false, alors cette fonction renvoie une table vide à moins que la partie n