La bandera es una unidad generada con un objeto `Class.FlagStand`, y volverá a aparecer
cuando sea capturada. Cuando un jugador toca el mango de este objeto, que debe ser un
hijo del objeto Flag, que es una parte llamada "Handle", la bandera será
agregada a la mochila del jugador y aparecerá en su mano. Un jugador no puede
seleccionar otras armas mientras lleva una bandera y puede soltar la bandera en
cualquier momento presionando "Backspace" en el teclado. Si el jugador que lleva
una bandera pisa otro FlagStand de un color de equipo diferente, la bandera será
eliminada de la mochila del jugador y se añadirá un punto a las estadísticas del
líder, si están disponibles. La bandera entonces regenerará en el
flag stand original.


Flag

El `Class.Team` para el que es esta bandera. Corresponde a los TeamColors en el
servicio `Class.Teams`.

Los objetos `Class.Flag` y `Class.FlagStand` fueron creados para permitir
a los desarrolladores hacer juegos de estilo 'captura la bandera' rápidamente.


Flag.TeamColor

El `Class.Team` para el que es esta bandera. Corresponde a los TeamColors en el
servicio `Class.Teams`.


El objeto Flag te ayuda a crear juegos de estilo 'captura la bandera'.


Este código está destinado a ser colocado en un Script dentro de una Herramienta. Permite a un jugador
generar explosiones al equipar la herramienta y hacer clic en el suelo. Lo hace
definiendo una función, `explode`, que crea una explosión no letal en
un punto dado. Luego, define una función, `onActivated`, que se ejecuta cuando la
herramienta es activada. Finalmente, conecta el evento Activated de la herramienta a la
función `onActivated`.

Para probar este código, intenta crear una Herramienta y poner una Parte dentro de ella. Nombra la
Parte "Handle". Luego, coloca un Script dentro de la Herramienta y pega el código en él.
Finalmente, coloca la Herramienta en el StarterPack.

Este ejemplo de código es para un objeto Tool con una Parte llamada Handle. Detecta
cuando Humanoides diferentes al portador actual golpean el mango, y les causa algo
de daño. Además, cuando se activa la herramienta, se desencadena una animación de corte
en los scripts de animación de personaje predeterminados. Prueba este script creando
un objeto Tool en StarterPack. Coloca una Parte dentro de él y nómbrala
Handle. Pega este código en un Script dentro de la herramienta y luego intenta cortar a
otro Humanoide!

Un `Tool` es un objeto que un objeto `Class.Humanoid` puede equipar. Para los jugadores,
se almacenan en un objeto `Class.Backpack` que pertenece a un `Class.Player`
objeto. En la experiencia, los jugadores pueden tener múltiples herramientas que aparecen como iconos
en la parte inferior de la pantalla. Equipar una herramienta la mueve del
`Class.Backpack` a un modelo `Class.Player.Character` en el
`Class.Workspace`. Por defecto, las herramientas se sostienen en la mano derecha y tienen un
mango en ellas, que es una `Class.BasePart` llamada `Handle` en su interior (aunque
no se requiere uno si `Class.Tool.RequiresHandle` es `false`). Las herramientas que van a
ser proporcionadas a jugadores (re)aparentes deben ser almacenadas en el
`Class.StarterPack`.


Este evento se dispara cuando el jugador hace clic mientras el `Class.Tool` está
equipado. **No** se dispara si la tecla <kbd>Ctrl</kbd> está presionada durante
el clic.

Este evento se utiliza típicamente para realizar una acción cuando el jugador utiliza la
herramienta, por ejemplo, lanzar un cohete desde una herramienta de arma lanzacohetes.

El siguiente código, cuando se coloca en un `Class.LocalScript`, crea una herramienta en
el `Class.Backpack` del jugador local y muestra "Herramienta activada" cuando el
jugador hace clic mientras la herramienta creada está equipada.

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

local tool = Instance.new("Tool")
tool.RequiresHandle = false
tool.Parent = Players.LocalPlayer.Backpack

function onActivation()
	print("Herramienta activada")
end

tool.Activated:Connect(onActivation)
```


Tool.Activated

Se dispara cuando el jugador hace clic mientras la herramienta está equipada.


Este evento se dispara cuando el jugador suelta su clic mientras el
`Class.Tool` está equipado y activado. Se utiliza típicamente para realizar una
acción cuando el jugador deja de usar una herramienta.

El siguiente código, cuando se coloca en un `Class.LocalScript`, crea una herramienta en
el `Class.Backpack` del jugador local y muestra "Herramienta desactivada" cuando el
jugador suelta su clic mientras la herramienta está equipada y activada.

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

local tool = Instance.new("Tool")
tool.RequiresHandle = false
tool.Parent = Players.LocalPlayer.Backpack

function toolDeactivated()
	print("Herramienta desactivada")
end

tool.Deactivated:Connect(toolDeactivated)
```


Tool.Deactivated

Se dispara cuando el jugador suelta su clic mientras la herramienta está equipada y
activada.


El ejemplo que se muestra a continuación imprimirá "Se equipó una herramienta" cada vez que la herramienta sea
equipada por el jugador. Tenga en cuenta que el ejemplo a continuación asume que ya ha
definido qué es "Herramienta".

Este evento se dispara cuando un jugador equipa el `Class.Tool` (lo saca de
su `Class.Backpack`).

