BasePart

La proprietà Anchored determina se la parte sarà immovibile per la fisica.Quando è abilitato, una parte non cambierà mai posizione a causa della gravità, delle collisioni di altre parti, dell'interseczione di altre parti o di qualsiasi altra causa legata alla fisica.Di Risultato, due parti ancorate non avranno mai fuoco l'evento Touched l'un l'altra.

Una parte ancorata può ancora essere spostata cambiando il suo CFrame o Position , e può ancora avere un non zero AssemblyLinearVelocity e AssemblyAngularVelocity .

Infine, se una parte non ancorata si unisce a una parte ancorata attraverso un oggetto come un Weld, anche essa agirà ancorata.Se una tale articolazione si rompe, la parte può essere nuovamente influenzata dalla fisica.Vedi Assemblaggi per maggiori dettagli.

La proprietà della rete non può essere impostata su parti ancorate.Se lo stato ancorato di una parte cambia sul Server, la proprietà di rete di quella parte verrà 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 vector di velocità angolare dell'assemblaggio di questa parte. È il tasso di cambio dell'orientamento in radianti al secondo.

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

Impostare la velocità direttamente può portare a una moto irrealistica.L'uso di Torque o AngularVelocity vincolo è preferito, o usa ApplyAngularImpulse() se vuoi un cambiamento istantaneo nella velocità.

Se la parte è di proprietà del Server, questa proprietà deve essere cambiata da un server Script (non da un LocalScript o un Script con RunContext impostato su Enum.RunContext.Client ).Se la parte è posseduta da un client attraverso proprietà automatica di proprietà, questa proprietà può essere modificata da uno script client o da uno script del server; cambiarla da uno script client per una parte di proprietà del server non avrà alcun effetto.

Una posizione calcolata attraverso il Mass e 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à accelerazione angolare, solo lineare.Un'assemblaggio con un centro di massa basso avrà un tempo migliore di rimanere in piedi sotto l'effetto della gravità.

Il vector di velocità lineare dell'assemblaggio di questa parte. È il tasso di cambiamento in posizione di AssemblyCenterOfMass in studs al secondo.

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

Impostare la velocità direttamente può portare a una moto irrealistica.Si preferisce utilizzare una restrizione VectorForce o usare ApplyImpulse() se si desidera un cambiamento istantaneo nella velocità.

Se la parte è di proprietà del Server, questa proprietà deve essere cambiata da un server Script (non da un LocalScript o un Script con RunContext impostato su Enum.RunContext.Client ).Se la parte è posseduta da un client attraverso proprietà automatica di proprietà, questa proprietà può essere modificata da uno script client o da uno script del server; cambiarla da uno script client per una parte di proprietà del server non avrà alcun effetto.

La somma della massa di tutte le BaseParts in questo assemblaggio della parte.Le parti che sono Massless e non sono la parte principale dell'assemblaggio non contribuiranno al AssemblyMass.

Se l'assemblaggio ha una parte ancorata, la massa dell'assemblaggio è considerata infinita.Restrizioni e altre interazioni fisiche tra assemblaggi non ancorati con una grande differenza di massa possono causare instabilità.

Questa proprietà indica il BasePart automaticamente scelto per rappresentare la parte principale dell'assemblaggio.È la stessa parte che viene restituita quando gli sviluppatori chiamano GetRootPart() .

La parte radice può essere modificata cambiando il RootPriority delle parti nell'assemblaggio.

Le parti che tutte condividono lo stesso AssemblyRootPart sono nella stessa assemblaggio.

Per ulteriori informazioni sulle parti radicali, vedi Assemblaggi.

AudioCanCollide determina se la parte interagirà fisicamente con la simulazione audio, simile a CastShadow per l'illuminazione.

Quando è disabilitato, l'audio passa attraverso la parte; non è occluso o riflesso.

La proprietà BackSurface determina il tipo di superficie utilizzata per la direzione positiva Z di una parte.Quando le facce di due parti vengono posizionate una accanto all'altra, possono creare una giunta tra loro.

