Quando è associato a un `Class.ViewportFrame`, `WorldModel` estende fisica limitata
per i suoi figli su quel `Class.ViewportFrame`. Ad esempio,
`Class.BasePart|BaseParts` che sono associati al `WorldModel` possono essere
animati e interrogati spazialmente (ad esempio con raycast), ma quelle parti non sono
**simulati**. Inoltre, puoi inserire personaggi `Class.Humanoid` nel
`WorldModel` e le loro articolazioni saranno impostate correttamente per l'animazione.

Per evitare possibili problemi di prestazioni, assicurati di creare `WorldModels`
solo quando desideri mostrarli e di eliminare `WorldModels` che attualmente non sono
in uso.

WorldModel

Estende la fisica limitata per i suoi figli su un genitore `Class.ViewportFrame`.

Questa classe base fornisce un'API per qualsiasi istanza destinata a gestire query spaziali 3D e simulazioni, come `Class.Workspace` e `Class.WorldModel`.

Il blocco di codice sottostante dimostra come utilizzare
`Class.WorldRoot:ArePartsTouchingOthers()` per verificare se i parti in una lista
stanno toccando altri parti nello spazio di lavoro che non sono nella lista.

Per prima cosa, lo script crea due parti quadrate che si sovrappongono di 1 stud,
`Part1` e `Part2`. Poi, stampa il valore restituito da ArePartsTouchingOthers()
quando Part1 viene passato in `partList` con tre valori di sovrapposizione diversi:
`0`, `0.999`, e `1`. Le prime due volte che ArePartsTouchingOthers() viene
chiamato restituisce `false` perché i valori di sovrapposizione sono inferiori
della distanza che Part1 e Part2 si sovrappongono. La terza chiamata restituisce
`true` perché il valore di sovrapposizione è uguale alla distanza in cui i parti
si sovrappongono.

**ArePartsTouchingOthers** restituisce true se almeno uno dei dati `Class.BasePart` è in contatto con altre parti. Due parti sono considerate "in contatto" se sono entro la soglia di distanza, `overlapIgnored`.

Se non vengono fornite parti, viene restituito false.

WorldRoot:ArePartsTouchingOthers

partList

Un elenco di parti che controlla se alcune parti nell'elenco stanno toccando altre parti non nell'elenco.

overlapIgnored

La soglia di sovrapposizione delle parti in studs che viene ignorata prima che le parti siano considerate in contatto.

True se e solo se alcune dei `Class.Part|parts` in `partList` stanno toccando altre parti (parti non nella partList). False se non vengono passate parti.

Restituisce true se uno qualsiasi dei dati `Class.BasePart` data sono in contatto con altre parti.

Lancia un raggio e restituisce la prima collisione con un `Class.BasePart` o
`Class.Terrain`. Stampa le proprietà del RaycastResult se è stato
colpito un risultato.


Lancia una forma a blocco in una direzione specificata e restituisce la prima collisione con una cella `Class.BasePart` o `Class.Terrain`. Questo è analogo a come `Class.WorldRoot:Raycast()` lancia un raggio lineare in una direzione per trovare una collisione, ma utilizza una forma 3D invece di un raggio.

A differenza di `Class.WorldRoot:GetPartsInPart()`, questo metodo non rileva le `Class.BasePart|BaseParts` che **inizialmente** intersectano la forma.

Se viene rilevata una collisione, viene restituito un `Datatype.RaycastResult` contenente le informazioni sull'impatto. La proprietà `Datatype.RaycastResult.Distance|Distance` rappresenta la distanza che la forma deve percorrere per trovare un impatto, e la proprietà `Datatype.RaycastResult.Position|Position` rappresenta il punto di intersezione che causa l'impatto.

Questo metodo genera un errore se viene passato un `Datatype.CFrame`, dimensione o direzione di input non validi.

WorldRoot:Blockcast

cframe

La posizione iniziale e la rotazione della forma a blocco lanciata.

size

La dimensione della forma a blocco lanciata in studs. La dimensione massima è 512 studs.

direction

La direzione della forma, con la magnitudine che rappresenta la distanza massima che la forma può percorrere. La distanza massima è 1024 studs.

params

Contiene il risultato dell'operazione di lancio della forma, o `nil` se nessuna `Class.BasePart` o cella `Class.Terrain` idonea è stata colpita.

Lancia una forma a blocco in una direzione specificata e restituisce un `Datatype.RaycastResult` se la forma colpisce una cella `Class.BasePart` o `Class.Terrain`.

Questa funzione sposta una tabella di `Class.BasePart|BaseParts` a una tabella di `Datatype.CFrame|CFrames` senza necessariamente attivare gli eventi di proprietà predefiniti `Class.Object.Changed|Changed`. Questo fornisce un modo molto veloce per spostare grandi numeri di parti, poiché non è necessario sostenere il costo di impostazioni di proprietà separate per ciascuna parte individuale.

Il terzo argomento consente di ottimizzare ulteriormente l'operazione di movimento. Per impostazione predefinita, l'evento `Class.Object.Changed|Changed` di ciascuna parte si attiva per `Class.BasePart.Position|Position`, `Class.BasePart.Orientation|Orientation`, e `Class.BasePart.CFrame|CFrame`. Tuttavia, se specificate `Enum.BulkMoveMode|FireCFrameChanged` come terzo argomento, solo l'evento `Class.Object.Changed|Changed` per la proprietà `Class.BasePart.CFrame|CFrame` si attiverà.

Nota che dovresti utilizzare questa funzione solo se sei sicuro che il movimento delle parti sia un collo di bottiglia nel tuo codice. Impostare semplicemente la proprietà `Class.BasePart.CFrame|CFrame` delle singole parti e dei modelli saldati è abbastanza veloce nella maggior parte dei casi.

WorldRoot:BulkMoveTo

cframeList

eventMode

Sposta una tabella di `Class.BasePart|BaseParts` a una tabella di `Datatype.CFrame|CFrames`.

**FindPartOnRay** utilizza [raycasting](/workspace/raycasting) per trovare la prima `Class.BasePart` o cella `Class.Terrain` che interseca il dato `Datatype.Ray`. Questa funzione restituisce la `Class.BasePart` o la cella del terreno colpita, il punto di intersezione, la normale della superficie al punto di intersezione e il materiale `Enum.Material` associato.

Se il parametro `ignoreDescendantsInstance` è fornito, il calcolo del raycasting ignorerà l'oggetto dato e tutti i suoi discendenti. Comporta un comportamento simile alla proprietà `Class.Mouse.TargetFilter`.

