BasePart

A propriedade Anchored determina se a peça será imóvel físico. Quando ativado, uma peça nunca mudará de posição devido à gravidade, outras colisões de peças, sobreposição de outras peças ou qualquer outra causa relacionada à física. Como resultado, duas peças ancoradas nunca ativarão o evento BasePart.Touched umas sobre as outras.

Uma peça ancorada ainda pode ser movida alterando sua CFrame ou Position, e ainda pode ter uma velocidade de movimento não zero AssemblyLinearVelocity e 1> Class.BasePart.AssemblyAngularVelocity|Rotation de peça1>.

Finalmente, se uma peça não ancorada for conectada a uma peça ancorada através de um objeto como um Weld, ela também será ativada. Se uma peça quebrar, a peça pode ser afetada pela física novamente. Veja Encontros para mais detalhes.

A propriedade da rede não pode ser definida em peças ancoradas. Se o status ancorado de uma peça mudar no servidor, a propriedade da rede dessa peça será afetada.

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)

O vetor de velocidade angular da montagem desta peça. É a taxa de mudança de orientação em radians por segundo.

A velocidade ângular é a mesma em todos os pontos da montagem.

Configurar a velocidade diretamente pode levar a movimentos irrealistas. Usar Torque ou AngularVelocity limite é preferido, ou use BasePart:ApplyAngularImpulse() se você quiser uma mudança instantânea na velocidade.

Se a peça for propriedade do servidor, esta propriedade deve ser alterada de um servidor Script (não de um

Uma posição calculada via o mass e position de todas as peças na montagem.

Se a montagem tiver uma peça ancorada, o centro de massa dessa peça será o centro de massa da montagem e a montagem terá infinita massa.

Conhecer o centro de massa pode ajudar a manter a estabilidade da montagem. Uma força aplicada ao centro de massa não causará aceleração angular, apenas linhares. Uma montagem com baixo centro de massa terá um tempo melhor de ficar de pé sob o efeito da gravidade.

O vetor de velocidade linear da montagem desta peça. É a taxa de mudança de posição do centro de massa da montagem em studs por segundo.

Se você quiser conhecer a velocidade em um ponto diferente do centro de massa da montagem, use BasePart:GetVelocityAtPosition() .

Configurar a velocidade diretamente pode levar a movimentos irrealistas. O uso de uma restrição VectorForce é preferido, ou use BasePart:ApplyImpulse() se você quiser uma mudança instantânea na velocidade.

Se a peça for propriedade do servidor, esta propriedade deve ser alterada de um servidor Script (não de um

A soma da massa de todos os parts nesta parte da montagem. Partes que são Massless e não são a parte raiz da montagem não contribuirão para a montagem.

Se a montagem tiver uma parte ancorada, a massa da montagem é considerada infinita. Con約束 e outras interações físicas entre montagens ancoradas com uma grande diferença de massa podem causar instabilidades.

Essa propriedade indica que a BasePart foi escolhida automaticamente para representar a raiz da montagem. É a mesma parte que é retornada quando os desenvolvedores chamam GetRootPart().

A parte raiz pode ser alterada alterando a RootPriority das peças na montagem.

Peças que compartilham a mesma raiz de montagem estão na mesma montagem.

Para mais informações sobre peças de raiz, see Montagens .

A propriedade BackSurface determina o tipo de superfície usada para a direção +Z de uma peça. Quando as faces de duas peças estão colocadas umas ao lado das outras, elas podem criar uma joint entre elas. Se definido para Motor, o BasePart.BackSurfaceInput determina como uma joint de motor deve se comportar.

A maioria dos tipos de superfície rende uma textura na parte de cima se o BasePart.Material for definido como Plástico. Alguns tipos de superfície - hinge, motor e stepmotor - renderizarão uma adornamento 3D em vez disso. Se esta propriedade for selecionada na janela Propriedades, será destacado no mundo do jogo, semelhante ao de um 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

A propriedade BottomSurface determina o tipo de superfície usada para a direção -Y de uma peça. Quando duas peças estão colocadas umas ao lado das outras, elas podem criar uma joint entre elas. Se definido para Motor, o BasePart.BottomSurfaceInput determina como uma joint de motor deve se comportar.

A maioria dos tipos de superfície rende uma textura na parte de cima se o BasePart.Material for definido como Plástico. Alguns tipos de superfície - hinge, motor e stepmotor - renderizarão uma adornamento 3D em vez disso. Se esta propriedade for selecionada na janela Propriedades, será destacado no mundo do jogo, semelhante ao de um 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

A propriedade BrickColor determina a cor de uma peça. Se a peça tiver um BasePart.Material, isso também determina a cor usada ao renderizar a textura do material. Para mais controle sobre a cor, a propriedade BasePart.Color pode ser usada (é uma variação Color3 da propriedade). Se a cor for configurar, a propriedade Class.BasePart.Color usará a cor mais próxima

As outras propriedades visuais de uma peça são determinadas por BasePart.Transparency e 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)

A propriedade CFrame determina tanto a posição quanto a orientação do BasePart no mundo. Ele atua como um local de referência arbitrário na geometria, mas ExtentsCFrame representa o verdadeiro 1> Datatype.CFrame1> de seu centro físico.

Ao configurar CFrame em uma peça, outras peças também são movidas relativamente à peça, mas recomenda-se que você use PVInstance:PivotTo() para mover um modelo inteiro, como quando teletransporta um personagem de um jogador.

Ao contrário de definir BasePart.Position, definir BasePart.CFrame sempre moverá a peça para o exato dado CFrame ; em outras palavras: 1> nenhuma sobreposição verificação é feita1> e o solvente de física tentará resolver qualquer sobreposição a menos

Para acompanhar as posições em relação a uma peça's CFrame , um Attachment pode ser útil.

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)