El opuesto de este evento, `Class.Tool.Unequipped`, se puede utilizar para
determinar cuándo el jugador des equipa la herramienta al ponerla en su
mochila.

Ten en cuenta que este evento **no** se dispara cuando `Class.Tool.RequiresHandle` está
habilitado y no hay un mango presente.


Tool.Equipped

mouse

Se dispara cuando la herramienta está equipada.


Este evento se dispara cuando un jugador des equipa el `Class.Tool` (la pone en su
`Class.Backpack`).

El opuesto de este evento, `Class.Tool.Equipped`, se puede utilizar para
determinar cuándo el jugador equipa la herramienta al sacarla de su
mochila.

Ten en cuenta que este evento **no** se dispara cuando `Class.Tool.RequiresHandle` está
habilitado y no hay un mango presente.


Tool.Unequipped

Se dispara cuando la herramienta está desequipada.


El código a continuación crea un `Class.Tool` en el `Class.Backpack` del jugador local
que vuelve al jugador invisible cuando se activa y visible cuando se desactiva.

Cuando se equipa, el script simula que la herramienta está activa y hace que el
jugador se vuelva invisible durante 3 segundos y luego simula que la herramienta se desactiva.
Mantener el botón izquierdo del ratón presionado hace que el jugador se vuelva invisible durante hasta 3
segundos, con un periodo de enfriamiento de 1 segundo, o hasta que el jugador suelte
su botón izquierdo del ratón.

Esta función simula la activación del `Class.Tool`. La herramienta debe estar
 equipada para que esta función funcione.


Tool:Activate

Esta función simula la desactivación del `Class.Tool`. La herramienta debe estar
 equipada para que esta función funcione.


Tool:Deactivate

Simula la desactivación del `Class.Tool`.


Tool

La propiedad CanBeDropped controla si el jugador puede soltar el
`Class.Tool`.

Si es verdadero, cuando se presiona el botón de retroceso, la herramienta será parentada
a `Class.Workspace` y se eliminará de la `Class.Backpack` del jugador. Si
es falso, no pasará nada cuando se presione el retroceso, y la herramienta
seguirá equipada.


Tool.CanBeDropped

Controla si el jugador puede soltar la herramienta.


El ejemplo de código a continuación crea `Class.Tool` en el
`Class.Backpack` del jugador local que aumenta su
`Class.Humanoid.JumpPower|JumpPower` de `50` a `150` durante 5 segundos.

Este ejemplo utiliza la propiedad `Class.Tool.Enabled` de la herramienta como un
debounce al establecer la propiedad en `true` cuando el jugador salta y
volver a `false` después de la duración de 5 segundos.

Desequipar la herramienta también impide que el jugador realice un super salto
al cambiar el `Class.Humanoid.JumpPower|JumpPower` de vuelta a `50`.

La propiedad **Enabled** se relaciona con si el `Class.Tool` puede ser
utilizado. Esto es útil si deseas evitar que un jugador use una herramienta,
pero no deseas eliminarla de su `Class.Backpack`.

Cuando se establece en `true`, el jugador puede usar la herramienta. Cuando se establece en `false`, la
herramienta está desactivada y el jugador no puede usarla; esto impide que la herramienta sea
activada o desactivada por los métodos `Class.Tool:Activate()` y
`Class.Tool:Deactivate()`, y evita que se disparen los
eventos `Class.Tool.Activated` y `Class.Tool.Deactivated`.


Tool.Enabled

Se relaciona con si la herramienta puede ser utilizada o no.


El código a continuación inserta un `Class.Tool` llamado **Stick** en el
`Class.BackPack` del jugador local. Cuando el jugador activa la herramienta,
el código imprime los valores de las propiedades de agarre de la herramienta.

La propiedad `Grip` almacena las propiedades de "grip" de la herramienta como un solo
`Datatype.CFrame`. Estas propiedades posicionan cómo el jugador sostiene la herramienta
y incluyen `Class.Tool.GripUp|GripUp`, `Class.Tool.GripRight|GripRight`,
`Class.Tool.GripForward|GripForward`, y `Class.Tool.GripPos|GripPos`.


Tool.Grip

Almacena las propiedades de "grip" de la herramienta como un `Datatype.CFrame`.


Una de las propiedades que especifica la orientación de una herramienta en la mano de un personaje.
Esto representa los valores `R02`, `R12`, y `R22` de la matriz de rotación
`Datatype.CFrame` del grip.

Otras propiedades de la herramienta que controlan cómo un personaje sostiene una herramienta incluyen
`Class.Tool.GripUp`, `Class.Tool.GripRight`, y `Class.Tool.GripPos`. Todas
estas propiedades se almacenan en un solo `Datatype.CFrame` en la
propiedad `Class.Tool.Grip`.


Tool.GripForward

Representa los valores `R02`, `R12`, y `R22` de la matriz de rotación
`Datatype.CFrame` del grip.


Esta propiedad controla el desplazamiento posicional de la matriz de soldadura de la herramienta. Es
una de varias propiedades utilizadas para posicionar cómo el personaje del jugador
sostiene la herramienta.

Otras propiedades que controlan cómo un personaje sostiene una herramienta incluyen
`Class.Tool.GripUp`, `Class.Tool.GripRight`, y `Class.Tool.GripForward`.
Todas estas propiedades se almacenan en un solo `Datatype.CFrame` en la
propiedad `Class.Tool.Grip`.


Tool.GripPos

El desplazamiento posicional de la matriz de soldadura de la herramienta.


