BasePart

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

Una parte anclada aún puede moverse cambiando su CFrame o Position , y aún puede tener un no cero AssemblyLinearVelocity y AssemblyAngularVelocity .

Por último, si una parte sin anclar se une a una parte anclada a través de un objeto como un Weld, también actuará anclada.Si se rompe tal junta, la parte puede ser afectada por la física nuevamente.Vea ensamblajes para más detalles.

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

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 angular de la montura de esta parte. Es la velocidad de cambio de orientación en radios por segundo.

La velocidad ángular es la misma en cada punto de la montura.

Establecer la velocidad directamente puede conducir a un movimiento poco realista.Se prefiere usar Torque o AngularVelocity la restricción, o usar ApplyAngularImpulse() si desea cambios instantáneos en la velocidad.

Si la parte es propiedad del servidor, esta propiedad debe cambiarse desde un servidor Script (no desde un LocalScript o un Script con RunContext configurado para Enum.RunContext.Client).Si la parte es propiedad de un cliente a través de propiedad automática , esta propiedad se puede cambiar desde un script de cliente o un script del servidor; cambiarlo desde un script de cliente para una parte propiedad del servidor no tendrá efecto.

Una posición calculada a través de la Mass y Position de todas las piezas en la asamblea.

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

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

El vector de velocidad lineal de la montura de esta parte. Es la velocidad de cambio en la posición de AssemblyCenterOfMass en studs por segundo.

Si quieres conocer la velocidad en un punto diferente al centro de masa de la montura, usa GetVelocityAtPosition().

Establecer la velocidad directamente puede conducir a un movimiento poco realista.Se prefiere usar una restricción VectorForce o usar ApplyImpulse() si desea cambios instantáneos en la velocidad.

Si la parte es propiedad del servidor, esta propiedad debe cambiarse desde un servidor Script (no desde un LocalScript o un Script con RunContext configurado para Enum.RunContext.Client).Si la parte es propiedad de un cliente a través de propiedad automática , esta propiedad se puede cambiar desde un script de cliente o un script del servidor; cambiarlo desde un script de cliente para una parte propiedad del servidor no tendrá efecto.

La suma de la masa de todos los BaseParts en la montaje de esta parte.Las piezas que son Massless y no son la parte raíz de la montura no contribuirán al AssemblyMass.

Si la ensambladora tiene una parte anclada, se considera que la masa de la ensambladora es infinita.Las restricciones y otras interacciones físicas entre ensamblajes sin anclar con una gran diferencia de masa pueden causar inestabilidades.

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

La parte raíz se puede cambiar cambiando el RootPriority de las partes en la asamblea.

Las piezas que todas comparten el mismo AssemblyRootPart están en la misma ensambladora.

Para obtener más información sobre partes raíz, vea Ensamblajes.

AudioCanCollide determina si la parte interactuará físicamente con la simulación de audio, similar a CastShadow para iluminación.

Cuando está desactivado, el audio pasa a través de la parte; no está oculto o reflejado.

La propiedad BackSurface determina el tipo de superficie utilizada para la dirección positiva Z de una parte.Cuando las caras de dos partes se colocan una al lado de la otra, pueden crear una junta entre ellas.

La propiedad BottomSurface determina el tipo de superficie utilizada para la dirección negativa Y de una parte.Cuando las caras de dos partes se colocan una al lado de la otra, pueden crear una junta entre ellas.

Esta propiedad determina el color de una parte.Si la parte tiene un Material, esto también determina el color utilizado al renderizar la textura del material.Para obtener más control sobre el color, se puede usar la propiedad Color y esta propiedad usará la más cercana BrickColor.

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

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 real CFrame de su centro físico.

Al establecer CFrame en una parte, otras piezas unidas también se mueven en relación con la parte, pero se recomienda que uses PVInstance:PivotTo() para mover un aplicación de modeladocompleto, como cuando se teletransporta el personaje de un jugador.

A diferencia de la configuración BasePart.Position , la configuración CFrame siempre moverá la parte al exacto dado CFrame ; en otras palabras: no se realiza ninguna verificación de superposición y el solucionador de física intentará resolver cualquier superposición a menos que ambas partes sean Anchored .

Para mantener un registro de posiciones relativas a una parte 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 interactuará físicamente con otras partes.Cuando está desactivado, otras partes pueden pasar por la parte sin interrupción.Las piezas utilizadas para decoración por lo general tienen CanCollide deshabilitadas, ya que no deben ser consideradas por el motor de física.

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