O CanCollide determina se uma peça interagirá fisicamente com outras peças. Quando desativado, outras peças podem passar através do tijolo sem serem afetadas. As peças usadas para 装oração geralmente têm CanCollide desativado, pois elas não precisam ser consideradas pelo motor de física.

Se uma parte não for BasePart.Anchored e tiver o CanCollide desativado, ela pode cair do mundo para ser eventualmente destruída por Workspace.FallenPartsDestroyHeight.

Quando o CanCollide está desativado, peças ainda podem disparar o evento BasePart.Touched (junto com as outras peças que o tocam). Você pode desativar isso com BasePart.CanTouch.

Para mais informações sobre colisões, see Colisões .

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

O CanQuery determina se a peça é considerada durante as operações de query espaçais, como GetPartBoundsInBox ou Raycast. CanCollide também deve ser desativado quando desativar o CanQuery. Essas funções nunca incluirão peças cujo CanQuery e 2>

Além disso, também é possível excluir peças que são descendentes de uma lista de peças dada usando um objeto OverlapParams ou RaycastParams ao chamar as funções de query espacial.

Esta propriedade determina se Class.BasePart.Touched|Touched

Nota que esta lógica de colisão pode ser definida para respeitar grupos de colisão através da propriedade Workspace.TouchesUseCollisionGroups. Se true, as peças em grupos não colisivos ignorarão ambas as colisões 1>e1> eventos de toque, tornando esta propriedade irrelevante.

Desempenho

Existe um pequeno ganho de desempenho em peças que têm ambas CanTouch e CanCollide definidos para false, pois essas peças nunca precisarão mais calcular qualquer tipo de

Determina se uma peça ou não cria uma sombra.

Nota que esta função não é não projetada para melhoria de desempenho. Deve ser desativada em peças onde você deseja ocultar as sombras que a peça projeta. Desativar esta propriedade para uma peça específica pode causar artifatos visuais nas sombras projetadas na peça.

