BasePart

A propriedade Anchored determina se a peça será imóvel pela física.Quando ativado, uma parte nunca mudará de posição devido à gravidade, colisões de outras partes, sobreposição de outras partes ou quaisquer outras causas relacionadas à física.Como resultado, duas peças ancoradas nunca dispararão o evento Touched umas contra as outras.

Uma peça ancorada ainda pode ser movida alterando seu CFrame ou Position, e ainda pode ter um não zero AssemblyLinearVelocity e AssemblyAngularVelocity.

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

A propriedade de rede não pode ser definida em partes ancoradas.Se o status de âncora 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 parte. É a taxa de mudança de orientação em radianos por segundo.

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

Definir a velocidade diretamente pode levar a movimentos irrealistas.Usar Torque ou AngularVelocity restrição é preferível, ou use ApplyAngularImpulse() se você quiser alteração instantânea na velocidade.

Se a peça for possuída pelo servidor, esta propriedade deve ser alterada de um servidor Script (não de um LocalScript ou um Script com RunContext definido para Enum.RunContext.Client).Se a peça for possuída por um cliente através de propriedade automática , esta propriedade pode ser alterada de um script de cliente ou de um script de servidor; alterá-la de um script de cliente para uma peça de propriedade do servidor não terá efeito.

Uma posição calculada através do Mass e Position de todas as peças na montagem.

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

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 linear.Uma montagem com um centro de massa baixo terá um tempo melhor de permanência de pé sob o efeito da gravidade.

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

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

Definir a velocidade diretamente pode levar a movimentos irrealistas.Usar uma restrição VectorForce é preferível, ou use ApplyImpulse() se você quiser mudança instantânea na velocidade.

Se a peça for possuída pelo servidor, esta propriedade deve ser alterada de um servidor Script (não de um LocalScript ou um Script com RunContext definido para Enum.RunContext.Client).Se a peça for possuída por um cliente através de propriedade automática , esta propriedade pode ser alterada de um script de cliente ou de um script de servidor; alterá-la de um script de cliente para uma peça de propriedade do servidor não terá efeito.

A soma da massa de todos os BaseParts na montagem desta parte.Peças que são Massless e não são a parte raiz da montagem não contribuirão para o AssemblyMass.

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

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

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

Peças que todas compartilham o mesmo AssemblyRootPart são na mesma montagem.

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

AudioCanCollide determina se a peça interagirá fisicamente com a simulação de áudio, semelhante a CastShadow para iluminação.

Quando desativado, o áudio passa pela parte; não é oculto ou refletido.

A propriedade BackSurface determina o tipo de superfície usada para a direção positiva Z de uma peça.Quando as faces de duas peças são colocadas ao lado uma da outra, elas podem criar uma junta entre elas.

A propriedade BottomSurface determina o tipo de superfície usada para a direção negativa Y de uma peça.Quando as faces de duas peças são colocadas ao lado uma da outra, elas podem criar uma junta entre elas.

Essa propriedade determina a cor de uma peça.Se a peça tiver um Material, isso também determina a cor usada ao renderizar a textura do material.Para mais controle sobre a cor, a propriedade Color pode ser usada e essa propriedade usará o mais próximo BrickColor.

Outras propriedades visuais de uma peça são determinadas por Transparency e Reflectance.

A propriedade CFrame determina tanto a posição quanto a orientação do BasePart no mundo.Ela atua como uma localização de referência arbitrária na geometria, mas ExtentsCFrame representa o real CFrame de seu centro físico.

Ao definir CFrame em uma peça, outras peças conectadas também são movidas em relação à peça, mas é recomendado que você use PVInstance:PivotTo() para mover um modelo inteiro, como quando teletransportar o personagem de um jogador.

Ao contrário de definir BasePart.Position , a configuração CFrame sempre moverá a peça para o exato dado CFrame ; em outras palavras: nenhuma verificação de sobreposição é feita e o solucionador de física tentará resolver qualquer sobreposição a menos que ambas as peças sejam Anchored .

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

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