Cuando CanCollide está deshabilitado, las piezas aún pueden disparar el evento Touched (así como las otras piezas que las tocan).Puedes desactivar esto con CanTouch .

Para obtener más información sobre las colisiones, consulte 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()

Esta propiedad determina si la parte se considera durante las operaciones de consulta espacial, como GetPartBoundsInBox o Raycast.Tenga en cuenta que CanCollide debe desactivarse para que CanQuery tenga efecto, y las funciones de consulta espacial nunca incluirán partes con CanQuery de false.

Aparte de esta propiedad, también es posible excluir partes que sean descendientes de una lista dada de partes usando un objeto OverlapParams o RaycastParams cuando se llaman las funciones de consulta espacial.

Esta propiedad determina si Touched y TouchEnded eventos de fuego en la parte.Si , otras partes sensibles también deben tener establecido para que los eventos de toque se desencadenar.Si false , los eventos de toque no se pueden configurar para la parte y tratar de hacerlo lanzará un error.Del mismo modo, si la propiedad se establece en false después de que se conecte un evento de toque, el evento se desconectará y se eliminará TouchTransmitter .

Tenga en cuenta que esta lógica de colisión se puede configurar para respetar grupos de colisión a través de la propiedad Workspace.TouchesUseCollisionGroups.Si true , las partes de grupos no colisionantes ignorarán ambos eventos de colisión y , haciendo que esta propiedad sea irrelevante.

Rendimiento

Hay un pequeño aumento de rendimiento en las partes que tienen tanto CanTouch como CanCollide establecidas a false , ya que estas partes nunca necesitarán calcular ningún tipo de colisión de parte a parte.Sin embargo, aún pueden ser golpeados por Raycasts y OverlapParams consultas.

Determina si una parte lanza una sombra o no.Desactivar esta propiedad para una parte dada puede causar artefactos visuales en las sombras que se proyectan sobre esa parte.

Esta propiedad no está diseñada para mejorar el rendimiento, pero en escenas complejas, desactivarla estratégicamente en ciertas partes puede mejorar el ejecución.Debido a la posibilidad de artefactos visuales, recomendamos dejarlo habilitado en todas las partes en la mayoría de situaciones.

La propiedad CenterOfMass describe la posición local del centro de masa de una parte.Si se trata de una sola asamblea de piezas, esta es la AssemblyCenterOfMass convertida del espacio mundial al local.En simple Parts , el centro de masa siempre es (0, 0, 0) , pero puede variar para WedgePart o MeshPart .

La propiedad CollisionGroup describe el nombre del grupo de colisión de la parte (máximo de 100 caracteres).Las piezas comienzan en el grupo predeterminado cuyo nombre es "Default" .Este valor no puede estar vacío.

Aunque esta propiedad en sí no se replica, el motor replica internamente el valor a través de otra propiedad privada para resolver 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 Material, esto también determina el color utilizado al renderizar la textura del material.

Si esta propiedad está establecer, BrickColor usará la coincidencia más cercana con este valor Color.

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

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

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

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

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

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

update()
human.HealthChanged:Connect(update)

CurrentPhysicalProperties indica las propiedades físicas actuales de la pieza.Puedes establecer valores personalizados para las propiedades físicas por parte, material personalizado , y invalidar/reemplazarde material.El motor de Roblox prioriza definiciones más granulares al determinar las propiedades físicas efectivas de una parte.Los valores de 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 anulación de material del material de la parte
• Propiedades físicas predeterminadas del material de la pieza

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

Si está habilitada, esta propiedad te permite configurar estas propiedades físicas.Si está deshabilitado, estas propiedades físicas se determinan por el Material 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 true , y cuando Workspace.FluidForces está habilitado, provoca que el motor de físicas compute fuerzas aerodinámicas en este BasePart .

El CFrame de los extremos físicos de la BasePart, que representa su centro físico.

El tamaño físico real del BasePart como lo considera el motor de física, por ejemplo en detección de colisiones .

La propiedad FrontSurface determina el tipo de superficie utilizada para la dirección negativa Z de una parte.Cuando las caras de dos partes se colocan una al lado de la otra, pueden crear una junta entre ellas.

La propiedad LeftSurface determina el tipo de superficie utilizada para la dirección negativa X de una parte.Cuando las caras de dos partes se colocan una al lado de la otra, pueden crear una junta entre ellas.

