BasePart

La proprietà Anchored determina se la parte sarà immovibile fisicamente. Quando è abilitata, una parte non cambierà mai la posizione a causa della gravità, delle altre collisioni di parti, dell'intersezione di altre parti o di qualsiasi altra causa fisica. Di Risultato, due parti ancorate non attiveranno mai l'evento BasePart.Touched l'una sull'altra.

Una parte ancorata può essere ancora spostata modificando la sua CFrame o Position, e può ancora avere una velocità di movimento non zero AssemblyLinearVelocity e 1> Class.BasePart.AssemblyAngularVelocity|Rotation di Angolo1> .

Infine, se una parte non ancorata viene unita a una parte ancorata attraverso un oggetto come un Weld, agirà anche su di essa. Se tale unione si rompe, la parte potrebbe essere influenzata dalla fisica di nuovo. Vedi Assemblies per ulteriori dettagli.

La proprietà della rete non può essere impostata su parti ancorate. Se lo stato dell'ancora di una parte cambia sul Server, la proprietà della rete di quella parte sarà influenzata.

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)

Il velocità angolare della produzione di questa parte. È il tasso di cambiamento di orientamento in radian per secondo.

La velocità angolare è la stessa a ogni punto dell'assemblaggio.

Impostare la velocità direttamente può portare a un movimento irrealistico. L'uso di Torque o AngularVelocity vincolo è preferito, o usare BasePart:ApplyAngularImpulse() se si vuole un cambiamento istantaneo in velocità.

