BasePart

La propiedad Anchored determina si la parte será inmóvil por física. Cuando se habilita, una parte nunca cambiará de posición debido a la gravedad, otras colisiones de partes, superposición de otras partes o cualquier otra causa relacionada con la física. Como resultado, dos partes ancladas nunca dispararán el evento BasePart.Touched uno del otro.

Una parte anclada aún puede ser movida cambiando su CFrame o Position, y aún puede tener una velocidad de movimiento no nulo AssemblyLinearVelocity y 1> Class.BasePart.AssemblyAngularVelocity|Rotation de apertura de1> .

Finalmente, si una parte no anclada se une a una parte anclada a través de un objeto como un Weld , también actuará anclado. Si tal joint se rompe, la parte puede ser afectada por la física de nuevo. Vea Ensamblajes para más detalles.

La propiedad de la red no se puede establecer en las partes ancladas. Si el estado de anclado de una parte cambia en el servidor, la propiedad de la red de esa parte se verá afectada.

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)

El vector de velocidad ángular de esta parte de la montaje. Es la tasa de cambio de orientación en radianes por segundo.

La velocidad de ángulo es la misma en cada punto de la instalación.

Establecer la velocidad directamente puede llevar a un movimiento irrealista. El uso de Torque o AngularVelocity约束 es preferido, o use BasePart:ApplyAngularImpulse() si desea un cambio instantáneo en la velocidad.