Una de las propiedades que especifica la orientación de una herramienta en la mano de un personaje.
Esto representa los valores `R00`, `R10`, y `R20` de la matriz de rotación
`Datatype.CFrame` del grip.

Otras propiedades de la herramienta que controlan cómo un personaje sostiene una herramienta incluyen
`Class.Tool.GripUp`, `Class.Tool.GripForward`, y `Class.Tool.GripPos`.
Todas estas propiedades se almacenan en un solo `Datatype.CFrame` en la
propiedad `Class.Tool.Grip`.


Tool.GripRight

Representa los valores `R00`, `R10`, y `R20` de la matriz de rotación
`Datatype.CFrame` del grip.


Una de las propiedades que especifica la orientación de una herramienta en la mano de un personaje.
Esto representa los valores `R01`, `R11`, y `R21` de la matriz de rotación
`Datatype.CFrame` del grip.

Otras propiedades de la herramienta que controlan cómo un personaje sostiene una herramienta incluyen
`Class.Tool.GripRight`, `Class.Tool.GripForward`, y
`Class.Tool.GripPos`. Todas estas propiedades se almacenan en un solo
`Datatype.CFrame` en la propiedad `Class.Tool.Grip`.


Tool.GripUp

Representa los valores `R01`, `R11`, y `R21` de la matriz de rotación
`Datatype.CFrame` del grip.


El código de muestra a continuación crea `Class.Tool` en el
`Class.Backpack` del jugador local que aumenta su `Class.Humanoid.Walkspeed|WalkSpeed`
de `16` a `30` durante 5 segundos.

Este ejemplo utiliza la propiedad `Class.Tool.ManualActivationOnly` de la herramienta como
un debounce al establecer la propiedad en `true` cuando el jugador comienza a correr
y en `false` cuando el jugador deja de correr. Como resultado, cuando el jugador
está corriendo, la herramienta no puede ser reactivada.

Desequipar la herramienta también detiene al jugador de correr cambiando el
`Class.Humanoid.Walkspeed|WalkSpeed` a `16`.

Esta propiedad controla si el `Class.Tool` puede ser activado sin
ejecutar explícitamente `Class.Tool:Activate()` en un script.

Cuando se establece en `true`, la herramienta solo disparará `Class.Tool.Activated` cuando
se llame a `Class.Tool:Activate()`. Esto también suprime la
función `Class.ContextActionService:BindActivate()`.

Cuando se establece en `false`, los clics del ratón (cuando la herramienta está equipada) también
dispararán `Class.Tool.Activated`.


Tool.ManualActivationOnly

Controla si el `Class.Tool` puede ser activado sin ejecutar
`Class.Tool:Activate()`.


Esta propiedad determina si un `Class.Tool` funciona sin un
mango.

Una herramienta tiene un mango cuando contiene una parte hija llamada **Handle**. Las herramientas
con mangos normalmente requieren que el jugador los equipe para sostener un objeto
para usarlas, por ejemplo, armas. Las herramientas sin mangos normalmente no
requieren que el jugador las equipe para sostener nada para usarlas, por
ejemplo, herramientas de "volar" o "invocar".

Cuando se establece en `true`, la herramienta funcionará solo con un mango. Cuando se establece en
`false`, la herramienta funcionará incluso sin un mango.


Tool.RequiresHandle

Determina si un `Class.Tool` funciona sin un mango.


La propiedad ToolTip controla el mensaje que se mostrará cuando el
`Class.Mouse` del jugador pase sobre el `Class.Tool` en su
`Class.Backpack`.

En general, el valor de esta propiedad debe describir qué es la herramienta
o su uso. Por ejemplo, para una herramienta de pala, puedes elegir establecer el
ToolTip a:

```lua
tool.ToolTip = "Pala"
```
o

```lua
tool.ToolTip = "Usar para cavar"
```
o

```lua
tool.ToolTip = "Pala - Usar para cavar"
```


Tool.ToolTip

Controla el mensaje mostrado cuando el mouse del jugador pasa sobre la
herramienta en su mochila.


Un objeto, como un arma, que puede ser equipado por un `Class.Humanoid`.


BackpackItem es una clase abstracta para los elementos de la mochila, como HopperBins y
Tools.


BackpackItem

El icono de textura que se muestra para una herramienta en la mochila del jugador.

Esta propiedad debe ser configurada con el ID de contenido de una imagen subida al
sitio web de Roblox. Solo se soportan URIs de activos para esta propiedad.

Si esta propiedad se deja en blanco, la GUI `Class.Backpack` mostrará el
nombre de la herramienta en su lugar.


BackpackItem.TextureContent

El icono de textura que se muestra para una herramienta en la mochila del jugador.
Solo soporta URIs de activos.


El icono de textura que se muestra para una herramienta en la mochila del jugador.

Esta propiedad debe ser configurada con el ID de contenido de una imagen subida al
sitio web de Roblox.

Si esta propiedad se deja en blanco, la GUI `Class.Backpack` mostrará el
nombre de la herramienta en su lugar.


BackpackItem.TextureId

El icono de textura que se muestra para una herramienta en la mochila del jugador.


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

Esta función devuelve una descripción de un volumen que contiene todos
`Class.BasePart` hijos dentro de un `Class.Model`. La orientación del volumen
se basa en la orientación de la `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 de la
`Class.Model.PrimaryPart|PrimaryPart` (si está presente) o el
`Class.Model.WorldPivot|WorldPivot` del modelo.

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

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

-- Redimensiona y posiciona la parte igual a la caja delimitadora del modelo
part.Size = size
part.CFrame = orientation
```

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