A propriedade CenterOfMass descreve a posição local do centro de massa de uma peça. Se esta for uma montagem de peça única, esta é a AssemblyCenterOfMass convertida do espaço do mundo para o espaço local. Em um simples Parts, o centro de massa é sempre (0,0,0

A propriedade CollisionGroup descreve o nome do grupo de colisão da parte (máximo de 100 caracteres). As partes começam no grupo padrão cujo nome é "Default". Este valor não pode ser vazio.

Embora esta propriedade em si seja não replicável, o motor internamente replica o valor através de outra propriedade privada para solucionar problemas de compatibilidade com versões anteriores.

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

A propriedade Cor determina a cor de uma peça. Se a peça tiver um BasePart.Material, isso também determina a cor usada ao renderizar a textura do material. Se esta propriedade for configurar, BasePart.BrickColor usará a cor mais próxima BrickColor para o valor Color3.

As outras propriedades visuais de uma peça são determinadas por BasePart.Transparency e 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)

O atributo físico atual indica as propriedades físicas atuais da peça. Você pode definir valores personalizados para as propriedades físicas por peça, material personalizado e Sobrepor/substituirde material. O motor prioriza mais definições granulares ao determinar as propriedades físicas eficazes de uma peça. Os valores na lista a seguir estão em ordem crescente de prioridade:

• Propriedades físicas personalizadas da peça
• Propriedades físicas personalizadas do material personalizado da peça
• Propriedades físicas personalizadas da sobreposição de material da peça
• Propriedades físicas padrão do material da peça

CustomPhysicalProperties permite que você personalize vários aspectos físicos de um Part, como sua densidade, fricção e elasticidade.

Se habilitado, esta propriedade permite que você configure essas propriedades físicas. Se desativado, essas propriedades físicas são determinadas pelo BasePart.Material da peça. A página para Enum.Material contém lista de vários materiais de peça.

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

Quando verdadeiro, e quando Workspace.FluidForces é ativado, causa o motor de física a calcular forças aerodinâmicas neste BasePart.

O CFrame dos extensos físicos da BasePart, representando seu centro físico.

O tamanho físico real do BasePart como visto pelo motor de física, por exemplo em detecção de colisão.

A propriedade FrontSurface determina o tipo de superfície usada para a direção -Z de uma peça. Quando as faces de duas peças estão colocadas umas ao lado das outras, elas podem criar uma joint entre elas. Se configurado para Motor, o BasePart.FrontSurfaceInput determina como uma joint de motor deve se comportar.

A maioria dos tipos de superfície rende uma textura na parte da face se o BasePart.Material for definido como Plástico. Alguns tipos de superfície, incluindo Hinge, Motor e SteppingMotor, renderizam uma adornamento 3D em vez disso. Se esta propriedade for selecionada na janela Propriedades, ela será destacada no mundo do jogo, semelhante ao de um 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

A propriedade LeftSurface determina o tipo de superfície usada para a direção -X de uma peça. Quando as faces de duas peças estão colocadas umas ao lado das outras, elas podem criar uma joint entre elas. Se configurado para Motor, o BasePart.LeftSurfaceInput determina como uma joint de motor deve se comportar.

A maioria dos tipos de superfície rende uma textura na parte da face se o BasePart.Material for definido como Plástico. Alguns tipos de superfície, incluindo Hinge, Motor e SteppingMotor, renderizam uma adornamento 3D em vez disso. Se esta propriedade for selecionada na janela Propriedades, ela será destacada no mundo do jogo, semelhante ao de um 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

A propriedade LocalTransparencyModifier é um multiplicador de BasePart.Transparency que só é visível para o cliente local. Não se replica do cliente para o servidor e é útil quando uma parte não deve renderizar para um cliente específico, como o modo de primeira pessoa do jogador não mostra as partes do corpo deles quando eles zoomam para o modo de primeira pessoa.

Essa propriedade modifica a transparência da peça local através da seguinte fórmula, com valores resultantes apertados entre 0 e 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>

A propriedade Bloqueada determina se um part (ou um model dentro dele) pode ser selecionado no Roblox Studio clicando nele. Essa propriedade é ativada com mais frequência em partes dentro de modelos de ambiente que não estão sendo editadas no momento. O Roblox Studio possui uma ferramenta Bloquear/Desbloquear Todos que pode alternar o

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