Si la parte es propiedad del servidor, esta propiedad debe cambiarse desde un servidor Class.Script (no desde un Class.LocalScript o un Class.Script con Class.Base

Una posición calculada a través de la mass y la position de todas las partes en la instalación.

Si la instalación tiene una parte anclada, el centro de masa de esa parte será el centro de masa de la instalación y la instalación tendrá masa infinita.

Conocer el centro de masa puede ayudar a la montaje a mantener la estabilidad. Una fuerza aplicada al centro de masa no causará aceleración angular, solo velocidad lineal. Una montaje con un centro de masa bajo tendrá un mejor tiempo para mantenerse de pie bajo el efecto de la gravedad.

El vector de velocidad lineal de la montura de esta parte. Es la tasa de cambio en la posición del montaje de la center of mass en studs por segundo.

Si desea conocer la velocidad en un punto diferente del centro de masa del montaje, use BasePart:GetVelocityAtPosition() .

Establecer la velocidad directamente puede llevar a un movimiento irrealista. El uso de un límite de VectorForce es preferible, o use BasePart:ApplyImpulse() si desea un cambio instantáneo en la velocidad.

Si la parte es propiedad del servidor, esta propiedad debe cambiarse desde un servidor Class.Script (no desde un Class.LocalScript o un Class.Script con Class.Base

La suma de la masa de todos los parts en esta parte de la montaje. Las partes que son Massless y no son la parte raíz de la montaje no contribuirán a la montaje.

Si la montura tiene una parte anclada, la masa de la montura se considera infinita. Los límites y otras interacciones físicas entre las monturas con una gran diferencia en la masa pueden causar instabilidades.

Esta propiedad indica que el BasePart se ha elegido automáticamente para representar la raíz de la instalación. Es la misma parte que se devuelve cuando los desarrolladores llaman GetRootPart().

La parte de raíz se puede cambiar al cambiar la RootPriority de las partes en la lista de montaje.

Las partes que todas comparten la misma raíz de montaje están en la misma montura.

Para obtener más información en las partes de raíz, see Ensamblajes .

La propiedad BackSurface determina el tipo de superficie utilizada para la dirección +Z de una parte. Cuando se colocan las caras de dos partes uno al lado del otro, pueden crear una interfaz de unión entre ellas. Si se establece en Motor, la propiedad BasePart.BackSurfaceInput determina cómo debe comportarse una interfaz de unión.

La mayoría de los tipos de superficie renderizan una textura en la cara de la parte si el BasePart.Material está configurado como Plástico. Algunos tipos de superficie -Hinge, Motor y SteppingMotor- renderizarán un adorno 3D en su lugar. Si esta propiedad se selecciona en la ventana Propiedades, se resaltará en el mundo del juego similar al de un SurfaceSelection .

local demoPart = script.Parent

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

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

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

La propiedad BottomSurface determina el tipo de superficie utilizada para la dirección -Y de una parte. Cuando se colocan las caras de dos partes uno al lado del otro, pueden crear una articulación entre ellas. Si se establece en Motor, la BasePart.BottomSurfaceInput determina cómo debe comportarse una articulación del motor.

La mayoría de los tipos de superficie renderizan una textura en la cara de la parte si el BasePart.Material está configurado como Plástico. Algunos tipos de superficie -Hinge, Motor y SteppingMotor- renderizarán un adorno 3D en su lugar. Si esta propiedad se selecciona en la ventana Propiedades, se resaltará en el mundo del juego similar al de un SurfaceSelection .

local demoPart = script.Parent

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

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

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

La propiedad BrickColor determina el color de una parte. Si la parte tiene un BasePart.Material, esto también determina el color utilizado al renderizar la textura del material. Para más control sobre el color, la propiedad BasePart.Color puede usarse (es una variante de Color3 de esta propiedad). Si Color establecer, esta propiedad usará el color más cercano.

Otras propiedades visuales de una parte se determinan por BasePart.Transparency y BasePart.Reflectance.

local part = script.Parent

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

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

local function onToggle()
	-- Toggle the anchored property
	part.Anchored = not part.Anchored
	
	-- Update visual state of the brick
	updateVisuals()
end

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

La propiedad CFrame determina tanto la posición como la orientación del BasePart en el mundo. Actúa como una ubicación de referencia arbitraria en la geometría, pero ExtentsCFrame representa el actual 1> Datatype.CFrame1> de su centro físico.

Al configurar CFrame en una parte, otras partes unidas también se mueven relativamente a la parte, pero se recomienda que uses PVInstance:PivotTo() para mover un aplicación de modeladoentero, como cuando se teletransporta un jugador.

A diferencia de la configuración de BasePart.Position, la configuración de BasePart.CFrame siempre moverá la parte al espacio de tiempo especificado CFrame ; en otras palabras: 1> no hay verificación de intersección1> y el solucionador de física intentará resolver cualquier intersección

Para seguir la posición relativa de una parte con respecto a su CFrame, un Attachment puede 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)

CanCollide determina si una parte interactúa físicamente con otras partes. Cuando está deshabilitado, otras partes pueden pasar a través del bloque sin problemas. Las partes utilizadas para 装oración generalmente tienen CanCollide deshabilitado, ya que no se necesitan considerar por el motor de física.

Si una parte no es BasePart.Anchored y tiene deshabilitado CanCollide, puede salir del mundo para ser finalmente destruida por Workspace.FallenPartsDestroyHeight .

Cuando CanCollide está deshabilitado, las piezas aún pueden activar el evento BasePart.Touched (como también las otras partes que las tocan). Puedes desactivar esto con BasePart.CanTouch .

Para obtener más información sobre las colisiones, see Colisiones .

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

local OPEN_TIME = 1

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

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

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

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

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

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

part.Touched:Connect(onTouch)
close()

CanQuery determina si la parte se considera durante las operaciones de consulta espacial, como GetPartBoundsInBox o Raycast . CanCollide también debe desactivarse cuando desactivas CanQuery. Estas funciones nunca incluirán partes cuyo CanRender y 1> CanCollide

Además propiedadesto, también es posible excluir partes que son descendientes de una lista de partes dada usando un objeto OverlapParams o RaycastParams cuando se llaman las funciones de consulta espacial.

Esta propiedad determina si Touched

Nota que esta lógica de colisión se puede configurar para respetar grupos de colisión a través de la propiedad Class.Workspace.TouchesUseCollisionGroups ". Si true , las partes en grupos no colisionarán ignorarán ambas colisiones 1> y 1> eventos de toque, haciendo así que esta propiedad sea irrelevante.

Rendimiento

Hay un pequeño aumento de rendimiento en las partes que tienen ambas CanTouch y CanCollide configuradas a false, ya que estas partes nunca tendrán que calcular ningún tipo de colisión de part

Determina si una parte proyecta una sombra o no.

Nota que esta característica no está diseñada para el rendimiento. Solo debe desactivarse en las partes en las que desea ocultar las sombras que proyecta la parte. Desactivar esta propiedad para una parte específica puede causar artefactos visuales en las sombras proyectadas en esa parte.

La propiedad CenterOfMass describe la posición local de la parte. Si esta es una simple montaje de partes, esta es la AssemblyCenterOfMass convertida del espacio del mundo a local. En un simple Parts, el centro de masa siempre es (0,0,0). Puede variar para 1> Class

La propiedad CollisionGroup describe el nombre del grupo de colisión de la parte (máximo de 100 caracteres). Las partes comienzan en el grupo por defecto cuyo nombre es "Default" . Este valor no se puede vaciar.

Aunque esta propiedad en sí misma no es replicable, el motor replica internamente el valor a través de otra propiedad privada para solucionar problemas de compatibilidad con versiones 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

La propiedad Color determina el color de una parte. Si la parte tiene un Class.BasePart.Material , esto también determina el color utilizado al rendizar la textura del material. Si esta propiedad está establecer, BasePart.Material usará el color más cercano a Color3.

Otras propiedades visuales de una parte se determinan por BasePart.Transparency y 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)