Se la parte è di proprietà del Server, questa proprietà deve essere cambiata da uno script del server Script (non da uno script del client Class.LocalScript</

Una posizione calcolata tramite il mass e il position di tutte le parti nell'assemblaggio.

Se l'assemblaggio ha una parte ancorata, il centro di massa di quella parte sarà il centro di massa dell'assemblaggio e l'assemblaggio avrà una massa infinita.

Conoscere il centro di massa può aiutare l'assemblaggio a mantenere la stabilità. Una forza applicata al centro di massa non causerà l'accelerazione angolare, solo lineare. Un'assemblaggio con un basso centro di massa avrà un tempo migliore per rimanere in piedi sotto l'effetto della gravità.

Il velocità lineare di questo pezzo dell'assemblaggio. È il tasso di cambiamento di posizione del centro di massa dell'assemblaggio. center of mass in studs per secondo.

Se vuoi conoscere la velocità in un punto diverso dal centro di massa dell'assemblaggio, usa BasePart:GetVelocityAtPosition() .

Impostare la velocità direttamente può portare a un movimento irrealistico. L'uso di un VectorForce vincolo può essere preferito, o usare BasePart:ApplyImpulse() se si vuole un cambiamento istantaneo in velocità.

Se la parte è di proprietà del Server, questa proprietà deve essere cambiata da uno script del server Script (non da uno script del client Class.LocalScript</

La somma della massa di tutti i parts in questa parte dell'assemblaggio. Le parti che sono Massless e non sono la parte di base dell'assemblaggio non contribuiscono alla Massa di Assemblaggio.

Se l'assemblaggio ha una parte ancorata, la massa dell'assemblaggio è considerata infinita. Le restrizioni e altre interazioni fisiche tra gli unanchored assemblaggi con una grande differenza in massa possono causare instabilità.

Questa proprietà indica automaticamente il BasePart che rappresenta la parte di radice dell'assemblaggio. È la stessa parte che viene restituita quando gli sviluppatori chiamano GetRootPart() .

La parte root può essere cambiata modificando il RootPriority delle parti nell'assemblaggio.

Le parti che condividono tutte la stessa Root di Assemblaggio sono nello stesso assemblaggio.

For more information on root parts, see Assemblies .

La proprietà BackSurface determina il tipo di superficie utilizzata per la direzione +Z di una parte. Quando le facce di due parti sono posizionate l'una accanto all'altra, possono creare un'interfaccia tra di loro. Se impostato su Motor, l'BasePart.BackSurfaceInput determina il modo in cui dovrebbe comportarsi un'interfaccia tra motore.

La maggior parte dei tipi di superficie rende una texture sulla parte del viso se il BasePart.Material è impostato su Plastica. Alcuni tipi di superficie - Hinge, Motor e SteppingMotor - renderanno comunque un adornamento 3D invece. Se questa proprietà è selezionata nella finestra Proprietà, sarà evidenziata nel mondo di gioco simile a quella di un SurfaceSelection .

local demoPart = script.Parent

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

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

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

La proprietà BottomSurface determina il tipo di superficie utilizzata per la direzione -Y di una parte. Quando le facce di due parti sono posizionate l'una accanto all'altra, possono creare un'interfaccia tra di loro. Se impostato su Motor, il BasePart.BottomSurfaceInput determina il modo in cui dovrebbe comportarsi un'interfaccia tra i motori.

La maggior parte dei tipi di superficie rende una texture sulla parte del viso se il BasePart.Material è impostato su Plastica. Alcuni tipi di superficie - Hinge, Motor e SteppingMotor - renderanno comunque un adornamento 3D invece. Se questa proprietà è selezionata nella finestra Proprietà, sarà evidenziata nel mondo di gioco simile a quella di un SurfaceSelection .

local demoPart = script.Parent

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

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

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

La proprietà BrickColor determina il colore di una parte. Se la parte ha un BasePart.Material, questo determina anche il colore utilizzato per rendere la Strutturadel materiale. Per ulteriori controlli sul colore, la proprietà BasePart.Color può essere utilizzata (è una variante Color3 di questa Proprietà). Se Color Impostareimpostato, questa proprietà utilizza il colore più vicino.

Altre proprietà visive di una parte sono determinati da BasePart.Transparency e BasePart.Reflectance .

local part = script.Parent

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

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

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

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

La proprietà CFrame determina sia la posizione che l'orientamento del BasePart nel Mondo. Si comporta come una posizione di riferimento arbitraria sulla geometria, ma ExtentsCFrame rappresenta il vero 1> Datatype.CFrame1> del suo centro fisico.

Quando si imposta CFrame su una parte, le altre parti connese sono anche spostate rispetto alla parte, ma si consiglia di utilizzare PVInstance:PivotTo() per spostare un modello intero, come quando si teletrasporta un personaggio del Giocatore.

A differenza di impostare BasePart.Position , impostare BasePart.CFrame muoverà sempre la parte all'esattitudine CFrame ; in altre parole: 1> nessun sovrapposizione verifica viene eseguita1> e il solvente fisico cercherà di risolvere qualsiasi sovr

Per tenere traccia delle posizioni rispetto a una parte's 2 Datatype.CFrame , un Attachment potrebbe essere utile.

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 se una parte interagisce fisicamente con altre parti. Quando è disabilitato, le altre parti possono passare attraverso il mattone ininterrotto. Le parti utilizzate per la 装orazione di solito hanno CanCollide disabilitato, poiché non sono necessarie in fisica.

Se una parte non è BasePart.Anchored e ha disabilitato CanCollide, potrebbe cadere dal mondo per essere finalmente distrutta da Workspace.FallenPartsDestroyHeight .

Quando CanCollide è disabilitato, le parti possono ancora attivare l'evento BasePart.Touched (anche le altre parti che le toccano). Puoi disabilitarlo con BasePart.CanTouch .

For more information on collisions, see Collisioni .

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

local OPEN_TIME = 1

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

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

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

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

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

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

part.Touched:Connect(onTouch)
close()

CanQuery determina se la parte è considerata durante le operazioni di query spaziale, come GetPartBoundsInBox o Raycast . CanCollide deve anche essere disabilitato quando disabiliti CanQuery. Queste funzioni non includeranno mai parti le cui CanQuery e 1> Class

Oltre a questa Proprietà, è anche possibile escludere parti che sono discendenti di una lista di parti specificata utilizzando un oggetto OverlapParams o RaycastParams quando si chiamano le funzioni di query spaziali.

Questa proprietà determina se Class.BasePart.Touched|Touched</

Nota che questa logica di collisione può essere impostata per rispettare gruppi di collisione attraverso la ProprietàWorkspace.TouchesUseCollisionGroups. Se true , le parti in non-collision gruppi ignoreranno entrambe le collisioni 1> e1> eventi di tocco, rendendo quindi questa proprietà irrilevante.

Prestazioni

Ci è un piccolo guadagno di prestazioni su parti che hanno sia CanTouch e CanCollide impostati su false, poiché queste parti non dovranno mai calcolare alcun tipo di collisioni tra parti

Determina se un part casta un'ombra o no.

Nota che questa funzione non è non progettata per l'ottimizzazione delle prestazioni. Dovrebbe essere disabilitata solo in parti in cui vuoi nascondere le ombre che la parte casta. Disabilitare questa proprietà per una parte specifica può causare arti visivi sugli ombre cast su quella parte.

La proprietà CenterOfMass descrive la posizione locale di un'area del centro di massa di una parte. Se questa è un'assemblaggio di singola parte, questa è la AssemblyCenterOfMass convertita dallo spazio del mondo in un'area del centro di massa locale. Su simple Parts , il centro di massa

La proprietà CollisionGroup descrive il nome del gruppo di collisione della parte (massimo di 100 caratteri). Le parti iniziano con il gruppo predefinito il cui nome è "Default" . Questo valore non può essere vuoto.

Anche se questa proprietà stessa non è replicata, il motore replica internamente il valore attraverso un'altra proprietà privata per risolvere i problemi di compatibilità in avanti.

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 proprietà Colore determina il colore di una parte. Se la parte ha un Class.BasePart.Material , questo determina anche il colore utilizzato per rendere la Strutturadel materiale. Se questa proprietà è Impostare, BasePart.Material userà il colore più vicino alla valuta Color3.

Altre proprietà visive di una parte sono determinati da BasePart.Transparency e BasePart.Reflectance .

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

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

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

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

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

update()
human.HealthChanged:Connect(update)

CurrentPhysicalProperties indica le proprietà fisiche attuali della parte. Puoi impostare valori personalizzati per le proprietà fisiche per parte, materiale personalizzato e Soprascriveredel materiale. Il motore prioritizza le definizioni più granulari quando si determinano le proprietà fisiche effettive di una parte. I valori nella seguente lista sono in ordine dal più alto alla più bassa priorità:

• Proprietà fisiche personalizzate della parte
• Proprietà fisiche personalizzate del materiale personalizzato della parte
• Proprietà fisiche personalizzate della parte che sovrascrivono il materiale
• Proprietà fisiche predefinite del materiale della parte

CustomPhysicalProperties ti consente di personalizzare varie proprietà fisiche di un Part , come la sua densità, frittzione e elasticità.

Se abilitato, questa proprietà ti consente di configurare queste proprietà fisiche. Se disabilitato, queste proprietà fisiche sono determinati dal BasePart.Material della parte. La pagina per Enum.Material contiene la lista dei diversi materiali di 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

Quando è vero, e quando Workspace.FluidForces è abilitato, fa in modo che il motore fisico calcoli le forze aerodinamiche su questo BasePart .

Il CFrame dei suoi estenti fisici del BasePart, rappresentante il suo centro fisico.

La dimensione fisica reale del BasePart come vista dal motore di fisica, ad esempio in rilevamento delle collisioni .

La proprietà FrontSurface determina il tipo di superficie utilizzata per la direzione -Z di una parte. Quando le facce di due parti sono posizionate l'una accanto all'altra, possono creare un'interfaccia tra di loro. Se impostato su Motor, l'BasePart.FrontSurfaceInput determina il modo in cui dovrebbe comportarsi un'interfaccia tra motori.

La maggior parte dei tipi di superficie rende una texture sulla parte del viso se il BasePart.Material è impostato su Plastica. Alcuni tipi di superficie, tra cui Hinge, Motor e SteppingMotor, rendono un adornamento 3D invece. Se questa proprietà è selezionata nella finestra Proprietà, viene evidenziata nel mondo di gioco simile a quella di un SurfaceSelection .

local demoPart = script.Parent

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

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

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

La proprietà LeftSurface determina il tipo di superficie utilizzata per la direzione -X di una parte. Quando le facce di due parti sono posizionate l'una accanto all'altra, possono creare un'interfaccia tra di loro. Se impostato su Motor, il BasePart.LeftSurfaceInput determina il modo in cui dovrebbe comportarsi un'interfaccia tra i motori.

La maggior parte dei tipi di superficie rende una texture sulla parte del viso se il BasePart.Material è impostato su Plastica. Alcuni tipi di superficie, tra cui Hinge, Motor e SteppingMotor, rendono un adornamento 3D invece. Se questa proprietà è selezionata nella finestra Proprietà, viene evidenziata nel mondo di gioco simile a quella di un SurfaceSelection .

local demoPart = script.Parent

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

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

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

La proprietà LocalTransparencyModifier è un moltiplicatore di BasePart.Transparency che è visibile solo al client locale. Non si replica dal client al server e è utile per quando una parte non dovrebbe essere rendere per un client locale specifico, come il fatto che il giocatore non vede le parti del corpo del loro personaggio quando si passa in prima persona.

Questa proprietà modifica la trasparenza della parte locale attraverso la seguente formula, con risultati valori schiacciati tra 0 e 1.

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

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

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

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

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

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

La proprietà Bloccata determina se un part (o un model (o entrambi sono selezionati in Roblox Studio facendo clic su di esso) può essere selezionato in Roblox Studio facendo clic su di esso. Questa proprietà è abilitata con maggior frequenza nelle parti all'interno dei modelli ambientali che non vengono modificati al 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 è una proprietà di proprietà che descrive il prodotto di un part's volume e densità. È restituito dalla funzione GetMass .

• Il volume di una parte è determinato dalla sua Size e dalla sua Shape , che varia a seconda del tipo di BasePart utilizzato, come WedgePart .
• La densità di una parte è determinata dal suo Material o CustomPhysicalProperties, se specificato.

Se questa proprietà è abilitata, il BasePart non contribuirà alla massa o all'inertia della sua assemblaggio finché non è saldato ad un'altra parte che ha massa.

Se la parte è la sua propria parte di radice secondo AssemblyRootPart , questo sarà ignorato per quella parte, e continuerà a contribuire alla sua assemblaggio come una parte normale. Le parti che non sono massless non dovrebbero mai diventare una parte di radice di assemblaggio a meno che tutte le altre parti nell'assemblaggio non siano anche massless.

Questo potrebbe essere utile per cose come accessori opzionali sui veicoli che non vuoi influire sulla gestione della macchina o una maglia di rendering senza massa fusa su una maglia di rendering più semplice.

Vedi anche Assemblies, un articolo che documenta le parti di root e come usarli.

La proprietà Material consente a un costruttore di impostare la texture e le proprietà fisiche predefinite di una parte (in caso che BasePart.CustomPhysicalProperties non sia impostato). Il materiale Plastica ha una Strutturamolto leggera, e il materiale SmoothPlastic non ha texture tutti/tutte. Alcune texture del materiale come DiamondPlate e Granite hanno una texture molto visibile. Ogni texture del materiale riflette il sole in modo diverso, in particolare il metallo.

Impostando questa proprietà quindi abilitando BasePart.CustomPhysicalProperties userà le proprietà fisiche predefinite di un materiale. Ad esempio, DiamondPlate è un materiale molto denso mentre Wood è molto leggero. La densità di una parte determina se fluttua nell'acqua del terreno.

Il materiale Vetro cambia il comportamento di rendering su impostazioni grafiche moderate. Applica un po 'di riflettanza (simile a BasePart.Reflectance ) e distorsione di prospettiva. L'effetto è particolarmente pronunciato su parti a forma di sfera (setta BasePart.Shape per palla). Gli oggetti semitransparenti e le parti di Vetro dietro le parti di Vetro sono invisibili.

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)

Il sistema cerca la MaterialVariant istanza con il nome specificato Materiallean e il inserisci / scriviBasePart.Material . Se trova con successo una corrispondente MaterialService esempio, usa questa istanza 1> Class.Material1> per sostituire il materiale predefinito. Il materiale predefinito può essere il materiale incorporato o un Override MaterialSpecificato in 4> Class.MaterialService4> .

La proprietà Orientation descrive la rotazione della parte in gradi intorno agli assi X, Y e Z utilizzando un Vector3. Le rotazioni vengono applicate in Y → X → Z ordine. Ciò differ

Quando si imposta questa proprietà qualsiasi Welds o Motor6Ds connessi a questa parte avrà la corrispondente C0 o 1> Class.JointInstance.C1|C11> proprietà aggi

WeldConstraints sarà anche temporaneamente disabilitato e riabilitato durante il Sposta.

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

Questa proprietà specifica l'Offset della parte dal suo CFrame, che è uguale a part:GetPivot() .

Questo è conveniente per impostare il pivot in una posizione nello Spaziolocale, ma impostare il pivot di una parte in una posizione nello spazio mondiale può essere fatto come segue:

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 proprietà Posizione descrive le coordinate di un part utilizzando un Vector3 . Riflette la posizione della parte's BasePart.CFrame, tuttavia può essere Impostare.

Quando si imposta questa proprietà qualsiasi Welds o Motor6Ds connessi a questa parte avrà la corrispondente C0 o 1> Class.JointInstance.C1|C11> proprietà aggi

WeldConstraints sarà anche temporaneamente disabilitato e riabilitato durante il Sposta.

Questo restituisce il tempo in secondi dal momento che la fisica della parte è stata aggiornata l'ultima volta sul client locale (o sul Server). Ritorna 0 quando la parte non ha fisica (Anchored)

La proprietà Riflettanza determina quanto un part rifletta la skybox. Un valore di 0 indica che la parte non riflette tutti/tutte, e un valore di 1 indica che la parte dovrebbe riflettere completamente.

La riflettanza non è influenzata da BasePart.Transparency , a meno che la parte non sia completamente trasparente, in cui caso la riflettanza non si renderà tutti/tutte. La riflettanza può o non può essere ignorata a seconda del BasePart.Material della parte.

local part = script.Parent

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

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

part.Touched:Connect(blink)

La proprietà ResizeIncrement è una proprietà di lettura che descrive il più piccolo cambiamento in dimensioni consentito dal metodo BasePart:Resize() . Si differenzia tra le implementazioni della classe BasePart . Ad esempio, Part ha questo set a 1 e 1> Class.

-- 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 proprietà ResizeableFaces (con un e , non ResizeableFaces) descrive l'utilizzo di un oggetto Faces per mostrare le diverse facce su cui una parte può essere ridimensionata.

-- 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 proprietà RightSurface determina il tipo di superficie utilizzata per la direzione +X di una parte. Quando le facce di due parti sono posizionate l'una accanto all'altra, possono creare un'interfaccia tra di loro. Se impostato su Motor, l'BasePart.RightSurfaceInput determina il modo in cui dovrebbe comportarsi un'interfaccia tra i motori.

La maggior parte dei tipi di superficie rende una texture sulla parte del viso se il BasePart.Material è impostato su Plastica. Alcuni tipi di superficie, tra cui Hinge, Motor e SteppingMotor, rendono una decorazione 3D invece. Se questa proprietà è selezionata nella finestra Proprietà, viene evidenziata nel mondo di gioco, simile all'area di una SurfaceSelection .

local demoPart = script.Parent

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

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

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

Questa proprietà è un numero intero tra -127 e 127 che prende la precedenza su tutte le altre regole per il tipo di radice Ordinare. Quando si considera più parti che non sono Anchored e condividono lo stesso valore Massless, una parte con una maggiore RootPrivacy

Puoi usare questa proprietà per controllare quale parte di un'assemblaggio è la parte di radice e mantenere la parte di radice stabile se le dimensioni cambiano.

Vedi anche Assemblies, un articolo che documenta le parti di root e come usarli.

La rotazione della parte in gradi per i tre assi.

Quando si imposta questa proprietà qualsiasi Welds o Motor6Ds connessi a questa parte avrà la corrispondente C0 o 1> Class.JointInstance.C1|C11> proprietà aggi

WeldConstraints sarà anche temporaneamente disabilitato e riabilitato durante il Sposta.

La proprietà Size di una parte determina le sue dimensioni visuali, mentre ExtentsSize rappresenta la dimensione reale utilizzata dal motore fisico, come in 2>

La dimensione della parte determina la sua massa che viene fornita da BasePart:GetMass() . Un'area della sua Size viene utilizzata da una varietà di altri oggetti:

• ParticleEmitter per determinare l'area da cui vengono generati le parti.
• BlockMesh per determinare parzialmente il prisma rettangolare renduto.
• SpecialMesh per determinare la dimensione della Mesh, magliarenduta.
• SurfaceLight per determinare lo spazio da illuminare.

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 proprietà TopSurface determina il tipo di superficie utilizzata per la direzione +Y di una parte. Quando le facce di due parti sono posizionate l'una accanto all'altra, possono creare un'interfaccia tra di loro. Se impostato su Motor, l'BasePart.TopSurfaceInput determina il modo in cui dovrebbe comportarsi un'interfaccia tra i motori.

La maggior parte dei tipi di superficie rende una texture sulla parte del viso se il BasePart.Material è impostato su Plastica. Alcuni tipi di superficie - Hinge, Motor e SteppingMotor - renderanno comunque un adornamento 3D invece. Se questa proprietà è selezionata nella finestra Proprietà, sarà evidenziata nel mondo di gioco simile a quella di un SurfaceSelection .

local demoPart = script.Parent

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

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

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

La proprietà Trasparenza controlla la visibilità di una parte su una scala di 0 a 1, dove 0 è completamente visibile (opaco), e un valore di 1 è completamente invisibile (non visualizzato tutti/tutte).

BasePart.Reflectance può ridurre la trasparenza generale di un mattone se impostato su un valore vicino a 1.

Mentre le parti completamente trasparenti non vengono visualizzate tutti/tutte, gli oggetti parzialmente trasparenti hanno alcuni costi di rendimento importanti. Avere molte parti trasparenti può rallentare le Prestazionedel Gioco.

Quando le parti trasparenti si sovrappongono, l'ordine di rendering può agire in modo imprevedibile - cerca di mantenere le parti semi-trasparenti dall'intersezione per evitare questo.

Il BasePart.LocalTransparencyModifier è un moltiplicatore di trasparenza che è visibile solo al client locale.

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

local OPEN_TIME = 1

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

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

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

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

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

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

part.Touched:Connect(onTouch)
close()

local function makeXRayPart(part)
	-- LocalTransparencyModifier will make parts see-through but only for the local
	-- client, and it won't replicate to the server
	part.LocalTransparencyModifier = 0.5
end

-- This function uses recursion to search for parts in the game
local function recurseForParts(object)
	if object:IsA("BasePart") then
		makeXRayPart(object)
	end

	-- Stop if this object has a Humanoid - we don't want to see-through players!
	if object:FindFirstChildOfClass("Humanoid") then
		return
	end

	-- Check the object's children for more parts
	for _, child in pairs(object:GetChildren()) do
		recurseForParts(child)
	end
end

recurseForParts(workspace)

Parametri

Restituzioni

Applica un istantaneo impulso di forza angolare a questa parte dell'assemblaggio, causando la rotazione dell'assemblaggio.

La velocità angolare risultante dall'impulso si basa sulla mass dell'assemblaggio. Quindi, un impulso più elevato è richiesto per spostare assemblaggi più massimi. Gli impulsi sono utili per casi in cui si vuole applicare una forza istantaneamente, come un'esplosione o una collisione.

Se la parte è di proprietà del Server, questa funzione deve essere chiamata da uno script del server Class.Script (non da uno script del server con Class.BaseScript.Run

Parametri

Restituzioni

Questa funzione applica un impulso di forza istantaneo all'assemblaggio di questa parte.

La forza viene applicata al centro di raccolta di massa di center of mass, quindi il movimento risultante sarà solo lineare.

La velocità risultante dall'impulso si basa sulla mass dell'assemblaggio. Quindi, un impulso più elevato è richiesto per spostare assemblaggi più massimi. Gli impulsi sono utili per casi in cui si vuole applicare una forza istantaneamente, come un'esplosione o una collisione.

Se la parte è di proprietà del Server, questa funzione deve essere chiamata da uno script del server Class.Script (non da uno script del server con Class.BaseScript.Run

Parametri

Restituzioni

Questa funzione applica un impulso di forza istantaneo all'assemblaggio di questa parte, nella posizione specificata nello Spaziodel mondo.

Se la posizione non è al centro dell'assemblaggio center of mass, l'impulso causerà un movimento posizionale e rotazionale.

La velocità risultante dall'impulso si basa sulla mass dell'assemblaggio. Quindi, un impulso più elevato è richiesto per spostare assemblaggi più massimi. Gli impulsi sono utili per casi in cui gli sviluppatori vogliono una forza applicata istantaneamente, come un'esplosione o una collisione.

Se la parte è di proprietà del Server, questa funzione deve essere chiamata da uno script del server Class.Script (non da uno script del server con Class.BaseScript.Run

Parametri

Restituzioni

Restituisce se le parti possono collidere tra loro o no. Questa funzione tiene conto dei gruppi di collisione delle due parti. Questa funzione si verrà errore se la parte specificata non è una BasePart.

Parametri

Restituzioni

La funzione CanSetNetworkOwnership controlla se puoi impostare la proprietà di rete di una parte.

Il valore di ritorno della funzione verifica se o no puoi chiamare BasePart:SetNetworkOwner() o BasePart:SetNetworkOwnershipAuto() senza incontrare un errore. Ritorna vero se puoi modificare/leggere la proprietà di rete, o ritorna falso e il motivo per cui non puoi, come una Stringa.

Restituzioni

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

Parametri

Restituzioni

Restituisce una tabella di parti connesse all'oggetto da qualsiasi tipo di Articolazionerigida.

Se recursive è vero, questa funzione restituirà tutte le parti nell'assemblaggio connessi in modo rigido alla BasePart.

Giunture rigide

Quando una connessione congiunge due parti insieme (Part0 → Part1) , una connessione è rigida se la fisica di Part1 è completamente bloccata da 1> Part01> . Questo si applica solo ai seguenti tipi di connessione:

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

Parametri

Restituzioni

Restituisci tutti i Giunti o Constritti che sono connessi a questa parte.

Restituzioni

GetMass() restituisce il valore della Proprietà Class.BasePart.Mass|Mass che è solo di lettura.

Questa funzione è pre-datata dalla ProprietàMass. Resta supportata per la compatibilità con l'archivio; dovresti usare la proprietà Mass direttamente.

Restituzioni

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)

Restituisce il giocatore corrente che è il proprietario di rete di questa parte, o nulla in caso di Server.

Restituzioni

Restituisce vero se il motore di gioco decide automaticamente il proprietario della rete per questa parte.

Restituzioni

Restituzioni

Restituisce la parte di base di un'assemblaggio. Quando si muove un'assemblaggio di parti utilizzando un CFrame . è importante spostare questa parte di base (questo sposterà tutte le altre parti connesse ad essa di conseguenza). Ulteriori informazioni sono disponibili nell'articolo Assemblies.

Questa funzione è pre-datata la proprietà AssemblyRootPart . Resta supportata per la compatibilità con l'architettura di retro-adesione, ma si dovrebbe usare AssemblyRootPart direttamente.

Restituzioni

Restituisce una tabella di tutte le parti che interagiscono fisicamente con questa parte. Se la parte stessa ha CanCollide impostato su false, allora questa funzione restituisce una tabella vuota a meno

Restituzioni