L'oggetto Platform crea un mattone che, quando toccato da un `Class.Player`, ancorerà il loro torso al mattone. Questo consente la creazione di veicoli in cui i giocatori possono stare in piedi senza essere sbalzati dentro la cabina/ponte del veicolo.

La Platform è quasi identica all'oggetto `Class.Seat`, tranne per il fatto che invece di sedersi, il giocatore rimarrà in piedi mentre è bloccato in posizione. Buono per le navi.

L'oggetto Platform è molto utile per far rimanere i caratteri delle persone in
un posto mentre si muovono, come su una nave o un camion. Quando un giocatore
tocca la Platform, viene creata una costrizione `Class.Weld`, in modo da essere
'attaccati' alla Platform e non possono muoversi finché quella saldatura non viene interrotta. Può essere
erosso premendo la barra spaziatrice, quando il giocatore salta per uscire dalla Platform.


Platform

Storicamente una forma di `Class.Seat` che non posizionava il giocatore in una
posa seduta. Questo oggetto non è più creabile e non può essere utilizzato da
sviluppatori.


Lo script qui sotto genera una nuova istanza di `Part` e imposta diverse delle proprietà della parte.

In particolare, lo script imposta la proprietà `Class.Part.Shape` a
`Enum.PartType.Ball`. Nomina anche la parte _JurassicPart_, la ancorala, la rende
un figlio di _Workspace_ e imposta il suo colore su bianco.

L'oggetto Part è un tipo di `Class.BasePart`. Si presenta in cinque diverse
forme primitive: Palla, Blocco, Cilindro, Wedge e CornerWedge.


Part

La proprietà Shape imposta la forma generale dell'oggetto su una delle
forme predefinite della lista di forme incorporate.

L'enum `Enum.PartType` controlla il valore della forma e ha cinque possibili
forme:

| Forma/Valore | Descrizione                             |
| ------------ | --------------------------------------- |
| Palla       | Una forma sferica.                     |
| Blocco      | Una forma a blocco.                    |
| Cilindro    | Una forma cilindrica.                  |
| Wedge       | Una forma a cuneo con una pendenza su un lato. |
| CornerWedge | Una forma a cuneo con pendenze su due lati. |

`Class.MeshPart` e [modellazione solida](/parts/solid-modeling)
possono essere utilizzati per ottenere forme di parti completamente personalizzate.

Le collisioni tra palle, blocchi e cunei, e corner wedges sono esatte,
mentre le collisioni tra terreno, cilindri, TriangleMeshes e altri
tipi di geometria sono approssimative. Questo significa che la forma della palla può essere
utile per creare collider stabili per le ruote delle auto.


Part.Shape

Un tipo comune di `Class.BasePart` che si presenta in diverse forme primitive.


La classe FormFactorPart è una classe astratta. Eredita dalla
`Class.BasePart` e aggiunge la proprietà `Class.FormFactorPart.FormFactor`
alle classi che ne ereditano.

FormFactorPart

Questo serviva a specificare un vincolo di griglia della dimensione del pezzo. Non fa più
nulla.

FormFactorPart.FormFactor

Determina come si comporta un pezzo quando viene ridimensionato e i valori che la sua dimensione
può assumere.

FormFactorPart.formFactor

La classe FormFactorPart è una classe astratta. Eredita dalla classe BasePart
ed aggiunge la proprietà FormFactor alle classi che ne ereditano.

Crea una parte blu e una parte rossa di destinazione. La parte blu cercherà di
raggiungere suavemente la parte rossa di destinazione. Muovi e ruota la destinazione per vedere il comportamento.
Cambiare smoothTime risulterà in una diversa velocità di levigatura.


`Class.BasePart` è una classe base astratta per oggetti nel mondo che vengono renderizzati
 e sono fisicamente simulati mentre si trovano in `Class.Workspace`. Ci sono diverse
 implementazioni di `Class.BasePart`, le più comuni sono `Class.Part` e
 `Class.MeshPart`. Altre includono `Class.WedgePart`, `Class.SpawnLocation`, e
 l'oggetto singleton `Class.Terrain`. In generale, quando la documentazione si riferisce a
 un "part", la maggior parte delle implementazioni di `Class.BasePart` funzioneranno e non
 solo `Class.Part`.

Per informazioni su come i `Class.BasePart|BaseParts` sono raggruppati in corpi rigidi
 simulati, vedere [Assemblies](/physics/assemblies).

Ci sono molti oggetti diversi che interagiscono con `Class.BasePart` (al di fuori di
 `Class.Terrain`), inclusi:

- Diversi `Class.BasePart|BaseParts` possono essere raggruppati all'interno di un `Class.Model`
e spostati nello stesso tempo usando `Class.PVInstance:PivotTo()`. Vedi
  [Models](/parts/models).
- Un `Class.Decal` applica una texture immagine allungata sulle facce di un
  `Class.BasePart`, mentre un `Class.Texture` applica una texture immagine a piastrelle sulle
  facce. Vedi [Textures and Decals](/parts/textures-decals).
- Un `Class.SurfaceGui` rende `Class.GuiObject|GuiObjects` sulla faccia di un
  part. Vedi
  [In-Experience UI Containers](/ui/in-experience-containers).
- `Class.Attachment|Attachments` possono essere aggiunti a un `Class.BasePart` per specificare
  `Datatype.CFrame|CFrames` relativi al part. Questi sono spesso utilizzati da
  oggetti fisici `Class.Constraint` come delineato in
  [Mechanical Constraints](/physics/mechanical-constraints) e
  [Mover Constraints](/physics/mover-constraints).
- Gli oggetti `Class.ParticleEmitter` emettono particelle uniformemente nel volume del
  `Class.BasePart` a cui sono genitori. Vedi
  [Particle Emitters](/effects/particle-emitters).