Propiedades físicas actuales indica las propiedades físicas actuales de la parte. Puede establecer valores personalizados para las propiedades físicas por parte, personalizado material y invalidar/reemplazarde material. El Motor prioriza más definiciones granulares al determinar las propiedades físicas efectivas de una parte. Los valores en la siguiente lista están en orden de la mayor a la menor prioridad:

• Propiedades físicas personalizadas de la parte
• Propiedades físicas personalizadas del material personalizado de la parte
• Propiedades físicas personalizadas de la interfaz de material de la parte
• Propiedades físicas predeterminadas del material de la parte

CustomPhysicalProperties te permite personalizar varios aspectos físicos de un Part, como su densidad, fricción y elasticidad.

Si se habilita, esta propiedad te permite configurar estas propiedades físicas. Si se deshabilita, estas propiedades físicas se determinan por el BasePart.Material de la parte. La página para Enum.Material contiene la lista de los diferentes materiales de la parte.

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

Cuando es cierto, y cuando Workspace.FluidForces está habilitado, causa que el motor de física calcular las fuerzas aerodinámicas en este BasePart .

El CFrame de los elementos físicos de la BasePart, representando su centro físico.

El tamaño físico real de la BasePart en cuanto a la física del motor de ejemplo en detecta colisiones .

La propiedad FrontSurface determina el tipo de superficie utilizada para la dirección -Z de una parte. Cuando se colocan las caras de dos partes uno al lado del otro, pueden crear una articulación entre ellas. Si se establece en Motor, el BasePart.FrontSurfaceInput determina cómo debe comportarse una articulación del motor.

La mayoría de los tipos de superficie renderizan una textura en la cara de la parte si el BasePart.Material está configurado como Plástico. Algunos tipos de superficie, incluido Hinge, Motor y SteppingMotor, renderizan un adorno 3D en su lugar. Si esta propiedad se selecciona en la ventana Propiedades, se resaltará en el mundo del juego similar al de un SurfaceSelection .

local demoPart = script.Parent

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

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

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