La propiedad LocalTransparencyModifier es un multiplicador para 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 debe renderizarse para un cliente específico, como cómo el jugador no ve las partes del cuerpo de su personaje cuando se acerca al modo de primera persona.

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

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

<th><code>Modificador de transparencia local</code></th>

    <th>Lado del servidor</th>

    <th>Lado del 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>

La propiedad Locked determina si una parte (o una Model está contenida dentro) puede ser seleccionada en Studio haciendo clic en ella.Esta propiedad se habilita con más frecuencia en partes dentro de modelos de entorno que no están siendo editadas en este 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 es una propiedad de solo lectura que describe el producto del volumen y la 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 parte no contribuirá a la masa total o inercia de su montaje mientras esté soldada a otra parte que tenga masa.

Si la parte es su propia parte raíz de acuerdo con AssemblyRootPart, se ignorará para esa parte y aún contribuirá con masa e inercia a su montaje como una parte normal.Las piezas que no tienen masa nunca deben convertirse en una parte raíz de montaje a menos que todas las otras piezas en la montura también sean sin masa.

Esto podría ser útil para cosas como accesorios opcionales en vehículos que no quieres afectar el manejo del automóvil o una malla de renderizado masiva soldada a una malla de colisión más simple.

Vea también Ensamblajes, un artículo que documenta qué son las partes raíz y cómo usarlas.

La propiedad Material permite establecer la textura y las propiedades físicas predeterminadas de una parte (en el caso de que CustomPhysicalProperties no esté desactivado).El material predeterminado Plastic tiene una textura muy ligera, mientras que el material SmoothPlastic no tiene textura en todos/todas.Algunas texturas de material como DiamondPlate y Granite tienen texturas muy visibles.La textura de cada material refleja la luz del sol de manera diferente, especialmente Foil .

Establecer esta propiedad y luego habilitar 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 pieza determina si flotará en el agua del terreno.

Los cambios de material Glass modifican el comportamiento de renderizado de gráficos moderados al aplicar un poco de reflejo (similar a Reflectance ) y distorsión de perspectiva.El efecto es especialmente pronunciado en piezas de forma esférica.Las piezas semi transparentes detrás de Glass piezas no son visibles.

El sistema busca la instancia con el nombre y el introducirespecificados.Si encuentra con éxito una instancia coincidente MaterialVariant, usa esa instancia para reemplazar el material predeterminado.El material predeterminado puede ser el material integrado o una anulación MaterialVariant especificada en MaterialService.

La propiedad Orientation describe la rotación de la parte en grados alrededor de los ejes X , Y y Z usando un Vector3.Las rotaciones se aplican en Y ⟩ X ⟩ Z orden.Esto se diferencia de los ángulos Euler correctos y en cambio son ángulos Tait-Bryan que describen yaw , pitch y roll .

También vale la pena notar cómo esta propiedad se diferencia del constructor CFrame.Angles() que aplica rotaciones en un orden diferente ( Z ⟩ Y ⟩ X ).Para un mejor control sobre la rotación de una parte, se recomienda que CFrame se establezca en su lugar.

Al establecer esta propiedad, cualquier Welds o Motor6Ds conectado a esta parte tendrá la propiedad coincidente C0 o C1 actualizada para permitir que la parte se mueva en relación con cualquier otra parte a la que esté unida.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 pieza desde su CFrame, que es BasePart:GetPivot() es igual a BasePart.CFrame multiplicado por BasePart.PivotOffset .

Esto es conveniente para establecer el eje en una ubicación en espacio local , pero establecer el eje de una pieza en una ubicación en espacio mundial se puede hacer de la siguiente manera:

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

-- 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 Position describe las coordenadas de una parte usando un Vector3.Refleja la posición de la parte de CFrame , sin embargo también se puede establecer.

Al establecer esta propiedad, cualquier Welds o Motor6Ds conectado a esta parte tendrá la propiedad coincidente C0 o C1 actualizada para permitir que la parte se mueva en relación con cualquier otra parte a la que esté unida.WeldConstraints también se desactivará temporalmente y se reactivará durante el herramienta de movimiento.

Indica el tiempo en segundos desde que la física de la parte se actualizó por última vez en el cliente local o en el servidor.Este valor será 0 cuando la parte no tenga física (Anchored es true).

La propiedad Reflectance determina cuánto refleja una parte el cielo.Un valor de 0 indica que la parte no es reflexiva en todos/todas, y un valor de 1 indica que la parte debe reflejar completamente.

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

