TriangleMeshPart è una classe intermedia astratta da cui `Class.MeshPart`
e `Class.PartOperation` ereditano. È stata creata per consolidare la
gestione delle proprietà geometriche fisiche tra le due sottoclassi. Implementa
il solo accesso in lettura a
`Class.TriangleMeshPart.CollisionFidelity|CollisionFidelity` e
`Class.TriangleMeshPart.CollisionPrecision|CollisionPrecision`.


TriangleMeshPart

Questa proprietà determina come il modello di collisione del
`Class.TriangleMeshPart` si relaziona alla geometria reale della mesh. Questa
proprietà non può essere letta o manipolata da script durante l'esecuzione.

Vedi [qui](/workspace/collisions#collision-fidelity) per una
rappresentazione visiva delle varie opzioni.

TriangleMeshPart.CollisionFidelity

Determina il livello di dettaglio a cui la fisica del pezzo si attiene alla sua mesh.

Questa proprietà descrive il compromesso tra precisione e prestazioni della
geometria di collisione del pezzo quando `Class.TriangleMeshPart.CollisionFidelity`
è impostato su `Enum.CollisionFidelity.Tunable`. Un valore di `0` favorisce
la massima prestazione con la mesh di collisione più semplice, mentre un valore di `1`
favorisce la massima precisione con una mesh di collisione che corrisponde
strettamente alla mesh visiva.


TriangleMeshPart.CollisionPrecision

Quantifica quanto sia precisa o performante una `Enum.CollisionFidelity.Tunable`
geometria di collisione, da `0` a `1`.


Controlla quale rappresentazione geometrica il motore fisico utilizza quando
calcola le forze e i momenti aerodinamici (fluidi) per il pezzo. Per default
è impostato su `Enum.FluidFidelity.Automatic`, in cui il motore seleziona una
rappresentazione per tuo conto.

- `Enum.FluidFidelity.Automatic` — il motore sceglie la rappresentazione;
  attualmente valuta le forze fluidi rispetto alla geometria di collisione
del pezzo.
- `Enum.FluidFidelity.UseCollisionGeometry` — le forze fluidi vengono valutate
  rispetto alla geometria di collisione del pezzo, corrispondente alla forma
  utilizzata per il rilevamento delle collisioni.
- `Enum.FluidFidelity.UsePreciseGeometry` — le forze fluidi vengono valutate
  rispetto alla geometria di mesh precisa del pezzo, producendo forze più
  accurate a un costo computazionale più elevato.

Poiché questa proprietà ha una sicurezza di scrittura a livello di plugin, è
configurata in Studio piuttosto che assegnata da script di runtime.

Questa impostazione influisce solo su un pezzo mentre le forze fluidi sono attive
per il luogo, che è governato da `Class.Workspace.FluidForces` (un
valore `Enum.FluidForces` che per default è `Default`; impostarlo su
`Experimental` abilita il modello di forza aerodinamica). Quando le forze fluidi non
vengono applicate al pezzo, la fedeltà scelta non ha effetto.


TriangleMeshPart.FluidFidelity

Determina la rappresentazione geometrica utilizzata per calcolare le forze
e i momenti aerodinamici.


Questa proprietà di sola lettura riporta la dimensione della geometria della
mesh del pezzo quando è stata caricata, come larghezza, altezza e profondità
in studs. Non è influenzata dal ridimensionamento del pezzo tramite
`Class.BasePart.Size`, quindi dividere
`Class.BasePart.Size` per `MeshSize` fornisce il fattore di scala attualmente
applicato alla geometria visiva e fisica della mesh.


TriangleMeshPart.MeshSize

La dimensione originale della geometria della mesh sorgente del pezzo,
prima di qualsiasi ridimensionamento applicato tramite `Class.BasePart.Size`.


Classe intermedia astratta che gestisce le proprietà geometriche fisiche per
PartOperations e MeshParts.

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
ed sono simulati fisicamente 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 `Class.BasePart|BaseParts` sono raggruppati in corpi rigidi simulati,
vedi [Assemblies](/physics/assemblies).

Ci sono molti oggetti diversi che interagiscono con `Class.BasePart` (oltre a `Class.Terrain`),
tra cui:

- Diversi `Class.BasePart|BaseParts` possono essere raggruppati all'interno di un `Class.Model` e
  spostati contemporaneamente utilizzando `Class.PVInstance:PivotTo()`. Vedi
  [Models](/parts/models).
- Un `Class.Decal` applica una texture immagine allungata alle facce di un
  `Class.BasePart`, mentre un `Class.Texture` applica una texture immagine a piastrelle alle
  facce. Vedi [Textures and Decals](/parts/textures-decals).
- Un `Class.SurfaceGui` renderizza `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 parentati. Vedi
  [Particle Emitters](/effects/particle-emitters).
- Oggetti di luce come `Class.PointLight` emettono luce dal centro di un
  `Class.BasePart` come illustrato in
  [Light Sources](/effects/light-sources).
- Se parentato a 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
invia solo dati al client notificandolo che due parti sono collide,
mentre `Class.BasePart.Touched` invia dati al server.

BasePart.LocalSimulationTouched

part

L'altra parte che è entrata in contatto con questa parte.

Si attiva sul client locale quando un'altra parte entra in contatto con questa parte.

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

BasePart.OutfitChanged

Si attiva quando l'aspetto della parte cambia a causa di una `Class.Shirt`.

Deprecato. Si attiva sul client locale quando una parte smette di toccare un'altra parte, in condizioni simili a quelle di `Class.BasePart.TouchEnded`. Questo evento è il corrispondente solo client di `Class.BasePart.TouchEnded`: notifica solo il client locale che le due parti si sono separate, mentre `Class.BasePart.TouchEnded` invia anche dati al server. Usa `Class.BasePart.TouchEnded` invece.

BasePart.StoppedTouching

otherPart

L'altra parte che ha smesso di toccare la parte data.

Si attiva sul client locale quando una parte smette di toccare un'altra parte.

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 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 causa di un movimento fisico, quindi non si attiverà
se la proprietà `Class.BasePart.CFrame|CFrame` è stata cambiata in modo tale
che la parte sovrappone un'altra parte. Questo significa anche che almeno una delle
parti coinvolte deve **non** essere `Class.BasePart.Anchored|Anchored` al
momento della collisione.

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

BasePart.Touched

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

Si attiva quando una parte tocca un'altra parte a causa 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 in congiunzione con
`Class.Workspace.TouchesUseCollisionGroups` per specificare se
[gruppi di collisione](/workspace/collisions#collision-filtering)
sono riconosciuti per la rilevazione.

BasePart.TouchEnded

L'altra parte che ha smesso di toccare questa parte.

Si attiva quando una parte smette di toccare un'altra parte a causa di un movimento fisico.

Dimostra `Class.BasePart:AngularAccelerationToTorque()`.


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

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

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

Se la parte 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 rotante ha un tensore di inerzia asimmetrico, la coppia
richiesta per ottenere una specifica accelerazione angolare è aumentata a causa
dell'orientamento variabile del corpo. Il parametro `angVelocity` tiene conto di questi effetti giroscopici. Se omesso, questi effetti giroscopici vengono omessi dal calcolo.

BasePart:AngularAccelerationToTorque

angAcceleration

Il vettore di accelerazione angolare desiderato nello spazio mondiale.

angVelocity

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

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

Restituisce la coppia necessaria per ottenere una data accelerazione angolare su
questa assemblaggio della parte, tenendo eventualmente conto degli effetti giroscopici.

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

La velocità angolare risultante dall'impulso dipende dalla `Class.BasePart.AssemblyMass|massa` dell'assemblaggio. Quindi è necessario un impulso maggiore per
muovere assemblaggi più massicci. Gli impulsi sono utili per i casi in cui si desidera
applicare una forza istantaneamente, come un'esplosione o una collisione.

Se la parte è [possessa](/physics/network-ownership) dal
server, questa funzione deve essere chiamata da uno `Class.Script` del server (non
da uno `Class.LocalScript` o da uno `Class.Script` con
`Class.BaseScript.RunContext|RunContext` impostato su `Enum.RunContext.Client`).
Se la parte è posseduta da un client tramite **automatico** possesso, questa
funzione può essere chiamata da uno script client **o** da uno script server;
chiamarla da uno script client per una parte posseduta dal server non avrà
alcun 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 istantaneo all'assemblaggio di questa parte.

La forza viene 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 è necessario un impulso maggiore per
muovere assemblaggi più massicci. Gli impulsi sono utili per i casi in cui si desidera
applicare una forza istantaneamente, come un'esplosione o una collisione.

Se la parte è [possessa](/physics/network-ownership) dal
server, questa funzione deve essere chiamata da uno `Class.Script` del server (non
da uno `Class.LocalScript` o da uno `Class.Script` con
`Class.BaseScript.RunContext|RunContext` impostato su `Enum.RunContext.Client`).
Se la parte è posseduta da un client tramite **automatico** possesso, questa
funzione può essere chiamata da uno script client **o** da uno script server;
chiamarla da uno script client per una parte posseduta dal server non avrà
alcun effetto.

BasePart:ApplyImpulse

Un vettore di impulso lineare da applicare all'assemblaggio.

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

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

Se la posizione non è 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 è necessario un impulso maggiore per
muovere assemblaggi più massicci. Gli impulsi sono utili per i casi in cui
gli sviluppatori vogliono applicare una forza istantaneamente, come un'esplosione o
una collisione.

Se la parte è [possessa](/physics/network-ownership) dal
server, questa funzione deve essere chiamata da uno `Class.Script` del server (non
da uno `Class.LocalScript` o da uno `Class.Script` con
`Class.BaseScript.RunContext|RunContext` impostato su `Enum.RunContext.Client`).
Se la parte è posseduta da un client tramite **automatico** possesso, questa
funzione può essere chiamata da uno script client **o** da uno script server;
chiamarla da uno script client per una parte posseduta dal server non avrà
alcun effetto.

BasePart:ApplyImpulseAtPosition

Un vettore di impulso da applicare all'assemblaggio.

position

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

Applica un impulso all'assemblaggio in una posizione specificata.

Iscrive `callback` ai dati di contatto che il motore fisico genera per questa parte durante il rilevamento delle collisioni. Una volta per fotogramma, dopo che la simulazione è stata eseguita, `callback` riceve un array di riepiloghi che descrivono ogni area di contatto in cui questa parte è stata coinvolta durante quel fotogramma. Ogni riepilogo riporta dove è avvenuto il contatto, in quale direzione era orientato e quanto velocemente si muovevano le due parti l'una rispetto all'altra in quel punto.

Questo metodo è un meccanismo separato da `Class.BasePart.Touched`.

Genera un errore se `callback` è `nil`, o se la parte non è un discendente di `Class.Workspace`.

#### Campi di Riepilogo

Ogni voce nell'array passato a `callback` è una tabella con le seguenti chiavi:

<table size="small">
<thead>
  <tr>
    <th>Chiave</th>
    <th>Tipo</th>
    <th>Riepilogo</th>
  </tr>
</thead>
<tbody>
  <tr>
    <td><code>Time</code></td>
    <td><code>number</code></td>
    <td>Tempo di simulazione, in secondi, del sotto-passo fisico che ha prodotto questo riepilogo.</td>
  </tr>
  <tr>
    <td><code>Part0</code></td>
    <td><code>Class.BasePart</code></td>
    <td>La parte iscritta.</td>
  </tr>
  <tr>
    <td><code>Part1</code></td>
    <td><code>Class.BasePart</code></td>
    <td>L'altra parte della coppia, che può essere <code>Class.Terrain</code>.</td>
  </tr>
  <tr>
    <td><code>Point</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Punto di contatto nello spazio mondiale, mediato sui punti nella patch.</td>
  </tr>
  <tr>
    <td><code>Normal</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Normale di contatto unitaria per la patch, orientata rispetto alla parte iscritta.</td>
  </tr>
  <tr>
    <td><code>RelativeVelocity</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Velocità di <code>Part1</code> rispetto a <code>Part0</code> nel punto di contatto.</td>
  </tr>
  <tr>
    <td><code>Area</code></td>
    <td><code>number</code></td>
    <td>Area stimata della patch di contatto, in stud quadrati. <code>0</code> per una patch di meno di tre punti, come un contatto su un bordo o un angolo.</td>
  </tr>
</tbody>
</table>

`Normal` è orientato rispetto alla parte iscritta piuttosto che a qualsiasi parte che il motore ha elencato per prima, quindi se entrambe le parti di una coppia sono iscritte, ogni iscrizione riceve il proprio riepilogo con se stessa come `Part0` e la normale invertita per corrispondere.

`RelativeVelocity` è la velocità di `Part1` rispetto a `Part0`, quindi la magnitudine della sua proiezione su `Normal` è la velocità con cui le due parti si stanno avvicinando o separando frontalmente, e la componente tangenziale a `Normal` descrive il contatto scivoloso e obliquo.

#### Comportamento di Reporting

- La registrazione dei contatti è abilitata solo mentre esiste almeno un'iscrizione in qualsiasi parte di `Class.Workspace`, e il costo di essa scala con il numero di parti iscritte piuttosto che con il numero totale di collisioni nella scena.
- I contatti tra più parti in stato di riposo non producono riepiloghi.
- I contatti da parti con `Class.BasePart.CanCollide` impostato su `false` non producono riepiloghi.
- La fisica può eseguire diversi sotto-passi per fotogramma, quindi una coppia che rimane in contatto attraverso diversi di essi produce fino a un riepilogo per patch per sotto-passo, tutti consegnati nella stessa invocazione di `callback`. Usa `Time` per ordinarli.
- La geometria di collisione non convessa produce un riepilogo per coppia di involucri convessi in contatto, e il contatto con `Class.Terrain` è ulteriormente suddiviso per normale di contatto, quindi entrambi possono generare diversi riepiloghi per la stessa coppia all'interno di un sotto-passo.
- Nulla viene replicato. Ogni client genera riepiloghi per le collisioni che possiede. Vedi
  [proprietà di rete](/physics/network-ownership).
- Distruggere la parte disconnette le sue iscrizioni.

BasePart:BindToCollisionSummaries

callback

Invocato con un array di tabelle di riepilogo, al massimo una volta per fotogramma, se la parte è stata coinvolta in una collisione.

Una `Datatype.RBXScriptConnection` che termina l'iscrizione quando disconnessa.

Si iscrive ai dati di contatto dettagliati per fotogramma per le collisioni in cui questa parte è coinvolta.

Rompe qualsiasi connessione superficiale con qualsiasi parte adiacente, inclusi `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 che viene controllata per la collidibilità.

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 puoi impostare la proprietà di rete di una parte.

Il valore di ritorno della funzione verifica se puoi chiamare `Class.BasePart:SetNetworkOwner()` o `Class.BasePart:SetNetworkOwnershipAuto()` senza incontrare un errore. Restituisce true se puoi modificare/leggere la proprietà di rete, oppure restituisce false e il motivo per cui non puoi, come stringa.

BasePart:CanSetNetworkOwnership

Se puoi modificare o leggere la proprietà di rete e il motivo.

Controlla se puoi impostare la proprietà di proprietà di rete di una parte.

Restituisce il punto più vicino sulla superficie della parte alla posizione nello spazio mondiale fornita. Se la posizione fornita è all'interno della parte, viene restituita così com'è.

Per le istanze di `Class.MeshPart` e `Class.PartOperation`, questo metodo rispetta il valore di `Enum.CollisionFidelity` della parte. I valori di ritorno possono differire a seconda che il mesh venga trattato come una scatola, un involucro o una forma più complessa.

BasePart:GetClosestPointOnSurface

Il punto nello spazio mondiale per trovare il punto di superficie più vicino.

Il punto più vicino sulla superficie della parte nello spazio mondiale.

Restituisce il punto più vicino sulla superficie della parte al punto dato.

Restituisce una tabella di parti collegate all'oggetto da qualsiasi tipo di giunto rigido.

Se `recursive` è true, questa funzione restituirà tutte le parti nell'assemblaggio rigidamente collegate al BasePart.

#### Giunti Rigidi

Quando un giunto collega due parti insieme `(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 parti collegate all'oggetto da qualsiasi tipo di `Class.JointInstance|giunto`.

Un array di `Class.BasePart|BaseParts` collegati a questa parte tramite giunti rigidi. Se `recursive` è true, include tutte le parti nell'assemblaggio.

Restituisce una tabella di parti collegate all'oggetto da qualsiasi tipo di giunto rigido.

Restituisce un array di tutti `Class.JointInstance|Giunti` e
`Class.Constraint|Vincoli` collegati a questa parte che sono attivi nella
simulazione.

Un giunto o un vincolo diventa attivo solo quando entrambe le parti a cui è
collegato si trovano all'interno dello **stesso** contenitore simulato, come
`Class.Workspace` o un `Class.WorldModel`. Se una delle parti collegate
è al di fuori di quel contenitore — ad esempio, parentata a
`Class.ServerStorage`, o in un diverso `Class.WorldModel` — il giunto non è
attivato. **GetJoints()** non include quel giunto su nessuna delle parti,
anche se l'istanza del giunto esiste ancora nel modello dei dati.


BasePart:GetJoints

Un array di tutti `Class.JointInstance|Giunti` e
`Class.Constraint|Vincoli` collegati alla parte che sono attivi
nella simulazione.


Restituisce tutti i Giunti o Vincoli collegati a questa parte che sono attivi
nella simulazione.


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

Poi, myMass è 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|Massa`.

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

BasePart:GetMass

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

BasePart:getMass

Restituisce il giocatore attuale che è il proprietario di rete di questa parte, o `nil` nel caso del server.

BasePart:GetNetworkOwner

Il giocatore attuale che è il proprietario di rete di questa parte, o `nil` nel caso del server.

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

BasePart:GetNetworkOwnershipAuto

Se il motore di gioco decide automaticamente il proprietario di rete per questa parte.

Restituisce gli oggetti `Class.NoCollisionConstraint` abilitati attualmente registrati per questa parte nel suo mondo fisico. Un `Class.NoCollisionConstraint` disabilita le collisioni tra le due parti specifiche a cui fa riferimento, mentre ciascuna di quelle parti può comunque collidere con il resto del mondo.

L'array restituito è vuoto se non è attualmente registrato alcun vincolo di questo tipo per questa parte. L'ordine dei vincoli restituiti non è garantito.

BasePart:GetNoCollisionConstraints

Un array degli oggetti `Class.NoCollisionConstraint` abilitati attualmente registrati per questa parte nel suo mondo fisico.

Restituisce gli oggetti `Class.NoCollisionConstraint` abilitati attualmente registrati per questa parte nel suo mondo fisico.

Questa funzione era rilevante quando l'interpolazione di compensazione del ritardo di Roblox delle parti online era interna. L'interpolazione è ora applicata direttamente al `Datatype.CFrame`.

BasePart:GetRenderCFrame

Il `Datatype.CFrame` che rappresenta dove la parte viene renderizzata, che ora è equivalente al `Class.BasePart.CFrame|CFrame` della parte.

OBSOLETE. Restituisce un CFrame che descrive dove la parte viene renderizzata.

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

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

BasePart:GetRootPart

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

Restituisce la parte base di un assemblaggio di parti.

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 non abbia un oggetto `Class.TouchTransmitter|TouchInterest` parentato ad essa (significa che qualcosa è collegato al suo evento Touched). Le parti che sono adiacenti ma non intersecano non sono considerate in contatto. Questa funzione precede la funzione `Class.WorldRoot:GetPartsInPart()`, che fornisce maggiore flessibilità e evita le regole speciali di `Class.TouchTransmitter|TouchInterest` descritte sopra. Usa `Class.WorldRoot:GetPartsInPart()` invece.

BasePart:GetTouchingParts

Una tabella di tutte le parti che intersecano e possono collidere con questa parte.

Restituisce una tabella di tutte le parti `Class.BasePart.CanCollide` vere che intersecano questa parte.

Restituisce la velocità lineare dell'assemblaggio della parte nella 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, la velocità lineare sarà sempre la stessa per ogni posizione.

BasePart:GetVelocityAtPosition

La posizione nello spazio mondiale in cui calcolare la velocità lineare dell'assemblaggio.

Un `Datatype.Vector3` che rappresenta la velocità lineare dell'assemblaggio nella posizione nello spazio mondiale specificata.

Restituisce la velocità lineare dell'assemblaggio della parte nella posizione data rispetto a questa parte.

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

Le seguenti proprietà della parte chiamante vengono applicate al risultato `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`

#### Migrazione

È altamente consigliato utilizzare il nuovo `Class.GeometryService:IntersectAsync()` invece di questo metodo. Oltre ad avere prestazioni migliori e più funzionalità, il nuovo metodo 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` (predefinito), ogni corpo distinto 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 del mesh nella stessa posizione relativa all'oggetto di prima dell'operazione, ma significa anche che il `(0, 0, 0)` di una parte restituita non è necessariamente al centro del suo corpo.

#### Note

- Le parti originali rimangono intatte dopo un'operazione di intersezione riuscita. Nella maggior parte dei casi, dovresti `Class.Instance.Destroy|Destroy()` tutte le parti originali e parentare il `Class.IntersectOperation` restituito allo stesso posto della `Class.BasePart` chiamante.
- Per impostazione predefinita, i colori delle facce dell'intersezione risultante vengono presi in prestito 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` su `true`.
- Se un'operazione di intersezione dovesse risultare in una parte con più di 20.000 triangoli, verrà semplificata a 20.000 triangoli.

BasePart:IntersectAsync

parts

Gli oggetti che partecipano all'intersezione.

collisionfidelity

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

renderFidelity

Il valore di `Enum.RenderFidelity` del risultato `Class.PartOperation`.

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

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

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

BasePart:IsGrounded

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

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

Crea un giunto su qualsiasi lato della `Class.BasePart|Part` che ha un `Enum.SurfaceType` che può creare un giunto, creerà un giunto con qualsiasi parte adiacente.

I giunti verranno creati tra i lati e qualsiasi superficie piana in contatto, a seconda delle superfici dei lati.

- Le superfici lisce non creeranno giunti
- Le superfici incollate creeranno un giunto `Class.Glue`
- Le saldature creeranno un giunto `Class.Weld` con qualsiasi superficie tranne Unjoinable
- Studs, Inlet o Universale creeranno ciascuno un giunto `Class.Snap` con una delle altre due superfici (ad es. Studs con Inlet e Universale)
- Le superfici Hinge e Motor creano istanze di giunto `Class.Rotate` e `Class.RotateV`

A differenza di `Class.Model:MakeJoints()`, questa funzione richiede un array di parti come parametro. Questo array è 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 alla `Class.BasePart` o all'antenato `Class.Model`. Per questo motivo, vengono spesso utilizzati per creare edifici e altri modelli distruttibili.

BasePart:MakeJoints

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

BasePart:makeJoints

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

BasePart:Resize

normalId

deltaAmount

Quanto crescere/ridursi sul lato specificato.

BasePart:resize

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

BasePart:SetNetworkOwner

playerInstance

Il giocatore a cui viene data la proprietà di rete della parte.

Imposta il giocatore dato come proprietario di rete per questa parte e tutte le parti collegate.

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

BasePart:SetNetworkOwnershipAuto

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

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

#### Migrazione

È altamente consigliato utilizzare il nuovo `Class.GeometryService:SubtractAsync()` invece di questo metodo. Oltre ad avere prestazioni migliori e più funzionalità, il nuovo metodo 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` (predefinito), ogni corpo distinto 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.

BasePart:SubtractAsync

Gli oggetti che partecipano alla sottrazione.

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

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

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

Dimostra `Class.BasePart:TorqueToAngularAcceleration()`.


Restituisce l'accelerazione angolare nello spazio mondiale che risulterebbe dall'applicazione della coppia specificata all'assemblaggio della parte, tenendo eventualmente conto degli effetti giroscopici.

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

Il calcolo utilizza:

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

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

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

#### Effetti Giroscopici

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

BasePart:TorqueToAngularAcceleration

torque

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

La velocità angolare attuale dell'assemblaggio nello spazio mondiale. Predefinito a `(0, 0, 0)`. Fornisci la velocità angolare dell'assemblaggio per tenere conto degli effetti giroscopici.

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

Restituisce l'accelerazione angolare che risulterebbe dall'applicazione di una coppia data all'assemblaggio di questa parte, tenendo eventualmente conto degli effetti giroscopici.

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

Le seguenti proprietà della parte chiamante vengono applicate al risultato `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`

#### Migrazione

È altamente consigliato utilizzare il nuovo `Class.GeometryService:UnionAsync()` invece di questo metodo. Oltre ad avere prestazioni migliori e più funzionalità, il nuovo metodo 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` (predefinito), ogni corpo distinto 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 del mesh nella stessa posizione relativa all'oggetto di prima dell'operazione, ma significa anche che il `(0, 0, 0)` di una parte restituita non è necessariamente al centro del suo corpo.

#### Note

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

BasePart:UnionAsync

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

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

BasePart

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


La proprietà `Anchored` determina se il part sarà immovibile dalla
fisica. Quando abilitato, un part non cambierà mai posizione a causa della gravità,
collisioni con altri part, sovrapposizione con altri part, o qualsiasi altro
causa legata alla fisica. Di conseguenza, due parti ancorate non attiveranno mai
eventi `Class.BasePart.Touched|Touched` l'uno sull'altro.

Un part ancorato può comunque essere spostato cambiando il suo
`Class.BasePart.CFrame|CFrame` o `Class.BasePart.Position|Position`, e
può ancora avere una velocità lineare non zero
`Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity` e
`Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity`.

Infine, se un part non ancorato è unito a un part ancorato tramite un
oggetto come un `Class.Weld`, anche esso 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 è immovibile dalla fisica.

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

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

Impostare direttamente la velocità può portare a movimenti irrealistici. È preferibile utilizzare
`Class.Torque` o `Class.AngularVelocity` come vincolo, oppure utilizzare
`Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()` se si desidera
un cambiamento istantaneo nella velocità.

Se il part è [possesso](/physics/network-ownership) dal
server, questa proprietà deve essere cambiata da uno `Class.Script` del server (non
da uno `Class.LocalScript` o un `Class.Script` con
`Class.BaseScript.RunContext|RunContext` impostato su `Enum.RunContext.Client`).
Se il part è posseduto da un client tramite **automatico** possesso, questa
proprietà può essere cambiata da uno script client **o** uno script
server; cambiarlo da uno script client per un part posseduto dal server non avrà
alcun 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 stabilità. Una
forza applicata al centro di massa non causerà 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à.

BasePart.AssemblyCenterOfMass

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

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

Se si desidera conoscere la velocità in un punto diverso dal centro di massa
dell'assemblaggio, utilizzare
`Class.BasePart:GetVelocityAtPosition()|GetVelocityAtPosition()`.

Impostare direttamente la velocità può portare a movimenti irrealistici. È preferibile utilizzare un
vincolo `Class.VectorForce`, oppure utilizzare
`Class.BasePart:ApplyImpulse()|ApplyImpulse()` se si desidera un cambiamento
istantaneo nella velocità.

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

BasePart.AssemblyLinearVelocity

La velocità lineare dell'assemblaggio del part.

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

Se l'assemblaggio ha un part ancorato, la massa dell'assemblaggio è considerata
infinita. 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 il part radice dell'assemblaggio. Se il part non è parentato al
`Class.Workspace`, questa proprietà sarà `nil`.

Il part radice può essere cambiato 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 sui part radice, vedere
[Assemblies](/physics/assemblies).

BasePart.AssemblyRootPart

Un riferimento al part 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.

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

/reference/engine/classes/TriangleMeshPart.yaml