La proprietà BottomSurface determina il tipo di superficie utilizzata per la direzione negativa Y di una parte.Quando le facce di due parti vengono posizionate una accanto all'altra, possono creare una giunta tra loro.

Questa proprietà determina il colore di una parte.Se la parte ha un Material, questo determina anche il colore utilizzato quando si rende la Strutturadel materiale.Per un maggiore controllo sul colore, la proprietà Color può essere utilizzata e questa proprietà utilizzerà il più vicino BrickColor .

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

La proprietà CFrame determina sia la posizione che l'orientamento del BasePart nel Mondo.Agisce come una posizione di riferimento arbitraria sulla geometria, ma ExtentsCFrame rappresenta l'effettiva CFrame del suo centro fisico.

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

A differenza della regolazione BasePart.Position , la regolazione CFrame sposterà sempre la parte all'esatta posizione data CFrame ; in altre parole: nessun controllo di sovrapposizione verrà eseguito e il solvente fisico cercherà di risolvere qualsiasi sovrapposizione a meno che entrambe le parti non siano Anchored .

Per tenere traccia delle posizioni relative a una parte di CFrame, un Attachment può 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 interagirà fisicamente con altre parti.Quando è disabilitato, altre parti possono passare attraverso la parte senza interruzioni.Le parti utilizzate per decorazione di solito hanno CanCollide disabilitato, poiché non devono essere considerate dall'engine di fisica.

Se una parte non è Anchored e ha CanCollide disabilitato, può cadere dal mondo per essere eventualmente distrutta da Workspace.FallenPartsDestroyHeight .

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

Per maggiori informazioni sulle collisioni, vedi 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()

Questa proprietà determina se la parte viene considerata durante le operazioni di query spaziali, come GetPartBoundsInBox o Raycast .Nota che CanCollide deve essere disabilitato perché CanQuery abbia effetto, e le funzioni di query spaziali non includeranno mai parti con CanQuery di false.

Al di là di questa Proprietà, è inoltre possibile escludere parti che sono discendenti di una lista data di parti utilizzando un oggetto OverlapParams o RaycastParams quando si chiamano le funzioni di query spaziali.

Questa proprietà determina se Touched e TouchEnded eventi si attivino sulla parte.Se true , altre parti sensibili devono anche avere CanTouch impostato su true per l'attivazione degli eventi di Lanciare.Se false , gli eventi di tocco non possono essere configurati per la parte e tentare di farlo lancerà un errore.Allo stesso modo, se la proprietà è impostata su false dopo che viene collegato un evento di tocco, l'evento verrà disconnesso e il TouchTransmitter verrà rimosso.

Nota che questa logica di collisione può essere impostata per rispettare gruppi di collisione attraverso la ProprietàWorkspace.TouchesUseCollisionGroups.Se true , le parti nei gruppi non sovrapposti ignoreranno sia gli eventi di collisione e , rendendo questa proprietà irrilevante.

Prestazioni

C'è un piccolo guadagno di prestazioni sulle parti che hanno sia CanTouch che CanCollide impostate su false , poiché queste parti non avranno mai bisogno di calcolare alcun tipo di collisione tra parti.Tuttavia, possono ancora essere colpiti da Raycasts e OverlapParams query.

Determina se una parte lancia o meno un'ombra.Disabilitare questa proprietà per una parte data può causare artefatti visivi sulle ombre lanciate su quella parte.

Questa proprietà non è progettata per l'ottimizzazione delle prestazioni, ma in scene complesse disabilitarla strategicamente su alcune parti può migliorare le Prestazione.A causa della possibilità di artefatti visivi, raccomandiamo di lasciarlo abilitato su tutte le parti nella maggior parte delle situazioni.

La proprietà CenterOfMass descrive la posizione locale del centro di massa di una parte.Se questa è un'assemblaggio di una sola parte, questa è la AssemblyCenterOfMass convertita dallo spazio mondiale a locale.Su semplice Parts , il centro di massa è sempre (0, 0, 0) , ma può variare per WedgePart o MeshPart .

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