La propiedad LeftSurface determina el tipo de superficie utilizada para la dirección -X de una parte. Cuando se colocan las caras de dos partes uno al lado del otro, pueden crear una articulación entre ellas. Si se establece en Motor, el BasePart.LeftSurfaceInput determina cómo debe comportarse una articulación del motor.

La mayoría de los tipos de superficie renderizan una textura en la cara de la parte si el BasePart.Material está configurado como Plástico. Algunos tipos de superficie, incluido Hinge, Motor y SteppingMotor, renderizan un adorno 3D en su lugar. Si esta propiedad se selecciona en la ventana Propiedades, se resaltará en el mundo del juego similar al de un SurfaceSelection .

local demoPart = script.Parent

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

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

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

La propiedad LocalTransparencyModifier es un multiplicador de BasePart.Transparency que solo es visible para el cliente local. No se replica desde el cliente al servidor y es útil para cuando una parte no debería renderizar para un cliente específico, como cómo el jugador no ve las partes del cuerpo de su personaje cuando se enfoque en el modo de primera persona.

Esta propiedad modifica la transparencia de la parte local a través de la siguiente fórmula, con valores resultantes ajustados entre 0 y 1.

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

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

  <tr>
    <td>0.5</td>
    <td>0.25</td>
    <td>0.5</td>
    <td>0.625</td>
  </tr>

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

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

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

La propiedad Bloqueado determina si un part (o un model dentro) puede ser seleccionado en Roblox Studio haciendo clic en él. Esta propiedad se habilita con más frecuencia en las partes dentro de los modelos de entorno que no están siendo editadas en este momento. Roblox Studio tiene una herramienta Bloquear/Desbloquear Todo que puede alternar el estado Bloque

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

Masa es una propiedad de propiedad de lectura que describe el producto de un volumen y densidad de una parte. Se devuelve por la función GetMass .

• El volumen de una parte se determina por su Size y su Shape, que varía dependiendo del tipo de BasePart utilizado, como WedgePart .
• La densidad de una parte se determina por su Material o CustomPhysicalProperties, si se especifica.

Si esta propiedad está habilitada, la BasePart no contribuirá a la masa o inercia total de su montaje si se solda a otra parte que tenga masa.

Si la parte es su propia raíz según AssemblyRootPart , esto se ignorará para esa parte, y aún contribuirá masa y inertia a su montaje como una parte normal. Las partes que no son masivas nunca deben convertirse en una raíz de montaje a menos que todas las otras partes en la montura también sean masivas.

Esto podría ser útil para cosas como accesorios opcionales en los vehículos que no quieres afectar el rendimiento del coche o un malla de renderizado masiva soldada a una malla de renderizado más simple.

También se vea Ensamblajes, un artículo que documenta qué son las partes de raíz y cómo usarlas.

La propiedad Material permite a un constructor establecer la textura y propiedades físicas predeterminadas de una parte (en el caso de que BasePart.CustomPhysicalProperties no esté). El material plástico por defecto tiene una textura muy clara, y el material liso no tiene textura en todos/todas. Algunas texturas de materiales, como DiamondPlate y Granite, tienen texturas muy visibles. La textura de cada material se refleja diferente, especialmente Foil.

Establecer esta propiedad y luego habilitar BasePart.CustomPhysicalProperties usará las propiedades físicas predeterminadas de un material. Por instancia, DiamondPlate es un material muy denso mientras que Wood es muy ligero. La densidad de una parte determina si flotará en el agua del terreno.

El material de Vidrio cambia el comportamiento de rendimiento en configuraciones gráficas moderadas. Aplica un poco de reflejividad (similar a BasePart.Reflectance ) y distorsión de perspectiva. El efecto es especialmente pronunciado en partes de forma esférica (set BasePart.Shape a Ball). Los objetos semitransparentes y las partes de Vidrio detrás de Glass no son visibles.

local part = script.Parent

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

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