-- Redefina o CFrame da peça para (0, 0, 0) sem rotação.
-- Isso às vezes é chamado de "identidade" CFrame
part.CFrame = CFrame.new()

-- Definido para uma posição específica (X, Y, Z)
part.CFrame = CFrame.new(0, 25, 10)

-- O mesmo que acima, mas use um Vector3 em vez disso
local point = Vector3.new(0, 25, 10)
part.CFrame = CFrame.new(point)

-- Defina o CFrame da peça para estar em um ponto, olhando para outro
local lookAtPoint = Vector3.new(0, 20, 15)
part.CFrame = CFrame.lookAt(point, lookAtPoint)

-- Gire o CFrame da peça por pi/2 radianos no eixo X local
part.CFrame = part.CFrame * CFrame.Angles(math.pi / 2, 0, 0)
-- Gire o CFrame da peça em 45 graus no eixo Y local
part.CFrame = part.CFrame * CFrame.Angles(0, math.rad(45), 0)
-- Gire o CFrame da peça em 180 graus no eixo global Z (note a ordem!)
part.CFrame = CFrame.Angles(0, 0, math.pi) * part.CFrame -- Pi radianos é igual a 180 graus

-- Compor dois CFrames é feito usando * (o operador de multiplicação)
part.CFrame = CFrame.new(2, 3, 4) * CFrame.new(4, 5, 6) --> igual a CFrame.new(6, 8, 10)

-- Ao contrário da multiplicação algebraica, a composição do CFrame não é comunicativa: a * b não é necessariamente b * a!
-- Imagine * como uma série ORDENADA de ações. Por exemplo, as seguintes linhas produzem diferentes CFrames:
-- 1) Deslize as unidades da parte 5 em X.
-- 2) Gire a peça 45 graus em torno de seu eixo Y.
part.CFrame = CFrame.new(5, 0, 0) * CFrame.Angles(0, math.rad(45), 0)
-- 1) Gire a peça 45 graus em torno de seu eixo Y.
-- 2) Deslize as unidades da parte 5 em X.
part.CFrame = CFrame.Angles(0, math.rad(45), 0) * CFrame.new(5, 0, 0)

-- Não há "divisão CFrame", mas simplesmente "fazendo a operação inversa".
part.CFrame = CFrame.new(4, 5, 6) * CFrame.new(4, 5, 6):Inverse() --> é igual a CFrame.new(0, 0, 0)
part.CFrame = CFrame.Angles(0, 0, math.pi) * CFrame.Angles(0, 0, math.pi):Inverse() --> igual ao CFrame.Angles(0, 0, 0)

-- Posicione uma peça em relação a outra (neste caso, coloque nossa peça no topo de outra peça)
part.CFrame = otherPart.CFrame * CFrame.new(0, part.Size.Y / 2 + otherPart.Size.Y / 2, 0)

CanCollide determina se uma parte vai interagir fisicamente com outras partes.Quando desativado, outras partes podem passar pela parte sem interrupção.Peças usadas para decoração geralmente têm CanCollide, pois não precisam ser consideradas pelo motor de física.

Se uma peça não for Anchored e tiver CanCollide desativada, ela pode cair do mundo para ser eventualmente destruída por Workspace.FallenPartsDestroyHeight .

Quando é desativado, as peças ainda podem disparar o evento (assim como as outras peças que as tocam).Você pode desativar isso com CanTouch .

Para mais informações sobre colisões, veja 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()

Essa propriedade determina se a peça é considerada durante operações de consulta espacial, como GetPartBoundsInBox ou Raycast.Observe que CanCollide deve ser desativado para que CanQuery tenha efeito, e as funções de consulta espacial nunca incluirão partes com CanQuery de false.

Além dessa propriedade, também é possível excluir partes que são descendentes de uma lista dada de partes usando um objeto OverlapParams ou RaycastParams quando chamar as funções de consulta espacial.