Sebbene questa proprietà stessa non sia replicata, il motore replica internamente il valore attraverso un'altra proprietà privata per risolvere i problemi di compatibilità retrospettiva.

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à Color determina il colore di una parte.Se la parte ha un Material, questo determina anche il colore utilizzato quando si rende la Strutturadel materiale.

Se questa proprietà è Impostare, BrickColor utilizzerà la corrispondenza più vicina a questo valore Color.

Altre proprietà visive di una parte sono determinate da Transparency e 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 attuali proprietà fisiche della parte.Puoi impostare valori personalizzati per le proprietà fisiche per parte, materiale personalizzato , e l'Soprascriveredel materiale.Il motore Roblox priorizza le definizioni più granulari quando determina le proprietà fisiche effettive di una parte.I valori nella seguente lista sono in ordine dal più alto al più basso priorità:

• Proprietà fisiche personalizzate della parte
• Proprietà fisiche personalizzate del materiale personalizzato della parte
• Proprietà fisiche personalizzate della sostituzione del materiale della parte
• Proprietà fisiche predefinite del materiale della parte

CustomPhysicalProperties ti consente di personalizzare vari aspetti fisici di una parte, come la sua densità, la friction e l'elasticità.

Se abilitata, questa proprietà ti consente di configurare queste proprietà fisiche.Se disabilitato, queste proprietà fisiche sono determinate dal Material della 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 true , e quando Workspace.FluidForces è abilitato, causa al motore fisico di calcolare le forze aerodinamiche su questo BasePart .

Il CFrame delle estensioni fisiche del BasePart, che rappresenta il suo centro fisico.

La dimensione fisica effettiva del BasePart come considerata dall'engine di fisica, ad esempio in rilevamento collisioni .

La proprietà FrontSurface determina il tipo di superficie utilizzata per la direzione negativa Z di una parte.Quando le facce di due parti vengono posizionate una accanto all'altra, possono creare una giunta tra loro.

La proprietà LeftSurface determina il tipo di superficie utilizzata per la direzione negativa X di una parte.Quando le facce di due parti vengono posizionate una accanto all'altra, possono creare una giunta tra loro.

La proprietà LocalTransparencyModifier è un moltiplicatore per Transparency che è visibile solo al client locale.Non si replica dal client al server e è utile per quando una parte non deve rendere per un client specifico, come quando il giocatore non vede le parti del corpo del suo personaggio quando si zoomizza in modalità prima persona.

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

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

<th><code>Modificatore di trasparenza locale</code></th>

    <th>Lato server</th>

    <th>Lato client</th>
  </tr>
</thead>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

La proprietà Locked determina se una parte (o un Model è contenuta) può essere selezionata in Studio facendo clic su di essa.Questa proprietà è più spesso abilitata su 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à read-only che descrive il prodotto del volume e della densità di una parte. Viene restituita dalla funzione GetMass().

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

Se questa proprietà è abilitata, la parte non contribuirà alla massa totale o all'inerzia della sua assemblaggio finché è saldata ad un'altra parte che ha massa.

Se la parte è la sua parte radice secondo AssemblyRootPart, questa verrà ignorata per quella parte e continuerà a contribuire alla sua assemblaggio massa e inerzia come una normale parte.Le parti che non hanno massa non dovrebbero mai diventare una parte radice di assemblaggio a meno che tutte le altre parti nell'assemblaggio non siano anche prive di massa.

Questo potrebbe essere utile per cose come accessori opzionali su veicoli che non vuoi influenzare la manovrabilità dell'auto o una mesh di rendering senza massa saldata a una Mesh, magliadi collisione più semplice.

Vedi anche Assemblaggi, un articolo che documenta quali parti di radice sono e come utilizzarle.

La proprietà Material consente di impostare la texture e le proprietà fisiche predefinite di una parte (nel caso che CustomPhysicalProperties non sia disattivata).Il materiale predefinito Plastic ha una Strutturamolto leggera, mentre il materiale SmoothPlastic non ha texture tutti/tutte.Alcune texture materiali come DiamondPlate e Granite hanno texture molto visibili.La texture di ciascun materiale riflette diversamente la luce solare, in particolare Foil .