local function onToggle()
	-- Toggle the anchored property
	part.Anchored = not part.Anchored
	
	-- Update visual state of the brick
	updateVisuals()
end

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

El sistema busca la instancia MaterialVariant con el nombre de MaterialInstance especificado y el introducirBasePart.Material . Si encuentra con éxito una instancia de MaterialIENT que coincida, usa esta instancia de MaterialINT para reemplazar el material predeterminado. El material predeterminado puede ser el material incrustado o un tipo de material especificado en MaterialService .

La propiedad de orientación describe la rotación en grados alrededor de los ejes X, Y y Z usando un Vector3. Las rotaciones se aplican en Y → X → Z orden. Esto difiere de las propiet

Cuando se establece esta propiedad cualquier Welds o Motor6Ds conectado a esta parte tendrá la propiedad correspondiente C0 o 1> Class.JointInstance.C1|C11> actualizada y permitirá

WeldConstraints también se desactivará temporalmente y se reactivará durante el herramienta de movimiento.

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

Esta propiedad especifica el desplazamiento del eje de la parte desde su CFrame, que es part:GetPivot() es el mismo que part.CFrame * part.PivotOffset .

Esto es conveniente para establecer el pivote en una ubicación en el espacio local, pero establecer el pivote de una parte en un lugar en el espacio del mundo se puede hacer como sigue:

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

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

resetPivot(script.Parent)

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

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

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

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

-- Run clock
while true do
	local components = os.date("*t")
	positionHand(hourHand, (components.hour + components.min / 60) / 12)
	positionHand(minuteHand, (components.min + components.sec / 60) / 60)
	positionHand(secondHand, components.sec / 60)
	task.wait()
end

La propiedad de la posición describe las coordenadas de un part usando un Vector3. Se refiere a la posición de la parte's BasePart.CFrame, sin embargo, también se puede establecer.

Cuando se establece esta propiedad cualquier Welds o Motor6Ds conectado a esta parte tendrá la propiedad correspondiente C0 o 1> Class.JointInstance.C1|C11> actualizada y permitirá

WeldConstraints también se desactivará temporalmente y se reactivará durante el herramienta de movimiento.

Esto devuelve el tiempo en segundos desde que la física de la parte fue actualizada por última vez en el cliente local (o el servidor). Devuelve 0 cuando la parte no tiene física (Anclada)

La propiedad de reflectancia determina la cantidad de un part que refleja la caja de cielo. Un valor de 0 indica que la parte no es reflejante en todos/todas, y un valor de 1 indica que la parte debe reflejar completamente.

La reflectancia no se ve afectada por BasePart.Transparency , a menos que la parte sea completamente transparente, en cuyo caso la reflectancia no se renderizará en todos/todas. La reflectancia puede o noarse ignorar dependiendo del BasePart.Material de la parte.

local part = script.Parent

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

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

part.Touched:Connect(blink)

La propiedad ResizeIncrement es una propiedad de lectura que describe el menor cambio de tamaño permitido por el método BasePart:Resize() . Se diferencia entre implementaciones de la clase abstracta BasePart . Por instancia, Class.Part tiene este conjunto a 1 y 2> Class.TrussPart tiene este

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

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

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

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

La propiedad ResizeableFaces (con un e , no ResizeableFaces) describe el uso de un objeto Faces para mostrar las diferentes caras en las que se puede escalar una parte. Para la mayoría de las implementaciones

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

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

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

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

La propiedad RightSurface determina el tipo de superficie utilizada para la dirección +X de una parte. Cuando se colocan las caras de dos partes al lado de cada otra, pueden crear una interfaz entre ellas. Si se establece en Motor, la BasePart.RightSurfaceInput determina cómo debe comportarse una interfaz entre ellos.

La mayoría de los tipos de superficie renderizan una textura en la cara de la parte si el BasePart.Material está configurado como Plástico. Algunos tipos de superficie, incluido Hinge, Motor y SteppingMotor, renderizarán un adorno 3D en su lugar. Si esta propiedad se selecciona en la ventana Propiedades, se resaltará en el mundo del juego similar al de un SurfaceSelection .