Essa propriedade determina se Touched e TouchEnded eventos atiram na parte.Se true , outras peças sensíveis também devem ter CanTouch definido para true para que eventos de Iniciar / executarsejam disparados.Se false , eventos de toque não podem ser configurados para a peça e tentar fazer isso irá gerar um erro.Da mesma forma, se a propriedade for definida como false após um evento de toque for conectado, o evento será desconectado e o TouchTransmitter removido.

Observe que essa lógica de colisão pode ser definida para respeitar grupos de colisão através da propriedade Workspace.TouchesUseCollisionGroups.Se true , partes em grupos não colidentes ignorarão ambos os eventos de colisão e , tornando esta propriedade irrelevante.

Desempenho

Há um pequeno ganho de desempenho em peças que tenham tanto CanTouch e CanCollide definidas para false, pois essas peças nunca precisarão calcular qualquer tipo de colisão de peças.No entanto, eles ainda podem ser atingidos por Raycasts e OverlapParams consultas.

Determina se uma peça lança ou não uma sombra.Desabilitar essa propriedade para uma parte dada pode causar artefatos visuais nas sombras lançadas sobre essa parte.

Essa propriedade não é projetada para melhoria de desempenho, mas em cenas complexas, desabilitá-la estrategicamente em certas partes pode melhorar o performance.Devido à possibilidade de artefatos visuais, recomendamos deixá-lo ativado em todas as partes na maioria das situações.

A propriedade CenterOfMass descreve a posição local do centro de massa de uma peça.Se esta for uma montagem de uma única peça, esta é a AssemblyCenterOfMass convertida do espaço mundial para o local.Em simples Parts , o centro de massa é sempre (0, 0, 0) , mas pode variar para WedgePart ou MeshPart .

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

Embora essa propriedade em si não seja replicada, o motor replica internamente o valor através de outra propriedade privada para resolver 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 Color determina a cor de uma peça.Se a peça tiver um Material, isso também determina a cor usada ao renderizar a textura do material.

Se esta propriedade for configurar, BrickColor usará a correspondência mais próxima a este valor Color.

Outras propriedades visuais de uma peça são determinadas por Transparency e Reflectance.

-- Coloque em um Script dentro de StarterCharacterScripts
-- Então jogue o jogo e brinque com a saúde do seu personagem
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

	-- Crie uma cor ao longo de uma transição com base na porcentagem da sua saúde
	-- A cor vai de colorHealthy (100%) ----- > colorUnhealthy (0%)
	local color = Color3.new(
		colorHealthy.R * percentage + colorUnhealthy.r * (1 - percentage),
		colorHealthy.G * percentage + colorUnhealthy.g * (1 - percentage),
		colorHealthy.B * percentage + colorUnhealthy.b * (1 - percentage)
	)
	setColor(color)
end

update()
human.HealthChanged:Connect(update)

CurrentPhysicalProperties 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 do Roblox prioriza definições mais granulares ao determinar as propriedades físicas efetivas de uma peça.Os valores na lista a seguir estão em ordem de prioridade mais alta para mais baixa:

• Propriedades físicas personalizadas da peça
• Propriedades físicas personalizadas do material personalizado da peça
• Propriedades físicas personalizadas da substituição do 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 uma peça, como sua densidade, fricção e elasticidade.

Se habilitada, essa propriedade permite que você configure essas propriedades físicas.Se desativado, essas propriedades físicas são determinadas pela Material da 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 true e quando Workspace.FluidForces é ativado, causa ao motor de física a computar forças aerodinâmicas neste BasePart .

O CFrame da extensão física do BasePart, representando seu centro físico.

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

A propriedade FrontSurface determina o tipo de superfície usada para a direção negativa Z de uma peça.Quando as faces de duas peças são colocadas ao lado uma da outra, elas podem criar uma junta entre elas.