Impostare questa proprietà e abilitare CustomPhysicalProperties utilizzerà 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 fluttuerà in acqua del terreno.

I cambiamenti del materiale Glass rendono il comportamento del rendering delle grafiche moderate modificando un po' di riflettanza (simile a Reflectance ) e distorsione della prospettiva.L'effetto è particolarmente pronunciato su parti a forma di sfera.Le parti semi-trasparenti dietro Glass parti non sono visibili.

Il sistema cerca l'istanza MaterialVariant con il nome e il tipo MaterialVariant specificati e Material inserisci / scrivi.Se trova con successo un'esempiocorrispondente MaterialVariant , utilizza quella istanza per sostituire il materiale predefinito.Il materiale predefinito può essere il materiale integrato o un override MaterialVariant specificato in MaterialService .

La proprietà Orientation descrive la rotazione della parte in gradi attorno al X , Y e Z assi usando un Vector3 .Le rotazioni vengono applicate in Y ⟩ X ⟩ Z ordine.Questo differisce dagli angoli corretti di Euler e invece è Tait-Bryan angoli che descrivono yaw , pitch e roll .

Vale anche la pena notare come questa proprietà differisca dal costruttore CFrame.Angles() che applica le rotazioni in un ordine diverso ( Z > Y > X ).Per un migliore controllo sulla rotazione di una parte, è consigliato impostare CFrame invece.

Quando si imposta questa Proprietà, qualsiasi Welds o Motor6Ds connesso a questa parte avrà la proprietà corrispondente C0 o C1 aggiornata per consentire alla parte di muoversi rispetto a qualsiasi altra parte a cui è connessa.WeldConstraints sarà anche temporaneamente disabilitato e riattivato durante la 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 lo spostamento del punto di rotazione della parte dal suo CFrame, che è BasePart:GetPivot() uguale a BasePart.CFrame moltiplicato da BasePart.PivotOffset .

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

local Workspace = game:GetService("Workspace")

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

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

resetPivot(script.Parent)

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

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

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

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

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

La proprietà Position descrive le coordinate di una parte utilizzando un Vector3 .Riflette la posizione della parte di CFrame , tuttavia può essere anche Impostare.

Quando si imposta questa Proprietà, qualsiasi Welds o Motor6Ds connesso a questa parte avrà la proprietà corrispondente C0 o C1 aggiornata per consentire alla parte di muoversi rispetto a qualsiasi altra parte a cui è connessa.WeldConstraints sarà anche temporaneamente disabilitato e riattivato durante la Sposta.

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

La proprietà Reflectance determina quanto una parte rifletta il cielo.Un valore di 0 indica che la parte non è riflettente tutti/tutte, e un valore di 1 indica che la parte dovrebbe riflettere completamente.

La riflettanza non è influenzata da Transparency a meno che la parte sia completamente trasparente, in tal caso la riflettanza non si renderà affatto.La riflettanza può o non può essere ignorata a seconda della Material della parte.

La proprietà ResizeIncrement è una proprietà read-only che descrive il più piccolo cambiamento di dimensione consentito dal metodo Resize().Si differenzia tra le implementazioni della classe astratta BasePart ; ad esempio, Part ha questo set a 1 mentre TrussPart ha questo set a 2 poiché le sezioni di truss individuali sono 2×2×2 in dimensioni.

La proprietà ResizeableFaces utilizza un oggetto Faces per descrivere i diversi volti su cui una parte può essere ridimensionata.Per la maggior parte delle implementazioni di BasePart , come Part e WedgePart , questa proprietà include tutti i volti.Tuttavia, imposterà il suo set a solo due facce poiché quei tipi di parti devono avere due dimensioni di lunghezza .