Massa é uma propriedade de leitura apenas que descreve o produto do volume e densidade de uma peça. Ele é retornado pela função Class.BasePart:GetMass()|GetMass ".

• O volume de uma peça é determinado por seu Size e seu Shape, que varia dependendo do tipo de BasePart usado, como WedgePart.
• A densidade de uma peça é determinada por seu Material ou CustomPhysicalProperties, se especificado.

Se esta propriedade for ativada, o BasePart não contribuirá para a massa ou inércia total de sua montagem, desde que seja soldado em outra peça que tenha massa.

Se a peça for sua própria peça raiz, de acordo com AssemblyRootPart, isso será ignorado para aquela peça, e ela ainda contribuirá para a massa e inatividade à sua montagem, como uma peça normal. Partes que não têm massa nunca devem se tornar uma peça raiz de montagem a menos que todas as outras peças na montagem sejam também não massas.

Isso pode ser útil para coisas como acessórios opcionais em veículos que você não quer afetar o controle do veículo ou uma malha de renderização em bruto soldada em uma malha de renderização mais simples.

Veja também Como Montar, um artigo que documenta quais são as partes de raiz e como usá-las.

A propriedade Material permite que um construtor defina a textura e propriedades físicas padrão de uma peça (no caso de Class.BasePart.CustomPhysicalProperties) não serem alteradas. O material padrão de plástico tem uma textura muito clara, e o material de plástico liso não tem textura em todos os casos. Algumas texturas de materiais, como DiamondPlate e Granite, têm texturas muito visíveis. Cada textura de material reflete a luz do sol

Configurar esta propriedade e ativar BasePart.CustomPhysicalProperties usará as propriedades físicas padrão de um material. Por instância, DiamondPlate é um material muito denso enquanto Wood é muito leve. A densidade de uma peça determina se ela flutuará na água do terreno.

O material de Vidro muda o comportamento de renderização em configurações gráficas moderadas. Ele aplica um pouco de refletividade (semelhante a BasePart.Reflectance ) e distorção de perspectiva. O efeito é especialmente pronunciado em partes de forma esférica (set BasePart.Shape para Bola). Objetos e partes de vidro por trás de vidro não são visíveis.

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)

O sistema procura a instância MaterialVariant com o nome especificado MaterialVariant e o digitarBasePart.Material. Se ele encontrar com sucesso uma instância MaterialVariant correspondente, ele usa esta instância MaterialVariant para substituir o material padrão. O material padrão pode ser o material incorporado ou um tipo MaterialVariant especificado em MaterialService.

A propriedade Orientação descreve a rotação da peça em graus ao redor dos eixos X, Y e Z usando um Vector3. As rotações são aplicadas em Y → X → Z ordem

Quando você definir essa propriedade qualquer Welds ou Motor6Ds conectado a esta parte terá a propriedade correspondente C0 ou 1> Class.JointInstance.C1|C11> atualizada

WeldSeconds também será desativado temporariamente e reativado durante o movimento.

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

Essa propriedade especifica o deslocamento do pivô da peça de sua CFrame, que é part:GetPivot() é o mesmo que part.CFrame * part.PivotOffset.

Isso é conveniente para definir o pivô em um local no espaço local , mas definir o pivô de uma peça para um local no espaço mundo pode ser feito da seguinte forma:

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

A propriedade Posição descreve as coordenadas de um part usando um Vector3. Ele reflete a posição do part BasePart.CFrame , no entanto, também pode ser configurar.

Quando você definir essa propriedade qualquer Welds ou Motor6Ds conectado a esta parte terá a propriedade correspondente C0 ou 1> Class.JointInstance.C1|C11> atualizada

WeldSeconds também será desativado temporariamente e reativado durante o movimento.

Isso retorna o tempo em segundos desde que a física da peça foi atualizada pela última vez no cliente local (ou no servidor). Retorna 0 quando a peça não tem física (Anchored)

A propriedade de refletância determina quanto um part refletirá a caixa de céu. Um valor de 0 indica que a parte não é refletiva em todas / todosos casos, e um valor de 1 indica que a parte deve ser totalmente refletiva.