A propriedade LeftSurface determina o tipo de superfície usada para a direção negativa X de uma peça.Quando as faces de duas peças são colocadas ao lado uma da outra, elas podem criar uma junta entre elas.

A propriedade LocalTransparencyModifier é um multiplicador para Transparency que só é visível para o cliente local.Ela não se replica do cliente para o servidor e é útil para quando uma parte não deve renderizar para um cliente específico, como quando o jogador não vê as partes do corpo de seu personagem quando se aproxima no modo de primeira pessoa.

Essa propriedade modifica a transparência da parte local através da seguinte fórmula, com os valores resultantes limitados entre 0 e 1.

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

<th><code>Modificador de Transparência Local</code></th>

    <th>Lado do Servidor</th>

    <th>Lado do Cliente</th>
  </tr>
</thead>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

A propriedade Locked determina se uma peça (ou uma Model dela está contida) pode ser selecionada no Studio clicando nela.Essa propriedade é mais frequentemente habilitada em partes dentro de modelos de ambiente que não estão sendo editadas no momento.

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

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

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

recursiveUnlock(model)

Mass é uma propriedade de leitura que descreve o produto do volume e da densidade de uma peça. É retornada pela função 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 estiver habilitada, a peça não contribuirá para a massa total ou inércia de sua montagem enquanto estiver soldada a outra peça que tenha massa.

Se a peça for sua própria peça de raiz de acordo com AssemblyRootPart, isso será ignorado para essa peça e ainda contribuirá com massa e inércia para sua montagem como uma peça normal.Peças que não tenham massa nunca devem se tornar uma parte raiz de montagem a menos que todas as outras peças na montagem também sejam sem massa.

Isso pode ser útil para coisas como acessórios opcionais em veículos que você não quer afetar o manuseio do carro ou uma malha de renderização sem massa soldada a uma malha de colisão mais simples.

Veja também Montagens, um artigo que documenta o que são peças raíz e como usá-las.

A propriedade Material permite que você defina a textura e as propriedades físicas padrão de uma peça (no caso de que CustomPhysicalProperties não esteja definido).O material padrão Plastic tem uma textura muito leve, enquanto o material SmoothPlastic não tem textura todas / todos.Algumas texturas de material como DiamondPlate e Granite têm texturas muito visíveis.A textura de cada material reflete a luz do sol de forma diferente, especialmente Foil .

Definir esta propriedade e ativar 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.

As alterações de material Glass mudam o comportamento de renderização em gráficos moderados, aplicando um pouco de refletância (semelhante a Reflectance ) e distorção de perspectiva.O efeito é especialmente pronunciado em peças em forma de esfera.Peças semi-transparentes atrás de Glass peças não são visíveis.

O sistema pesquisa a instância com o nome e o digitarespecificados.Se encontrar com sucesso uma instância correspondente MaterialVariant, ela usa essa instância para substituir o material padrão.O material padrão pode ser o material integrado ou um substituto MaterialVariant especificado em MaterialService .

A propriedade Orientation descreve a rotação da peça em graus em torno dos eixos X , Y e Z usando um Vector3.As rotações são aplicadas em Y > X > Z ordem.Isso difere dos ângulos Euler corretos e é, em vez disso, ângulos Tait-Bryan que descrevem yaw , pitch e roll .

Também vale a pena notar como essa propriedade difere do construtor CFrame.Angles() que aplica rotações em uma ordem diferente ( Z > Y > X ).Para um melhor controle sobre a rotação de uma peça, é recomendado que CFrame seja definido em vez disso.

Ao definir esta propriedade, qualquer Welds ou Motor6Ds conectado a esta parte terá a propriedade correspondente C0 ou C1 atualizada para permitir que a parte se mova em relação a quaisquer outras partes com as quais está conectada.WeldConstraints também será desativado temporariamente e reativado durante o movimento.

local part = script.Parent

local INCREMENT = 360 / 20