Questa proprietà è più comunemente utilizzata con strumenti per la costruzione e la manipolazione delle parti e ha poca utilità al di fuori di tale contesto.La classe può essere utilizzata in combinazione con questa Proprietàper visualizzare solo le maniglie su facce che possono essere ridimensionate su una parte.

-- 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 positiva X di una parte.Quando le facce di due parti vengono posizionate una accanto all'altra, possono creare una giunta tra loro.

Questa proprietà è un intero tra -127 e 127 che ha precedenza su tutte le altre regole per la classificazione della parte Ordinare.Quando si considerano più parti che non sono Anchored e che condividono lo stesso valore Massless , una parte con un valore più alto RootPriority prenderà la priorità su quelle con un valore più basso RootPriority .

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

Vedi anche Assemblaggi, un articolo che documenta quali parti di radice sono e come utilizzarle.

La rotazione della parte in gradi per i tre assi.

Quando si imposta questa Proprietà, qualsiasi Welds o Motor6Ds connesso a questa parte avrà la proprietà corrispondente C0 o C1 aggiornata per consentire alla parte di muoversi rispetto a qualsiasi altra parte a cui è connessa.WeldConstraints sarà anche temporaneamente disabilitato e riattivato durante la Sposta.

La proprietà di una parte Size determina le sue dimensioni visive , mentre ExtentsSize rappresenta la dimensione effettiva utilizzata dall'engine di fisica, come in rilevamento collisioni .Le dimensioni individuali (lunghezza, larghezza, altezza) possono essere così basse come 0.001 e così alte come 2048.Le dimensioni delle dimensioni inferiori a saranno rappresentate visivamente come se le dimensioni della parte fossero .

Una parte di Size è utilizzata in una varietà di modi aggiuntivi:

• Per influenzare la sua massa come data da GetMass() .
• By ParticleEmitter per determinare l'area da cui vengono generati le particelle.
• By BlockMesh per determinare parzialmente il prisma rettangolare renduto.
• By SpecialMesh per determinare la dimensione della Mesh, magliarenderta per alcuni MeshTypes .
• By 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 positiva Y di una parte.Quando le facce di due parti vengono posizionate una accanto all'altra, possono creare una giunta tra loro.

La proprietà Transparency controlla la visibilità di una parte su una scala di 0 a 1 dove 0 è completamente visibile (opaca) e 1 è completamente invisibile (non viene rappresentata tutti/tutte).

Mentre le parti completamente trasparenti non vengono tutti/tutterenderizzate, gli oggetti parzialmente trasparenti hanno alcuni costi di rendering importanti.Avere molte parti trasparenti può influire sulle Prestazione.

Quando le parti trasparenti si sovrappongono, l'ordine di rendering può agire in modo imprevedibile, quindi dovresti evitare le parti semi-trasparenti dall'incrociarsi.

Vedi anche LocalTransparencyModifier come moltiplicatore a Transparency 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()

Parametri

Restituzioni

Applica un impulso di forza angolare istantanea all'assemblaggio di questa parte, causando l'assemblaggio a ruotare.

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

Se la parte è di proprietà del Server, questa funzione deve essere chiamata da un server Script (non da un LocalScript o da un Script con RunContext impostato su Enum.RunContext.Client ).Se la parte è di proprietà di un client attraverso proprietà automatica , questa funzione può essere chiamata da uno script client o da uno script del server; chiamarla da uno script client per una parte di proprietà del server non avrà alcun effetto.

Parametri

Restituzioni

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

La forza viene applicata all'assemblaggio di center of mass, quindi il movimento risultante sarà solo lineare.

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

Se la parte è di proprietà del Server, questa funzione deve essere chiamata da un server Script (non da un LocalScript o da un Script con RunContext impostato su Enum.RunContext.Client ).Se la parte è di proprietà di un client attraverso proprietà automatica , questa funzione può essere chiamata da uno script client o da uno script del server; chiamarla da uno script client per una parte di proprietà del server non avrà alcun effetto.

Parametri

Restituzioni

Questa funzione applica un impulso di forza istantanea all'assemblaggio di questa parte, alla posizione specificata nello Spaziomondiale.