A refletância não é afetada por BasePart.Transparency, a menos que a peça seja totalmente transparente, no qual caso a refletância não será renderizada em todas / todosos casos. A refletância pode ou não ser ignorada dependendo do BasePart.Material da peça.

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)

A propriedade ResizeIncrement é uma propriedade de leitura única que descreve a menor mudança de tamanho permitida pelo método BasePart:Resize(). Ela difere entre implementações da classe abstrata BasePart. Por instância, Part tem este set para 1 e 2>Class.Base

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

A propriedade ResizeableFaces (com um e , não ResizeableFaces) descreve usar um objeto Faces o diferentes rostos em que uma peça pode ser redim

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

A propriedade RightSurface determina o tipo de superfície usada para a direção +X de uma peça. Quando as faces de duas peças estão colocadas umas ao lado das outras, elas podem criar uma joint entre elas. Se configurado para Motor, o BasePart.RightSurfaceInput determina como uma joint de motor deve se comportar.

A maioria dos tipos de superfície rende uma textura na parte de cima se o BasePart.Material for definido como Plástico. Alguns tipos de superfície, incluindo Hinge, Motor e SteppingMotor, renderizam uma adornamento 3D em vez disso. Se esta propriedade for selecionada na janela Propriedades, ela será destacada no mundo do jogo, semelhante ao de um 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

Essa propriedade é um número inteiro entre -127 e 127 que tem precedência sobre todas as outras regras para a classificação da parte de ordenar / classificar. Ao considerar várias partes que não são Anchored e que compartilham o mesmo valor de Massless, uma parte com uma maior prioridade terá

Você pode usar esta propriedade para controlar qual parte de uma montagem é a raiz e manter a raiz estável se a mudança de tamanho.

Veja também Como Montar, um artigo que documenta quais são as partes de raiz e como usá-las.

A rotação da peça em graus para os três eixos.

Quando você definir essa propriedade qualquer Welds ou Motor6Ds conectado a esta parte terá a propriedade correspondente C0 ou 1> Class.JointInstance.C1|C11> atualizada

WeldSeconds também será desativado temporariamente e reativado durante o movimento.

A propriedade Size de uma peça determina suas dimensões visuais , enquanto ExtentsSize representa o tamanho real usado pelo motor de colisão,

O tamanho da peça determina sua massa, que é dada por BasePart:GetMass(). Um peça's Size é usado por uma variedade de outros objetos:

• ParticleEmitter para determinar a área de onde as partículas são geradas.
• BlockMesh para determinar parcialmente o prisma retangular renderizado.
• SpecialMesh para alguns MeshTypes, para determinar o tamanho do malha renderizada.
• SurfaceLight para determinar o espaço a ser iluminado.

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

A propriedade TopSurface determina o tipo de superfície usada para a direção +Y de uma peça. Quando as faces de duas peças estão colocadas umas ao lado das outras, elas podem criar uma joint entre elas. Se definido para Motor, o BasePart.TopSurfaceInput determina como uma joint de motor deve se comportar.

A maioria dos tipos de superfície rende uma textura na parte de cima se o BasePart.Material for definido como Plástico. Alguns tipos de superfície - hinge, motor e stepmotor - renderizarão uma adornamento 3D em vez disso. Se esta propriedade for selecionada na janela Propriedades, será destacado no mundo do jogo, semelhante ao de um 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

A propriedade Transparência controla a visibilidade de uma parte em uma escala de 0 a 1, onde 0 é completamente visível (opaco), e um valor de 1 é completamente invisível (não renderizado em todas / todos).

BasePart.Reflectance pode reduzir a transparência geral de um tijolo se definido perto de 1.

Embora peças totalmente transparentes não sejam renderizadas em todas / todosos casos, objetos parcialmente transparentes têm alguns custos de renderização significativos. Ter muitas peças de transfusão pode desacelerar o performancedo jogo.

Quando peças transparentes sobreposição, a ordem de renderização pode agir imprevisível - tente manter peças semi- transparentes de sobreposição para evitar isso.

