BasePart

Mostrar obsoleto

*Este contenido se traduce usando la IA (Beta) y puede contener errores. Para ver esta página en inglés, haz clic en aquí.

No creable
No explorable

BasePart es una clase base abstracta para objetos en el mundo que se renderizan y se simulan físicamente mientras están en el Workspace.Hay varias implementaciones de BasePart , la más común siendo Part y MeshPart .Otros incluyen WedgePart , SpawnLocation , y el objeto singleton Terrain .Generalmente, cuando la documentación se refiere a una "parte", la mayoría de las implementaciones BasePart trabajarán y no solo Part .

Para obtener información sobre cómo se agrupan BaseParts en cuerpos rígidos simulados, consulte ensamblajes .

Hay muchos objetos diferentes que interactúan con BasePart (diferentes a Terrain ), incluyendo:

Resumen

Propiedades

Propiedades heredados de PVInstance

Métodos

Métodos heredados de PVInstance

Eventos

Propiedades

Anchored

Leer paralelo

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.

Muestras de código

This code sample will allow a part to be clicked to toggle its anchored property. When toggled, the visual appearance of the part is updated (red means anchored, yellow means free).

Part Anchored Toggle

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)

AssemblyAngularVelocity

No replicado
Leer paralelo

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.

AssemblyCenterOfMass

Solo lectura
No replicado
Leer paralelo

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.

AssemblyLinearVelocity

No replicado
Leer paralelo

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.

AssemblyMass

Solo lectura
No replicado
Leer paralelo

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.

AssemblyRootPart

Solo lectura
No replicado
Leer paralelo

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

Leer paralelo

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.

BackSurface

Leer paralelo

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.

BottomSurface

Leer paralelo

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.

BrickColor

No replicado
Leer paralelo

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.

CFrame

Leer paralelo

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.

Muestras de código

This code sample demonstrates setting a part's CFrame in many different ways. It showcases how to create and compose CFrame values. It references a sibling part called "OtherPart" for demonstrating relative positioning.

Setting Part CFrame

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

Leer paralelo

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.

Muestras de código

This code sample shows how a part can fade away when touched by a Humanoid then reappear a moment after to create a passable door.

Fade Door

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

Leer paralelo

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.

CanTouch

Leer paralelo

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.

CastShadow

Leer paralelo

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.

CenterOfMass

Solo lectura
No replicado
Leer paralelo

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 .

CollisionGroup

No replicado
Leer paralelo

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.

Muestras de código

This example demonstrates one basic use of collision groups. It assigns BallPart to "CollisionGroupBall" and DoorPart to "CollisionGroupDoor", then makes the two groups non-collidable using PhysicsService:CollisionGroupSetCollidable().

PhysicsService:RegisterCollisionGroup

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

Color

No replicado
Leer paralelo

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.

Muestras de código

This code sample colors a player's entire character based on how much health they have. It generates a color based on their max health, then sets the color properties of objects within their character, removing any extra objects.

Character Health Body Color

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

Solo lectura
No replicado
Leer paralelo

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

Leer paralelo

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.

Muestras de código

This code sample demonstrates how to set the CustomPhysicalProperties property of a part.

Set CustomPhysicalProperties

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

EnableFluidForces

Leer paralelo

Cuando true , y cuando Workspace.FluidForces está habilitado, provoca que el motor de físicas compute fuerzas aerodinámicas en este BasePart .

ExtentsCFrame

Solo lectura
No replicado
Leer paralelo

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

ExtentsSize

Solo lectura
No replicado
Leer paralelo

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

FrontSurface

Leer paralelo

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.

LeftSurface

Leer paralelo

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.

LocalTransparencyModifier

Oculto
No replicado
Leer paralelo

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>

Locked

Leer paralelo

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.

Muestras de código

This code sample uses the concept of recursion to unlock all parts that are a descendant of a model.

Recursive Unlock

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

Solo lectura
No replicado
Leer paralelo

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

Massless

Leer paralelo

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.

Leer paralelo

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.

MaterialVariant