- Gli oggetti luce come `Class.PointLight` emettono luce dal centro di un
  `Class.BasePart` come illustrato in
  [Light Sources](/effects/light-sources).
- Se genitore di un `Class.Tool` e dato il nome **Handle**, un
  `Class.BasePart` può essere tenuto dai personaggi. Vedi
  [In-Experience Tools](/players/tools).

Attivato quando un'altra parte entra in contatto con un altro oggetto. Questo evento
invio solo dati al client notificandolo che due parti sono collise,
mentre `Class.BasePart.Touched` invia dati al server.

BasePart.LocalSimulationTouched

part

Attivato se l'aspetto della parte è influenzato dalla classe `Class.Shirt`.

BasePart.OutfitChanged

BasePart.StoppedTouching

otherPart

Questo esempio di codice crea un BillboardGui su una parte che mostra il numero di
parti attualmente in contatto con essa.


Questo esempio di codice dimostra come collegare l'evento `Class.BasePart.Touched`
di più parti in un `Class.Model` a una sola funzione.


L'evento **Touched** si attiva quando una parte entra in contatto con un'altra
parte. Ad esempio, se **PartA** urta **PartB**, allora
`Class.BasePart.Touched|PartA.Touched` si attiva con **PartB**, e
`Class.BasePart.Touched|PartB.Touched` si attiva con **PartA**.

Questo evento si attiva solo a seguito di movimenti fisici, quindi non si attiverà
se la proprietà `Class.BasePart.CFrame|CFrame` è stata cambiata in modo tale
che la parte sovrappone un'altra parte. Ciò significa anche che almeno una delle
parti coinvolte non deve essere `Class.BasePart.Anchored|Anchored` al momento
  della collisione.