El tamaño de extensión del `Datatype.Vector3` del `Class.Model`.

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.

Este valor, históricamente, devolvía el CFrame de una posición central en el
modelo.

Model:GetModelCFrame

Este código crearía un modelo, pondría algunas piezas en él, las posicionaría aleatoriamente,
y luego imprimiría su tamaño:

La función GetModelSize devuelve el tamaño `Datatype.Vector3` del
`Class.Model`.

Model:GetModelSize

Cuando este método se llama desde un `Class.Script`, devuelve todos los
objetos `Class.Player` para los que este modelo es persistente. Cuando se llama desde
un `Class.LocalScript`, este método solo comprueba si este modelo es persistente
para el `Class.Players.LocalPlayer|LocalPlayer`.

Model:GetPersistentPlayers

Una tabla con todos los objetos `Class.Player` para los que este modelo es
persistente.

Devuelve todos los objetos `Class.Player` para los que este modelo es
persistente. El comportamiento varía según si este método se llama
desde un `Class.Script` o un `Class.LocalScript`.

El siguiente código demuestra cómo GetPrimaryPartCFrame y
SetPrimaryPartCFrame pueden usarse para rotar un modelo.

Se crea un modelo simple en el Workspace y se inicia un bucle que
rotará el modelo 10 grados alrededor del eje Y cada 0.2 segundos.

Esta función ha sido reemplazada por `Class.PVInstance:GetPivot()` que
actúa como un reemplazo y no cambia el comportamiento de tu código. Usa
`Class.PVInstance:GetPivot()` para nuevos trabajos y migra tus existentes
llamadas a `Class.Model:GetPrimaryPartCFrame()` cuando sea conveniente.

Devuelve el `Datatype.CFrame` de la `Class.Model.PrimaryPart` del modelo.

Esta función es equivalente a lo siguiente.

    Model.PrimaryPart.CFrame

Ten en cuenta que esta función lanzará un error si no existe parte primaria para el
`Class.Model`. Si este comportamiento no es deseado, los desarrolladores pueden hacer lo siguiente,
lo cual será igual a `nil` si no hay parte primaria.

    local cFrame = Model.PrimaryPart y Model.PrimaryPart.CFrame

Model:GetPrimaryPartCFrame

Devuelve el `Datatype.CFrame` de la `Class.Model.PrimaryPart` del modelo.
Esta función lanzará un error si no existe parte primaria para el
`Class.Model`.

Este ejemplo de código demuestra cómo sustituir en un reemplazo para todas las copias
de un modelo de árbol usando `Class.Model:PivotTo()` y `Class.Model:ScaleTo()`. El
pivot y la escala de los modelos se utilizan como referencia, asegurando que los
sizes y ubicaciones relativas de los modelos de reemplazo coincidan con los de los
originales.


Los modelos contienen un factor de escala canónica persistente, que empieza en 1
para los modelos recién creados y cambia a medida que se escala el modelo al llamar
`Class.Model:ScaleTo()`. Esta función devuelve el factor de escala canónica actual del modelo.

El factor de escala actual no impacta _directamente_ el tamaño de las instancias
bajo el modelo. Se utiliza para la creación de contenido y propósitos de scripting
para recordar cómo se ha escalado el modelo en relación a su tamaño original.

Dentro de una sesión dada, el modelo almacenará en caché la información del tamaño original
preciso de las instancias descendientes después de la primera llamada a
`Class.Model:ScaleTo()`. Eso significa que llamar a
`Class.Model:ScaleTo()|ScaleTo(x)` seguido de
`Class.Model:ScaleTo()|ScaleTo(1)` te devolverá _exactamente_
el configuración original del modelo sin deriva de punto flotante. Evitar
la deriva de punto flotante es la motivación para tener una función Scale**To**
 en lugar de una función Scale**By**.

El factor de escala impacta el comportamiento del motor de una manera: El factor de escala
del modelo se aplicará a los desplazamientos de las uniones de
`Class.Animation|Animations` reproducidas en un `Class.AnimationController`
bajo ese modelo, para que los rigs animados reproduzcan correctamente
las animaciones incluso cuando se escalen.

Model:GetScale

El factor de escala canónica actual del modelo.

Devuelve la escala canónica del modelo, que por defecto es 1 para los modelos
recién creados y cambiará a medida que se escale mediante
`Class.Model:ScaleTo()`.

Este ejemplo de código demuestra cómo se pueden hacer juntas usando la
función Model:MakeJoints.

Se instancia un modelo, con dos partes una encima de la otra. La parte superior está
anclada y la parte inferior no. Normalmente, cuando está parentada al Workspace
la parte inferior caería al Baseplate.

Sin embargo, como la propiedad TopSurface de la parte inferior está configurada en
Enum.SurfaceType.Weld, esto significa que cuando se ejecuta Model:MakeJoints se
hace una conexión entre ellas.

Por lo tanto, la parte inferior no cae hasta que se rompen las juntas en el modelo.
Esto suele hacerse usando Model:BreakJoints, pero en este ejemplo la
conexión se rompe usando una explosión.

Este ejemplo de código demuestra la creación de juntas en dos partes que son
hermanas del script (PartA y PartB). Utiliza MakeJoints en dos partes que tocan
con tipos de superficie compatibles (Studs y Inlet).