-- Gire a peça continuamente
while true do
	for degrees = 0, 360, INCREMENT do
		-- Defina apenas a rotação do eixo Y
		part.Rotation = Vector3.new(0, degrees, 0)
		-- Uma maneira melhor de fazer isso seria definir CFrame
		--part.CFrame = CFrame.new(part.Position) * CFrame.Angles(0, matemática.rad(graus), 0
		task.wait()
	end
end

Essa propriedade especifica o deslocamento do pivô da peça de seu CFrame , que é BasePart:GetPivot() igual a BasePart.CFrame multiplicado por BasePart.PivotOffset .

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

local Workspace = game:GetService("Workspace")

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

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

resetPivot(script.Parent)

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

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

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

-- Criar mãos
local hourHand = createHand(7, 1, 0)
local minuteHand = createHand(10, 0.6, 0.1)
local secondHand = createHand(11, 0.2, 0.2)

-- Executar relógio
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 Position descreve as coordenadas de uma peça usando um Vector3.Ela reflete a posição do CFrame da peça, no entanto também pode ser configurar.

Ao definir esta propriedade, qualquer Welds ou Motor6Ds conectado a esta parte terá a propriedade correspondente C0 ou C1 atualizada para permitir que a parte se mova em relação a quaisquer outras partes com as quais está conectada.WeldConstraints também será desativado temporariamente e reativado durante o movimento.

Indica o tempo em segundos desde que a física da parte foi atualizada pela última vez no cliente local ou no servidor.Este valor será 0 quando a peça não tiver física (Anchored é true).

A propriedade Reflectance determina quanto uma parte reflete o céu.Um valor de 0 indica que a peça não é reflexiva de todas / todos, e um valor de 1 indica que a peça deve refletir totalmente.

A refletância não é afetada por Transparency a menos que a peça seja totalmente transparente, caso em que a refletância não renderizará de todas / todos.A refletância pode ou não pode ser ignorada dependendo do Material da peça.

A propriedade ResizeIncrement é uma propriedade de leitura que descreve a menor mudança de tamanho permitida pelo método Resize().Diferem entre implementações da classe abstrata BasePart ; por instância, Part tem este conjunto para 1 enquanto TrussPart tem este conjunto para 2 já que as seções de treliça individuais são 2×2×2 em tamanho.

A propriedade ResizeableFaces usa um objeto Faces para descrever as diferentes faces em que uma peça pode ser redimensionada.Para a maioria das implementações de BasePart , como Part e WedgePart, esta propriedade inclui todos os rostos.No entanto, definirá seu conjunto para apenas duas faces, pois esses tipos de peças devem ter duas dimensões de comprimento .

Essa propriedade é mais comumente usada com ferramentas para construir e manipular peças e tem pouco uso fora desse contexto.A classe Handles, que tem a propriedade Handles.Faces, pode ser usada em conjunto com essa propriedade para exibir apenas as alças em faces que podem ser redimensionadas em uma peça.

-- 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 positiva X de uma peça.Quando as faces de duas peças são colocadas ao lado uma da outra, elas podem criar uma junta entre elas.

Essa propriedade é um inteiro entre -127 e 127 que tem precedência sobre todas as outras regras para classificar a parte ordenar / classificar.Ao considerar múltiplas partes que não são Anchored e que compartilham o mesmo valor Massless , uma parte com um valor mais alto RootPriority terá prioridade sobre aquelas com menor valor RootPriority.

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

Veja também Montagens, um artigo que documenta o que são peças raíz e como usá-las.

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

Ao definir esta propriedade, qualquer Welds ou Motor6Ds conectado a esta parte terá a propriedade correspondente C0 ou C1 atualizada para permitir que a parte se mova em relação a quaisquer outras partes com as quais está conectada.WeldConstraints também será desativado temporariamente e reativado durante o movimento.

A propriedade de uma peça determina suas dimensões visuais , enquanto representa o tamanho real usado pelo motor de física, como em detecção de colisão .As dimensões individuais (comprimento, largura, altura) podem ser tão baixas quanto 0.001 e tão altas quanto 2048.Dimensões de tamanho abaixo de serão representadas visualmente como se as dimensões da peça fossem .

Uma parte de Size é usada de várias maneiras adicionais:

• Para influenciar sua massa como dada por GetMass() .
• Por ParticleEmitter para determinar a área de onde as partículas são geradas.
• Por BlockMesh para determinar parcialmente o prisma retangular renderizado.
• Por SpecialMesh para determinado MeshTypes para determinar o tamanho da malha renderizada.
• Por 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 positiva Y de uma peça.Quando as faces de duas peças são colocadas ao lado uma da outra, elas podem criar uma junta entre elas.

A propriedade Transparency controla a visibilidade de uma parte em uma escala de 0 a 1, onde 0 é completamente visível (opaca) e 1 é completamente invisível (não renderizada em todas / todos).

Enquanto peças totalmente transparentes não são renderizadas de todas / todos, objetos parcialmente transparentes têm alguns custos de renderização significativos.Ter muitas partes translúcidas pode impactar o performance.

Quando peças transparentes se sobrepõem, a ordem de renderização pode agir de forma imprevisível, então você deve evitar que peças semi-transparentes se sobreponham.

Veja também LocalTransparencyModifier como um multiplicador para Transparency que só é visível ao 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()

Parâmetros

Devolução

Aplica um impulso de força angular instantâneo à montagem desta parte, fazendo com que a montagem gire.

A velocidade angular resultante do impulso depende da mass da montagem.Então, é necessário um impulso maior para mover montagens mais massivas.Impulsos são úteis para casos em que você quer uma força aplicada imediatamente, como uma explosão ou colisão.

Se a peça for possuída pelo servidor, esta função deve ser chamada de um servidor Script (não de um LocalScript ou um Script com RunContext definido para Enum.RunContext.Client ).Se a peça for possuída por um cliente através de propriedade automática , esta função pode ser chamada de um script de cliente ou de um script de servidor; chamá-la de um script de cliente para uma peça de propriedade do servidor não terá efeito.

Parâmetros

Devolução

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

A força é aplicada na montagem de center of mass, portanto, o movimento resultante será apenas linear.

A velocidade resultante do impulso depende da montagem de mass.Então, é necessário um impulso maior para mover montagens mais massivas.Impulsos são úteis para casos em que você quer uma força aplicada imediatamente, como uma explosão ou colisão.

Se a peça for possuída pelo servidor, esta função deve ser chamada de um servidor Script (não de um LocalScript ou um Script com RunContext definido para Enum.RunContext.Client ).Se a peça for possuída por um cliente através de propriedade automática , esta função pode ser chamada de um script de cliente ou de um script de servidor; chamá-la de um script de cliente para uma peça de propriedade do servidor não terá efeito.

Parâmetros

Devolução

Essa função aplica um impulso de força instantâneo à montagem desta parte, na posição especificada no espaço mundial.

Se a posição não estiver na montagem de center of mass, o impulso causará um movimento posicional e rotacional.

A velocidade resultante do impulso depende da montagem de mass.Então, é necessário um impulso maior para mover montagens mais massivas.Impulsos são úteis para casos em que os desenvolvedores querem uma força aplicada imediatamente, como uma explosão ou colisão.

Se a peça for possuída pelo servidor, esta função deve ser chamada de um servidor Script (não de um LocalScript ou um Script com RunContext definido para Enum.RunContext.Client ).Se a peça for possuída por um cliente através de propriedade automática , esta função pode ser chamada de um script de cliente ou de um script de servidor; chamá-la de um script de cliente para uma peça de propriedade do servidor não terá efeito.

Parâmetros

Devolução

Retorna se as peças podem colidir umas com as outras ou não.Essa função leva em consideração os grupos de colisão das duas partes.Essa função irá falhar se a peça especificada não for uma BasePart.

Parâmetros

Devolução

A função CanSetNetworkOwnership verifica se você pode definir a propriedade de rede de uma peça.

O valor de retorno da função verifica se você pode ou não chamar BasePart:SetNetworkOwner() ou BasePart:SetNetworkOwnershipAuto() sem encontrar um erro.Ele retorna verdadeiro se você puder modificar/ler a propriedade da rede ou retornar falso e a razão 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çãorígida.

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

Juntas Rígidas

Quando uma junta conecta duas partes juntas (Part0 → Part1) , uma junta é rígida se a física de Part1 estiver completamente bloqueada por Part0 .Isso só se aplica aos seguintes tipos conjuntos:

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

Parâmetros

Devolução

Retorne todos os Juntos ou Restrições que estão conectados a esta Parte.

Devolução

ObterMass retorna o valor da propriedade read-only Mass.

Essa função precede a propriedade de Massa. Ela permanece suportada para compatibilidade com versões anteriores; você deve usar a propriedade de Massa 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 proprietário 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.Ao mover uma montagem de peças usando um CFrame.é importante mover esta parte da base (isso moverá todas as outras partes conectadas a ela de acordo).Mais informações estão disponíveis no artigo Montagens.

Essa função precede a propriedade AssemblyRootPart. Ela permanece suportada para 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 própria peça tiver o CanCollide definido como falso, então essa função retorna uma tabela vazia a menos que a peça tenha um objeto relacionado a ela (significando que algo está conectado ao seu evento Tocado).Peças adjacentes, mas não intersectantes, não são consideradas tocantes.Essa função precede a função WorldRoot:GetPartsInPart(), que fornece mais flexibilidade e evita as regras especiais TouchInterest descritas acima.Use WorldRoot:GetPartsInPart() em vez disso.

Devolução

Retorna a velocidade linear da montagem da peça na posição dada em relação a esta peça.Pode ser usado para identificar a velocidade linear das peças em uma montagem diferente da peça raiz.Se a montagem não tiver velocidade angular, então a velocidade linear será sempre a mesma para cada posição.

Parâmetros

Devolução

Retorna verdadeiro se o objeto estiver conectado a uma parte que o manterá no lugar (por exemplo, uma parte Anchored), caso contrário, retorna falso.Em uma montagem que tem uma peça Anchored parte, todas as outras peças são ancoradas.

Devolução

Muda o tamanho de um objeto assim como usar a ferramenta de redimensionamento do Studio.

Parâmetros

Devolução

Define o jogador dado como proprietário da rede para isso e todas as peças conectadas.Quando playerInstance é nil, o servidor será o proprietário em vez de um jogador.

Parâmetros

Devolução

Permite que o motor do jogo decida dinamicamente quem vai lidar com a física da peça (um dos clientes ou do servidor).

Devolução

Parâmetros

Devolução

Cria um novo IntersectOperation a partir da geometria intersecante da peça e das outras peças no matriz / listadado.Apenas Parts são suportadas, não Terrain ou MeshParts.Semelhante a Clone() , o objeto retornado não tem nenhum conjunto Parent.

As seguintes propriedades da parte de chamada são aplicadas ao resultante IntersectOperation :

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

Na comparação de imagem a seguir, IntersectAsync() é chamado no bloco roxo usando uma tabela que contém o bloco azul.O resultante IntersectOperation resolve em uma forma da geometria intersecante de ambas as partes.

<figcaption>Peças separadas</figcaption>

<figcaption>Resultando em <code>Class.IntersectOperation</code></figcaption>

Notas

• As peças originais permanecem intactas após uma operação de intersecção bem-sucedida.Na maioria dos casos, você deve Destroy() todas as peças originais e parente o retornado IntersectOperation no mesmo local que o chamando BasePart.
• Por padrão, as cores do rosto da interseção resultante são emprestadas da propriedade Color da parte original.Para alterar toda a interseção para uma cor específica, defina sua propriedade UsePartColor para true.
• Se uma operação de intersecção resultasse em uma peça com mais de 20.000 triângulos, ela seria simplificada para 20.000 triângulos.

Parâmetros

Devolução

Cria um novo UnionOperation a partir da peça, menos a geometria ocupada pelas peças no matriz / listadado.Apenas Parts são suportadas, não Terrain ou MeshParts.Semelhante a Clone() , o objeto retornado não tem nenhum conjunto Parent.

Observe que a união resultante não pode estar vazia devido às subtrações. Se a operação resultar em geometria completamente vazia, ela falhará.

Na comparação de imagem a seguir, SubtractAsync() é chamado no cilindro azul usando uma tabela que contém o bloco roxoO resultante UnionOperation resolve em uma forma que omite a geometria do bloco da do cilindro.

<figcaption>Peças separadas</figcaption>

<figcaption>Resultando em <code>Class.UnionOperation</code></figcaption>

Parâmetros

Devolução

local Workspace = game:GetService("Workspace")

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

-- Realizar operação de subtração
local success, newSubtract = pcall(function()
	return mainPart:SubtractAsync(otherParts)
end)

-- Se a operação for bem-sucedida, posicione-a no mesmo local e associá-la ao espaço de trabalho
if success and newSubtract then
	newSubtract.Position = mainPart.Position
	newSubtract.Parent = Workspace
end

-- Destrua peças originais que permanecem intactas após a operação
mainPart:Destroy()
for _, part in otherParts do
	part:Destroy()
end

Cria um novo UnionOperation a partir da peça, mais a geometria ocupada pelas peças no matriz / listadado.Apenas Parts são suportadas, não Terrain ou MeshParts.Semelhante a Clone() , o objeto retornado não tem nenhum conjunto Parent.

As seguintes propriedades da parte de chamada são aplicadas ao resultante UnionOperation :

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

Na comparação de imagem a seguir, UnionAsync() é chamado no bloco azul usando uma tabela que contém o cilindro roxo.O resultante UnionOperation resolve em uma forma da geometria combinada de ambas as partes.

<figcaption>Peças separadas</figcaption>

<figcaption>Resultando em <code>Class.UnionOperation</code></figcaption>

Notas

• As peças originais permanecem intactas após uma operação de união bem-sucedida.Na maioria dos casos, você deve Destroy() todas as peças originais e parente o retornado UnionOperation no mesmo local que o chamando BasePart.
• Por padrão, a união resultante respeita a propriedade Color de cada uma de suas partes.Para alterar toda a união para uma cor específica, defina sua propriedade UsePartColor para true.
• Se uma operação de união resultar em uma peça com mais de 20.000 triângulos, ela será simplificada para 20.000 triângulos.

Parâmetros

Devolução

local Workspace = game:GetService("Workspace")

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

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

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

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

Incêndios quando uma parte para de tocar outra parte em condições semelhantes às de BasePart.Touched .

Este evento funciona em conjunto com Workspace.TouchesUseCollisionGroups para especificar se grupos de colisão são reconhecidos para detecção.

Parâmetros

local part = script.Parent

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

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

local numTouchingParts = 0

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

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

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

O evento Tocado é acionado quando uma parte entra em contato com outra parte.Por instância, se ParteA bater em ParteB , então PartA.Touched foge com ParteB e PartB.Touched foge com ParteA .

Este evento só é disparado como resultado de movimento físico, então não será disparado se a propriedade CFrame for alterada de forma que a peça se sobreponha a outra peça.Isso também significa que pelo menos uma das peças envolvidas deve não estar na hora da colisão.

Este evento funciona em conjunto com Workspace.TouchesUseCollisionGroups para especificar se grupos de colisão são reconhecidos para detecção.

Parâmetros

local part = script.Parent

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

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

local numTouchingParts = 0

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

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

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

local model = script.Parent

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

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

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