La propiedad ResizeIncrement es una propiedad de solo lectura que describe el cambio más pequeño en el tamaño permitido por el método Resize().Difiere entre las implementaciones de la clase abstracta BasePart ; por instancia, Part tiene este conjunto a 1 mientras que TrussPart tiene este conjunto a 2 ya que las secciones de truss individuales son de 2×2×2 en tamaño.

La propiedad ResizeableFaces usa un objeto Faces para describir las diferentes caras en las que una parte puede ser redimensionada.Para la mayoría de las implementaciones de BasePart, como Part y WedgePart, esta propiedad incluye todos los rostros.Sin embargo, configurará su conjunto a solo dos caras ya que ese tipo de piezas deben tener dos dimensiones de longitud .

Esta propiedad se usa más comúnmente con herramientas para construir y manipular piezas y tiene poco uso fuera de ese contexto.La clase puede usarse en conjunción con esta propiedad para mostrar solo los asideros en las caras que se pueden redimensionar en una pieza.

-- 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 positiva X de una parte.Cuando las caras de dos partes se colocan una al lado de la otra, pueden crear una junta entre ellas.

Esta propiedad es un entero entre -127 y 127 que tiene precedencia sobre todas las otras reglas para el ordenarde la parte raíz.Al considerar múltiples partes que no son Anchored y que comparten el mismo valor Massless , una parte con un valor más alto RootPriority tomará prioridad sobre aquellas con un valor más bajo RootPriority.

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

Vea también Ensamblajes, un artículo que documenta qué son las partes raíz y cómo usarlas.

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

Al establecer esta propiedad, cualquier Welds o Motor6Ds conectado a esta parte tendrá la propiedad coincidente C0 o C1 actualizada para permitir que la parte se mueva en relación con cualquier otra parte a la que esté unida.WeldConstraints también se desactivará temporalmente y se reactivará durante el herramienta de movimiento.

La propiedad de una parte determina sus dimensiones visuales , mientras que representa el tamaño real utilizado por el motor de físicas, como en detección de colisión .Las dimensiones individuales (longitud, ancho, altura) pueden ser tan bajas como 0.001 y tan altas como 2048.Las dimensiones de tamaño por debajo de serán representadas visualmente como si las dimensiones de la pieza fueran .

La parte Size se usa de una variedad de maneras adicionales:

• Para influir en su masa como se indica por GetMass() .
• Por ParticleEmitter para determinar el área desde la cual se generan las partículas.
• Por BlockMesh para determinar parcialmente el prisma rectangular renderizado.
• Por SpecialMesh para cierto MeshTypes para determinar el tamaño de la malla renderizada.
• Por 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 positiva Y de una parte.Cuando las caras de dos partes se colocan una al lado de la otra, pueden crear una junta entre ellas.

La propiedad Transparency controla la visibilidad de una parte en una escala de 0 a 1 donde 0 es completamente visible (opaca) y 1 es completamente invisible (no se renderiza en todos/todas).

Aunque las piezas completamente transparentes no se renderizan en todos/todas, los objetos parcialmente transparentes tienen algunos costos de renderizado significativos.Tener muchas partes translúcidas puede afectar el ejecución.

Cuando las piezas transparentes se superponen, el orden de renderizado puede actuar de forma impredecible, por lo que deberías evitar que las piezas semitransparentes se superpongan.

Vea también LocalTransparencyModifier como multiplicador de Transparency 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()

Parámetros

Devuelve

Aplica un impulso de fuerza ángular instantáneo a la montura de esta parte, lo que hace que la montura gire.

La velocidad ángular resultante del impulso depende de la mass de la montura.Así que se requiere un impulso más alto para mover ensambles más masivos.Los impulsos son útiles para casos en los que se desea aplicar una fuerza de forma instantánea, como una explosión o colisión.

Si la parte es propiedad del servidor, esta función debe llamarse desde un servidor Script (no desde un LocalScript o un Script con RunContext configurado para Enum.RunContext.Client ).Si la parte es propiedad de un cliente a través de propiedad automática , esta función se puede llamar desde un script de cliente o un script del servidor; llamarla desde un script de cliente para una parte propiedad del servidor no tendrá efecto.

Parámetros

Devuelve

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

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

La velocidad resultante del impulso depende de la mass de la montura.Así que se requiere un impulso más alto para mover ensambles más masivos.Los impulsos son útiles para casos en los que se desea aplicar una fuerza de forma instantánea, como una explosión o colisión.