I parametri `terrainCellsAreCubes` e `ignoreWater` determinano se le celle `Class.Terrain` devono essere trattate come cubi o meno e se l'acqua deve essere ignorata o meno.

Per includere o escludere più oggetti e i loro discendenti, utilizzate le varianti `Class.WorldRoot:FindPartOnRayWithWhitelist()` e `Class.WorldRoot:FindPartOnRayWithIgnoreList()`.

#### Note

- Teoricamente, un raggio si estende all'infinito in una direzione. Tuttavia, la lunghezza massima del vettore direzionale su Roblox è di 15000 studs.
- La lunghezza (magnitudine) del vettore direzionale è importante, poiché parti più lontane della sua lunghezza non saranno testate.
- Se il raggio non interseca nulla, i valori di ritorno saranno `nil` e il punto alla fine del raggio, rispettivamente.
- Le parti che si trovano in un [gruppo di collisione](/workspace/collisions#collision-filtering) che non collidono con il gruppo di collisione "Default" vengono ignorate implicitamente.

WorldRoot:FindPartOnRay

ignoreDescendantsInstance

terrainCellsAreCubes

ignoreWater

La `Class.BasePart` o la cella `Class.Terrain` colpita, il punto di intersezione `Datatype.Vector3`, la normale della superficie `Datatype.Vector3` al punto di intersezione e il `Enum.Material` della `Class.BasePart` o della cella del terreno colpita.

Restituisce la prima `Class.BasePart` o cella `Class.Terrain` che interseca il dato `Datatype.Ray`.

WorldRoot:findPartOnRay

Questa funzione è una variante di `Class.WorldRoot:FindPartOnRay()` con l'aggiunta di un elenco di esclusione. Questo ti consente di ignorare determinate parti o `Class.Model|Models`.

Coloro che desiderano **includere** un gruppo specifico di oggetti dovrebbero invece utilizzare `Class.WorldRoot:FindPartOnRayWithWhitelist()`.

WorldRoot:FindPartOnRayWithIgnoreList

ignoreDescendantsTable

La `Class.BasePart` o cella `Class.Terrain` colpita, il punto di intersezione `Datatype.Vector3`, la normale della superficie `Datatype.Vector3` al punto di intersezione e il `Enum.Material` della `Class.BasePart` o cella del terreno colpita.

Restituisce la prima `Class.BasePart` o cella `Class.Terrain` che interseca il dato `Datatype.Ray` che non è in, né è un discendente di un oggetto nell'elenco di esclusione fornito.

Questa funzione è una variante di `Class.WorldRoot:FindPartOnRay()` con l'aggiunta di un elenco di inclusione. Questo ti consente di rilevare solo determinate parti o `Class.Model|Models` ed è particolarmente utile quando, ad esempio, si cercano punti di intersezione tra un raggio e una singola parte.

Se viene dato un valore `nil` nell'elenco di inclusione, le istanze successive verranno ignorate.

Coloro che desiderano **escludere** un gruppo specifico di oggetti dovrebbero invece utilizzare `Class.WorldRoot:FindPartOnRayWithIgnoreList()`.

WorldRoot:FindPartOnRayWithWhitelist

whitelistDescendantsTable

La `Class.BasePart` o cella `Class.Terrain` colpita, il punto di intersezione `Datatype.Vector3`, la normale della superficie `Datatype.Vector3` al punto di intersezione e il `Enum.Material` della `Class.BasePart` o della cella del terreno colpita.

Restituisce la prima `Class.BasePart` o cella `Class.Terrain` che interseca il dato `Datatype.Ray` che è in, o è un discendente di un oggetto nell'elenco di inclusione fornito.

Restituisce un array di `Class.BasePart|BaseParts` nella data `Datatype.Region3`.

Questa funzione accetta un parametro maxParts opzionale (default 20) che limita il numero di `Class.BasePart|BaseParts` che possono essere restituiti. Una volta raggiunto questo numero, la ricerca di `Class.BasePart|BaseParts` si fermerà. Questo significa che alcune `Class.BasePart|BaseParts` potrebbero non essere restituite anche se si trovano all'interno della `Datatype.Region3`

Il parametro facoltativo `ignoreDescendantsInstance` può essere utilizzato per specificare un'istanza specifica per la quale essa stessa e tutti i suoi discendenti dovrebbero essere ignorati da questa funzione. Questo può essere utile quando, ad esempio, si desidera verificare se ci sono parti all'interno di una `Class.BasePart` diversa dalla `Class.BasePart` stessa.

```
local min = part.Position - (0.5 * part.Size)
local max = part.Position + (0.5 * part.Size)
local region = Region3.new(min, max)
local parts = worldroot:FindPartsInRegion3(region, part)  -- Ignora parto
```
Le varianti di questo metodo `Class.WorldRoot:FindPartsInRegion3WithIgnoreList()` e `Class.WorldRoot:FindPartsInRegion3WithWhiteList()` esistono per fornire funzionalità specifiche di esclusione e inclusione.

Se non vengono trovati `Class.BasePart|BaseParts`, verrà restituito un array vuoto.

WorldRoot:FindPartsInRegion3

region

maxParts

Il numero massimo di `Class.BasePart|BaseParts` da restituire.

Un array di `Class.BasePart|BaseParts` all'interno della `Datatype.Region3`.

Restituisce un array di `Class.BasePart|BaseParts` nella data `Datatype.Region3`.

WorldRoot:findPartsInRegion3

Restituisce un array di `Class.BasePart|BaseParts` nella data `Datatype.Region3` che non sono in, né sono un discendente di un'entrata nell'elenco di esclusione fornito.

Se viene dato un valore `nil` nell'elenco di esclusione, le istanze successive non verranno ignorate. Se non vengono trovati `Class.BasePart|BaseParts`, verrà restituito un array vuoto.

Questa funzione è una variante di `Class.WorldRoot:FindPartsInRegion3()` con l'aggiunta di un elenco di esclusione. Questo consente allo sviluppatore di escludere determinate `Class.BasePart|BaseParts` o `Class.Model|Models` dalla ricerca. Coloro che desiderano trovare `Class.BasePart|BaseParts` in una `Datatype.Region3` utilizzando un elenco di inclusione dovrebbero utilizzare `Class.WorldRoot:FindPartsInRegion3WithWhiteList()`.

WorldRoot:FindPartsInRegion3WithIgnoreList

Un array di `Class.BasePart|BaseParts` trovati all'interno della `Datatype.Region3`.

Restituisce un array di `Class.BasePart|BaseParts` nella data `Datatype.Region3` che non sono in, né sono un discendente di un'entrata nell'elenco di esclusione fornito.

Restituisce un array di `Class.BasePart|BaseParts` nella data `Datatype.Region3` che sono in, o discendenti di un'entrata nell'elenco di inclusione fornito.

Se viene dato un valore `nil` nell'elenco di inclusione, le istanze successive non verranno ignorate. Se non vengono trovati `Class.BasePart|BaseParts`, verrà restituito un array vuoto.

Questa funzione è una variante di `Class.WorldRoot:FindPartsInRegion3()` con l'aggiunta di un elenco di inclusione. Questo consente allo sviluppatore di includere solo determinate `Class.BasePart|BaseParts` o `Class.Model|Models` nella ricerca. Coloro che desiderano trovare `Class.BasePart|BaseParts` in una `Datatype.Region3` utilizzando un elenco di esclusione dovrebbero utilizzare `Class.WorldRoot:FindPartsInRegion3WithIgnoreList()`.

WorldRoot:FindPartsInRegion3WithWhiteList

Restituisce un array di `Class.BasePart|BaseParts` nella data `Datatype.Region3` che sono in, o discendenti di un'entrata nell'elenco di inclusione fornito.

`Class.WorldRoot:GetPartBoundsInBox()` restituisce un array di parti i cui **bounding box** sovrappongono un box il cui volume è descritto utilizzando il dato centro (`Datatype.CFrame`) e dimensione (`Datatype.Vector3`).

Come evidenziato, questo metodo di query spaziale considera in modo efficiente il volume delle bounding box delle parti piuttosto che il loro volume effettivamente occupato. Questo può essere importante quando si considerano cilindri, sfere, unioni e `Class.MeshPart|MeshParts` che hanno forme non a blocco. Per i casi in cui l'accuratezza è particolarmente importante, utilizza invece `Class.WorldRoot:GetPartsInPart()`, o filtra ulteriormente i risultati di questo metodo tu stesso.

Questo metodo utilizza un oggetto `Datatype.OverlapParams` per descrivere porzioni riutilizzabili della query spaziale, come un elenco di inclusione o esclusione, il numero massimo di parti da interrogare, quale [gruppo di collisione](/workspace/collisions#collision-filtering) utilizzare e se la query favorisca il valore `Class.BasePart.CanCollide` per una parte intersecata rispetto al suo valore `Class.BasePart.CanQuery`.

WorldRoot:GetPartBoundsInBox

La posizione del centro del volume del box dato da interrogare.

La dimensione del volume di box dato da interrogare.

overlapParams

Contiene porzioni riutilizzabili dei parametri della query spaziale.

Un array di `Class.BasePart|BaseParts` che corrispondono alla query spaziale.

Restituisce un array di parti i cui **bounding box** sovrappongono un dato box.

`Class.WorldRoot:GetPartBoundsInRadius()` restituisce un array di parti i cui **bounding box** sovrappongono una sfera il cui volume è descritto utilizzando il dato centro (`Datatype.Vector3`) e raggio (numero).

Come evidenziato, questo metodo di query spaziale considera in modo efficiente il volume delle bounding box delle parti rispetto al loro volume effettivamente occupato. Questo può essere importante quando si considerano cilindri, sfere, unioni e `Class.MeshPart|MeshParts` che hanno forme non a blocco. Per i casi in cui l'accuratezza è particolarmente importante, utilizza invece `Class.WorldRoot:GetPartsInPart()`, o filtra ulteriormente i risultati di questo metodo tu stesso.

Questo metodo utilizza un oggetto `Datatype.OverlapParams` per descrivere porzioni riutilizzabili dei parametri della query spaziale, come un elenco di inclusione o esclusione, il numero massimo di parti da interrogare, quale [gruppo di collisione](/workspace/collisions#collision-filtering) utilizzare, e se la query favorisca il valore `Class.BasePart.CanCollide` per una parte intersecata rispetto al suo valore `Class.BasePart.CanQuery`.

WorldRoot:GetPartBoundsInRadius

position

La posizione del centro del volume di sfera dato da interrogare.

radius

Il raggio del volume di sfera dato da interrogare.

Restituisce un array di parti i cui **bounding box** sovrappongono una data sfera.

`Class.WorldRoot:GetPartsInPart()` restituisce un array di parti il cui spazio occupato è condiviso con la parte data (che deve esistere nello stesso `Class.WorldRoot` delle parti da interrogare). Questo metodo può essere utilizzato al posto di `Class.BasePart:GetTouchingParts()` ed è generalmente una scelta migliore.

Come notato, questo metodo di query spaziale considera il **volume esatto** occupato dalla parte data utilizzando un controllo di collisione geometrica. Ad esempio, una parte concava/vuota non corrisponderà alle parti interrogate all'interno di essa a meno che non si sovrappongano/toccano effettivamente una parte del genere. Per volumi più semplici, considera di utilizzare `Class.WorldRoot:GetPartBoundsInBox()` o `Class.WorldRoot:GetPartBoundsInRadius()`, poiché sono meno accurate ma più efficienti.

Questo metodo utilizza un oggetto `Datatype.OverlapParams` per descrivere porzioni riutilizzabili dei parametri della query spaziale, come un elenco di inclusione o esclusione, il numero massimo di parti da interrogare, quale [gruppo di collisione](/workspace/collisions#collision-filtering) utilizzare, e se la query favorisca il valore `Class.BasePart.CanCollide` per una parte intersecata rispetto al suo valore `Class.BasePart.CanQuery`.

WorldRoot:GetPartsInPart

part

La parte il cui volume deve essere controllato rispetto ad altre parti.

Restituisce un array di parti il cui spazio occupato è condiviso con la parte data.

Questa funzione sposta la parte specificata nella posizione specificata tramite [cinematica inversa](https://en.wikipedia.org/wiki/Inverse_kinematics) anziché muoverla direttamente, per assicurarsi che eventuali giunti, `Class.Constraint|constraints` o collisioni a cui la parte partecipa rimangano fisicamente soddisfatte. Attualmente, questa funzione è disponibile solo in Studio per i `Class.Plugin|plugins`, poiché attualmente confligge con la fisica di un gioco in esecuzione.

**Stiffness translation** è un numero compreso tra 0 e 1 che specifica quanto aggressivamente abbinare la posizione della parte alla posizione della parte del target CFrame. **Stiffness di rotazione** è un numero compreso tra 0 e 1 che specifica quanto aggressivamente abbinare la rotazione della parte alla rotazione della parte del target CFrame.

Ad esempio:

- Se la rigidità della traduzione e la rigidità della rotazione sono entrambe uguali a 1, la parte sarà spostata esattamente nel CFrame target indipendentemente dagli eventuali vincoli fisici.
- Se la rigidità della traduzione e la rigidità della rotazione sono entrambe uguali a 0.5, la parte cercherà di spostarsi esattamente nel CFrame target, ma potrebbe essere spinta via dai vincoli fisici.
- Se la rigidità della traduzione e la rigidità della rotazione sono entrambe uguali a 0, il CFrame target verrà ignorato e i vincoli fisici verranno risolti per l'oggetto nella posizione in cui si trovava.

WorldRoot:IKMoveTo

target

La posizione in cui spostare la parte specificata.

translateStiffness

Un numero compreso tra 0 e 1 che specifica quanto aggressivamente abbinare la posizione della parte alla posizione della parte del target `Datatype.CFrame`.

rotateStiffness

Un numero compreso tra 0 e 1 che specifica quanto aggressivamente abbinare la rotazione della parte alla rotazione della parte del target `Datatype.CFrame`.

collisionsMode

Ti consente di specificare quali oggetti devono essere influenzati dalla risoluzione fisica.

Sposta la parte specificata nella posizione specificata tramite la cinematica inversa anziché muoverla direttamente, per assicurarsi che eventuali giunti, restrizioni o collisioni a cui la parte partecipa rimangano fisicamente soddisfatte.

**IsRegion3Empty** restituisce un bool che indica se non ci sono `Class.BasePart|BaseParts` all'interno della data `Datatype.Region3`.

Il parametro opzionale `ignoreDescendantsInstance` può essere utilizzato per specificare un'istanza specifica per la quale essa stessa e tutti i suoi discendenti devono essere ignorati da questa funzione. Questo può essere utile quando, ad esempio, si desidera verificare se ci sono parti all'interno di una `Class.BasePart` diversa dalla `Class.BasePart` stessa.

```
local min = part.Position - (0.5 * part.Size)
local max = part.Position + (0.5 * part.Size)
local region = Region3.new(min, max)
local isPartEmpty = worldroot:IsRegion3Empty(region, part)  -- Ignora parte
```
Se più di un oggetto e i suoi discendenti devono essere esclusi dalla ricerca, gli sviluppatori dovrebbero utilizzare `Class.WorldRoot:IsRegion3EmptyWithIgnoreList()`.

Questa funzione restituisce solo se una regione è vuota o meno. Gli sviluppatori che desiderano trovare `Class.BasePart|BaseParts` in una regione devono utilizzare `Class.WorldRoot:FindPartsInRegion3()`.

#### Come funzionano i controlli Region3?

Controllare se una parte sovrappone un `Datatype.Region3` non è un processo semplice. È in realtà dispendioso in termini di tempo e complicato. Invece, controlla se le parti si trovano approssimativamente nella stessa area. Quando questa funzione viene chiamata, determina quali voxel contengono il `Datatype.Region3`. Quindi determina quali parti potrebbero essere in quei voxel. Questo lo fa confrontando la bounding box allineata agli assi (a volte chiamata AABB) della parte con i voxel. La bounding box allineata agli assi può essere vista in Roblox Studio quando una parte è selezionata.

Questo significa che l'area ispezionata dalla funzione potrebbe essere più grande del `Datatype.Region3`. Per questo motivo, si raccomanda di assicurarsi che il `Datatype.Region3` sia sulla griglia voxel. Il modo migliore per farlo è impostare le coordinate del `Datatype.Region3` su multipli di 4 (poiché i voxel sono 4 x 4 x 4 studs).

Questo metodo è un modo abbastanza rapido e semplice per vedere se ci sono parti in un'area generale. Se un gioco ha bisogno di sapere se le parti sono esattamente in un'area, allora deve essere utilizzata `Class.BasePart:GetTouchingParts()`. C'è un costo maggiore per utilizzare `Class.BasePart:GetTouchingParts()` dato che è necessaria una parte nel `Class.WorldRoot` e la funzione richiede più tempo per l'esecuzione.

WorldRoot:IsRegion3Empty

ignoreDescendentsInstance

Restituisce un bool che indica se non ci sono `Class.BasePart|BaseParts` all'interno della data `Datatype.Region3`.

Restituisce un booleano che indica se non ci sono `Class.BasePart|BaseParts` all'interno della data `Datatype.Region3`, ignorando eventuali `Class.BasePart|BaseParts` che sono discendenti degli oggetti all'interno dell'elenco di esclusione dato. Se un valore `nil` è dato nell'elenco di esclusione, le istanze successive non verranno ignorate.

Questa funzione restituisce solo se una regione è vuota o meno. Gli sviluppatori che cercano di trovare `Class.BasePart|BaseParts` specifiche in una regione dovrebbero utilizzare `Class.WorldRoot:FindPartsInRegion3WithIgnoreList()`.

Questa funzione è una variante di `Class.WorldRoot:IsRegion3Empty()` con l'aggiunta di un elenco di esclusione. Nei casi in cui è necessario un elenco di inclusione, gli sviluppatori dovrebbero controllare se vengono restituite parti da `Class.WorldRoot:FindPartsinRegion3WithWhitelist()`.

WorldRoot:IsRegion3EmptyWithIgnoreList

ignoreDescendentsTable

Restituisce un booleano che indica se non ci sono `Class.BasePart|BaseParts` all'interno della data `Datatype.Region3`, ignorando eventuali `Class.BasePart|BaseParts` che sono discendenti degli oggetti all'interno dell'elenco di esclusione dato.

Lancia un raggio e restituisce la prima collisione con un `Class.BasePart` o
`Class.Terrain`. Stampa le proprietà del RaycastResult se è stata
colpita un risultato.


Lancia un raggio utilizzando un'origine, una direzione e opzionale `Datatype.RaycastParams`. Se trova un `Class.BasePart` o cella `Class.Terrain` idonea, viene restituito un `Datatype.RaycastResult` contenente i risultati dell'operazione. Se non viene fornito un oggetto `Datatype.RaycastParams`, vengono utilizzati i valori predefiniti (tutte le parti sono considerate e l'acqua di `Class.Terrain` non è ignorata).

Nota che la lunghezza (magnitudine) del vettore direzionale è importante, poiché oggetti/terrain più lontani della sua lunghezza non saranno testati. Se stai usando un `Datatype.CFrame` per aiutarti a creare i componenti del raggio, considera di usare `Datatype.CFrame.LookVector` come vettore direzionale e moltiplicalo per la lunghezza desiderata come mostrato nell'esempio seguente. La lunghezza massima del vettore direzionale è di 15.000 studs.

Questo metodo **non** utilizza un oggetto `Datatype.Ray`, ma le sue componenti di origine e di direzione possono essere prese in prestito da `Datatype.Ray.Origin` e `Datatype.Ray.Direction`.

WorldRoot:Raycast

origin

Il vettore direzionale del raggio. Nota che la lunghezza di questo vettore è importante, poiché le parti/terrain più lontane della sua lunghezza non saranno testate.

raycastParams

Un oggetto utilizzato per specificare l'idoneità delle collisioni nell'operazione di raycast. Se non fornito, vengono utilizzati i valori predefiniti dove tutte le parti sono considerate e l'acqua di `Class.Terrain` non è ignorata.

Contiene i risultati di un'operazione di raycast, o `nil` se nessuna `Class.BasePart` o cella `Class.Terrain` idonea è stata colpita.

Lancia un raggio utilizzando un'origine, direzione e opzionale `Datatype.RaycastParams`, quindi restituisce un `Datatype.RaycastResult` se un oggetto o terreno idoneo interseca il raggio.

WorldRoot:Shapecast

Lancia una sfera e restituisce la prima collisione con un `Class.BasePart` o
`Class.Terrain`. Stampa le proprietà del RaycastResult se è stato
colpito.


Lancia una forma sferica in una direzione specificata e restituisce la prima collisione con una cella `Class.BasePart` o `Class.Terrain`. Questo è analogo a come `Class.WorldRoot:Raycast()` lancia un raggio lineare in una direzione per trovare una collisione, ma utilizza una forma 3D invece di un raggio.

A differenza di `Class.WorldRoot:GetPartsInPart()`, questo metodo non rileva le `Class.BasePart|BaseParts` che **inizialmente** intersectano la forma.

Se viene rilevata una collisione, viene restituito un `Datatype.RaycastResult` contenente le informazioni sull'impatto. La proprietà `Datatype.RaycastResult.Distance|Distance` rappresenta la distanza che la forma deve percorrere per trovare un impatto, e la proprietà `Datatype.RaycastResult.Position|Position` rappresenta il punto di intersezione che causa l'impatto.

Questo metodo genera un errore se vengono forniti input non validi di raggio o direzione.

WorldRoot:Spherecast

La posizione iniziale della forma sferica lanciata.

Il raggio della forma sferica lanciata in studs. Il raggio massimo è di 256 studs.

La direzione del lancio della forma, con la magnitudine che rappresenta la distanza massima che la forma può percorrere. La distanza massima è 1024 studs.

Lancia una forma sferica in una direzione specificata e restituisce un `Datatype.RaycastResult` se la forma colpisce una cella `Class.BasePart` o `Class.Terrain`.

Simula le parti nello spazio di lavoro per un periodo di tempo fisso chiamando la
funzione StepPhysics una volta per fotogramma fino a quando non è trascorso un tempo specificato.


Avanza la simulazione per le parti nel mondo in avanti in base a un incremento di tempo specificato e a un set opzionale di `Class.BasePart`. Quando viene specificato un set di parti, solo quelle parti saranno simulate e tutte le altre parti nel mondo saranno trattate come ancorate. Quando questo argomento è omesso, tutte le parti nel mondo saranno incluse nella simulazione. L'incremento di tempo specificato può essere qualsiasi numero positivo, con valori più grandi che aumentano il tempo di esecuzione della funzione. A seconda del valore dell'incremento di tempo, il sistema fisico potrebbe suddividerlo in più singoli passaggi per mantenere l'accuratezza e la stabilità della simulazione. Anche se la funzione esegue più passaggi, i risultati della simulazione saranno visibili solo una volta completata la funzione. Per visualizzare i singoli passaggi di una simulazione, la funzione può essere chiamata una volta per RenderStep tramite l'evento `Class.RunService.RenderStepped`.

WorldRoot:StepPhysics

L'ammontare di tempo che verrà simulato. Questo argomento deve essere un numero positivo. Valori più grandi aumenteranno il tempo di esecuzione di questa funzione.

parts

Array opzionale di parti che verrannosimulate. Questo set deve contenere istanze di tipo `Class.BasePart`; qualsiasi altro tipo verrà ignorato.

Avanza la simulazione per le parti nel mondo in avanti in base a un incremento di tempo specificato e a un set opzionale di `Class.BasePart|BaseParts`.

WorldRoot

Classe base per la gestione della simulazione fisica e delle query spaziali 3D.

Il seguente esempio include una funzione di base che prende una tabella di oggetti
ed è genitore in un nuovo Modello, restituendo quel Modello.

I modelli sono oggetti contenitore, il che significa che raggruppano insieme oggetti. Sono
utilizzati al meglio per contenere collezioni di `Class.BasePart|BaseParts` e hanno un certo numero
di funzioni che ne estendono la funzionalità.

I modelli sono destinati a rappresentare raggruppamenti **geometrici**. Se il tuo raggruppamento non ha
alcuna interpretazione geometrica, per esempio una collezione di
`Class.Script|Scripts`, usa invece una `Class.Folder`.

I modelli i cui componenti sono uniti insieme con giunti (in modo che possano
muoversi o essere distrutti tramite simulazione fisica) di solito hanno un
`Class.Model.PrimaryPart|PrimaryPart` impostato, poiché specifica quale parte all'interno
del modello il pivot e la bounding box "seguiranno" mentre il modello si muove. I modelli statici
che rimangono fermi in un posto non beneficiano della presenza di una parte primaria impostata.

I modelli hanno un ampio raggio di applicazioni, inclusi i personaggi dei giocatori di Roblox.
Hanno anche un certo numero di comportamenti unici che è importante tenere a
mente:

- Quando un `Class.Humanoid` e un `Class.Part` chiamato **Head** sono parentati sotto
  un modello, una GUI di nome/salute apparirà sopra il modello; vedere
  [Visualizzazione Nome/Salute del Personaggio](/characters/name-health-display)
  per dettagli.
- Se la posizione di una parte sull'asse **Y** supera il
  `Class.Workspace.FallenPartsDestroyHeight`, e questo era l'ultimo oggetto
  all'interno di un `Class.Model`, anche il modello sarà distrutto.
- Quando utilizzato in un luogo con `Class.Workspace.StreamingEnabled` impostato su true,
  il valore di `Class.Model.ModelStreamingMode|ModelStreamingMode` controlla
  vari comportamenti riguardo a come il modello e eventuali discendenti vengono replicati
  e/o rimossi dai client. Inoltre, il valore di
  `Class.Model.LevelOfDetail|LevelOfDetail` influisce sul rendering del modello.

Come per tutti i tipi di `Class.Instance`, il fatto che un modello padre `Class.Model` sia
replicato a un client non garantisce che tutti i suoi bambini siano
replicati. Questo è particolarmente importante se queste istanze vengono
accedute da codice che viene eseguito sul client, come in un `Class.LocalScript`.
Utilizzando `Class.Model.ModelStreamingMode|ModelStreamingMode` con valori come
`Enum.ModelStreamingMode|Atomic` si può garantire che l'intero modello e tutti i
suoi discendenti siano presenti se il modello padre esiste sul client, oppure
si può utilizzare `Class.Instance:WaitForChild()|WaitForChild()` quando l'atomicità non è
desiderata.

Imposta questo modello come persistente per il giocatore specificato. I modelli
persistenti rimangono presenti per il giocatore indipendentemente dalle impostazioni o
condizioni di streaming.

`Class.Model.ModelStreamingMode|ModelStreamingMode` deve essere impostato su
`Enum.ModelStreamingMode|PersistentPerPlayer` affinché il comportamento venga modificato
come risultato dell'aggiunta.

Model:AddPersistentPlayer

playerInstance

Il `Class.Player` per rendere questo modello persistente.

Imposta questo modello come persistente per il giocatore specificato.
`Class.Model.ModelStreamingMode|ModelStreamingMode` deve essere impostato su
`Enum.ModelStreamingMode|PersistentPerPlayer` affinché il comportamento venga modificato
come risultato dell'aggiunta.

In questo esempio, i joints in ogni Modello del personaggio del Giocatore aggiunto verranno rotti
3 secondi dopo la comparsa. Rompere questi joints causerà la morte dell'Umanoide.


Questo esempio di codice dimostra la creazione manuale di giunture su due parti che sono
sorelle dello script (PartA e PartB). Crea una giuntura su due parti che si toccano
con tipi di superficie compatibili (Studs e Inlet).

Interrompe le connessioni tra `BaseParts`, incluse le connessioni superficiali con
qualsiasi parte adiacente, `Class.WeldConstraint|WeldConstraints`, e tutte
`Class.Weld|Welds` e altre `Class.JointInstance|JointInstances`.

Quando BreakJoints viene utilizzato su un modello di personaggio di un giocatore,
`Class.Humanoid` del personaggio morirà in quanto si basa sul giunto del collo.

Nota che, sebbene i giunti prodotti da connessioni superficiali con adiacenti
Part possono tecnicamente essere ricreati utilizzando `Class.Model:MakeJoints()`, questo
ripristinerà solo giunti prodotti dalle superfici. Gli sviluppatori non dovrebbero fare affidamento
su questo poiché, dopo la rottura dei giunti, le parti potrebbero non trovarsi più in
contatto tra di loro.

Model:BreakJoints

Interrompe le connessioni tra `BaseParts`, incluse le connessioni superficiali con
qualsiasi parte adiacente, `Class.WeldConstraint|WeldConstraints` e tutti
`Class.Weld|Welds` e altre `Class.JointInstance|JointInstances`.

Model:breakJoints

Questa funzione restituisce una descrizione di un volume che contiene tutti
`Class.BasePart` figli all'interno di un `Class.Model`. L'orientamento del volume
è basato sull'orientamento della `Class.Model.PrimaryPart|PrimaryPart`,
e corrisponde alla casella di selezione renderizzata in Studio quando il modello è
selezionato. Rispecchiando il comportamento di `Class.Terrain:FillBlock()`, restituisce un
`Datatype.CFrame` che rappresenta il centro di quella bounding box e un
`Datatype.Vector3` che rappresenta la sua grandezza. La grandezza può essere imprecisa
al runtime se vincoli fisici stanno agendo sulle parti all'interno del
`Class.Model`.

L'orientamento della bounding box corrisponde all'orientamento del
`Class.PVInstance.GetPivot|Pivot` - sia il pivot della
`Class.Model.PrimaryPart|PrimaryPart` (se presente) o il
`Class.Model.WorldPivot|WorldPivot` del modello.

```lua
local Workspace = game:GetService("Workspace")

local model = Workspace.Model
local part = Workspace.Part
local orientation, size = model:GetBoundingBox()

-- Ridimensiona e posiziona la parte uguale alla bounding box del modello
part.Size = size
part.CFrame = orientation
```

Model:GetBoundingBox

Un `Datatype.CFrame` che rappresenta l'orientamento del volume
seguìto da un `Datatype.Vector3` che rappresenta la dimensione del volume.

Restituisce una descrizione di un volume che contiene tutte le parti di un modello.

Il codice di esempio qui sotto dimostra come Model.GetExtentsSize può essere utilizzato per ottenere
la dimensione della bounding box che contiene i pezzi.

Restituisce la dimensione della più piccola bounding box che contiene tutte le
`Class.BasePart|BaseParts` nel `Class.Model`. L'orientamento corrisponde
all'orientamento del `Class.PVInstance.GetPivot|Pivot` - sia il
pivot della `Class.Model.PrimaryPart|PrimaryPart` (se presente) o il
`Class.Model.WorldPivot|WorldPivot` del modello.

Nota che questa funzione restituisce solo la dimensione della più piccola bounding box, e
lo sviluppatore deve impiegare il proprio metodo per ottenere la posizione della
bounding box.

Model:GetExtentsSize

La dimensione `Datatype.Vector3` degli estremi del `Class.Model`.

Restituisce la dimensione della più piccola bounding box che contiene tutte le
`Class.BasePart|BaseParts` nel `Class.Model`, allineata con la
`Class.Model.PrimaryPart` se è impostata.

Questo valore storicamente restituiva il CFrame di una posizione centrale nel
modello.

Model:GetModelCFrame

Questo codice crea un modello, ci mette dentro alcune parti, le posiziona casualmente,
e poi stampa la sua dimensione:


La funzione GetModelSize restituisce la dimensione `Datatype.Vector3` del
`Class.Model`.

Model:GetModelSize

Restituisce la dimensione Vector3 del modello.

Quando questo metodo viene chiamato da un `Class.Script`, restituisce tutti gli
oggetti `Class.Player` per i quali questo modello è persistente. Quando viene chiamato da
un `Class.LocalScript`, questo metodo controlla solo se questo modello è persistente
per il `Class.Players.LocalPlayer|LocalPlayer`.

Model:GetPersistentPlayers

Una tabella con tutti gli oggetti `Class.Player` per i quali questo oggetto modello è
persistente.

Restituisce tutti gli oggetti `Class.Player` per i quali questo oggetto modello è
persistente. Il comportamento varia a seconda che questo metodo venga chiamato
da un `Class.Script` o da un `Class.LocalScript`.

Il seguente codice dimostra come GetPrimaryPartCFrame e
SetPrimaryPartCFrame possano essere utilizzati per ruotare un modello.

Un semplice modello viene creato nello Workspace e viene avviato un ciclo che
ruoterà il modello di 10 gradi attorno all'asse Y ogni 0,2 secondi.

Questa funzione è stata sostituita da `Class.PVInstance:GetPivot()` che
funge da sostituto e non modifica il comportamento del tuo codice. Usa
`Class.PVInstance:GetPivot()` per nuovi lavori e migra le tue chiamate
esistenti a `Class.Model:GetPrimaryPartCFrame()` quando conveniente.

Restituisce il `Datatype.CFrame` della `Class.Model.PrimaryPart` del modello.

Questa funzione è equivalente alla seguente.

    Model.PrimaryPart.CFrame

Nota che questa funzione genererà un errore se non esiste una parte primaria per il
`Class.Model`. Se questo comportamento non è desiderato, gli sviluppatori possono fare
quanto segue, che sarà uguale a `nil` se non esiste la parte primaria.

    local cFrame = Model.PrimaryPart and Model.PrimaryPart.CFrame

Model:GetPrimaryPartCFrame

Restituisce il `Datatype.CFrame` della `Class.Model.PrimaryPart` del modello.
Questa funzione genererà un errore se non esiste parte primaria per il
`Class.Model`.

Questo esempio di codice dimostra come sostituire tutte le copie di un modello di albero utilizzando `Class.Model:PivotTo()` e `Class.Model:ScaleTo()`. Il pivot e la scala dei modelli sono utilizzati come riferimento per garantire che le dimensioni e le posizioni relative dei modelli di sostituzione corrispondano a quelle degli originali.


I modelli contengono un fattore di scala canonico persistente, che parte da 1
per i modelli appena creati e cambia man mano che il modello viene scalato chiamando
`Class.Model:ScaleTo()`. Questa funzione restituisce l'attuale fattore di scala canonico
del modello.

L'attuale fattore di scala non influisce _direttamente_ sulla dimensione delle istanze
sotto il modello. Viene utilizzato per l'autore di contenuti e per scopi di scripting
per ricordare come il modello è stato scalato rispetto alla sua dimensione originale.

All'interno di una data sessione, il modello memorizzerà le informazioni esatte sulla dimensione originale
delle istanze discendenti dopo la prima chiamata a
`Class.Model:ScaleTo()`. Questo significa che chiamare
`Class.Model:ScaleTo()|ScaleTo(x)` seguito da
`Class.Model:ScaleTo()|ScaleTo(1)` ti riporterà _esattamente_ alla
configurazione originale del modello senza deriva in virgola mobile. Evitare
la deriva in virgola mobile è la motivazione per avere una funzione Scale**To**
invece di una funzione Scale**By**.

Il fattore di scala influenza anche il comportamento del motore in un modo: Il fattore di scala
di un modello sarà applicato agli offset dei giunti di
`Class.Animation|Animations` riprodotti su un `Class.AnimationController`
sotto quel modello, affinché i rig animati riproducano correttamente
animazioni anche quando scalati.

Model:GetScale

L'attuale fattore di scala canonico del modello.

Restituisce la scala canonica del modello, che per i modelli appena creati
diventa 1 e cambierà man mano che verrà scalarizzato tramite
`Class.Model:ScaleTo()`.

Questo esempio di codice dimostra come i giunti possono essere creati utilizzando la
funzione Model:MakeJoints.

Un modello è istanziato, con due parti una sopra l'altra. La parte superiore è
ancorata e la parte inferiore non lo è. Normalmente, quando è collegata allo Workspace
a la parte inferiore cadrebbe sulla Baseplate.

Tuttavia, poiché la proprietà TopSurface della parte inferiore è impostata su
Enum.SurfaceType.Weld, questo significa che quando Model:MakeJoints viene eseguito, viene
creata una connessione tra di esse.

Pertanto, la parte inferiore non cade fino a quando i giunti nel modello non sono
rotti. Questo viene spesso fatto utilizzando Model:BreakJoints, ma in questo esempio la
connessione è interrotta utilizzando un'esplosione.

Questo esempio di codice dimostra la creazione di giunti su due parti che sono
sorelle dello script (PartA e PartB). Utilizza MakeJoints su due parti toccanti
con tipi di superficie compatibili (Studs e Inlet).

L'unione basata su SurfaceType è deprecata. Non utilizzare MakeJoints per nuovi
progetti. Utilizza invece `Class.WeldConstraint|WeldConstraints` e
`Class.HingeConstraint|HingeConstraints`.

Scorre tra tutti i `Class.BasePart|Parts` nel `Class.Model` e crea
giunti tra le parti specificate e qualsiasi superficie piana che si tocca,
a seconda delle superfici delle parti.

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

Questa funzione non funziona se la parte non è un discendente di
`Class.Workspace`. Pertanto, devi prima assicurarti che il modello sia parentato
al Workspace prima di utilizzare MakeJoints.

Model:MakeJoints

Scorre tra tutti i `Class.BasePart|BaseParts` nel `Class.Model`. Se la superficie di qualsiasi
parte ha un SurfaceType che può creare un giunto, creerà un giunto con
qualsiasi parte adiacente.

Model:makeJoints

Model:move

location

Questo esempio dimostra come `Class.Model:MoveTo()` eviti le collisioni.

Viene creato un semplice `Class.Model` in due parti e la sua `Class.Model.PrimaryPart`
viene impostata. Un grosso oggetto di ostacolo viene posizionato accanto ad esso.

Dopo 5 secondi, `Class.Model:MoveTo()` viene utilizzato per indirizzare il modello a muoversi
all'interno dell'oggetto di ostacolo. Tuttavia, poiché MoveTo non sposterà un modello all'interno
di un ostacolo, il `Class.Model` viene spostato verso l'alto lungo l'asse Y e posizionato sopra
l'ostacolo.


Muove la `Class.Model.PrimaryPart|PrimaryPart` nella posizione data. Se
non è stata specificata alcuna parte primaria, verrà utilizzata la parte radice del
modello, ma la parte radice non è deterministica e si raccomanda che
venga sempre impostata una parte primaria quando si utilizza `Class.Model:MoveTo()|MoveTo()`.

Se ci sono ostruzioni dove il modello è da essere spostato, come
`Class.Terrain` o altre `Class.BasePart|BaseParts`, il modello verrà
spostato verticalmente verso l'alto fino a quando non ci sarà
niente in mezzo. Se questo comportamento non è desiderato, dovrebbe essere
utilizzato `Class.PVInstance:PivotTo()`.

Nota che la rotazione non è preservata quando si sposta un modello con
`Class.Model:MoveTo()|MoveTo()`. Si raccomanda di utilizzare
`Class.Model:TranslateBy()|TranslateBy()` o `Class.PVInstance:PivotTo()`
se l'attuale rotazione del modello deve essere preservata.

Model:MoveTo

Il `Datatype.Vector3` in cui verrà spostato il `Class.Model`.

Muove la `Class.Model.PrimaryPart|PrimaryPart` nella posizione data. Se
non è stata specificata alcuna parte primaria, verrà utilizzata la parte radice del
modello.

Model:moveTo

Rende questo modello non più persistente per il giocatore specificato. Ciò non
garantisce che il modello verrà immediatamente rimosso per il giocatore; dopo
aver chiamato questo metodo, il modello sarà trattato come
`Enum.ModelStreamingMode|Atomic` per quel giocatore e rimarrà presente
finché è all'interno del raggio di streaming target.

`Class.Model.ModelStreamingMode|ModelStreamingMode` deve essere impostato su
`Enum.ModelStreamingMode|PersistentPerPlayer` affinché il comportamento venga modificato
come risultato della rimozione.

Model:RemovePersistentPlayer

Il `Class.Player` per rendere questo modello non più persistente.

Rende questo modello non più persistente per il giocatore specificato.
`Class.Model.ModelStreamingMode|ModelStreamingMode` deve essere impostato su
`Enum.ModelStreamingMode|PersistentPerPlayer` affinché il comportamento venga modificato
come risultato della rimozione.

Ripristina la rotazione delle parti del modello alla rotazione di identità precedentemente
impostata, che avviene tramite il metodo `Class.Model:SetIdentityOrientation()`.

Model:ResetOrientationToIdentity

I modelli contengono un fattore di scala canonico persistente, che parte da 1
per i modelli appena creati. Questa funzione scala il modello, attorno alla posizione del pivot,
rispetto a come apparirebbe con un fattore di scala di 1. Per
realizzare ciò, esegue due operazioni:

- Imposta l'attuale fattore di scala del modello sul valore specificato
- Ridimensiona e riposiziona di conseguenza tutte le istanze discendenti

Il ridimensionamento delle posizioni avviene attorno alla posizione del pivot.

Tutte le proprietà "geometriche" delle istanze discendenti saranno scalate. Questo
ovviamente include le dimensioni delle parti, ma ecco alcuni altri esempi di
proprietà che vengono scalate:

- La lunghezza dei giunti come `Class.WeldConstraint|WeldConstraints`, e
  `Class.RopeConstraint`
- Velocità e forze fisiche come `Class.HingeConstraint`
- Proprietà visive come dimensioni di emettitori di particelle
- Altre proprietà di lunghezza come `Class.Sound.RollOffMinDistance`

Model:ScaleTo

newScaleFactor

Imposta il fattore di scala del modello, regolando la dimensione e la posizione di
tutte le istanze discendenti in modo che abbiano quel fattore di scala rispetto alle
loro dimensioni e posizioni iniziali quando il fattore di scala era 1.

Imposta la rotazione di identità del modello dato, consentendo di ripristinare
la rotazione dell'intero modello in seguito, tramite l'uso del metodo
`ResetOrientationToIdentity`.

Model:SetIdentityOrientation

Questa funzione è stata sostituita da `Class.PVInstance:PivotTo()` che
funge da sostituto più performante e non modifica il comportamento del tuo codice. Usa
`Class.PVInstance:PivotTo()` per nuovi lavori e migra le tue chiamate
esistenti a `Class.Model:SetPrimaryPartCFrame()` quando conveniente.

Imposta il `Class.BasePart.CFrame` della `Class.Model.PrimaryPart` del modello.
Tutte le altre parti nel modello verranno anch'esse spostate e manterranno la loro
orientazione e offset rispetto alla `Class.Model.PrimaryPart`.

Nota, questa funzione genererà un errore se non esiste `Class.Model.PrimaryPart`
per il modello. Questo può causare problemi se, ad esempio, la parte primaria non è
gia stata impostata o è stata distrutta.

Model:SetPrimaryPartCFrame

Imposta il `Class.BasePart.CFrame` della `Class.Model.PrimaryPart` del modello.
Tutte le altre parti nel modello verranno anch'esse spostate e manterranno la loro
orientazione e offset rispetto alla `Class.Model.PrimaryPart`.

Questo campione dimostra come `Class.Model:TranslateBy()` ignori le collisioni
 e rispetti l'orientamento del modello.

Viene creato un semplice modello `Class.Model` a due parti, ruotato di 45 gradi
sull'asse Y, e il suo `Class.Model.PrimaryPart` è impostato. Una grande parte di ostacolo
è posizionata accanto ad esso.

Dopo 5 secondi, `Class.Model:TranslateBy()` viene utilizzato per indirizzare il
modello a muoversi all'interno della parte di ostacolo. Il modello si muoverà
dentro l'ostacolo e manterrà il proprio orientamento attuale.


Sposta un `Class.Model` tramite l'offset `Datatype.Vector3` dato, preservando
l'orientazione del modello. Se un'altra `Class.BasePart` o `Class.Terrain`
esiste già nella nuova posizione, il `Class.Model` sovrapporrà detto oggetto.

La traduzione viene applicata nello spazio mondiale piuttosto che nello spazio dell'oggetto,
ciò significa che, anche se le parti del modello sono orientate in modo diverso, si muoverà sempre
lungo l'asse standard.

Model:TranslateBy

Sposta un `Class.Model` tramite l'offset `Datatype.Vector3` dato, preservando
l'orientazione del modello. Se un'altra `Class.BasePart` o `Class.Terrain`
esiste già nella nuova posizione, il `Class.Model` sovrapporrà detto oggetto.

Model

I modelli sono oggetti contenitore, il che significa che raggruppano insieme oggetti. Sono
utilizzati al meglio per contenere collezioni di `Class.BasePart|BaseParts` e hanno un certo numero
di funzioni che ne estendono la funzionalità.

/reference/engine/classes/WorldModel.yaml