La unión basada en SurfaceType está en desuso. No uses MakeJoints para nuevos
proyectos. Usa `Class.WeldConstraint|WeldConstraints` y
`Class.HingeConstraint|HingeConstraints` en su lugar.

Revisa todos los `Class.BasePart|Parts` en el `Class.Model` y crea
uniones entre las Partes especificadas y cualquier superficie plana en contacto,
 dependiendo de las superficies de las partes.

- Las superficies suaves no crearán uniones
- Las superficies de pegamento crearán una unión `Class.Glue`
- La soldadura creará una unión `Class.Weld` con cualquier superficie, excepto
  Unjoinable
- Studs, Inlet o Universal crearán cada uno una unión `Class.Snap` con
  cualquiera de las otras dos superficies (por ejemplo, Studs con Inlet y
  Universal)
- Superficies de bisagra y motor crean instancias de unión `Class.Rotate` y
  `Class.RotateV`

Esta función no funciona si la Parte no es un descendiente de
`Class.Workspace`. Por lo tanto, debes asegurarte primero de que el Modelo esté parentado
a Workspace antes de usar MakeJoints.

Model:MakeJoints

Revisa todos los `Class.BasePart|BaseParts` en el `Class.Model`. Si algún
lado de parte tiene un SurfaceType que puede crear una unión, creará una unión
con cualquier parte adyacente.

Model:makeJoints

Model:move

location

Este ejemplo demuestra cómo `Class.Model:MoveTo()` evita colisiones.

Se crea un simple `Class.Model` de dos partes, y su `Class.Model.PrimaryPart`
es configurado. Una gran parte de obstrucción se coloca al lado.

Después de 5 segundos, se usa `Class.Model:MoveTo()` para dirigir el modelo a
moverse dentro de la parte de obstrucción. Sin embargo, como MoveTo no moverá un modelo dentro
de una obstrucción, el `Class.Model` se mueve hacia arriba en el eje Y y se coloca encima
de la obstrucción.


Mueve la `Class.Model.PrimaryPart|PrimaryPart` a la posición dada. Si
no se ha especificado una parte primaria, se usará la parte raíz del modelo,
pero la parte raíz no es determinista y se recomienda que
siempre configures una parte primaria al usar `Class.Model:MoveTo()|MoveTo()`.

Si hay obstrucciones donde se debe mover el modelo, como
`Class.Terrain` u otros `Class.BasePart|BaseParts`, el modelo se moverá
verticalmente hacia arriba hasta que no haya nada en el camino. Si este
comportamiento no es deseado, se debe utilizar `Class.PVInstance:PivotTo()`
en su lugar.

Ten en cuenta que la rotación no se preserva al mover un modelo con
`Class.Model:MoveTo()|MoveTo()`. Se recomienda usar ya sea
`Class.Model:TranslateBy()|TranslateBy()` o `Class.PVInstance:PivotTo()`
si se necesita preservar la rotación actual del modelo.

Model:MoveTo

position

El `Datatype.Vector3` al que se mueve el `Class.Model`.

Mueve la `Class.Model.PrimaryPart|PrimaryPart` a la posición dada. Si
no se ha especificado una parte primaria, se usará la parte raíz del modelo.

Model:moveTo

Hace que este modelo ya no sea persistente para el jugador especificado. Esto no
garantiza que el modelo se eliminará inmediatamente para el jugador; después
de llamar a este método, el modelo se tratará como
`Enum.ModelStreamingMode|Atomic` para ese jugador y permanecerá presente
siempre que esté dentro del radio de streaming objetivo.

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

Model:RemovePersistentPlayer

El `Class.Player` para hacer que este modelo ya no sea persistente.

Hace que este modelo ya no sea persistente para el jugador especificado.
`Class.Model.ModelStreamingMode|ModelStreamingMode` debe estar establecido en
`Enum.ModelStreamingMode|PersistentPerPlayer` para que el comportamiento cambie
como resultado de la eliminación.

Restablece la rotación de las partes del modelo a la rotación de identidad
anteriormente establecida, que se hace a través del método
`Class.Model:SetIdentityOrientation()`.

Model:ResetOrientationToIdentity

Los modelos contienen un factor de escala canónica persistente, que empieza en 1
para los modelos recién creados. Esta función escala el modelo, alrededor de la ubicación del pivote,
en relación a cómo se vería con un factor de escala de 1. Para
lograr esto, hace dos cosas:

- Establece el factor de escala actual del modelo al valor especificado
- Redimensiona y reposiciona todas las instancias descendientes en consecuencia

La escala de las ubicaciones se realiza alrededor de la ubicación del pivote.

Todas las propiedades "geométricas" de las instancias descendientes serán escaladas. Eso
obviamente incluye los tamaños de las partes, pero aquí hay algunos otros ejemplos de
propiedades que se escalan:

- La longitud de las uniones como `Class.WeldConstraint|WeldConstraints`, y
  `Class.RopeConstraint`
- Velocidades y fuerzas físicas como `Class.HingeConstraint`
- Propiedades visuales como tamaños de emisores de partículas
- Otras propiedades de longitud como `Class.Sound.RollOffMinDistance`

Model:ScaleTo

newScaleFactor

Establece el factor de escala del modelo, ajustando el tamaño y la ubicación de
 todas las instancias descendientes para que tengan ese factor de escala en relación a