Si la parte es propiedad del servidor, esta función debe llamarse desde un servidor Script (no desde un LocalScript o un Script con RunContext configurado para Enum.RunContext.Client ).Si la parte es propiedad de un cliente a través de propiedad automática , esta función se puede llamar desde un script de cliente o un script del servidor; llamarla desde un script de cliente para una parte propiedad del servidor no tendrá efecto.

Parámetros

Devuelve

Esta función aplica un impulso de fuerza instantáneo a la montura de esta parte, en la posición especificada en el espacio mundial.

Si la posición no está en la center of mass del montaje, el impulso causará un movimiento posicional y rotatorio.

La velocidad resultante del impulso depende de la mass de la montura.Así que se requiere un impulso más alto para mover ensambles más masivos.Los impulsos son útiles para casos en los que los desarrolladores quieren una fuerza aplicada instantáneamente, como una explosión o colisión.

Si la parte es propiedad del servidor, esta función debe llamarse desde un servidor Script (no desde un LocalScript o un Script con RunContext configurado para Enum.RunContext.Client ).Si la parte es propiedad de un cliente a través de propiedad automática , esta función se puede llamar desde un script de cliente o un script del servidor; llamarla desde un script de cliente para una parte propiedad del servidor no tendrá efecto.

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 puedes establecer la propiedad de red de una parte.

El valor de devolución de la función verifica si puedes llamar BasePart:SetNetworkOwner() o BasePart:SetNetworkOwnershipAuto() sin encontrar un error.Devuelve verdadero si puedes modificar/leer la propiedad de la red o devuelve falso 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ónrígida.

Si recursive es verdadera, esta función devolverá todas las partes en la ensambladora conectadas rípidamente a la BasePart.

Juntas rígidas

Cuando una junta conecta dos partes juntas (Part0 → Part1) , una junta es rígida si la física de Part1 está completamente bloqueada por Part0 .Esto solo se aplica a los siguientes tipos conjuntos:

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

Parámetros

Devuelve

Devuelve todas las juntas o restricciones que estén conectadas a esta parte.

Devuelve

GetMass devuelve el valor de la propiedad de solo lectura Mass.

Esta función precede a la propiedad de masa. Sigue siendo compatible para la compatibilidad con versiones anteriores; debe usar la propiedad de 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 nil en caso del servidor.

Devuelve

Devuelve verdadero si el motor de juegos decide automáticamente al propietario de la red para esta parte.

Devuelve

Devuelve

Devuelve la parte base de una asamblea.Al mover una asamblea de piezas usando un CFrame .es importante mover esta parte base (esto moverá todas las otras partes conectadas a ella de acuerdo).Más información está disponible en el artículo Ensamblajes.

Esta función precede a la propiedad AssemblyRootPart . Se mantiene admitida para la compatibilidad con versiones anteriores, pero deberías usar AssemblyRootPart directamente.

Devuelve

Devuelve una tabla de todas las partes que interactúan físicamente con esta parte.Si la propia parte tiene CanCollide establecido en falso, entonces esta función devuelve una tabla vacía a menos que la parte tenga un objeto TouchInterest asociado a ella (lo que significa que algo está conectado a su evento Tocado).Las piezas que son adyacentes pero no se intersectan no se consideran que tocan.Esta función precede a la función WorldRoot:GetPartsInPart() que proporciona más flexibilidad y evita las reglas especiales TouchInterest descritas anteriormente.Usa WorldRoot:GetPartsInPart() en lugar.

Devuelve

Devuelve la velocidad lineal de la montura de la pieza en la posición dada con respecto a esta pieza.Se puede utilizar para identificar la velocidad lineal de las piezas en una ensambladora diferente a la pieza raíz.Si la asamblea no tiene velocidad ángular, entonces la velocidad lineal siempre será la misma para cada posición.

Parámetros

Devuelve

Devuelve verdadero si el objeto está conectado a una parte que lo mantendrá en su lugar (por ejemplo, una parte Anchored), de lo contrario devuelve falso.En una asamblea que tiene una parte Anchored parte, todas las demás partes están ancladas.

Devuelve

Cambia el tamaño de un objeto al igual que usando la herramienta de redimensionamiento de Studio.

Parámetros

Devuelve

Establece al jugador dado como propietario de la red para esto y todas las piezas conectadas.Cuando playerInstance es nil, el servidor será el propietario en lugar de un jugador.