local demoPart = script.Parent

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

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

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

Esta propiedad es un número entero entre -127 y 127 que toma la prioridad sobre todas las demás reglas para la ordenarde la parte de raíz. Cuando se considera una parte que no es Anchored y que comparte el mismo valor de Massless, una parte con una mayor prioridad tomará la prioridad sobre aqu

Puede usar esta propiedad para controlar qué parte de una instalación es la raíz y mantener la raíz estable si cambia el tamaño.

También se vea Ensamblajes, un artículo que documenta qué son las partes de raíz y cómo usarlas.

La rotación de la parte en grados para los tres ejes.

Cuando se establece esta propiedad cualquier Welds o Motor6Ds conectado a esta parte tendrá la propiedad correspondiente C0 o 1> Class.JointInstance.C1|C11> actualizada y permitirá

WeldConstraints también se desactivará temporalmente y se reactivará durante el herramienta de movimiento.

La propiedad Size de una parte determina sus dimensiones visuales, mientras que Class.BasePart.ExtentsSize|ExtentsSize representa el tamaño real utilizado por el motor de física, como en detección de col

El tamaño de la parte determina su masa que se da por BasePart:GetMass() . Un parte's Size es usado por una variedad de otros objetos:

• ParticleEmitter para determinar el área desde la que se generan las partículas.
• BlockMesh para determinar parcialmente el prisma rectangular renderizado.
• SpecialMesh para ciertos MeshTypes , para determinar el tamaño de la malla renderizada.
• SurfaceLight para determinar el espacio para iluminar.

local TOWER_BASE_SIZE = 30

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

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

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

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

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

La propiedad TopSurface determina el tipo de superficie utilizada para la dirección +Y de una parte. Cuando se colocan las caras de dos partes uno al lado del otro, pueden crear una interfaz entre ellas. Si se establece en Motor, la BasePart.TopSurfaceInput determina cómo debe comportarse una interfaz entre ellos.

La mayoría de los tipos de superficie renderizan una textura en la cara de la parte si el BasePart.Material está configurado como Plástico. Algunos tipos de superficie -Hinge, Motor y SteppingMotor- renderizarán un adorno 3D en su lugar. Si esta propiedad se selecciona en la ventana Propiedades, se resaltará en el mundo del juego similar al de un SurfaceSelection .

local demoPart = script.Parent

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

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

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

La propiedad de Transparencia controla la visibilidad de una parte en una escala de 0 a 1, donde 0 es completamente visible (opaco), y un valor de 1 es completamente invisible (no renderizado en todos/todas).

BasePart.Reflectance puede reducir la transparencia total de un bloque si se establece en un valor cercano a 1.

Aunque no se renderizan partes completamente transparentes en todos/todas, los objetos parcialmente transparentes tienen algunos costos de renderizado importantes. Tener muchas partes de translúcido puede ralentizar el ejecucióndel juego.

Cuando las partes transparentes se superponen, el orden de renderizado puede actuar impredeciblemente - trate de mantener las partes semi- transparentes de superponerse para evitar esto.

El BasePart.LocalTransparencyModifier es un multiplicador de Transparencia que solo es visible para el 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

Devuelve

Aplica un impulso de fuerzaangular instantáneo a esta parte de la montaje, lo que provoca que la montaje gire.

La velocidad de ángulo resultante de la impulsión se basa en la mass del montaje. Por lo tanto, un mayor impulso es requerido para mover montajes más grandes. Los impulsos son útiles para casos en los que desea aplicar una fuerza de manera instantánea, como una explosión o colisión.