sus tamaños y ubicaciones iniciales cuando el factor de escala era 1.

Establece la rotación de identidad del modelo dado, permitiéndote restablecer la
rotación de todo el modelo más tarde, a través del uso del método
`ResetOrientationToIdentity`.

Model:SetIdentityOrientation

Esta función ha sido reemplazada por `Class.PVInstance:PivotTo()` que
actúa como un reemplazo más eficiente y no cambia el comportamiento de tu
código. Usa `Class.PVInstance:PivotTo()` para nuevos trabajos y migra tus
existentes llamadas a `Class.Model:SetPrimaryPartCFrame()` cuando sea conveniente.

Establece el `Class.BasePart.CFrame` de la `Class.Model.PrimaryPart` del modelo.
Todas las demás partes en el modelo también se moverán y mantendrán su
orientación y desplazamiento respectivos respecto a la `Class.Model.PrimaryPart`.

Ten en cuenta que esta función lanzará un error si no existe `Class.Model.PrimaryPart`
para el modelo. Esto puede causar problemas si, por ejemplo, la parte primaria
nunca se estableció o ha sido destruida.

Model:SetPrimaryPartCFrame

cframe

El `Datatype.CFrame` que se debe establecer.

Establece el `Class.BasePart.CFrame` de la `Class.Model.PrimaryPart` del modelo.
Todas las demás partes en el modelo también se moverán y mantendrán su
orientación y desplazamiento respectivos respecto a la `Class.Model.PrimaryPart`.

Este ejemplo demuestra cómo `Class.Model:TranslateBy()` ignora las colisiones
y respeta la orientación del modelo.

Se crea un `Class.Model` simple de dos partes, rotado 45 grados en el eje Y,
y se establece su `Class.Model.PrimaryPart`. Se coloca una gran parte de obstrucción
al lado.

Después de 5 segundos, se utiliza `Class.Model:TranslateBy()` para dirigir el modelo a
moverse dentro de la parte de obstrucción. El modelo se moverá dentro de la
obstrucción y mantendrá su orientación actual.


Desplaza un `Class.Model` por el desplazamiento `Datatype.Vector3` dado, preservando
la orientación del modelo. Si ya existe otro `Class.BasePart` o `Class.Terrain`
en la nueva posición, entonces el `Class.Model` se superpondrá
con dicho objeto.

La traducción se aplica en el espacio mundial en lugar del espacio del objeto,
lo que significa que incluso si las partes del modelo están orientadas de manera diferente, aún
se moverá a lo largo del eje estándar.

Model:TranslateBy

delta

El `Datatype.Vector3` por el cual se traduce el `Class.Model`.

Desplaza un `Class.Model` por el desplazamiento `Datatype.Vector3` dado, preservando
la orientación del modelo. Si ya existe otro `Class.BasePart` o `Class.Terrain`
en la nueva posición, entonces el `Class.Model` se superpondrá
con dicho objeto.

Model

Establece el nivel de detalle en el modelo para experiencias con
[streaming](/workspace/streaming) habilitado. Los modelos compuestos o
imposter no admiten física, detección de colisiones ni
raycasting.

Cuando se establece en `Enum.ModelLevelOfDetail|StreamingMesh`, un modelo
"imposter" de menor resolución (malla coloreada y gruesa que envuelve todos los
componentes secundarios del modelo) se renderiza fuera del radio de streaming. No admite
texturas.

Cuando se establece en `Enum.ModelLevelOfDetail|SLIM`, un modelo **SLIM** (Modelo
Interactivo Ligero Escalable) renderiza un compuesto de todos los componentes
secundarios a resoluciones progresivamente más bajas a distancias basadas en el
radio de streaming. Esto mejora enormemente la calidad visual en comparación con
`Enum.ModelLevelOfDetail|StreamingMesh`.

Cuando se establece en `Enum.ModelLevelOfDetail|Disabled` o
`Enum.ModelLevelOfDetail|Automatic`, las mallas de menor resolución no se
displayarán.


Model.LevelOfDetail

Establece el nivel de detalle en el modelo para experiencias con
streaming de instancias habilitado.

Controla cómo se transmiten hacia adentro y hacia afuera los `Class.Model|Models` cuando
se habilita el [streaming](/workspace/streaming) de instancias. El comportamiento
depende del enum seleccionado. No tiene efecto cuando el streaming no está habilitado.

Esta propiedad solo debe modificarse en Studio a través de la
ventana de [Propiedades](/studio/properties) cuando el streaming está
habilitado, o en `Class.Script|Scripts`, pero nunca en
`Class.LocalScript|LocalScripts` (hacerlo puede resultar en un comportamiento indefinido).

Model.ModelStreamingMode

Controla el comportamiento de streaming del modelo en `Class.Model|Models` cuando
se habilita el streaming de instancias.

Este ejemplo de código crea y lanza un modelo de dado, luego indica si
aterrizó con el lado azul hacia arriba. Si `Class.Model.PrimaryPart` no se establece,
el pivote / caja delimitadora del dado rotaría, ya que las partes dentro de él
son simuladas físicamente durante el lanzamiento.

Apunta a la parte primaria del `Class.Model`. La parte primaria es la
`Class.BasePart` que actúa como la referencia física para el pivote del
modelo. Es decir, cuando las partes dentro del modelo se mueven debido a la
simulación física u otros medios, el pivote se moverá sincronizado con la parte
primaria.

