Cuando se parenta a un `Class.ViewportFrame`, `WorldModel` extiende física limitada
para sus hijos a ese `Class.ViewportFrame`. Por ejemplo,
`Class.BasePart|BaseParts` que están parentados al `WorldModel` pueden ser
animados y consultados espacialmente (por ejemplo, mediante raycasts), pero esas partes
**no** son simuladas. Además, puedes poner personajes de `Class.Humanoid` en el
`WorldModel` y sus articulaciones se configurarán correctamente para la animación.

`WorldModel` también expone la
`Class.WorldModel.UseWorkspaceCollisionGroups|UseWorkspaceCollisionGroups`
propiedad para determinar si utiliza grupos de colisión de `Class.Workspace` o
sus propios grupos de colisión independientes para las consultas.

Para evitar posibles problemas de rendimiento, asegúrate de crear `WorldModels`
solo cuando quieras mostrarlos y de eliminar `WorldModels` que actualmente no
estén en uso.


WorldModel

Cuando es `false` (por defecto), este `WorldModel` utiliza sus propios grupos de colisión
para todo comportamiento relacionado con colisiones.

Cuando es `true`, este `WorldModel` utiliza grupos de colisión de `Class.Workspace`.
Además, el estado del grupo de colisión de este `WorldModel` puede seguir
siendo modificado.


WorldModel.UseWorkspaceCollisionGroups

Determina si este `WorldModel` utiliza grupos de colisión de `Class.Workspace`
o sus propios grupos de colisión independientes para las consultas.


Esta clase base proporciona una API para cualquier instancia destinada a manejar consultas espaciales en 3D y simulaciones, como `Class.Workspace` y `Class.WorldModel`.

El bloque de código a continuación demuestra cómo usar
`Class.WorldRoot:ArePartsTouchingOthers()` para comprobar si las partes en una lista están
tocando alguna parte en el espacio de trabajo que no está en la lista.

Primero, el script crea dos partes cuadradas que se superponen 1 stud, `Part1` y
`Part2`. Luego, imprime el valor devuelto por ArePartsTouchingOthers() cuando
Part1 se pasa en `partList` con tres valores de superposición diferentes: `0`, `0.999`,
y `1`. Las dos primeras veces que se llama a ArePartsTouchingOthers() devuelven `false`
porque los valores de superposición son menores que la distancia a la que Part1 y Part2
se superponen. La tercera llamada devuelve `true` porque el valor de superposición es igual a
la distancia a la que las partes se superponen.

**ArePartsTouchingOthers** devuelve verdadero si al menos uno de los `Class.BasePart` dados está tocando otras partes. Dos partes se consideran "tocando" si están dentro del umbral de distancia, `overlapIgnored`.

Si no se proporcionan partes, se devuelve falso.

WorldRoot:ArePartsTouchingOthers

partList

Una lista de partes que verifica si alguna parte en la lista está tocando partes que no están en la lista.

overlapIgnored

El umbral de superposición de partes en studs que se ignora antes de considerar que las partes están tocando.

Verdadero si y solo si cualquiera de los `Class.Part|parts` en `partList` están tocando otras partes (partes que no están en partList). Falso si no se pasan partes.

Devuelve verdadero si cualquiera de los `Class.BasePart` dados están tocando otras partes.

Lanza un bloque y devuelve la primera colisión con un `Class.BasePart` o
`Class.Terrain`. Imprime las propiedades del RaycastResult si se obtuvo un resultado.

Lanza una forma de bloque en una dirección dada y devuelve la primera colisión con un `Class.BasePart` o una celda de `Class.Terrain`. Esto es análogo a cómo `Class.WorldRoot:Raycast()` lanza un rayo lineal en una dirección para encontrar una colisión, pero utiliza una forma 3D en lugar de un rayo.

A diferencia de `Class.WorldRoot:GetPartsInPart()`, este método no detecta `Class.BasePart|BaseParts` que **inicialmente** intersectan la forma.

Si se detecta un golpe, se devuelve un `Datatype.RaycastResult` que contiene la información de la colisión. La propiedad `Datatype.RaycastResult.Distance|Distance` representa la distancia que la forma tiene que recorrer para encontrar un golpe, y la propiedad `Datatype.RaycastResult.Position|Position` representa el punto de intersección que causa el golpe.

Este método lanza un error si se le pasan entradas inválidas de `Datatype.CFrame`, tamaño o dirección.

WorldRoot:Blockcast

cframe

La posición inicial y rotación de la forma de bloque lanzada.

size

El tamaño de la forma de bloque lanzada en studs. El tamaño máximo es 512 studs.

direction

Dirección de la forma lanzada, con la magnitud representando la distancia máxima que la forma puede recorrer. La distancia máxima es de 1024 studs.

params

Un objeto utilizado para especificar la elegibilidad de impacto en la operación de shapecast.
Si no se proporciona, se utilizan valores predeterminados donde se consideran todas las partes y el agua de `Class.Terrain` no se ignora.

Contiene el resultado de la operación de lanzamiento de forma, o `nil` si no se golpeó ninguna `Class.BasePart` o celda de `Class.Terrain` elegible.

Lanza una forma de bloque en una dirección dada y devuelve un `Datatype.RaycastResult` si la forma golpea un `Class.BasePart` o una celda de `Class.Terrain`.

Esta función mueve un array de `Class.BasePart|BaseParts` a un array de
`Datatype.CFrame|CFrames` sin necesariamente activar la propiedad por defecto
`Class.Object.Changed|Changed`. Esto proporciona una forma muy rápida de
mover grandes cantidades de partes, ya que no tienes que pagar el costo de
conjuntos de propiedades separados para cada parte individual.

Tanto `partList` como `cframeList` son arrays secuenciales (tablas Luau con
índices enteros que comienzan en 1), no diccionarios. Cada parte en el índice `i`
en `partList` se mueve al `Datatype.CFrame|CFrame` en el índice `i` en
`cframeList`. Los arrays deben contener el mismo número de entradas.

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