Questo evento funziona insieme a
`Class.Workspace.TouchesUseCollisionGroups` per specificare se
[gruppi di collisione](/workspace/collisions#collision-filtering)
  sono riconosciuti per la detection.

BasePart.Touched

L'altra parte che è entrata in contatto con la parte fornita.

Si attiva quando una parte tocca un'altra parte come risultato di un movimento fisico.

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

Questo evento funziona insieme a
`Class.Workspace.TouchesUseCollisionGroups` per specificare se
[gruppi di collisione](/workspace/collisions#collision-filtering)
  sono riconosciuti per la detection.

BasePart.TouchEnded

Si attiva quando una parte smette di toccare un'altra parte come risultato di un movimento fisico.

Restituisce il vettore di coppia nello spazio globale che deve essere applicato all'assemblaggio
per ottenere l'accelerazione angolare specificata. Questo risultato può essere
utilizzato per determinare la coppia che dovrebbe essere applicata tramite un'istanza `Class.Torque`
oppure `Class.BasePart:ApplyAngularImpulse()`.

Il calcolo utilizza l'equazione di rotazione di Euler dove _I_ è il tensore di inerzia
nello spazio globale dell'assemblaggio, _α_ è l'accelerazione angolare desiderata e
_ω_ è la velocità angolare.

_τ = I · α + ω × (I · ω)_

Se l'oggetto non è un discendente di `Class.Workspace`, questo metodo restituisce
un vettore di infinito. Se l'assemblaggio è ancorato, restituisce anch'esso un vettore di
infinito.

#### Effetti giroscopici

Quando un assemblaggio in rotazione ha un tensore di inerzia asimmetrico, la coppia
necessaria per raggiungere un'accelerazione angolare specificata è aumentata a causa
della variazione di orientamento del corpo. Il parametro facoltativo `angVelocity`
considera questi effetti giroscopici. Se omesso, tali effetti giroscopici vengono
omessi dal calcolo.

```lua
local part = workspace.Part
local angularVelocity = part.AssemblyAngularVelocity
local desiredAcceleration = Vector3.new(0, 10, 0)

-- Calcola la coppia necessaria per ottenere l'accelerazione desiderata
local torque = part:AngularAccelerationToTorque(desiredAcceleration, angularVelocity)
```

BasePart:AngularAccelerationToTorque

angAcceleration

Il vettore di accelerazione angolare desiderato nello spazio globale.

angVelocity

La velocità angolare attuale dell'assemblaggio nello spazio globale. Per impostazione
predefinita è `(0, 0, 0)`. Fornire la velocità angolare dell'assemblaggio per tenere
conto degli effetti giroscopici.

Un `Datatype.Vector3` che rappresenta la coppia richiesta nello spazio globale per
produrre l'accelerazione angolare specificata.

Restituisce la coppia necessaria per raggiungere una data accelerazione angolare su questa
assemblaggio dell'oggetto, tenendo conto facoltativamente degli effetti giroscopici.

Applica un impulso di forza angolare istantanea all'assemblaggio di questo oggetto,
facendo girare l'assemblaggio.

La velocità angolare risultante dall'impulso dipende dalla `Class.BasePart.AssemblyMass|massa` dell'assemblaggio.
Quindi, è richiesto un impulso maggiore per muovere assemblaggi più pesanti. Gli impulsi sono utili nei casi in cui desideri che una forza sia applicata
istantaneamente, come un'esplosione o una collisione.

Se l'oggetto è [possesso](/physics/network-ownership) dal
server, questa funzione deve essere chiamata da un `Class.Script` del server (non
 da un `Class.LocalScript` o da un `Class.Script` con
`Class.BaseScript.RunContext|RunContext` impostato su `Enum.RunContext.Client`).
 Se l'oggetto è posseduto da un client tramite il possesso **automatico**, questa
funzione può essere chiamata sia da uno script client **che** da uno script server;
chiamarla da uno script client per un oggetto di proprietà del server non avrà effetto.

BasePart:ApplyAngularImpulse

impulse

Un vettore di impulso angolare da applicare all'assemblaggio.

Applica un impulso angolare all'assemblaggio.

Questa funzione applica un impulso di forza istantanea all'assemblaggio di questo oggetto.

La forza è applicata al `Class.BasePart.AssemblyCenterOfMass|centro di massa` dell'assemblaggio,
quindi il movimento risultante sarà solo lineare.

La velocità risultante dall'impulso dipende dalla `Class.BasePart.AssemblyMass|massa`
dell'assemblaggio. Quindi, è richiesto un impulso maggiore per muovere assemblaggi più pesanti.
Gli impulsi sono utili nei casi in cui desideri che una forza sia applicata istantaneamente,
come un'esplosione o una collisione.

Se l'oggetto è [possesso](/physics/network-ownership) dal
server, questa funzione deve essere chiamata da un `Class.Script` del server (non
 da un `Class.LocalScript` o da un `Class.Script` con
`Class.BaseScript.RunContext|RunContext` impostato su `Enum.RunContext.Client`).
 Se l'oggetto è posseduto da un client tramite il possesso **automatico**, questa
funzione può essere chiamata sia da uno script client **che** da uno script server;
chiamarla da uno script client per un oggetto di proprietà del server non avrà effetto.

BasePart:ApplyImpulse

Un vettore di impulso lineare da applicare all'assemblaggio.

Applica un impulso all'assemblaggio nel `Class.BasePart.AssemblyCenterOfMass|centro di massa` dell'assemblaggio.

Questa funzione applica un impulso di forza istantanea all'assemblaggio di questo oggetto, in
una posizione specificata nello spazio globale.

Se la posizione non si trova al `Class.BasePart.AssemblyCenterOfMass|centro di massa`
dell'assemblaggio, l'impulso causerà un movimento posizionale e rotazionale.

La velocità risultante dall'impulso dipende dalla `Class.BasePart.AssemblyMass|massa`
dell'assemblaggio. Quindi, è richiesto un impulso maggiore per muovere assemblaggi più pesanti.
Gli impulsi sono utili nei casi in cui gli sviluppatori vogliono che una forza sia applicata
istantaneamente, come un'esplosione o una collisione.

Se l'oggetto è [possesso](/physics/network-ownership) dal
server, questa funzione deve essere chiamata da un `Class.Script` del server (non
 da un `Class.LocalScript` o da un `Class.Script` con
`Class.BaseScript.RunContext|RunContext` impostato su `Enum.RunContext.Client`).
 Se l'oggetto è posseduto da un client tramite il possesso **automatico**, questa
funzione può essere chiamata sia da uno script client **che** da uno script server;
chiamarla da uno script client per un oggetto di proprietà del server non avrà effetto.

BasePart:ApplyImpulseAtPosition

Un vettore di impulso da applicare all'assemblaggio.

position

La posizione, nello spazio globale, in cui applicare l'impulso.

Applica un impulso all'assemblaggio in una posizione specificata.

Rompe qualsiasi connessione superficiale con qualsiasi parte adiacente, compresi
`Class.Weld` e altri `Class.JointInstance`.

BasePart:BreakJoints

BasePart:breakJoints

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

BasePart:CanCollideWith

La parte specificata da controllare per la collisibilità.

Restituisce se le parti possono collidere tra loro.

Questo esempio verifica se la proprietà di rete del primo
`BasePart` chiamato _Part_ nel `Workspace` può essere impostata.


La funzione CanSetNetworkOwnership controlla se è possibile impostare il possesso di rete di un oggetto.

Il valore restituito dalla funzione verifica se è possibile chiamare
`Class.BasePart:SetNetworkOwner()` o
`Class.BasePart:SetNetworkOwnershipAuto()` senza riscontrare un errore.
Restituisce true se puoi modificare/leggere il possesso di rete, oppure restituisce
false e il motivo per cui non puoi, come stringa.

BasePart:CanSetNetworkOwnership

Se puoi modificare o leggere il possesso di rete e il motivo.

Controlla se è possibile impostare il possesso di rete di un oggetto.

Restituisce il punto più vicino sulla superficie dell'oggetto alla data posizione
nello spazio globale. Se la posizione fornita è all'interno dell'oggetto, viene restituita
così com'è.

Per le istanze `Class.MeshPart` e `Class.PartOperation`, questo metodo
rispetta il valore `Enum.CollisionFidelity` dell'oggetto. I valori di ritorno possono
variare a seconda di se la mesh viene trattata come una scatola, un involucro o una
forma più complessa.

BasePart:GetClosestPointOnSurface

Il punto nello spazio globale per cui trovare il punto più vicino sulla superficie.

Il punto più vicino sulla superficie dell'oggetto nello spazio globale.

Restituisce il punto più vicino sulla superficie dell'oggetto al punto fornito.

Restituisce una tabella di oggetti connessi all'oggetto da qualsiasi tipo di giunto rigido.

Se `recursive` è true questa funzione restituirà tutti gli oggetti nell'assemblaggio connessi rigidamente al BasePart.

#### Giunti rigidi

Quando un giunto collega due oggetti `(Part0 → Part1)`, un giunto è
**rigido** se la fisica di `Part1` è completamente bloccata da `Part0`.
Questo si applica solo ai seguenti tipi di giunto:

- `Class.Weld`
- `Class.Snap`
- `Class.ManualWeld`
- `Class.Motor`
- `Class.Motor6D`
- `Class.WeldConstraint`

BasePart:GetConnectedParts

recursive

Una tabella di oggetti connessi all'oggetto da qualsiasi tipo di
`Class.JointInstance|giunto`.

Restituisce una tabella di oggetti connessi all'oggetto da qualsiasi tipo di giunto rigido.

Restituisce tutti i giunti o vincoli connessi a questa parte.

BasePart:GetJoints

Un array di tutti i giunti o vincoli connessi alla parte.

Questo esempio crea un nuovo oggetto, myPart, nello Workspace del gioco, con
dimensioni 4x6x4 studs. L'oggetto è anche ancorato.

Quindi, myMass viene impostato per essere uguale alla massa del nuovo oggetto. La massa dell'oggetto è
stampata alla fine dell'istruzione di stampa:

> La massa del mio oggetto è ...

**GetMass** restituisce il valore della proprietà di sola lettura `Class.BasePart.Mass|Mass`.

Questa funzione precede la proprietà Mass. Rimane supportata per
compatibilità retroattiva; dovresti usare la proprietà Mass direttamente.

BasePart:GetMass

Restituisce il valore della proprietà `Class.BasePart.Mass|Mass`.

BasePart:getMass

Restituisce il giocatore attuale che è il proprietario di rete di questo oggetto, o `nil`
in caso di server.

BasePart:GetNetworkOwner

Il giocatore attuale che è il proprietario di rete di questo oggetto, o `nil` in
caso di server.

Restituisce true se il motore di gioco decide automaticamente il proprietario di rete
per questo oggetto.

BasePart:GetNetworkOwnershipAuto

Se il motore di gioco decide automaticamente il proprietario di rete per
questo oggetto.

BasePart:GetNoCollisionConstraints

Questa funzione era rilevante quando l'interpolazione per compensare il lag di Roblox
era interna. L'interpolazione ora viene applicata direttamente al `Datatype.CFrame`.

BasePart:GetRenderCFrame

OBSOLETO. Restituisce un CFrame che descrive dove l'oggetto viene renderizzato.

Restituisce la parte base di un assemblaggio. Quando si sposta un assemblaggio di parti
utilizzando un `Datatype.CFrame`, è importante spostare questa parte base (questo
muoverà tutte le altre parti collegate di conseguenza). Maggiori informazioni
sono disponibili nell'articolo [Assemblaggi](/physics/assemblies).

Questa funzione precede la proprietà
`Class.BasePart.AssemblyRootPart|AssemblyRootPart`. Rimane
supportata per compatibilità retroattiva, ma dovresti usare
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` direttamente.

BasePart:GetRootPart

La parte base di un assemblaggio (una raccolta di parti collegate
insieme).

Restituisce la parte base di un assemblaggio di parti.

Restituisce una tabella di tutti gli oggetti che interagiscono fisicamente con questo
oggetto. Se l'oggetto stesso ha CanCollide impostato su false, questa funzione
restituisce una tabella vuota a meno che l'oggetto non abbia un
`Class.TouchTransmitter|TouchInterest` oggetto parentato ad esso (il che significa
che qualcosa è connesso al suo evento Touched). Gli oggetti che sono adiacenti ma
non intersecanti non sono considerati toccanti. Questa funzione precede il
funzione `Class.WorldRoot:GetPartsInPart()`, che offre maggiore
flessibilità e evita le speciali regole di `Class.TouchTransmitter|TouchInterest`
descritte sopra. Usa `Class.WorldRoot:GetPartsInPart()` invece.

BasePart:GetTouchingParts

Una tabella di tutti gli oggetti che intersecano e possono collidere con questo oggetto.

Restituisce una tabella di tutti i `Class.BasePart.CanCollide` veri oggetti che
intersecano questo oggetto.

Restituisce la velocità lineare dell'assemblaggio dell'oggetto nella posizione fornita
rispetto a questo oggetto. Può essere utilizzato per identificare la velocità lineare di
oggetti in un assemblaggio diverso dalla parte principale. Se l'assemblaggio non ha
velocità angolare, allora la velocità lineare sarà sempre la stessa per
ogni posizione.

BasePart:GetVelocityAtPosition

Restituisce la velocità lineare dell'assemblaggio dell'oggetto nella posizione fornita
rispetto a questo oggetto.

Crea un nuovo `Class.IntersectOperation` dalla geometria intersecante della
parte e delle altre parti nell'array fornito. Solo le `Class.Part|Parts`
supportate, non `Class.Terrain` o `Class.MeshPart|MeshParts`. Simile a
`Class.Instance:Clone()|Clone()`, l'oggetto restituito non ha un set
`Class.Instance.Parent|Parent`.

Le seguenti proprietà dalla parte chiamante sono applicate all'operazione `Class.IntersectOperation`:

- `Class.BasePart.Color|Color`, `Class.BasePart.Material|Material`,
  `Class.BasePart.MaterialVariant|MaterialVariant`,
  `Class.BasePart.Reflectance|Reflectance`,
  `Class.BasePart.Transparency|Transparency`
- `Class.BasePart.CanCollide|CanCollide`
- `Class.BasePart.Anchored|Anchored`, `Class.BasePart.Density|Density`,
  `Class.BasePart.Elasticity|Elasticity`,
  `Class.BasePart.ElasticityWeight|ElasticityWeight`,
  `Class.BasePart.Friction|Friction`,
  `Class.BasePart.FrictionWeight|FrictionWeight`

Nell'immagine seguente,
`Class.BasePart:IntersectAsync()|IntersectAsync()` viene chiamato sul blocco viola
utilizzando una tabella che contiene il blocco blu. L'operazione `Class.IntersectOperation`
si risolve in una forma della geometria intersecante di entrambe le parti.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Intersect.jpg"
width="720" alt="Due blocchi sovrapposti" />
<figcaption>Parti separate</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Intersect-Result.jpg"
width="720" alt="Parti intersecate in un nuovo modello solido" />
<figcaption>Risultato <code>Class.IntersectOperation</code></figcaption>
</figure>

#### Note

- Le parti originali rimangono intatte dopo un'operazione di intersezione
  riuscita. Nella maggior parte dei casi, dovresti effettuare `Class.Instance.Destroy|Destroy()`
  su tutte le parti originali e parentare il `Class.IntersectOperation` restituito
  allo stesso posto dell'oggetto chiamante `Class.BasePart`.
- Per impostazione predefinita, i colori delle facce dell'intersezione risultante
  sono presi dalla proprietà `Class.BasePart.Color|Color` delle parti originali. Per
  cambiare l'intera intersezione in un colore specifico, imposta la sua
  proprietà `Class.PartOperation.UsePartColor|UsePartColor` a `true`.
- Se un'operazione di intersezione dovesse risultare in una parte con più di 20.000
  triangoli, sarà semplificata a 20.000 triangoli.

BasePart:IntersectAsync

parts

Gli oggetti che partecipano all'intersezione.

collisionfidelity

Il valore di `Enum.CollisionFidelity` per il
risultante `Class.IntersectOperation`.

renderFidelity

Il valore di `Enum.RenderFidelity` risultante
`Class.PartOperation`.

Risultato `Class.IntersectOperation` con nome predefinito **Intersect**.

Nota: è altamente raccomandato utilizzare la nuova
`Class.GeometryService:IntersectAsync` invece di questa funzione. Oltre ad avere
delle migliori performance e più funzionalità, la nuova funzione differisce come
segue:

- L'output è un array di istanze piuttosto che un'unica istanza.
- Le parti di input non devono essere parentate alla scena, consentendo operazioni
  in background.
- Quando l'opzione `SplitApart` è impostata su `true` (impostazione predefinita), ogni corpo distinto
  verrà restituito in un proprio `Class.PartOperation`.
- Tutte le parti restituite sono nello spazio delle coordinate della parte principale, quindi
  le loro posizioni `Class.PVInstance.Origin` sono le stesse di quelle della parte principale.
  Questo mantiene i vertici della mesh nella stessa posizione
  rispetto all'oggetto come prima dell'operazione, ma significa anche
  che il `(0, 0, 0)` di una parte restituita non è necessariamente al centro della
  propria superficie.

  Crea un nuovo `Class.IntersectOperation` dalla geometria sovrapposta
  della parte e delle altre parti nell'array fornito.

Restituisce true se l'oggetto è connesso a una parte che lo terrà in
posizione (ad esempio una parte ancorata `Class.BasePart.Anchored|Anchored`), altrimenti restituisce
false. In un assemblaggio che ha una parte ancorata `Class.BasePart.Anchored|Anchored`,
tu ogni parte è ancorata.

BasePart:IsGrounded

Se l'oggetto è connesso a una parte che lo terrà in posizione.

Restituisce true se l'oggetto è connesso a una parte che lo terrà in
posizione (ad esempio una parte ancorata `Class.BasePart.Anchored|Anchored`), altrimenti restituisce
false.

Crea un giunto su qualsiasi lato del `Class.BasePart|Part` che ha un
`Enum.SurfaceType` che può fare un giunto; creerà un giunto con quali parti adiacenti.

I giunti saranno creati tra i lati e qualsiasi superficie di contatto piana,
dipendente dalle superfici dei lati.

- Le superfici lisce non creeranno giunti
- Le superfici adesive creeranno un giunto `Class.Glue`
- Le superfici di saldatura creeranno un giunto `Class.Weld` con qualsiasi superficie tranne
  Unjoinable
- Gli Stud, Inlet o Universal creeranno ciascuno un giunto `Class.Snap` con
  altre due superfici (ad esempio, Studs con Inlet e Universal)
- Le superfici Hinge e Motor creano istanze di giunto `Class.Rotate` e `Class.RotateV`

Diverse dalla funzione `Class.Model:MakeJoints()`, questa funzione richiede un array di
parti come parametro. Questo array viene fornito come segue:

```
part:MakeJoints({part1, part2, part3})
```
I giunti si rompono se viene applicata una forza sufficiente a causa di un
`Class.Explosion`, a meno che un oggetto `Class.ForceField` non sia parentato all'oggetto `Class.BasePart` o al suo
generale `Class.Model`. Per questo motivo, essi sono spesso utilizzati per fare
gli edifici e altri modelli distruttibili.

BasePart:MakeJoints

Crea un giunto su qualsiasi lato dell'oggetto che ha un ID superficie che può
fare un giunto.

BasePart:makeJoints

Cambia la dimensione di un oggetto proprio come usare lo strumento di ridimensionamento dello Studio.

BasePart:Resize

normalId

deltaAmount

Quanto crescere/ridursi sul lato specificato.

BasePart:resize

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

BasePart:SetNetworkOwner

playerInstance

Il giocatore a cui viene dato il possesso di rete dell'oggetto.

Imposta il giocatore dato come proprietario della rete per questa parte e tutte le
parti connesse.

Permette al motore di gioco di decidere dinamicamente chi gestirà la fisica
dell'oggetto (uno dei client o il server).

BasePart:SetNetworkOwnershipAuto

Questo esempio dimostra come sottrarre parte(i) da un'altra
`Class.BasePart` per formare un'operazione `Class.UnionOperation` negata.

Crea un nuovo `Class.UnionOperation` dalla parte, meno la geometria
occupata dalle parti nell'array fornito. Solo le `Class.Part|Parts` sono
supportate, non `Class.Terrain` o `Class.MeshPart|MeshParts`. Simile a
`Class.Instance:Clone()|Clone()`, l'oggetto restituito non ha un set
`Class.Instance.Parent|Parent`.

Nota che l'unione risultante non può essere vuota a causa delle sottrazioni. Se l'operazione
risultasse in geometria completamente vuota, fallirà.

Nell'immagine seguente, `Class.BasePart:SubtractAsync()|SubtractAsync()` viene chiamato sul cilindro blu utilizzando una tabella contenente il blocco viola.
L'operazione `Class.UnionOperation` risultante si risolve in una forma che omette la geometria
 del blocco da quella del cilindro.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Subtract.jpg"
width="720" alt="Un blocco lungo sovrapposto a un cilindro" />
<figcaption>Parti separate</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Negate-Result.jpg" width="720"
alt="Parte del blocco sottratta dal cilindro" />
<figcaption>Risultato <code>Class.UnionOperation</code></figcaption>
</figure>

BasePart:SubtractAsync

Gli oggetti che partecipano alla sottrazione.

Il valore di `Enum.CollisionFidelity` per il
risultante `Class.UnionOperation`.

Il valore di `Enum.RenderFidelity` della
risultante `Class.PartOperation`.

Risultante `Class.UnionOperation` con nome predefinito **Union**.

Nota: è altamente raccomandato utilizzare la nuova `Class.GeometryService:UnionAsync`
invece di questa funzione. Oltre ad avere migliori performance e più funzionalità,
nella nuova funzione differisce come segue:

- L'output è un array di istanze piuttosto che un'unica istanza.
- Le parti di input non devono essere parentate alla scena, consentendo operazioni
  in background.
- Quando l'opzione `SplitApart` è impostata su `true` (impostazione predefinita), ogni
  corpo distinto verrà restituito in un proprio `Class.PartOperation`.
- Tutte le parti restituite sono nello spazio delle coordinate della parte principale,
  quindi le loro posizioni `Class.PVInstance.Origin` sono le stesse di quelle della parte principale.
  Questo mantiene i vertici della mesh nella stessa posizione rispetto all'oggetto come prima
  dell'operazione, ma significa anche che il `(0, 0, 0)` di una parte restituita non è
  necessariamente al centro della propria superficie.

  Crea un nuovo `Class.UnionOperation` dalla parte, meno la geometria
  occupata dalle parti nell'array fornito.

Restituisce l'accelerazione angolare nello spazio globale che risulterebbe dall'applicazione
della coppia specificata all'assemblaggio dell'oggetto, tenendo conto facoltativamente
degli effetti giroscopici.

Questo è l'inverso di `Class.BasePart:AngularAccelerationToTorque()`. È utile per
predire come un assemblaggio risponderà a una coppia applicata.

Il calcolo utilizza:

**α = I⁻¹ · (τ − ω × (I · ω))**

dove **I** è il tensore di inerzia nello spazio globale dell'assemblaggio, **τ** è la
coppia applicata, e **ω** è la velocità angolare.

Se l'oggetto non è un discendente di `Class.Workspace`, restituisce `(0, 0, 0)`.
Se l'assemblaggio è ancorato, restituisce `(0, 0, 0)`.

#### Effetti giroscopici

Quando un assemblaggio in rotazione ha un tensore di inerzia asimmetrico,
l'accelerazione risultante da una coppia applicata dipende anche dalla
temporale velocità angolare attuale. Il parametro `angVelocity` tiene
conto di questi effetti giroscopici. Se omesso (impostato a zero per
default), il risultato ignora questo contributo dal risultato.

```lua
local part = workspace.Part
local angularVelocity = part.AssemblyAngularVelocity
local appliedTorque = Vector3.new(0, 100, 0)

-- Predici l'accelerazione angolare da questa coppia
local angAccel = part:TorqueToAngularAcceleration(appliedTorque, angularVelocity)
```

BasePart:TorqueToAngularAcceleration

torque

Il vettore di coppia applicato all'assemblaggio nello spazio globale.

Un `Datatype.Vector3` che rappresenta l'accelerazione angolare risultante
nello spazio globale.

Restituisce l'accelerazione angolare che risulterebbe dall'applicazione di una data
coppia all'assemblaggio di questo oggetto, tenendo conto facoltativamente degli effetti giroscopici.

Questo esempio dimostra come combinare la geometria di una `Class.BasePart`
con la geometria di altre parti per formare un `Class.UnionOperation`.

Crea un nuovo `Class.UnionOperation` dalla parte, più la geometria
occupata dalle parti nell'array fornito. Solo `Class.Part|Parts` sono
supportate, non `Class.Terrain` o `Class.MeshPart|MeshParts`. Simile a
`Class.Instance:Clone()|Clone()`, l'oggetto restituito non ha un set
`Class.Instance.Parent|Parent`.

Le seguenti proprietà dalla parte chiamante sono applicate all'operazione `Class.UnionOperation`:

- `Class.BasePart.Color|Color`, `Class.BasePart.Material|Material`,
  `Class.BasePart.MaterialVariant|MaterialVariant`,
  `Class.BasePart.Reflectance|Reflectance`,
  `Class.BasePart.Transparency|Transparency`
- `Class.BasePart.CanCollide|CanCollide`
- `Class.BasePart.Anchored|Anchored`, `Class.BasePart.Density|Density`,
  `Class.BasePart.Elasticity|Elasticity`,
  `Class.BasePart.ElasticityWeight|ElasticityWeight`,
  `Class.BasePart.Friction|Friction`,
  `Class.BasePart.FrictionWeight|FrictionWeight`

Nell'immagine seguente,
`Class.BasePart:UnionAsync()|UnionAsync()` viene chiamato sul blocco blu
utilizzando una tabella contenente il cilindro viola. L'operazione
`Class.UnionOperation` risultante si risolve in una forma della geometria combinata di
entrambe le parti.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Union.jpg"
width="720" alt="Blocchi e cilindri sovrapposti" />
<figcaption>Parti separate</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Union-Result.jpg" width="720"
alt="Parti unite in un'unica unione solida" />
<figcaption>Risultato <code>Class.UnionOperation</code></figcaption>
</figure>

#### Note

- Le parti originali rimangono intatte dopo un'operazione di unione
  riuscita. Nella maggior parte dei casi, dovresti effettuare `Class.Instance.Destroy|Destroy()`
  su tutte le parti originali e parentare il `Class.UnionOperation` restituito
dallo stesso luogo dell'oggetto chiamante `Class.BasePart`.
- Per impostazione predefinita, l'unione risultante rispetta la
  `Class.BasePart.Color|Color` proprietà di ciascuna delle sue parti. Per cambiare
  l'intera unione in un colore specifico, imposta la
  `Class.PartOperation.UsePartColor|UsePartColor` proprietà a `true`.
- Se un'operazione di unione dovesse risultare in una parte con più di 20.000
  triangoli, sarà semplificata a 20.000 triangoli.

BasePart:UnionAsync

Gli oggetti che partecipano all'unione con la parte chiamante.

Nota: è altamente raccomandato utilizzare la nuova
`Class.GeometryService:UnionAsync` invece di questa funzione. Oltre ad avere
delle migliori performance e più funzionalità, la nuova funzione differisce come
segue:

- L'output è un array di istanze piuttosto che un'unica istanza.
- Le parti di input non devono essere parentate alla scena, consentendo operazioni
  in background.
- Quando l'opzione `SplitApart` è impostata su `true` (impostazione predefinita), ogni distinto
  corpo verrà restituito nel proprio `Class.PartOperation`.
- Tutte le parti restituite sono nello spazio delle coordinate della parte principale, quindi
  le loro posizioni `Class.PVInstance.Origin` sono le stesse di quelle della parte principale.
  Questo mantiene i vertici della mesh nella stessa posizione rispetto all'oggetto come prima
  dell'operazione, ma significa anche che il `(0, 0, 0)` di una parte restituita non è
  necessariamente al centro della propria superficie.

Crea un nuovo `Class.UnionOperation` dalla parte, più la geometria
occupata dalle parti nell'array fornito.

BasePart

Questo esempio di codice permetterà a una parte di essere cliccata per attivare o disattivare la sua
proprietà di ancoraggio. Quando attivata, l'aspetto visivo della parte viene aggiornato (rosso
significa ancorato, giallo significa libero).


La proprietà `Anchored` determina se il part sarà immobile per
la fisica. Quando abilitata, un part non cambierà mai posizione a causa della gravità,
collisioni con altri part, sovrapposizioni con altri part, o qualsiasi altra
causa legata alla fisica. Di conseguenza, due part ancorati non attiveranno mai
eventi di `Class.BasePart.Touched|Touched` l'uno sull'altro.

Un part ancorato può ancora essere spostato cambiando il suo
`Class.BasePart.CFrame|CFrame` o `Class.BasePart.Position|Position`, e
può avere ancora una
`Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity` e
`Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity` diverse da zero.

Infine, se un part non ancorato è unito a un part ancorato tramite un
oggetto come un `Class.Weld`, anche questo agirà come ancorato. Se tale giunto
si rompe, il part potrebbe essere nuovamente influenzato dalla fisica. Vedi
[Assemblies](/physics/assemblies) per ulteriori dettagli.

La proprietà di proprietà di rete non può essere impostata su parti ancorate. Se lo stato di
ancoraggio di un part cambia sul server, la proprietà di rete di quel part sarà
influenzata.

BasePart.Anchored

Determina se un part è immobile per la fisica.

Il vettore di velocità angolare di questo assemblaggio di part. È il tasso di
cambiamento dell'orientamento in radianti al secondo.

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

Impostare direttamente la velocità può portare a un moto irrealistico. È
preferibile usare un vincolo `Class.Torque` o `Class.AngularVelocity`, o usare
`Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()` se vuoi un cambiamento
istantaneo nella velocità.

Se il part è [proprietario](/physics/network-ownership) del
server, questa proprietà deve essere cambiata da uno `Class.Script` del server (non
da un `Class.LocalScript` o un `Class.Script` con
`Class.BaseScript.RunContext|RunContext` impostato su `Enum.RunContext.Client`).
Se il part è di proprietà di un client tramite **proprietà automatica**, questa
proprietà può essere cambiata sia da uno script client **o** uno script
server; cambiarla da uno script client per un part di proprietà del server non avrà
effetto.

BasePart.AssemblyAngularVelocity

La velocità angolare dell'assemblaggio del part.

Una posizione calcolata tramite la `Class.BasePart.Mass|Mass` e
`Class.BasePart.Position|Position` di tutti i part nell'assemblaggio.

Se l'assemblaggio ha un part ancorato, il centro di massa di quel part sarà
il centro di massa dell'assemblaggio, e l'assemblaggio avrà massa infinita.

Conoscere il centro di massa può aiutare l'assemblaggio a mantenere stability. 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
per rimanere eretto sotto l'effetto della gravità.

BasePart.AssemblyCenterOfMass

Il centro di massa dell'assemblaggio del part nello spazio mondiale.

Il vettore di velocità lineare di questo assemblaggio di part. È il tasso di
cambiamento nella posizione di
`Class.BasePart.AssemblyCenterOfMass|AssemblyCenterOfMass` in studs al
secondo.

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

Impostare direttamente la velocità può portare a un moto irrealistico. È preferibile
usare un vincolo `Class.VectorForce`, o usare `Class.BasePart:ApplyImpulse()|ApplyImpulse()`
se vuoi un cambiamento istantaneo nella velocità.

Se il part è [proprietario](/physics/network-ownership) del
server, questa proprietà deve essere cambiata da uno `Class.Script` del server (non
 da un `Class.LocalScript` o un `Class.Script` con
`Class.BaseScript.RunContext|RunContext` impostato su `Enum.RunContext.Client`).
Se il part è di proprietà di un client tramite **proprietà automatica**, questa
proprietà può essere cambiata sia da uno script client **o** uno script
server; cambiarla da uno script client per un part di proprietà del server non avrà
effetto.

BasePart.AssemblyLinearVelocity

La velocità lineare dell'assemblaggio del part.

La somma della massa di tutti i `Class.BasePart|BaseParts` in quest'assemblaggio.
I part che sono `Class.BasePart.Massless|Massless` e non sono
la parte radice dell'assemblaggio non contribuiranno alla `AssemblyMass`.

Se l'assemblaggio ha un part ancorato, la massa dell'assemblaggio è considerata
infinita. I vincoli e altre interazioni fisiche tra assemblaggi non ancorati con una
grande differenza di massa possono causare instabilità.

BasePart.AssemblyMass

La massa totale dell'assemblaggio del part.

Questa proprietà indica il `Class.BasePart` scelto automaticamente per
rappresentare la parte radice dell'assemblaggio. Se il part non è genitore di 
`Class.Workspace`, questa proprietà sarà `nil`.

La parte radice può essere cambiata modificando il
`Class.BasePart.RootPriority|RootPriority` dei part nell'assemblaggio.

I part che condividono tutti lo stesso `AssemblyRootPart` sono nello stesso assemblaggio.

Per ulteriori informazioni sulle parti radici, vedi
[Assemblies](/physics/assemblies).

BasePart.AssemblyRootPart

Un riferimento alla parte radice dell'assemblaggio.

`AudioCanCollide` determina se il part interagirà fisicamente
con la simulazione audio, simile a `Class.BasePart.CastShadow|CastShadow`
per l'illuminazione.

Quando disabilitato, l'audio passa attraverso il part; non è né
occluso né riflesso.

BasePart.AudioCanCollide

Determina se il part interagirà fisicamente con la simulazione audio,
simile a `Class.BasePart.CastShadow|CastShadow` per l'illuminazione.

Questo esempio di codice dimostra come le proprietà della superficie possono essere impostate utilizzando solo un
NormalId (Superior, Fronte, ecc). Cambia l'-SurfaceInput di un motore da NoInput,
Costante e Sin per mostrare come ciascuno funziona utilizzando le proprietà -ParamA e -ParamB.

La proprietà `BackParamA` è pertinente quando la
`Class.BasePart.BackSurface` è impostata su Motor o SteppingMotor e
`Class.BasePart.BackSurfaceInput` è impostata su Sin. Determina l'**ampiezza**
della velocità angolare del motore.

BasePart.BackParamA

Determina il primo parametro per il SurfaceType sulla faccia posteriore di un
part.

La proprietà `BackParamB` è pertinente quando la
`Class.BasePart.BackSurface` è impostata su Motor o SteppingMotor e
`Class.BasePart.BackSurfaceInput` è impostata su Costante o Sin. Per Costante,
determina la velocità angolare costante del motore. Per Sin, determina la **frequenza**
della velocità angolare del motore.

BasePart.BackParamB

Determina il secondo parametro per il SurfaceType sulla faccia posteriore di un
part.

La proprietà `BackSurface` determina il tipo di superficie utilizzata per la
direzione positiva **Z** di un part. Quando le facce di due part sono poste
vicine l'una all'altra, possono creare un giunto tra di loro.

BasePart.BackSurface

Determina il tipo di superficie per la faccia posteriore di un part.

La proprietà `BackSurfaceInput` determina il tipo di input fornito a
un `Class.BasePart.BackSurface`. Questo è solo pertinente per Motor o
SteppingMotor SurfaceTypes. Questa proprietà determina come
`Class.BasePart.BackParamA` e `Class.BasePart.BackParamB` sono utilizzati. Per
breve, queste proprietà saranno indicate come ParamA e ParamB,
rispettivamente.

- Di default, questa è impostata su NoInput. Questo ferma completamente il motore.
- Per Costante, il motore ruota a una velocità costante pari a
  `ParamB`.
- Per Sin, il motore ruota a una velocità pari a
  `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. Vedi
  `Class.Workspace.DistributedGameTime`.

BasePart.BackSurfaceInput

Determina il tipo di input per la faccia posteriore di un part.

La proprietà `BottomParamA` è pertinente quando la
`Class.BasePart.BottomSurface` è impostata su Motor o SteppingMotor e
`Class.BasePart.BottomSurfaceInput` è impostata su Sin. Determina l'**ampiezza**
della velocità angolare del motore.

BasePart.BottomParamA

Determina il primo parametro per il SurfaceType sulla faccia inferiore di un
part.

La proprietà `BottomParamB` è pertinente quando la
`Class.BasePart.BottomSurface` è impostata su Motor o SteppingMotor e
`Class.BasePart.BottomSurfaceInput` è impostata su Costante o Sin. Per
Costante, determina la velocità angolare costante del motore. Per Sin, determina la **frequenza**
della velocità angolare del motore.

BasePart.BottomParamB

Determina il secondo parametro per il SurfaceType sulla faccia inferiore di un
part.

La proprietà `BottomSurface` determina il tipo di superficie utilizzata per la
direzione negativa **Y** di un part. Quando le facce di due part sono poste
vicine l'una all'altra, possono creare un giunto tra di loro.

BasePart.BottomSurface

Determina il tipo di superficie per la faccia inferiore di un part.

La classe base astratta per oggetti nel mondo che interagiscono fisicamente.