Ten en cuenta que los `Class.Model|Models` no tienen `PrimaryPart` configurado por defecto.
Si estás creando un modelo que necesita ser afectado por la física, debes
configurar manualmente esta propiedad en Studio o dentro de un script. Si la
parte primaria **no** está configurada, el pivote permanecerá en la misma ubicación en
el espacio mundial, incluso si las partes dentro del modelo son movidas.

También ten en cuenta que al establecer esta propiedad, debe ser un
`Class.BasePart` que sea descendiente del modelo. Si intentas establecer
`Class.Model.PrimaryPart` en un `Class.BasePart` que **no** es un
descendiente del modelo, se configurará en esa parte pero se restablecerá a `nil`
 durante el siguiente paso de simulación &mdash; este es un comportamiento heredado para
soportar scripts que suponen que pueden configurar temporalmente la parte primaria en un
`Class.BasePart` que no es un descendiente del modelo.

La regla general para los modelos es que:

- Los modelos cuyas partes están unidas a través de uniones físicas como
  `Class.WeldConstraint|WeldConstraints` o `Class.Motor6D|Motor6Ds`
  deben tener una parte primaria asignada. Por ejemplo, los modelos de
  personajes de Roblox tienen su `Class.Model.PrimaryPart` configurado en el
  **HumanoidRootPart** por defecto.
- Los modelos estáticos (generalmente `Class.BasePart.Anchored|Anchored`) que permanecen en
  un lugar a menos que un script los mueva explícitamente no requieren un
  `Class.Model.PrimaryPart` y tienden a no beneficiarse de tener uno configurado.

Model.PrimaryPart

La parte primaria del `Class.Model`, o `nil` si no está configurada explícitamente.

Configurar esta propiedad en la ventana de Propiedades escalará el modelo como
si se hubiera llamado a `Class.Model:ScaleTo()` en él, escalando todas las instancias
hijas en el modelo, como materiales, imágenes y la geometría 3D de las
partes, para que el modelo tenga el factor de escala especificado en relación a su
 tamaño original.

Esta propiedad solo está disponible en Studio y lanzará un error si se utiliza
en un `Class.Script` o `Class.LocalScript`. Se recomienda usar
`Class.Model:ScaleTo()` y `Class.Model:GetScale()` desde scripts.

Model.Scale

Propiedad solo para editores utilizada para escalar el modelo alrededor de su pivote. Configurar
esta propiedad moverá la escala como si se hubiera llamado a `Class.Model:ScaleTo()` en ella.

Este ejemplo de código muestra una función personalizada para restablecer el pivot de un modelo
de vuelta al centro de la caja delimitadora de ese modelo.

Esta propiedad determina dónde está ubicado el pivote de un `Class.Model` que **no** tiene un
`Class.Model.PrimaryPart` establecido. Si el `Class.Model` **tiene** un
`Class.Model.PrimaryPart|PrimaryPart`, el pivote del `Class.Model` es igual al pivote de esa parte
primaria en su lugar, y esta propiedad `Class.Model.WorldPivot|WorldPivot` se ignora.

Para un `Class.Model` recién creado, su pivote se tratará como el centro
de la caja delimitadora de su contenido hasta la **primer vez** que se
e establezca su propiedad `Class.Model.WorldPivot`. Una vez que el pivote del mundo se establece por\ primera vez, es imposible restaurar este comportamiento inicial.

Comúnmente, mover el modelo con las herramientas de Studio, o con funciones
de movimiento de modelos como `Class.PVInstance:PivotTo()` y
`Class.Model:MoveTo()`, establecerá el pivote del mundo y así finalizará este nuevo
comportamiento del modelo.

El propósito de este comportamiento es permitir que el código de Luau obtenga un pivote
sensible simplemente creando un nuevo modelo y parentando objetos en él, evitando la
necesidad de establecer explícitamente `Class.Model.WorldPivot` cada vez que creas un
modelo en el código.

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

local model = Instance.new("Model")
Workspace.BluePart.Parent = model
Workspace.RedPart.Parent = model
model.Parent = Workspace

print(model:GetPivot())  -- Actualmente igual al centro de la caja delimitadora que contiene "BluePart" y "RedPart"