local partList = { Workspace.Part1, Workspace.Part2 }
local cframeList = { CFrame.new(0, 5, 0), CFrame.new(10, 5, 0) }
Workspace:BulkMoveTo(partList, cframeList, Enum.BulkMoveMode.FireCFrameChanged)
```
El tercer argumento te permite optimizar aún más la operación de movimiento.
Por defecto, el evento `Class.Object.Changed|Changed` de cada parte se activa
para `Class.BasePart.Position|Position`,
`Class.BasePart.Orientation|Orientation`, y
`Class.BasePart.CFrame|CFrame`. Sin embargo, si especificas
`Enum.BulkMoveMode|FireCFrameChanged` como el tercer argumento, solo se
activará el evento `Class.Object.Changed|Changed` para la
propiedad `Class.BasePart.CFrame|CFrame`.

Ten en cuenta que solo debes usar esta función si estás seguro de que el
movimiento de partes es un cuello de botella en tu código. Simplemente
establecer la propiedad `Class.BasePart.CFrame|CFrame` de partes individuales
y modelos soldados es lo suficientemente rápido en la mayoría de los casos.

WorldRoot:BulkMoveTo

Un array de `Class.BasePart|BaseParts` que se moverán. Cada entrada se
coincide por índice con la entrada correspondiente en `cframeList`.

cframeList

Un array de `Datatype.CFrame|CFrames` a los que se moverán las partes,
coincidiendo por índice con `partList`. Ambos arrays deben tener la misma longitud.

eventMode

Un enum `Enum.BulkMoveMode` que especifica cuáles
`Class.Object.Changed|Changed` eventos se activan durante el movimiento. El valor predeterminado es
`Enum.BulkMoveMode|FireAllEvents`.

Mueve un array de `Class.BasePart|BaseParts` a un array de
`Datatype.CFrame|CFrames`.

Devuelve si los dos grupos de colisión especificados colisionarán en este
mundo. Este método también devolverá `true` si alguno de los grupos está
no registrado en este mundo, ya que la máscara de colisión predeterminada
colisiona con todos los grupos.


WorldRoot:CollisionGroupsAreCollidable

name1

name2

Devuelve si los dos grupos colisionarán en este mundo.


Establece el estado de colisión entre dos grupos en este mundo. Este método
lanzará un error si alguno de los grupos no está registrado en este mundo,
por lo que se recomienda que confirmes el registro de cada grupo a través
de `Class.WorldRoot:IsCollisionGroupRegistered()` antes de hacer esta llamada.


WorldRoot:CollisionGroupSetCollidable

collidable

Establece el estado de colisión entre dos grupos en este mundo.


**FindPartOnRay** utiliza [raycasting](/workspace/raycasting) para
encontrar el primer `Class.BasePart` o celda de `Class.Terrain` que intersecta
con un `Datatype.Ray` dado. Esta función devuelve el `Class.BasePart` o
la celda de terreno golpeada, el punto de intersección, la normal de la
superficie en el punto de intersección y el `Enum.Material` asociado.

Si se proporciona el parámetro `ignoreDescendantsInstance`, el cálculo de
raycasting ignorará el objeto dado y todos sus descendientes. Se comporta
similar a la propiedad `Class.Mouse.TargetFilter`.

Los parámetros `terrainCellsAreCubes` e `ignoreWater` determinan si las
celdas de `Class.Terrain` deben ser tratadas como cubos o no, y si el agua
debe ser ignorada o no.

Para incluir o excluir múltiples objetos y sus descendientes, utiliza
`Class.WorldRoot:FindPartOnRayWithWhitelist()` y
`Class.WorldRoot:FindPartOnRayWithIgnoreList()`.

#### Notas

- Teóricamente, un rayo se extiende infinitamente en una dirección. Sin
  embargo, la longitud máxima del vector de dirección en Roblox es de 15000
  studs.
- La longitud (magnitud) del vector direccional es importante, ya que las
  partes que están más lejos que su longitud no serán probadas.
- Si el rayo no intersecta nada, los valores de retorno serán `nil`
  y el punto al final del rayo, respectivamente.
- Las partes que están en un
  [grupo de colisión](/workspace/collisions#collision-filtering)
  que no colisiona con el grupo de colisión "Default" son ignoradas
  implícitamente.


WorldRoot:FindPartOnRay

Un `Datatype.Ray` cuya origen y dirección definen el raycast.

ignoreDescendantsInstance

Una `Class.Instance` cuyos descendientes son ignorados en el raycast.


terrainCellsAreCubes

Si las celdas de `Class.Terrain` se tratan como cubos completos al
calcular la intersección. El valor predeterminado es falso.

ignoreWater

Si las celdas de agua de `Class.Terrain` son ignoradas por el rayo. El valor predeterminado es
falso.

El `Class.BasePart` o celda de `Class.Terrain` golpeada, el punto de intersección `Datatype.Vector3`, la normal de superficie `Datatype.Vector3` en el punto de intersección, y el `Enum.Material` del `Class.BasePart` o celda de terreno golpeada.

Devuelve el primer `Class.BasePart` o celda de `Class.Terrain` que intersecta
con el `Datatype.Ray` dado.


WorldRoot:findPartOnRay

Esta función es una variante de `Class.WorldRoot:FindPartOnRay()` con la
adición de una lista de ignorados. Esto te permite ignorar ciertas partes o
`Class.Model|Models`.

Aquellos que buscan **incluir** un grupo específico de objetos deben
utilizar en su lugar `Class.WorldRoot:FindPartOnRayWithWhitelist()`.


WorldRoot:FindPartOnRayWithIgnoreList

Un `Datatype.Ray` cuyo origen y dirección definen el raycast.


ignoreDescendantsTable

Un array de objetos cuyos descendientes son excluidos del raycast.


Si las celdas de `Class.Terrain` son tratadas como cubos completos al
calcular la intersección. El valor predeterminado es falso.


Si las celdas de agua de `Class.Terrain` son ignoradas por el rayo. El
valor predeterminado es falso.


El `Class.BasePart` o celda de `Class.Terrain` golpeada, el
`Datatype.Vector3` punto de intersección, la `Datatype.Vector3`
norma de superficie en el punto de intersección, y el `Enum.Material`
del `Class.BasePart` o celda de terreno golpeada.


Devuelve el primer `Class.BasePart` o celda de `Class.Terrain` que intersecta
con el `Datatype.Ray` dado que no está en, ni es un descendiente de un
objeto en, la lista de ignorados dada.


Esta función es una variante de `Class.WorldRoot:FindPartOnRay()` con la
adición de una lista de inclusión. Esto te permite detectar solo ciertas
partes o `Class.Model|Models` y es particularmente útil cuando, por
ejemplo, se busca puntos de intersección entre un rayo y una sola parte.

Si se proporciona un valor `nil` en la lista de inclusión, las instancias
posteriores a este serán ignoradas.

Aquellos que buscan **excluir** un grupo específico de objetos deben
utilizar en su lugar `Class.WorldRoot:FindPartOnRayWithIgnoreList()`.


WorldRoot:FindPartOnRayWithWhitelist

whitelistDescendantsTable

Un array de objetos cuyos descendientes son los únicos candidatos
considerados en el raycast.


Devuelve el primer `Class.BasePart` o celda de `Class.Terrain` que intersecta
con el `Datatype.Ray` dado que está en, o es un descendiente de un objeto
en, la lista de inclusión dada.


Devuelve un array de `Class.BasePart|BaseParts` en el dado
`Datatype.Region3`.

Esta función toma un parámetro opcional maxParts (predeterminado 20) que
limita el número de `Class.BasePart|BaseParts` que pueden ser devueltos. Una vez
que se ha alcanzado este número, la búsqueda de `Class.BasePart|BaseParts`
se detendrá. Esto significa que algunas `Class.BasePart|BaseParts` pueden no ser devueltas
even si están dentro del `Datatype.Region3`

El parámetro opcional `ignoreDescendantsInstance` puede ser utilizado para especificar
una instancia específica para la cual ella misma y todos sus descendientes deben ser
ignorados por esta función. Esto puede ser útil cuando, por ejemplo, se busca
ver si alguna `Class.BasePart|BaseParts` está dentro de un `Class.BasePart` que no
sea el `Class.BasePart` mismo.

```
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)  -- Ignorar parte
```
Las variantes de este método `Class.WorldRoot:FindPartsInRegion3WithIgnoreList()` y
`Class.WorldRoot:FindPartsInRegion3WithWhiteList()` existen para proporcionar
funcionalidad específica de exclusión e inclusión.

Si no se encuentran `Class.BasePart|BaseParts`, se devolverá un array vacío.


WorldRoot:FindPartsInRegion3

region

Una `Class.Instance` que debe ser ignorada.


maxParts

La cantidad máxima de `Class.BasePart|BaseParts` que se devolverán.


Un array de `Class.BasePart|BaseParts` dentro del `Datatype.Region3`.


Devuelve un array de `Class.BasePart|BaseParts` en el dado
`Datatype.Region3`.


WorldRoot:findPartsInRegion3

Devuelve un array de `Class.BasePart|BaseParts` en el dado
`Datatype.Region3` que no están en, ni son descendientes de una entrada en,
la lista de ignorados dada.

Si se proporciona un valor `nil` en la lista de ignorados, las instancias
posteriores a este valor no serán ignoradas. Si no se encuentran `Class.BasePart|BaseParts`, se devolverá un array vacío.

Esta función es una variante de `Class.WorldRoot:FindPartsInRegion3()` con
la adición de una lista de ignorados. Esto permite al desarrollador excluir
ciertos `Class.BasePart|BaseParts` o `Class.Model|Models` de la
búsqueda. Aquellos que buscan encontrar `Class.BasePart|BaseParts` en un
`Datatype.Region3` utilizando una lista de inclusión deben usar
`Class.WorldRoot:FindPartsInRegion3WithWhiteList()`.


WorldRoot:FindPartsInRegion3WithIgnoreList

El número máximo de `Class.BasePart|BaseParts` a ser devueltos.


Un array de `Class.BasePart|BaseParts` encontrados dentro del
`Datatype.Region3`.


Devuelve un array de `Class.BasePart|BaseParts` en el dado
`Datatype.Region3` que no están en, ni son descendientes de una entrada en,
la lista de ignorados dada.


Devuelve un array de `Class.BasePart|BaseParts` en el dado
`Datatype.Region3` que están en, o son descendientes de una entrada en,
la lista de inclusión dada.

Si se proporciona un valor `nil` en la lista de inclusión, las instancias
posteriores a este valor no serán ignoradas. Si no se encuentran `Class.BasePart|BaseParts`, se devolverá un array vacío.

Esta función es una variante de `Class.WorldRoot:FindPartsInRegion3()` con
la adición de una lista de inclusión. Esto permite al desarrollador incluir
solo ciertos `Class.BasePart|BaseParts` o `Class.Model|Models` en la
búsqueda. Aquellos que buscan encontrar `Class.BasePart|BaseParts` en un
`Datatype.Region3` utilizando una lista de exclusión deben usar
`Class.WorldRoot:FindPartsInRegion3WithIgnoreList()`.


WorldRoot:FindPartsInRegion3WithWhiteList

Devuelve un array de `Class.BasePart|BaseParts` en el dado
`Datatype.Region3` que están en, o son descendientes de una entrada en,
la lista de inclusión dada.


Devuelve el número máximo de grupos de colisión que el motor soporta por
mundo. Este valor es actualmente 32.


WorldRoot:GetMaxCollisionGroups

Devuelve el número máximo de grupos de colisión en este mundo.


`Class.WorldRoot:GetPartBoundsInBox()` devuelve un array de partes cuyas
**cajas delimitadoras** se superponen a una caja cuyo volumen se describe
usando el centro dado (`Datatype.CFrame`) y el tamaño (`Datatype.Vector3`).

Como se enfatiza, este método de consulta espacial considera eficientemente el
volumen de las cajas delimitadoras de las partes en lugar de su volumen
real ocupado. Esto puede ser importante al considerar cilindros, esferas,
uniones y `Class.MeshPart|MeshParts` que tienen formas no bloque. Para
casos donde la precisión es especialmente importante, usa `Class.WorldRoot:GetPartsInPart()`
en su lugar, o filtra aún más los resultados de este método tú mismo.

Este método utiliza un objeto `Datatype.OverlapParams` para describir porciones
reutilizables de la consulta espacial, como una lista de inclusión o exclusión,
el número máximo de partes a consultar, qué
[grupo de colisión](/workspace/collisions#collision-filtering) usar,
y si la consulta favorece el valor de
`Class.BasePart.CanCollide` de una parte intersectada sobre su valor de
`Class.BasePart.CanQuery`.


WorldRoot:GetPartBoundsInBox

La ubicación del centro del volumen de la caja dada a ser consultada.


El tamaño del volumen de la caja dada a ser consultada.


overlapParams

Contiene porciones reutilizables de los parámetros de consulta espacial.


Un array de `Class.BasePart|BaseParts` que coincidieron con la consulta
espacial.


Devuelve un array de partes cuyas **cajas delimitadoras** se superponen a una
caja dada.


`Class.WorldRoot:GetPartBoundsInRadius()` devuelve un array de partes cuyas
**cajas delimitadoras** se superponen a una esfera cuyo volumen se describe
usando el centro dado (`Datatype.Vector3`) y el radio (número).

Como se enfatiza, este método de consulta espacial considera eficientemente el
volumen de las cajas delimitadoras de las partes en lugar de su volumen
real ocupado. Esto puede ser importante al considerar cilindros, esferas,
uniones y `Class.MeshPart|MeshParts` que tienen formas no bloque. Para
casos donde la precisión es especialmente importante, usa `Class.WorldRoot:GetPartsInPart()`
en su lugar, o filtra aún más los resultados de este método tú mismo.

Este método utiliza un objeto `Datatype.OverlapParams` para describir porciones
reutilizables de la consulta espacial, como una lista de inclusión o exclusión,
el número máximo de partes a consultar, qué
[grupo de colisión](/workspace/collisions#collision-filtering) usar,
y si la consulta favorece el valor de
`Class.BasePart.CanCollide` de una parte intersectada sobre su valor de
`Class.BasePart.CanQuery`.


WorldRoot:GetPartBoundsInRadius

position

La ubicación del centro del volumen de la esfera dada a ser consultada.


radius

El radio del volumen de la esfera dada a ser consultada.


Devuelve un array de partes cuyas **cajas delimitadoras** se superponen a una
esfera dada.


`Class.WorldRoot:GetPartsInPart()` devuelve un array de partes cuyo
espacio ocupado se comparte con la parte dada (que debe existir en el mismo
`Class.WorldRoot` que las partes a ser consultadas). Este método puede ser
utilizado en lugar de `Class.BasePart:GetTouchingParts()` y generalmente es una
mejor opción.

Como se indicó, este método de consulta espacial considera el **volumen exacto**
ocupado por la parte dada utilizando una verificación de colisión geométrica completa.
Como ejemplo, una parte cóncava/hueca no coincidirá con las partes consultadas dentro
de ella a menos que realmente se superpongan/tocen dicha parte. Para volúmenes más
simples, considera usar `Class.WorldRoot:GetPartBoundsInBox()` o
`Class.WorldRoot:GetPartBoundsInRadius()`, ya que son menos precisos pero
funcionan de manera más eficiente.

Este método utiliza un objeto `Datatype.OverlapParams` para describir porciones
reutilizables de la consulta espacial, como una lista de inclusión o exclusión,
el número máximo de partes a consultar, qué
[grupo de colisión](/workspace/collisions#collision-filtering) usar,
y si la consulta favorece el valor de
`Class.BasePart.CanCollide` de una parte intersectada sobre su valor de
`Class.BasePart.CanQuery`.


WorldRoot:GetPartsInPart

part

La parte cuyo volumen se va a verificar contra otras partes.


Devuelve un array de partes cuyo espacio ocupado se comparte con la parte dada.


Devuelve una tabla con información sobre todos los grupos de colisión de este mundo. Cada
valor en la tabla devuelta es a su vez una tabla que contiene dos miembros:

<table>
  <thead>
    <tr>
      <th>Miembro</th>
      <th>Tipo</th>
      <th>Descripción</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>mask</td>
      <td>entero</td>
      <td>La máscara del grupo de colisión; solo para uso interno.</td>
    </tr>
    <tr>
      <td>name</td>
      <td>cadena</td>
      <td>Nombre del grupo de colisión.</td>
    </tr>
  </tbody>
</table>


WorldRoot:GetRegisteredCollisionGroups

Devuelve una tabla con información sobre todos los grupos de colisión de este mundo.


Esta función mueve la parte especificada a la ubicación especificada a través de
[cinemática inversa](https://en.wikipedia.org/wiki/Inverse_kinematics)
en lugar de moverla directamente, para asegurar que cualquier unión,
`Class.Constraint|constraints`, o colisiones en las que participe esa parte
permanecen físicamente satisfechas. Actualmente, esta función solo está disponible
en Studio para `Class.Plugin|plugins`, ya que actualmente entra en conflicto con la
física de un juego en ejecución.

**Translate stiffness** es un número entre 0 y 1 que especifica cuán
agresivamente hacer coincidir la posición de la parte con la parte de posición del
CFrame objetivo. **Rotate stiffness** es un número entre 0 y 1 que especifica
cuán agresivamente hacer coincidir la rotación de la parte con la parte de rotación del
CFrame objetivo.

Por ejemplo:

- Si la rigidez de traducción y la rigidez de rotación son ambas iguales a 1, entonces
  la parte se moverá exactamente al CFrame objetivo sin importar qué
  restricciones físicas haya sobre ella.
- Si la rigidez de traducción y la rigidez de rotación son ambas iguales a 0.5, entonces
  la parte intentará moverse exactamente al CFrame objetivo, pero puede ser
  empujada fuera del camino por restricciones físicas sobre ella.
- Si la rigidez de traducción y la rigidez de rotación son ambas iguales a 0, entonces
  el CFrame objetivo será ignorado y las restricciones físicas se resolverán para el
  objeto en la posición donde estaba.


WorldRoot:IKMoveTo

target

La ubicación a la que mover la parte especificada.


translateStiffness

Un número entre 0 y 1 que especifica cuán agresivamente hacer coincidir la
posición de la parte con la parte de posición del `Datatype.CFrame` objetivo.


rotateStiffness

Un número entre 0 y 1 que especifica cuán agresivamente hacer coincidir la
rotación de la parte con la parte de rotación del `Datatype.CFrame` objetivo.


collisionsMode

Te permite especificar qué objetos deben ser afectados por la resolución
física.


Mueve la parte especificada a la ubicación especificada a través de cinemática inversa
en lugar de moverla directamente, para asegurar que cualquier unión, restricción,
o colisiones en las que participe esa parte permanezcan físicamente satisfechas.


Verifica si un grupo de colisión está registrado en este mundo. Se recomienda
que llames a este método antes de llamar a métodos que lanzan errores para
grupos de colisión no registrados, como
`Class.WorldRoot:CollisionGroupSetCollidable()`.


WorldRoot:IsCollisionGroupRegistered

name

Verifica si un grupo de colisión está registrado en este mundo.


**IsRegion3Empty** devuelve un bool que indica si no hay
`Class.BasePart|BaseParts` dentro del `Datatype.Region3` dado.

El parámetro opcional `ignoreDescendantsInstance` puede ser utilizado para especificar
una instancia específica para la cual ella misma y todos sus descendientes deben ser
ignorados por esta función. Esto puede ser útil cuando, por ejemplo, se busca
ver si alguna `Class.BasePart|BaseParts` está dentro de un `Class.BasePart` que no
sea el `Class.BasePart` mismo.

```
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)  -- Ignorar parte
```
Si se necesita excluir más de un objeto y sus descendientes de la
búsqueda, los desarrolladores deben usar
`Class.WorldRoot:IsRegion3EmptyWithIgnoreList()`.

Esta función solo devuelve si una región está vacía o no. Los desarrolladores que buscan
encontrar `Class.BasePart|BaseParts` en una región deben usar
`Class.WorldRoot:FindPartsInRegion3()`.

#### ¿Cómo funcionan las verificaciones de Region3?

Verificar si una parte se superpone a un `Datatype.Region3` no es un proceso simple.
De hecho, es complicado y consume tiempo. En su lugar, verifica si las partes
están aproximadamente en la misma área. Cuando se llama a esta función, determina
qué vóxeles contienen el `Datatype.Region3`. Luego determina qué partes podrían
estar en esos vóxeles. Hace esto comparando la caja delimitadora alineada al eje
(a veces llamada AABB) de la parte con los vóxeles. La caja delimitadora alineada al eje
se puede ver en Roblox Studio cuando se selecciona una parte.

Esto significa que el área que inspecciona la función puede ser más grande
que el `Datatype.Region3`. Por esta razón, se recomienda asegurarse de que el
`Datatype.Region3` esté en la cuadrícula de vóxeles. La mejor manera de hacer
esto es configurando las coordenadas del `Datatype.Region3` a múltiplos
de 4 (ya que los vóxeles son de 4 x 4 x 4 studs).

Este método es una forma bastante rápida y fácil de ver si hay partes en un
área general. Si un juego necesita saber si las partes están exactamente en un área,
entonces se debe usar `Class.BasePart:GetTouchingParts()`. Hay un costo mayor
por usar `Class.BasePart:GetTouchingParts()` ya que se necesita una parte
en el `Class.WorldRoot` y la función tarda más en ejecutarse.


WorldRoot:IsRegion3Empty

ignoreDescendentsInstance

Verdadero si el `Datatype.Region3` está vacío.


Devuelve un bool que indica si no hay `Class.BasePart|BaseParts`
 dentro del `Datatype.Region3` dado.


Devuelve un booleano que indica si no hay
`Class.BasePart|BaseParts` dentro del `Datatype.Region3` dado, ignorando
cualquier `Class.BasePart|BaseParts` que sean descendientes de los objetos dentro
de la lista de ignorados dada. Si se proporciona un valor `nil` en la lista de
ignorados, las instancias posteriores a este valor no serán ignoradas.

Esta función solo devuelve si una región está vacía o no. Los desarrolladores que buscan
encontrar `Class.BasePart|BaseParts` específicos en una región deben usar
`Class.WorldRoot:FindPartsInRegion3WithIgnoreList()`.

Esta función es una variante de `Class.WorldRoot:IsRegion3Empty()` con la
adición de una lista de ignorados. En casos donde se requiere una lista de inclusión
en su lugar, los desarrolladores deben verificar si alguna parte es devuelta por
`Class.WorldRoot:FindPartsinRegion3WithWhitelist()`.


WorldRoot:IsRegion3EmptyWithIgnoreList

ignoreDescendentsTable

Devuelve un booleano que indica si no hay
`Class.BasePart|BaseParts` dentro del `Datatype.Region3` dado, ignorando
cualquier `Class.BasePart|BaseParts` que sean descendientes de los objetos dentro
de la lista de ignorados dada.


Lanza un rayo y devuelve la primera colisión con un `Class.BasePart` o
`Class.Terrain`. Imprime las propiedades del RaycastResult si se produjo
una colisión.

Lanza un rayo usando un origen, dirección y opcional
`Datatype.RaycastParams`. Si encuentra un `Class.BasePart` o
celda de `Class.Terrain` elegible, se devuelve un `Datatype.RaycastResult` que contiene
los resultados de la operación. Si no se proporciona un objeto `Datatype.RaycastParams`, se
utilizan los valores predeterminados (todas las partes son consideradas y
el agua de `Class.Terrain` no es ignorada).

Ten en cuenta que la longitud (magnitud) del vector direccional es importante,
ya que los objetos/terreno más alejados que su longitud no serán probados. Si
estás utilizando un `Datatype.CFrame` para ayudar a crear los componentes del rayo,
considera usar `Datatype.CFrame.LookVector` como el vector direccional y
multiplicarlo por la longitud deseada como se muestra en el ejemplo a continuación. La
longitud máxima del vector de dirección es de 15,000 studs.

Este método **no** utiliza un objeto `Datatype.Ray`, pero sus componentes de
origen y dirección pueden ser tomados de `Datatype.Ray.Origin` y
`Datatype.Ray.Direction`.


WorldRoot:Raycast

origin

El vector direccional del rayo. Ten en cuenta que la longitud de este vector
es importante, ya que las partes/terreno más alejados que su longitud no serán
probados.


raycastParams

Un objeto utilizado para especificar la elegibilidad de impacto en la operación de raycast.
Si no se proporciona, se utilizan valores predeterminados donde todas las partes son
consideradas y el agua de `Class.Terrain` no es ignorada.


Contiene los resultados de una operación de raycast, o `nil` si no se golpeó
ningún `Class.BasePart` o celda de `Class.Terrain` elegible.


Lanza un rayo usando un origen, dirección y opcional
`Datatype.RaycastParams`, luego devuelve un `Datatype.RaycastResult` si un
objeto o terreno elegible intersecta el rayo.


Registra un nuevo grupo de colisión en este mundo con el nombre dado. El
nombre no puede ser `"Default"`.

Ten en cuenta que este método tiene un ligero costo de rendimiento basado en el
número de `Class.BasePart|BaseParts` en el mundo, por lo que se recomienda
que registres todos los grupos de colisión en el tiempo de edición a través del
[editor](/workspace/collisions#collision-groups) de Studio y llames a
`Class.WorldRoot:UnregisterCollisionGroup()|UnregisterCollisionGroup()`
y `Class.WorldRoot:RenameCollisionGroup()|RenameCollisionGroup()` tan
pocas veces como sea posible.


WorldRoot:RegisterCollisionGroup

Registra un nuevo grupo de colisión en este mundo con el nombre dado.


Renombra el grupo de colisión registrado especificado en este mundo, pero no
**renombra** la propiedad `Class.BasePart.CollisionGroup|CollisionGroup`
de las partes que utilizan el grupo. El primer argumento de este método es el
nombre del grupo a renombrar, el segundo argumento es el nuevo nombre para el
grupo. Si el grupo especificado no existe, este método no hará nada. Las
convenciones de nomenclatura para el nuevo nombre siguen las mismas reglas que
si el grupo se estuviera creando con
`Class.WorldRoot:RegisterCollisionGroup()|RegisterCollisionGroup()`.

Este método lanzará un error en tiempo de ejecución en las siguientes circunstancias:

- Se proporciona un nombre inválido o vacío para cualquiera de los argumentos.
- El método es llamado desde un cliente.

Ten en cuenta que este método tiene un ligero costo de rendimiento basado en el
número de `Class.BasePart|BaseParts` en el mundo, por lo que se recomienda
que registres todos los grupos de colisión en el tiempo de edición a través del
[editor](/workspace/collisions#collision-groups) de Studio y los renombres
tan pocas veces como sea posible.


WorldRoot:RenameCollisionGroup

from

Renombra el grupo de colisión especificado en este mundo.


Lanza la forma del `Class.BasePart` dado en una dirección dada y
devuelve la primera colisión con un `Class.BasePart` o celda de `Class.Terrain`.
Esto es análogo a cómo `Class.WorldRoot:Raycast()` lanza un rayo lineal en una
dirección para encontrar una colisión, pero utiliza una forma 3D en lugar de
un rayo. A diferencia de `Class.WorldRoot:Blockcast()` y
`Class.WorldRoot:Spherecast()`, que utilizan una caja o esfera simple, este
método lanza la geometría real de la parte proporcionada.

A diferencia de `Class.WorldRoot:GetPartsInPart()`, este método no detecta
`Class.BasePart|BaseParts` que **inicialmente** intersectan la forma.

Si se detecta un golpe, se devuelve un `Datatype.RaycastResult` que contiene
la información del golpe. La propiedad `Datatype.RaycastResult.Distance|Distance`
representa la distancia que la forma tiene que recorrer para encontrar un golpe,
y la propiedad `Datatype.RaycastResult.Position|Position` representa el
punto de intersección que causa el golpe.

Este método lanza un error si se le pasa una parte no existente, una
dirección inválida, o una parte con geometría de `Class.Terrain`.


WorldRoot:Shapecast

La parte cuya forma se lanza. El lanzamiento utiliza la geometría de esta parte
(bloque, bola, malla, etc.) y su tamaño; partes excesivamente grandes pueden
no ser soportadas, y no puede ser una parte de `Class.Terrain`.


Dirección del lanzamiento de la forma, con la magnitud representando la
máxima distancia que la forma puede recorrer. La distancia máxima es de 1024
studs.


Un objeto utilizado para especificar la elegibilidad de impacto en la operación de lanzamiento de forma.
Si no se proporciona, se utilizan valores predeterminados donde todas las demás partes son
consideradas y el agua de `Class.Terrain` no es ignorada. La parte que se
lanza siempre se excluye de los resultados.


Contiene el resultado de la operación de lanzamiento de forma, o `nil` si no
se golpeó ningún `Class.BasePart` o celda de `Class.Terrain` elegible.


Lanza la forma de un `Class.BasePart` dado en una dirección y devuelve un
`Datatype.RaycastResult` si la forma golpea un `Class.BasePart` o
celda de `Class.Terrain`.


Lanza una esfera y devuelve la primera colisión con un `Class.BasePart` o
`Class.Terrain`. Imprime las propiedades del RaycastResult si se ha
obtained un resultado.

Lanza una forma esférica en una dirección dada y devuelve la primera
colisión con un `Class.BasePart` o celda de `Class.Terrain`. Esto es
análogo a cómo `Class.WorldRoot:Raycast()` lanza un rayo lineal en una
dirección para encontrar una colisión, pero utiliza una forma 3D en lugar de un rayo.

A diferencia de `Class.WorldRoot:GetPartsInPart()`, este método no detecta
`Class.BasePart|BaseParts` que **inicialmente** intersectan la forma.

Si se detecta un golpe, se devuelve un `Datatype.RaycastResult` que contiene
la información del golpe. La propiedad `Datatype.RaycastResult.Distance|Distance`
representa la distancia que la forma tiene que recorrer para encontrar un golpe,
y la propiedad `Datatype.RaycastResult.Position|Position` representa el
punto de intersección que causa el golpe.

Este método lanza un error si se le pasan entradas de radio o dirección inválidas.


WorldRoot:Spherecast

La posición inicial de la forma esférica lanzada.


El radio de la forma esférica lanzada en studs. El radio máximo es
256 studs.


Dirección del lanzamiento de la forma, con la magnitud representando la
máxima distancia que la forma puede recorrer. La distancia máxima es 1024
studs.


Un objeto utilizado para especificar la elegibilidad de impacto en la operación de lanzamiento de forma.
Si no se proporciona, se utilizan valores predeterminados donde todas las partes son
consideradas y el agua de `Class.Terrain` no es ignorada.


Lanza una forma esférica en una dirección dada y devuelve un
`Datatype.RaycastResult` si la forma golpea un `Class.BasePart` o
celda de `Class.Terrain`.


Simula las partes en el espacio de trabajo durante un período de tiempo fijo llamando a la
función StepPhysics una vez por frame hasta que haya transcurrido un tiempo especificado.

Avanza la simulación para partes en el mundo hacia adelante basado en un
incremento de tiempo especificado y un conjunto opcional de `Class.BasePart`. Cuando se
especifica un conjunto de partes, solo estas partes serán simuladas y todas
las demás partes en el mundo serán tratadas como ancladas. Cuando se deja
fuera este argumento, todas las partes en el mundo serán incluidas en la
simulación. El incremento de tiempo especificado puede ser cualquier número positivo,
con valores más grandes aumentando el tiempo de ejecución de la función. Dependiendo del
valor del incremento de tiempo, el sistema de física puede subdividirlo en múltiples
pasos individuales para mantener la precisión y estabilidad de la simulación.
Incluso si la función realiza múltiples subpasos, los resultados de la
simulación solo se verán una vez que la función complete. Para visualizar los
pasos individuales de una simulación, la función puede ser llamada una vez por
RenderStep a través del evento `Class.RunService.RenderStepped`.


WorldRoot:StepPhysics

La cantidad de tiempo que será simulada. Este argumento debe ser un
número positivo. Valores más grandes aumentarán el tiempo de ejecución de esta
función.


parts

Array opcional de partes que serán simuladas. Este conjunto debe contener
instancias que son del tipo `Class.BasePart`; cualquier otro tipo será
ignorada.


Avanza la simulación para partes en el mundo hacia adelante basado en un
incremento de tiempo especificado y un conjunto opcional de
`Class.BasePart|BaseParts`.


Desregistra el grupo de colisión para el nombre dado en este mundo, con los
siguientes comportamientos:

- Si se proporciona un nombre inválido, el método no hará nada.
- Si se proporciona el nombre reservado `"Default"` **o** si el método es
  llamado desde un cliente, lanzará un error.
- Si hay partes en el grupo de colisión cuando se elimina, esas
  partes seguirán manteniendo el mismo nombre de grupo de colisión. El comportamiento
  físico de las partes en un grupo eliminado es indefinido, por lo que se recomienda
  mover cualquier parte en un grupo eliminado a otro grupo, como el
  grupo `"Default"`.

Ten en cuenta que este método tiene un ligero costo de rendimiento basado en el
número de `Class.BasePart|BaseParts` en el mundo, por lo que se recomienda
que registres todos los grupos de colisión en el tiempo de edición a través del
[editor](/workspace/collisions#collision-groups) de Studio y llames a este
método tan pocas veces como sea posible.


WorldRoot:UnregisterCollisionGroup

Desregistra el grupo de colisión para el nombre dado en este mundo.


WorldRoot

Clase base para manejar la simulación de física y consultas espaciales en 3D.

El siguiente ejemplo incluye una función básica que toma una tabla de objetos
y los parenta en un nuevo Modelo, devolviendo ese Modelo.

Los modelos son objetos contenedores, lo que significa que agrupan objetos juntos. Son
mejor utilizados para contener colecciones de `Class.BasePart|BaseParts` y tienen un número
de funciones que amplían su funcionalidad.

Los modelos están destinados a representar agrupaciones **geométricas**. Si tu agrupación no tiene
una interpretación geométrica, por ejemplo, una colección de
`Class.Script|Scripts`, utiliza un `Class.Folder` en su lugar.

Los modelos cuyas partes constitutivas están unidas con articulaciones (para que puedan
moverse o ser destruidas a través de simulación física) suelen tener un
`Class.Model.PrimaryPart|PrimaryPart` establecido, ya que especifica qué parte dentro
del modelo seguirá como pivote y caja delimitadora a medida que se mueve el modelo. Los
modelos estáticos que permanecen en un lugar no se benefician de tener una parte primaria configurada.

Los modelos tienen una amplia gama de aplicaciones, incluidos los personajes de jugador de Roblox.
También tienen una serie de comportamientos únicos que son importantes tener en
cuenta:

- Cuando un `Class.Humanoid` y un `Class.Part` llamado **Head** están parentados bajo
  un modelo, aparecerá una GUI de nombre/salud sobre el modelo; consulta
  [Visualización de Nombre/Salud del Personaje](/characters/name-health-display)
  para más detalles.
- Si la posición de una parte en el eje **Y** alcanza el
  `Class.Workspace.FallenPartsDestroyHeight`, y era el último objeto
  dentro de un `Class.Model`, el modelo también será destruido.
- Cuando se utiliza en un lugar con `Class.Workspace.StreamingEnabled` configurado en verdadero,
  el valor de `Class.Model.ModelStreamingMode|ModelStreamingMode` controla
  varios comportamientos sobre cómo se replica
  y/o se elimina el modelo y sus descendientes de los clientes. Además, el valor de
  `Class.Model.LevelOfDetail|LevelOfDetail` impacta el renderizado del modelo.

Como con todos los tipos de `Class.Instance`, el hecho de que un padre `Class.Model` sea
replicado a un cliente no garantiza que todos sus hijos se
replicarán. Esto es particularmente importante si estas instancias están siendo
accedidas por código que se ejecuta en el cliente, como en un `Class.LocalScript`.
Usar `Class.Model.ModelStreamingMode|ModelStreamingMode` con valores como
`Enum.ModelStreamingMode|Atomic` puede asegurar que el modelo completo y todos sus
descendientes están presentes si el modelo padre existe en el cliente, o puedes
usar `Class.Instance:WaitForChild()|WaitForChild()` cuando la atomicidad no es
deseada.

Establece este modelo como persistente para el jugador especificado. Los modelos
persistentes permanecen presentes para el jugador independientemente de las configuraciones o
condiciones de streaming.

`Class.Model.ModelStreamingMode|ModelStreamingMode` debe estar configurado en
`Enum.ModelStreamingMode|PersistentPerPlayer` para que el comportamiento cambie
como resultado de la adición.

Model:AddPersistentPlayer

playerInstance

El `Class.Player` para hacer este modelo persistente.

Establece este modelo como persistente para el jugador especificado.
`Class.Model.ModelStreamingMode|ModelStreamingMode` debe estar configurado en
`Enum.ModelStreamingMode|PersistentPerPlayer` para que el comportamiento cambie
como resultado de la adición.

En este ejemplo, las articulaciones en cada modelo de personaje de jugador añadido serán rotas
3 segundos después de aparecer. Romper estas articulaciones hará que el Humanoide
muera.

Este ejemplo de código demuestra la creación manual de juntas en dos partes que son
hermanas del script (PartA y PartB). Crea una junta en dos partes tocantes
con tipos de superficie compatibles (Studs e Inlet).

Rompe conexiones entre `BaseParts`, incluidas conexiones de superficie con
cualquier parte adyacente, `Class.WeldConstraint|WeldConstraints`, y todas
`Class.Weld|Welds` y otras `Class.JointInstance|JointInstances`.

Cuando se utiliza BreakJoints en un modelo de personaje de jugador, el
`Class.Humanoid` del personaje morirá ya que depende de la articulación del cuello.

Ten en cuenta que aunque las uniones producidas por conexiones de superficie con
partes adyacentes pueden técnicamente recrearse usando `Class.Model:MakeJoints()`, esto
solo recreará uniones producidas por superficies. Los desarrolladores no deben confiar
en esto, ya que las partes que siguen a las uniones rotas ya no pueden estar en
contacto entre sí.

Model:BreakJoints

Rompe conexiones entre `BaseParts`, incluidas conexiones de superficie con
cualquier parte adyacente, `Class.WeldConstraint|WeldConstraints` y todas
`Class.Weld|Welds` y otras `Class.JointInstance|JointInstances`.

Model:breakJoints

Demuestra `Class.Model:GetBoundingBox()`.


Esta función devuelve una descripción de un volumen que contiene todos los hijos de `Class.BasePart` dentro de un `Class.Model`. La orientación del volumen se basa en la orientación del `Class.Model.PrimaryPart|PrimaryPart`, y coincide con la caja de selección renderizada en Studio cuando se selecciona el modelo. Reflejando el comportamiento de `Class.Terrain:FillBlock()`, devuelve un `Datatype.CFrame` que representa el centro de esa caja delimitadora y un `Datatype.Vector3` que representa su tamaño. El tamaño puede ser inexacto en tiempo de ejecución si las restricciones físicas están actuando sobre las partes dentro del `Class.Model`.

La orientación de la caja delimitadora coincide con la orientación del `Class.PVInstance.GetPivot|Pivot` - ya sea el pivote del `Class.Model.PrimaryPart|PrimaryPart` (si está presente) o el `Class.Model.WorldPivot|WorldPivot` del modelo.

Model:GetBoundingBox

Un `Datatype.CFrame` que representa la orientación del volumen
seguido de un `Datatype.Vector3` que representa el tamaño del volumen.

Devuelve una descripción de un volumen que contiene todas las partes de un Modelo.

El siguiente ejemplo de código demuestra cómo Model.GetExtentsSize se puede usar para obtener
el tamaño de la caja delimitadora que contiene las piezas.

Devuelve el tamaño de la caja delimitadora más pequeña que contiene todas las
`Class.BasePart|BaseParts` en el `Class.Model`. La orientación coincide
con la orientación de la `Class.PVInstance.GetPivot|Pivot`, ya sea el
pivote de la `Class.Model.PrimaryPart|PrimaryPart` (si está presente) o el
`Class.Model.WorldPivot|WorldPivot` del modelo.

Ten en cuenta que esta función solo devuelve el tamaño de la caja delimitadora más pequeña,
y el desarrollador debe emplear su propio método para obtener la posición de la
caja delimitadora.

Model:GetExtentsSize

Devuelve el tamaño de la caja delimitadora más pequeña que contiene todas las
`Class.BasePart|BaseParts` en el `Class.Model`, alineada con el
`Class.Model.PrimaryPart` si está establecida.

Model

Los modelos son objetos contenedores, lo que significa que agrupan objetos juntos. Son
mejor utilizados para contener colecciones de `Class.BasePart|BaseParts` y tienen un número
de funciones que amplían su funcionalidad.

/reference/engine/classes/WorldModel.yaml