Se la posizione non è alla assemblaggio di center of mass, l'impulso causerà un movimento posizionale e rotatorio.

La velocità risultante dall'impulso si basa sull'assemblaggio di mass .Quindi è richiesto un impulso più elevato per spostare assemblaggi più massicci.Gli impulsi sono utili nei 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 un server Script (non da un LocalScript o da un Script con RunContext impostato su Enum.RunContext.Client ).Se la parte è di proprietà di un client attraverso proprietà automatica , questa funzione può essere chiamata da uno script client o da uno script del server; chiamarla da uno script client per una parte di proprietà del server non avrà alcun effetto.

Parametri

Restituzioni

Restituisce se le parti possono o meno scontrarsi tra loro.Questa funzione tiene conto dei gruppi di collisione delle due parti.Questa funzione darà 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 restituzione della funzione verifica se puoi chiamare BasePart:SetNetworkOwner() o BasePart:SetNetworkOwnershipAuto() senza incontrare un errore.Restituisce vero se puoi modificare/leggere la proprietà della rete, o restituisce false e il motivo per cui non puoi, come 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 rigorosamente connesse alla BasePart.

Articolazioni rigide

Quando una giunta connette due parti insieme (Part0 → Part1) , una giunta è rigida se la fisica di Part1 è completamente bloccata da Part0 .Questo si applica solo ai seguenti tipi congiunti:

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

Parametri

Restituzioni

Restituisci tutti i Giunti o Confinamenti che sono connessi a questa Parte.

Restituzioni

GetMass restituisce il valore della proprietà read-only Mass.

Questa funzione precede la ProprietàMass. Rimane supportata per la compatibilità retrospettiva; 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 attuale che è il proprietario di rete di questa parte, o nil in caso del Server.

Restituzioni

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

Restituzioni

Restituzioni

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

Questa funzione precede la ProprietàAssemblyRootPart . Rimane supportata per la compatibilità retrospettiva, ma dovresti 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 che la parte abbia un oggetto TouchInterest ad essa parentedato (ovvero qualcosa è connesso al suo evento Touched).Le parti adiacenti ma non intersecanti non sono considerate toccanti.Questa funzione precede la funzione WorldRoot:GetPartsInPart() che fornisce maggiore flessibilità e evita le regole speciali TouchInterest descritte sopra.Usa WorldRoot:GetPartsInPart() invece.

Restituzioni

Restituisce la velocità lineare dell'assemblaggio della parte alla posizione data rispetto a questa parte.Può essere utilizzato per identificare la velocità lineare delle parti in un'assemblaggio diverso dalla parte radice.Se l'assemblaggio non ha velocità angolare, allora la velocità lineare sarà sempre la stessa per ogni posizione.

Parametri

Restituzioni

Restituisce vero se l'oggetto è connesso a una parte che lo terrà in posizione (ad esempio una parte Anchored), altrimenti restituisce falso.In un'assemblaggio che ha una parte Anchored , ogni altra parte è a terra.

Restituzioni

Cambia le dimensioni di un oggetto proprio come l'utilizzo dello strumento ridimensionamento di Studio.

Parametri

Restituzioni

Imposta il giocatore dato come proprietario della rete per questo e tutte le parti connesse.Quando playerInstance è nil, il server sarà il proprietario invece di un Giocatore.

Parametri

Restituzioni

Consente al motore di gioco di decidere dinamicamente chi gestirà la fisica della parte (uno dei client o del Server).

Restituzioni

Parametri

Restituzioni

Crea una nuova IntersectOperation dalla geometria intersecante della parte e delle altre parti nell'vettorefornito.Sono supportati solo Parts , non Terrain o MeshParts .Simile a Clone() , l'oggetto restituito non ha alcun set Parent .

Le seguenti proprietà dalla parte chiamante vengono applicate al risultato IntersectOperation :

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

Nella seguente comparazione delle immagini, IntersectAsync() è chiamato sul blocco viola utilizzando un tavolo che contiene il blocco blu.Il risultante IntersectOperation si risolve in una forma della geometria intersecante di entrambe le parti.