model:PivotTo(CFrame.new(0, 10, 0))  -- Esto funciona sin necesidad de establecer explícitamente "model.WorldPivot"
```

Model.WorldPivot

Determina dónde está ubicado el pivote de un `Class.Model` que **no** tiene un
`Class.Model.PrimaryPart` establecido.

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.

Una `Class.PVInstance` es una clase abstracta que no se puede crear. Es la
base para todos los objetos que tienen una ubicación física en el mundo.


Este ejemplo de código es un script simple de teleportación que mueve tu personaje
10&nbsp;studs hacia adelante en la dirección en la que actualmente estás mirando cuando presionas
la <kbd>F</kbd> tecla. Lo hace obteniendo el pivot actual con
`Class.PVInstance:GetPivot()` y llamando a `PVInstance|PivotTo` para mover el
personaje hacia adelante.

Esta función obtiene el pivote de una `Class.PVInstance`. Esto se utiliza a menudo
con `Class.PVInstance:PivotTo()` para mover un modelo.

`Class.Model|Models` y `Class.BasePart|BaseParts` son ambos
`Class.PVInstance|PVInstances` ("Instancias de Velocidad de Posición") y así ambos
tienen esta función.


PVInstance:GetPivot

Obtiene el pivote de una `Class.PVInstance`.


Transforma la `Class.PVInstance` junto con todas sus descendientes
`Class.PVInstance|PVInstances` de tal manera que el pivote ahora se ubica en el
`Datatype.CFrame` especificado. Esta es la función principal que se debe
usar para mover `Class.Model|Models` mediante scripting.

`Class.BasePart|BaseParts` se mueven de esta manera al transformar su
`Datatype.CFrame` por el desplazamiento necesario.
`Class.Model|Models` se mueven de esta forma al transformar su
`Class.Model.WorldPivot` por el desplazamiento necesario.

Nota que, por razones de eficiencia, los eventos `Class.Object.Changed` no
se desencadenan para `Class.BasePart.Position|Position` y
`Class.BasePart.Orientation|Orientation` de `Class.BasePart|BaseParts`
movidos de esta manera; solo se desencadenan para `Datatype.CFrame`.

Al llamar a `Class.PVInstance:PivotTo()|PivotTo` en `Class.Model|Models`,
los desplazamientos de las partes y modelos descendientes se almacenan en caché, de tal manera que
las llamadas posteriores a `Class.PVInstance:PivotTo()|PivotTo` en el mismo modelo
o no acumulan deriva de punto flotante entre las partes que conforman el
modelo.

`Class.Model|Models` y `Class.BasePart|BaseParts` son ambos
`Class.PVInstance|PVInstances` ("Instancias de Velocidad de Posición") y así ambos
tienen esta función.


PVInstance:PivotTo

targetCFrame

El `Datatype.CFrame` que el pivote de `Class.PVInstance` debe igualar
despues de moverlo.


Transforma la `Class.PVInstance` junto con todas sus descendientes
`Class.PVInstance|PVInstances` de tal manera que el pivote ahora se ubica en el
`Datatype.CFrame` especificado.


PVInstance

PVInstance.Origin

PVInstance.Pivot Offset

Clase abstracta para todos los objetos que tienen una ubicación física en el mundo.


`Instance` es la clase base para todas las clases de la jerarquía de clases de Roblox
que pueden ser parte del árbol de `Class.DataModel`.

No es posible crear directamente objetos `Instance` en la raíz, pero el constructor especial
`Datatype.Instance.new()` crea objetos a través de código, tomando el
nombre de la clase como parámetro y devolviendo el objeto creado.

Demuestra cómo detectar cambios en la ascendencia de una instancia al conectarse al
`Class.Instance.AncestryChanged` evento.

El Parent de ChangingPart se establece en diferentes valores con el tiempo. El padre de
la parte es el ancestro de la parte, por lo que el evento `Class.Instance.AncestryChanged`
se activará cada vez que cambie.


Se activa cuando esta instancia es reparentada o cuando cualquiera de sus
ancestros es reparentado.

Puedes usar este evento para rastrear la eliminación de una instancia en el
Studio, como la eliminación manual en el Explorador o a través de un
plugin. Si necesitas detectar cuándo una instancia es destruida usando
`Class.Instance:Destroy()`, usa en su lugar el evento
`Class.Instance.Destroying`.

Instance.AncestryChanged

child

La instancia cuya propiedad `Class.Instance.Parent|Parent` ha cambiado,
que puede ser esta instancia o un ancestro más distante, **no**
es necesariamente la instancia a la que el controlador está conectado.

parent

Se activa cuando la propiedad `Class.Instance.Parent` de este objeto o uno de
sus ancestros es cambiada.

Este evento se activa cada vez que se cambia cualquier atributo en la instancia,
incluyendo cuando un atributo se establece en `nil`. El nombre del
atributo cambiado se pasa a la función conectada.

Por ejemplo, el siguiente fragmento de código conecta la función
`attributeChanged()` para que se active cada vez que cambia uno de los
atributos de la parte:

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

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "cambiado")
end

part.AttributeChanged:Connect(attributeChanged)
```
Consulta también `Class.Instance:GetAttributeChangedSignal()` que devuelve un
evento que se activa cuando un atributo específico cambia.

Instance.AttributeChanged

attribute

El nombre del atributo que ha sido cambiado.

Se activa cada vez que se cambia un atributo en la `Class.Instance`.

Este fragmento imprime los nombres de los objetos a medida que se añaden al Espacio de Trabajo:

Se activa después de que un objeto es parentado a esta `Class.Instance`.

Nota, al usar este método en un cliente para detectar objetos creados por el
servidor, es necesario usar `Class.Instance:WaitForChild()` al
indexar los descendientes de este objeto. Esto se debe a que el objeto y sus
descendientes no se garantiza que se repliquen desde el servidor al cliente
simultáneamente. Por ejemplo:

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

Workspace.ChildAdded:Connect(function(child)
	-- Usa WaitForChild() ya que los descendientes pueden no haberse replicado aún
	local head = child:WaitForChild("Head")
end)
```
Nota, este evento solo opera para hijos inmediatos de la
`Class.Instance`. Para un evento que capture todos los descendientes, usa
`Class.Instance.DescendantAdded`.

Consulta también `Class.Instance.ChildRemoved`.

Instance.ChildAdded

La `Class.Instance` que ha sido añadida.

Se activa después de que un objeto es parentado a esta `Class.Instance`.

Instance

`Instance` es la clase base para todas las clases de la jerarquía de clases de Roblox
que pueden ser parte del árbol de `Class.DataModel`.