No replicado
Leer paralelo

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.

Orientation

Oculto
No replicado
Leer paralelo

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 YXZ 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 ( ZYX ).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.

Muestras de código

This code sample rotates a part continually on the Y axis.

Part Spinner

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

PivotOffset

Leer paralelo

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)

Muestras de código

This code sample shows a custom function for resetting the pivot of a model back to the center of that model's bounding box.

Reset Pivot

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)

This code sample creates a clock at the origin with a minute, second, and hour hand, and makes it tick, displaying the local time.

Clock Hands

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

Position

Oculto
No replicado
Leer paralelo

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.

ReceiveAge

Oculto
Solo lectura
No replicado
Leer paralelo

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

Reflectance

Leer paralelo

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.

ResizeIncrement

Solo lectura
No replicado
Leer paralelo

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.

ResizeableFaces

Solo lectura
No replicado
Leer paralelo

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.

Muestras de código

This code sample creates a Handles object and shows how to set the Faces property of the object. It also references ResizeableFaces of a part. Try placing this script in multiple kinds of parts to see how ResizeableFaces varies.

Resize Handles

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

RightSurface

Leer paralelo

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.

RootPriority

Leer paralelo

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.

Rotation

No replicado
Leer paralelo

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.

No replicado
Leer paralelo

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.

Muestras de código

This code sample constructs a pyramid by stacking parts that get progressively smaller. It also colors the parts so they blend between a start color and end color.

Pyramid Builder

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

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.

Transparency

Leer paralelo

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.

Muestras de código

This code sample shows how a part can fade away when touched by a Humanoid then reappear a moment after to create a passable door.

Fade Door

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

Métodos

AngularAccelerationToTorque

Parámetros

angAcceleration: Vector3
Valor predeterminado: ""
angVelocity: Vector3
Valor predeterminado: "0, 0, 0"

Devuelve

ApplyAngularImpulse

()

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

impulse: Vector3

Un vector de impulso ángulo para aplicar a la montura.

Valor predeterminado: ""

Devuelve

()

ApplyImpulse

()

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

impulse: Vector3

Un vector de impulso lineal para aplicar a la montura.

Valor predeterminado: ""

Devuelve

()

ApplyImpulseAtPosition

()

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

impulse: Vector3

Un vector de impulso para aplicar a la montura.

Valor predeterminado: ""
position: Vector3

La posición, en el espacio mundial, para aplicar el impulso.

Valor predeterminado: ""

Devuelve

()

CanCollideWith

Escribir paralelo

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

part: BasePart

La parte especificada que se está verificando por posibles colisiones.

Valor predeterminado: ""

Devuelve

Si las partes pueden chocar entre sí.

CanSetNetworkOwnership

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

Si puedes modificar o leer la propiedad de la red y la razón.

Muestras de código

This example checks whether or not the network ownership of the first BasePart named Part in the Workspace can be set.

Check if a Part's Network Ownership Can Be Set

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

GetClosestPointOnSurface

Parámetros

position: Vector3
Valor predeterminado: ""

Devuelve

GetConnectedParts

Instances
Escribir paralelo

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:

Parámetros

recursive: boolean

Una tabla de partes conectadas al objeto por cualquier tipo de joint .

Valor predeterminado: false

Devuelve

Instances

GetJoints

Instances
Escribir paralelo

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


Devuelve

Instances

Un array de todas las juntas o restricciones conectadas a la parte.

GetMass

Escribir paralelo

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

La masa de la parte.

Muestras de código

This example creates a new part, myPart, in the game's Workspace, with dimensions 4x6x4 studs. The part is also anchored.

Then, myMass is set to equal the mass of the new part. The mass of the part is printed at the end of the print statement:

My part's mass is ...

Finding a Part's Mass

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)

GetNetworkOwner

Escribir paralelo

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


Devuelve

El jugador actual que es el propietario de la red de esta parte, o nil en caso del servidor.

GetNetworkOwnershipAuto

Escribir paralelo

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


Devuelve

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

GetNoCollisionConstraints