<figcaption>Parti separate</figcaption>

<figcaption>Risultante <code>Class.IntersectOperation</code> ></figcaption>

Notizie

• Le parti originali rimangono intatte dopo un'operazione di intersezione riuscita.Nella maggior parte dei casi, dovresti Destroy() tutte le parti originali e dare in prestito il ritorno IntersectOperation allo stesso posto della chiamata BasePart .
• Per impostazione predefinita, i colori del viso dell'intersezione risultante sono presi in prestito dalla proprietà Color delle parti originali.Per cambiare l'intera intersezione a un colore specifico, imposta la sua proprietà UsePartColor a true.
• Se un'operazione di intersezione risulterebbe in una parte con più di 20.000 triangoli, verrà semplificata a 20.000 triangoli.

Parametri

Restituzioni

Crea una nuova UnionOperation dalla parte, meno la geometria occupata dalle parti nell'vettorefornito.Sono supportati solo Parts , non Terrain o MeshParts .Simile a Clone() , l'oggetto restituito non ha alcun set Parent .

Si noti che l'unione risultante non può essere vuota a causa delle sottrazioni. Se l'operazione dovesse risultare in una geometria completamente vuota, fallirà.

Nella seguente comparazione delle immagini, SubtractAsync() è chiamato sul cilindro blu utilizzando una tabella che contiene il blocco violaIl risultante UnionOperation si risolve in una forma che omite la geometria del blocco da quella del cilindro.

<figcaption>Parti separate</figcaption>

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

Parametri

Restituzioni

local Workspace = game:GetService("Workspace")

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

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

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

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

Crea una nuova UnionOperation dalla parte, più la geometria occupata dalle parti nell'vettorefornito.Sono supportati solo Parts , non Terrain o MeshParts .Simile a Clone() , l'oggetto restituito non ha alcun set Parent .

Le seguenti proprietà dalla parte chiamante vengono applicate al risultato UnionOperation :

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

Nella seguente comparazione delle immagini, UnionAsync() è chiamato sul blocco blu utilizzando una tabella che contiene il cilindro viola.Il risultante UnionOperation si risolve in una forma della geometria combinata di entrambe le parti.

<figcaption>Parti separate</figcaption>

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

Notizie

• Le parti originali rimangono intatte dopo un'operazione di unione riuscita.Nella maggior parte dei casi, dovresti Destroy() tutte le parti originali e dare in prestito il ritorno UnionOperation allo stesso posto della chiamata BasePart .
• Per impostazione predefinita, l'unione risultante rispetta la proprietà Color di ciascuna delle sue parti.Per cambiare l'intera unione a un colore specifico, imposta la sua proprietà UsePartColor a true.
• Se un'operazione di unione darà come risultato una parte con più di 20.000 triangoli, verrà semplificata a 20.000 triangoli.

Parametri

Restituzioni

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

Si accende quando una parte smette di toccare un'altra parte in condizioni simili a quelle di BasePart.Touched .

Questo evento funziona in combinazione con Workspace.TouchesUseCollisionGroups per specificare se i gruppi di collisione sono riconosciuti per la rilevazione.

Parametri

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)

L'evento Toccato si attiva quando una parte entra in contatto con un'altra parte.Ad esempio, se PartA sbatte su PartB , allora PartA.Touched brucia con PartB e PartB.Touched brucia con PartA .

Questo evento si attiva solo a causa di un movimento fisico, quindi non si attiverà se la proprietà CFrame è stata modificata in modo che la parte si sovrapponga ad un'altra parte.Questo significa anche che almeno una delle parti coinvolte non deve non essere Anchored al momento della collisione.

Questo evento funziona in combinazione con Workspace.TouchesUseCollisionGroups per specificare se i gruppi di collisione sono riconosciuti per la rilevazione.

Parametri

local part = script.Parent

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

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

local numTouchingParts = 0

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

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

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

local model = script.Parent

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

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

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