Parámetros

Devuelve

Permite que el motor de juegos decida dinámicamente quién manejará la física de la parte (uno de los clientes o el servidor).

Devuelve

Parámetros

Devuelve

Crea un nuevo IntersectOperation de la geometría interseccionada de la pieza y de las otras piezas en el matriz/listadado.Solo se admiten Parts , no Terrain o MeshParts .Al igual que Clone() , el objeto devuelto no tiene ningún set Parent .

Las siguientes propiedades de la parte llamante se aplican al resultante IntersectOperation :

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

En la siguiente comparación de imágenes, IntersectAsync() se llama al bloque púrpura usando una tabla que contiene el bloquesazul.El resultante IntersectOperation se resuelve en una forma de la geometría interseccional de ambas partes.

<figcaption>Separar piezas</figcaption>

<figcaption>Resultando <code>Clase.IntersectOperation</code></figcaption>

Notas

• Las piezas originales se mantienen intactas después de una operación de intersección exitosa.En la mayoría de los casos, deberías Destroy() todas las piezas originales y padre al lugar de devolución IntersectOperation al mismo lugar que la llamada BasePart .
• Por defecto, los colores de la cara de la intersección resultante se toman de la propiedad Color de las partes originales.Para cambiar toda la intersección a un color específico, establece su propiedad UsePartColor a true.
• Si una operación de intersección resultara en una parte con más de 20,000 triángulos, se simplificará a 20,000 triángulos.

Parámetros

Devuelve

Crea un nuevo UnionOperation de la parte, menos la geometría ocupada por las piezas en el matriz/listadado.Solo se admiten Parts , no Terrain o MeshParts .Al igual que Clone() , el objeto devuelto no tiene ningún set Parent .

Tenga en cuenta que la unión resultante no puede estar vacía debido a las restas. Si la operación resultara en una geometría completamente vacía, fallará.

En la siguiente comparación de imágenes, SubtractAsync() se llama al cilindro azul usando una tabla que contiene el bloquespúrpura.El resultante UnionOperation resuelve en una forma que omite la geometría del bloquesde la del cilindro.

<figcaption>Separar piezas</figcaption>

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

Parámetros

Devuelve

local Workspace = game:GetService("Workspace")

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

-- Perform subtract operation
local success, newSubtract = pcall(function()
	return mainPart:SubtractAsync(otherParts)
end)

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

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

Crea un nuevo UnionOperation de la parte, más la geometría ocupada por las piezas en el matriz/listadado.Solo se admiten Parts , no Terrain o MeshParts .Al igual que Clone() , el objeto devuelto no tiene ningún set Parent .

Las siguientes propiedades de la parte llamante se aplican al resultante UnionOperation :

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

En la siguiente comparación de imágenes, UnionAsync() se llama al bloque azul usando una tabla que contiene el cilindro púrpura.El resultante UnionOperation se resuelve en una forma de la geometría combinada de ambas partes.

<figcaption>Separar piezas</figcaption>

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

Notas

• Las piezas originales se mantienen intactas después de una operación de unión exitosa.En la mayoría de los casos, deberías Destroy() todas las piezas originales y padre al lugar de devolución UnionOperation al mismo lugar que la llamada BasePart .
• Por defecto, la unión resultante respeta la propiedad Color de cada una de sus partes.Para cambiar toda la unión a un color específico, establece su propiedad UsePartColor a true.
• Si una operación de unión resultara en una parte con más de 20,000 triángulos, se simplificará a 20,000 triángulos.

Parámetros

Devuelve

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

Se enciende cuando una parte deja de tocar a otra parte en condiciones similares a las de BasePart.Touched .

Este evento funciona en conjunción con Workspace.TouchesUseCollisionGroups para especificar si grupos de colisión se reconocen para la detección

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)

El evento Tocado se activa cuando una parte entra en contacto con otra parte.Por instancia, si ParteA se choca con ParteB , entonces PartA.Touched dispara con ParteB , y PartB.Touched dispara con ParteA .

Este evento solo se activa como resultado de un movimiento físico, por lo que no se activará si la propiedad CFrame cambia para que la parte se sobreponga a otra parte.Esto también significa que al menos una de las partes involucradas debe no estar Anchored en el momento de la colisión

Este evento funciona en conjunción con Workspace.TouchesUseCollisionGroups para especificar si grupos de colisión se reconocen para la detección

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