O BasePart.LocalTransparencyModifier é um multiplicador de Transparência que só é vísível para o cliente 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)

Parâmetros

Devolução

Aplica um impulso de força angular instantâneo a esta peça, fazendo com que a peça gire.

A velocidade angular resultante da impulsação confia na montagem mass. Portanto, um impulso mais alto é necessário para mover mais montagens massivas. Impulsos são úteis para casos em que você deseja uma força aplicada instantaneamente, como uma explosão ou colisão.

Se a peça for propriedade do servidor, esta função deve ser chamada de um script de servidor Script (não de um <

Parâmetros

Devolução

Essa função aplica um impulso de força instantânea para a montagem desta parte.

A força é aplicada no centro de massa da montagem, então o movimento resultante será linear.

A velocidade resultante da impulsação confia na montagem mass. Portanto, um impulso mais forte é necessário para mover montagens mais massivas. Impulsos são úteis para casos em que você deseja uma força aplicada instantaneamente, como uma explosão ou colisão.

Se a peça for propriedade do servidor, esta função deve ser chamada de um script de servidor Script (não de um <

Parâmetros

Devolução

Essa função aplica um impulso de força instantânea à montagem desta peça, na posição especificada no espaço do mundo.

Se a posição não estiver no centro de massa da montagem, o impulso causará um movimento de posição e rotação.

A velocidade resultante da impulsação confia na montagem mass. Portanto, um impulso mais forte é necessário para mover montagens mais massivas. Impulsos são úteis para casos em que os desenvolvedores querem uma força aplicada instantaneamente, como uma explosão ou colisão.

Se a peça for propriedade do servidor, esta função deve ser chamada de um script de servidor Script (não de um <

Parâmetros

Devolução

Retorna se as peças podem colidir entre si ou não. Essa função leva em conta os grupos de colisão das duas peças. Essa função erra se a peça especificada não for uma BasePeça.

Parâmetros

Devolução

A função CanSetNetworkOwnership verifica se você pode configurar a propriedade da rede de uma parte.

O valor de retorno da função verifica se você pode ou não chamar BasePart:SetNetworkOwner() ou BasePart:SetNetworkOwnershipAuto() sem encontrar um erro. Retorna true se você puder modificar/ler a propriedade da rede, ou retorna false e o motivo pela qual você não pode, como uma string / cadeia / texto.

Devolução

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

Parâmetros

Devolução

Retorna uma tabela de peças conectadas ao objeto por qualquer tipo de articulação rígida.

Se recursive for verdadeiro, esta função retornará todas as peças na montagem conectadas firmemente à BasePart.

Juntas Rígidas

Quando uma conexão juntar duas peças juntas (Part0 → Part1) , uma conexão é rígida se as físicas de Part1 estiverem completamente bloqueadas por Part1. Isso só se aplica aos seguintes tipos de conexão:

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

Parâmetros

Devolução

Retorne todas as Joints ou Constraints que estão conectadas a esta Peça.

Devolução

GetMass retorna o valor da propriedade read-only Mass.

Essa função está desatualizada para a propriedade Mass. Ela ainda é compatível com versões anteriores; você deve usar a propriedade Mass diretamente.

Devolução

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)

Retorna o jogador atual que é o dono da rede desta parte, ou nil no caso do servidor.

Devolução

Retorna verdadeiro se o motor de jogo decidir automaticamente o proprietário da rede para esta parte.

Devolução

Devolução

Retorna a parte base de uma montagem. Quando mover uma montagem de peças usando um CFrame . é importante mover essa parte base (isso moverá todas as outras peças conectadas a ele). Mais informações estão disponíveis no artigo Montagens.

Essa função está pré-datada na propriedade AssemblyRootPart. Ela ainda é suportada para a compatibilidade com versões anteriores, mas você deve usar AssemblyRootPart diretamente.

Devolução

Retorna uma tabela de todas as peças que estão fisicamente interagindo com esta peça. Se a peça em si tiver o CanCollide definido como falso, então esta função retorna uma tabela

Devolução