Instances

Devuelve

Instances

GetRootPart

Escribir paralelo

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

La parte base de una ensamblación (una colección de partes conectadas entre sí).

GetTouchingParts

Instances

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

Instances

Una tabla de todas las partes que se intersectan y pueden chocar con esta parte.

GetVelocityAtPosition

Escribir paralelo

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

position: Vector3
Valor predeterminado: ""

Devuelve

IsGrounded

Escribir paralelo

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

Si el objeto está conectado a una parte que lo mantendrá en su lugar.

Resize

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

Parámetros

normalId: Enum.NormalId

El lado para cambiar el tamaño.

Valor predeterminado: ""
deltaAmount: number

Cuánto crecer/encogerse en el lado especificado.

Valor predeterminado: ""

Devuelve

Si la parte se redimensiona.

SetNetworkOwner

()

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

playerInstance: Player

El jugador que recibe la propiedad de red de la parte.

Valor predeterminado: "nil"

Devuelve

()

SetNetworkOwnershipAuto

()

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

()

TorqueToAngularAcceleration

Parámetros

torque: Vector3
Valor predeterminado: ""
angVelocity: Vector3
Valor predeterminado: "0, 0, 0"

Devuelve

IntersectAsync

Proporciona

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 :

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.

Two block parts overlapping

<figcaption>Separar piezas</figcaption>
Parts intersected into a new solid model

<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

parts: Instances

Los objetos que participan en la intersección.

Valor predeterminado: ""
collisionfidelity: Enum.CollisionFidelity

El valor Enum.CollisionFidelity para el resultante IntersectOperation.

Valor predeterminado: "Default"
renderFidelity: Enum.RenderFidelity

El valor Enum.RenderFidelity de la resultante PartOperation.

Valor predeterminado: "Automatic"

Devuelve

Resultando IntersectOperation con el nombre predeterminado Intersect .

SubtractAsync

Proporciona

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.

Longer block overlapping a cylinder

<figcaption>Separar piezas</figcaption>
Block part subtracted from cylinder

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

Parámetros

parts: Instances

Los objetos que participan en la restitución.

Valor predeterminado: ""
collisionfidelity: Enum.CollisionFidelity

El valor Enum.CollisionFidelity para el resultante UnionOperation.

Valor predeterminado: "Default"
renderFidelity: Enum.RenderFidelity

El valor Enum.RenderFidelity de la resultante PartOperation.

Valor predeterminado: "Automatic"

Devuelve

Resultando UnionOperation con el nombre predeterminado Unión .

Muestras de código

This example demonstrates how to subtract part(s) from another BasePart to form a negated UnionOperation.

BasePart:SubtractAsync()

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

UnionAsync

Proporciona

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 :

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.

Block and cylinder parts overlapping

<figcaption>Separar piezas</figcaption>
Parts joined together into a single solid union

<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

parts: Instances

Los objetos que participan en la unión con la parte llamante.

Valor predeterminado: ""
collisionfidelity: Enum.CollisionFidelity

El valor Enum.CollisionFidelity para el resultante UnionOperation.

Valor predeterminado: "Default"
renderFidelity: Enum.RenderFidelity

El valor Enum.RenderFidelity de la resultante PartOperation.

Valor predeterminado: "Automatic"

Devuelve

Resultando UnionOperation con el nombre predeterminado Unión .

Muestras de código

This example demonstrates how to combine the geometry of one BasePart with the geometry of other part(s) to form a UnionOperation.

BasePart:UnionAsync()

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

Eventos

TouchEnded

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

otherPart: BasePart

Muestras de código

This code sample creates a BillboardGui on a part that displays the number of parts presently touching it.

Touching Parts Count

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)

Touched

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

otherPart: BasePart

La otra parte que entró en contacto con la parte dada.


Muestras de código

This code sample creates a BillboardGui on a part that displays the number of parts presently touching it.

Touching Parts Count

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)

This code sample demonstrates how to connect the BasePart.Touched event of multiple parts in a Model to one function.

Model Touched

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