Si la parte es propiedad del servidor, esta función debe ser llamada desde un servidor Class.Script (no desde un servidor Class.LocalScript o un script

Parámetros

Devuelve

Esta función aplica un impulso de fuerza instantánea a la montaje de esta parte.

La fuerza se aplica en el centro de la montagem, center of mass, por lo que el movimiento resultante solo será lineal.

La velocidad resultante de la impulsión se basa en la mass del montaje. Por lo tanto, un impulso más grande es requerido para mover montajes más grandes. Los impulsos son útiles para casos en los que se aplica una fuerza instantáneamente, como una explosión o una colisión.

Si la parte es propiedad del servidor, esta función debe ser llamada desde un servidor Class.Script (no desde un servidor Class.LocalScript o un script

Parámetros

Devuelve

Esta función aplica un impulso de fuerza instantánea a la instalación de esta parte, en la posición especificada en el espacio del mundo.

Si la posición no está en el centro de masa del montaje, el impulso causará un movimiento de masa posicional y de rotación.

La velocidad resultante de la impulsión se basa en la mass de la instalación. Por lo tanto, un impulso más masivo se requiere para mover aún más montajes. Los impulsos son útiles para los casos en los que los desarrolladores quieren aplicar una fuerza instantáneamente, como una explosión o una colisión.

Si la parte es propiedad del servidor, esta función debe ser llamada desde un servidor Class.Script (no desde un servidor Class.LocalScript o un script

Parámetros

Devuelve

Devuelve si las partes pueden chocar entre sí o no. Esta función tiene en cuenta los grupos de colisión de las dos partes. Esta función fallará si la parte especificada no es una BasePart.

Parámetros

Devuelve

La función CanSetNetworkOwnership comprueba si puede establecer la propiedad de la red de una parte.

El valor de la función de regreso verifica si o no puedes llamar BasePart:SetNetworkOwner() o BasePart:SetNetworkOwnershipAuto() sin encontrar un error.返回 true si puedes modificar/leer la propiedad de la red, o返回 false y la razón por la que no puedes, como una cadena.

Devuelve

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

Devuelve

Devuelve una tabla de partes conectadas al objeto por cualquier tipo de articulación rígida.

Si recursive es cierto, esta función devolverá todas las partes en la instalación conectadas firmemente a la BasePart.

Uniones Rígidas

Cuando una conexión juntar dos partes juntas (Part0 → Part1) , una conexión es rígida si la física de Part1 está completamente bloqueada por 1> Part01> . Esto solo se aplica a los siguientes tipos de conexión:

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

Parámetros

Devuelve

Devuelva todos los Joints o Constraints que estén conectados a esta parte.

Devuelve

GetMass 返回 read-only Mass propiedad

Esta función es predecesora de la propiedad Masa. Se sigue admitiendo para la compatibilidad con versiones anteriores; deberías usar la propiedad Masa directamente.

Devuelve

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)

Devuelve al jugador actual que es el propietario de la red de esta parte, o nulo en caso del servidor.

Devuelve

Regresa true si el motor del juego decide automáticamente el propietario de la red para esta parte.

Devuelve

Devuelve

Devuelve la parte base de una montura. Cuando se mueve una montura de partes usando un CFrame . es importante mover esta parte de la base (esto moverá todas las demás partes conectadas a él). más información en el artículo Montajes.

Esta función es predecesora de la propiedad AssemblyRootPart. Se mantiene soportado para la compatibilidad con versiones anteriores, pero deberías usar AssemblyRootPart directamente.

Devuelve

Restaura una tabla de todas las partes que están físicamente interactuando con esta parte. Si la parte en sí misma tiene el valor de CanCollide establecido como falso, entonces esta función devuelve una tabla

Devuelve

Devuelve la velocidad lineal del montaje de la parte en la posición especificada. Se puede usar para identificar la velocidad lineal de las partes en un montaje diferente a la parte de raíz. Si el montaje no tiene velocidad angular, entonces la velocidad lineal siempre será la misma para cada posición.

Parámetros