> For the complete documentation index, see [llms.txt](https://docs.decentraland.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/entities-components.md).

# Entities y Components

Aprende lo esencial sobre entities y components en una escena de Decentraland

Las escenas de Decentraland se construyen en torno a [*Entities*, *Components* y *Systems*](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system). Este es un patrón común que se utiliza en la arquitectura de varios motores de juegos y que permite una composición y escalabilidad sencillas.

![](https://1216664193-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-47dcd6cd9846e4d62d320e0ba061c9261d2e4f2a%2Fecs-big-picture.webp?alt=media)

## Resumen

*Entities* son la unidad básica para construir todo en las escenas de Decentraland. Cada objeto 3D visible e invisible y cada reproductor de audio de tu escena será una Entity. Una Entity no es más que un identificador al que pueden hacer referencia los Components. La Entity en sí no tiene propiedades ni métodos propios; simplemente sirve para agrupar varios Components.

*Components* definen las características de una Entity. Por ejemplo, un `Transform` almacena las coordenadas, la rotación y la escala de la Entity. Un `MeshRenderer` le da a la Entity una forma visible (como un cubo o una esfera) cuando se renderiza en la escena; un `Material` le da a la Entity un color o una textura. También puedes crear Components personalizados para almacenar los datos que necesita tu escena; por ejemplo, un `health` personalizado podría almacenar el valor de salud restante de una Entity y añadirse a las Entities que representan a los enemigos no jugadores de un juego.

Si tienes experiencia en desarrollo web, piensa en las Entities como el equivalente de los *elementos* de un árbol *DOM* y en los Components como los *atributos* de esos elementos.

En el [Scene Editor de Creator Hub](https://docs.decentraland.org/creator/content-creator-es/scene-editor/primeros-pasos/about-editor.md), puedes ver los Components que pertenecen a una Entity seleccionándola.

![](https://1216664193-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-b7c82899df98d40a8760f7e0668ce2aaed751945%2Fcomponents-example.webp?alt=media)

{% hint style="warning" %}
**📔 Nota**: En versiones anteriores del SDK, las Entities eran *objetos* que se instanciaban y podían ampliarse para añadir funciones. A partir de la versión 7.0 del SDK, las Entities son solo un ID. Esta estructura se ajusta mejor a los principios de la [programación orientada a datos](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/data-oriented-programming.md) y puede mejorar el rendimiento de la escena.
{% endhint %}

![](https://1216664193-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-a7a82338639fce594aa9a8459ae54b9579f3e0c1%2Fecs-components-new.webp?alt=media)

Los Components como `Transform`, `Material` o cualquiera de los Components de *forma* están estrechamente vinculados al renderizado de la escena. Si cambian los valores de estos Components, eso basta para que el Engine cambie la forma en que se renderiza la escena en el siguiente fotograma.

El Engine es la parte central de la escena que administra todas las demás partes. Determina qué Entities se renderizan y cómo interactúan los jugadores con ellas. También coordina qué funciones de los [Systems](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/systems.md) se ejecutan y cuándo.

Los Components están diseñados para almacenar datos sobre la Entity a la que hacen referencia. Solo pueden almacenar estos datos; no pueden modificarlos por sí mismos. Todos los cambios en los valores de los Components los realizan los [Systems](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/systems.md). Los Systems están completamente desacoplados de los propios Components y Entities. Las Entities y los Components no dependen de los *Systems* que actúan sobre ellos.

## Sintaxis de Entities y Components

El siguiente ejemplo muestra algunas operaciones básicas para declarar y configurar Entities y Components básicos.

```ts
export function main() {
	// Crear una entidad
	const door = engine.addEntity()

	// Asignar una posición a la entidad mediante un componente Transform
	Transform.create(door, {
		position: Vector3.create(5, 1, 5),
	})

	// Asignar una forma visible a la entidad mediante un componente GltfContainer
	GltfContainer.create(door, {
		src: 'assets/models/door.glb',
	})
}
```

{% hint style="warning" %}
**📔 Nota**: En versiones anteriores del SDK, era necesario añadir manualmente una entidad al Engine para empezar a renderizarla. Desde la versión 7 del SDK, las entidades se añaden implícitamente al Engine en cuanto se les asigna un componente.
{% endhint %}

Al crear un componente, siempre se asigna a una entidad principal. Los valores del componente afectan entonces a la entidad.

{% hint style="info" %}
**💡 Consejo**: En lugar de crear entidades de una en una, puedes generar todo un árbol de entidades y componentes a la vez desde un archivo [composite](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/composites.md) .
{% endhint %}

## Eliminar entidades

Para eliminar una entidad del Engine, usa `engine.removeEntity()`. Esta función devuelve un valor `boolean`: `true` si se eliminó la entidad, `false` si se rechazó la eliminación.

```ts
export function main() {
	// Crear una entidad
	const door = engine.addEntity()

	// Asignar una forma visible a la entidad mediante un componente GltfContainer
	GltfContainer.create(door, {
		src: 'assets/models/door.glb',
	})

	// Eliminar entidad
	const removed = engine.removeEntity(door)
	console.log('Entity removed:', removed) // true
}
```

Si una entidad eliminada tiene entidades secundarias, estas vuelven a tener como entidad principal la predeterminada `engine.RootEntity` ; esta se encuentra en la posición base de la escena y tiene una escala de *1*.

### Entidades reservadas por el Renderer

El Renderer reserva algunos ID de entidad para los avatares de jugadores remotos. No puedes eliminar estas entidades. Si llamas a `engine.removeEntity()` en una entidad reservada por el Renderer, devuelve `false` y deja intactos todos sus componentes.

Las entidades reservadas con nombre [son un caso especial:](#reserved-entities) (`engine.RootEntity`, `engine.PlayerEntity`, `engine.CameraEntity`) `engine.removeEntity()` sigue devolviendo `false` para estas entidades (sus ID nunca se liberan), pero sus componentes **sí** se eliminan. Esto significa que puedes borrar tus propios componentes de ellas (por ejemplo, eliminar un componente `InputModifier` de `engine.PlayerEntity`), aunque el ID de la entidad nunca se libera.

```ts
// Se intenta eliminar una entidad reservada
const result = engine.removeEntity(engine.PlayerEntity)
console.log(result) // false — el ID de la entidad no se libera
// Pero se eliminan los componentes propios de la escena de PlayerEntity
```

Puedes comprobar el valor devuelto al eliminar entidades para gestionar casos límite:

```ts
if (!engine.removeEntity(someEntity)) {
	console.log('No se pudo eliminar la entidad (reservada)')
}
```

### Eliminar una entidad junto con sus entidades secundarias

Para eliminar una entidad y también todas sus entidades secundarias (y, de forma recursiva, las entidades secundarias de estas), usa el `removeEntityWithChildren()` helper.

```ts
export function main() {
	// Crear entidad principal
	const door = engine.addEntity()

	// Crear entidad secundaria
	const doorKnob = engine.addEntity()

	// Dar una forma visible a las entidades
	GltfContainer.create(door, {
		src: 'models/door.glb',
	})
	GltfContainer.create(doorKnob, {
		src: 'models/doorKnob.glb',
	})

	// Principal
	Transform.create(doorKnob, {
		parent: door,
	})

	// Eliminar la entidad principal y sus entidades secundarias
	removeEntityWithChildren(engine, door)
}
```

{% hint style="warning" %}
**Nota:** Si hay una entidad reservada por el renderer en algún punto del árbol, `removeEntityWithChildren` elimina todas las demás entidades descendientes, pero deja la entidad reservada en su sitio. El `Transform.parent` de la entidad reservada apuntará a una entidad eliminada. Esto solo ocurre si la escena establece como entidad principal de una entidad reservada una entidad de la escena, algo poco frecuente.
{% endhint %}

{% hint style="info" %}
**💡 Consejo**: En algunos casos, en lugar de eliminar una entidad del engine, podría ser mejor hacerla invisible, por si quieres volver a cargarla sin demora. Consulta [Hacer invisible](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/shape-components.md#make-invisible)
{% endhint %}

### Eliminar entidades entre bastidores

Una entidad es simplemente un ID al que hacen referencia sus componentes. Por eso, al eliminar una entidad, en realidad eliminas cada uno de los componentes que hacen referencia a ella. Si eliminas manualmente todos los componentes de una entidad, el jugador la verá igual que si usaras `engine.removeEntity()`. Sin embargo, `engine.removeEntity()` también realiza tareas internas adicionales de seguimiento y marca el ID de la entidad como ya no utilizado, por lo que siempre es la forma recomendada de eliminar una entidad.

## Entidades anidadas

Una entidad puede tener otras entidades como entidades secundarias. Gracias a esto, podemos organizar las entidades en árboles, igual que el HTML de una página web.

![](https://1216664193-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-05ea75b83fc4f7f0d533368199638177ef38915b%2Fecs-nested-entities-new.webp?alt=media)

Para establecer una entidad como principal de otra, la entidad secundaria debe tener un componente `Transform`  . Luego puedes establecer el campo `parent` con una referencia a la entidad principal.

```ts
export function main() {
	// Crear entidades
	const parentEntity = engine.addEntity()

	const childEntity = engine.addEntity()

	// Establecer entidad principal
	Transform.create(childEntity, {
		parent: parentEntity,
	})
}
```

Una vez asignada una entidad principal, puedes consultar cuál es desde la entidad secundaria, mediante el campo `parent` de su `Transform` componente.

```ts
// Obtener el padre de una entidad
const parent = Transform.get(childEntity).parent
```

Si una entidad padre tiene un `Transform` componente que afecta a su posición, escala o rotación, sus entidades hijas también se ven afectadas. Los valores de posición o rotación se suman y los valores de escala se multiplican.

Si la entidad padre o la entidad hija no tiene un `Transform` componente, se usan los siguientes valores predeterminados.

* Para la **posición**, el centro del padre está en *0, 0, 0*
* Para la **rotación** , la rotación del padre es el cuaternión *0, 0, 0, 1* (equivalente a los ángulos de Euler *0, 0, 0*)
* Para la **escala**, se considera que el padre tiene un tamaño de *1*. Cualquier cambio de tamaño del padre afecta proporcionalmente a la escala y a la posición.

Las entidades que no tienen un componente de forma son invisibles en la escena. Se pueden usar como contenedores para gestionar y posicionar varias entidades como un grupo.

Para separar una entidad hija de su padre, puedes asignar el padre de la entidad a `engine.RootEntity`.

```ts
const mutableChildTransform = Transform.getMutable(childEntity)
mutableChildTransform.parent = engine.RootEntity
```

{% hint style="warning" %}
**📔 Nota**: Al trabajar con entidades anidadas que se sincronizan con otros jugadores, usa la función `parentEntity()` en lugar de la entidad `parent` en Transform. Consulta [Entidades con padre](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/networking/serverless-multiplayer.md#parented-entities)
{% endhint %}

En Scene Editor, puedes ver toda la jerarquía de entidades anidadas de tu escena en el panel de la izquierda.

![](https://1216664193-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-55a529bfbd47e68e693cebfc82a98cb927678757%2Fentity-tree-example.webp?alt=media)

## Obtener una entidad por ID

Cada entidad de tu escena tiene un número único *id*. Puedes recuperar del motor un componente que haga referencia a una entidad específica usando este ID.

```typescript
// obtener un componente Transform
Transform.get(1000 as Entity)
```

{% hint style="warning" %}
**📔 Nota**: Los ID de entidad entre *0* y *511* están reservados por el motor para entidades fijas, como el Avatar del jugador, la escena base, etc.
{% endhint %}

Por ejemplo, si el clic de un jugador o un [raycast](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/raycasting.md) impacta en una entidad, se devuelve el ID de la entidad alcanzada y puedes usar el comando anterior para obtener el componente Transform de la entidad que coincide con ese ID. También puedes obtener cualquier otro componente de esa entidad de la misma manera.

## Obtener una entidad por nombre

Al añadir entidades mediante arrastrar y soltar en Scene Editor, cada entidad tiene un nombre único. Usa `engine.getEntityOrNullByName()` función para hacer referencia a una de estas Entities desde tu código. Pasa el nombre de la Entity como una cadena, tal como aparece en la UI de Scene Editor, en la vista de árbol de la izquierda.

```ts
function main() {
	const door = engine.getEntityOrNullByName('door3')
}
```

{% hint style="warning" %}
**📔 Nota**: Asegúrate de usar `engine.getEntityOrNullByName()` solo dentro de la función `main()` o en funciones que se ejecuten después de `main()`, o en un System. Si se usa fuera de uno de esos contextos, es posible que las Entities creadas en la UI de Scene Editor aún no se hayan instanciado.
{% endhint %}

Puedes realizar cualquier acción en una Entity obtenida mediante este método, como añadir o eliminar Components, modificar los valores de los Components existentes o eliminar la Entity del Engine.

```ts
function main() {
	// obtener la Entity
	const door = engine.getEntityOrNullByName('door-3')
	// comprobar que la Entity existe
	if (door) {
		// agregar un callback de eventos de puntero
		pointerEventsSystem.onPointerDown(
			{
				entity: door,
				opts: { button: InputAction.IA_PRIMARY, hoverText: 'Open' },
			},
			function () {
				// abrir puerta
			}
		)
	}
}
```

Todas las Entities añadidas mediante la UI de Scene Editor tienen un componente `Name` , puedes iterar por todas ellas de esta manera:

```ts
function main() {
	for (const [entity, name] of engine.getEntitiesWith(Name)) {
		console.log({ entity, name })
	}
}
```

## Añadir o reemplazar un componente

Cada Entity solo puede tener un componente de un tipo determinado. Por ejemplo, si intentas asignar un Transform a una Entity que ya tiene uno, se producirá un error.

Para evitar este error, puedes usar `.createOrReplace` en lugar de `.create`. Este comando sobrescribe cualquier componente existente del mismo tipo, si lo hay; de lo contrario, crea un componente nuevo, igual que `.create`.

```ts
Transform.createOrReplace(door, {
	position: Vector3.create(5, 1, 5),
})
```

{% hint style="warning" %}
**📔 Nota**: Como `.createOrReplace` realiza una comprobación adicional antes de crear el componente, siempre es más eficiente usar `.create`. Si tienes la certeza de que la Entity aún no tiene un componente como el que estás añadiendo, usa `.create`.
{% endhint %}

## Acceder a un componente de una Entity

Puedes acceder a los Components de una Entity usando las funciones `.get()` o `getMutable()` de la Entity.

```ts
export function main() {
	// Crear entidad
	const box = engine.addEntity()

	// Crear y añadir un componente a esa Entity
	Transform.create(box)

	// Obtener una versión de solo lectura del componente
	let transform = Transform.get(box)

	// Obtener una versión mutable del componente
	let transform = Transform.getMutable(box)
}
```

La función `get()` obtiene una referencia de solo lectura al componente. No puedes cambiar ningún valor a través de esta referencia al componente.

Si quieres cambiar los valores del componente, usa la función `getMutable()` en su lugar. Si cambias los valores en la versión mutable del componente, estarás modificando directamente la Entity a la que pertenece ese componente.

Consulta [datos mutables](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/patrones-de-programacion/mutable-data.md) para obtener más detalles.

{% hint style="warning" %}
**📔 Nota**: Usa solo `getMutable()` si realmente vas a modificar los valores del componente. De lo contrario, usa siempre `get()`. Esta práctica sigue los principios de [programación orientada a datos](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/data-oriented-programming.md), y puede mejorar significativamente el rendimiento de la escena.
{% endhint %}

```ts
// Obtener una versión mutable del componente
let transform = Transform.getMutable(box)

// change a value of the component
transform.scale.x = 5
```

El ejemplo anterior modifica directamente el valor de *x* de scale en el componente Transform.

Si no tienes la certeza de que la entidad tenga el componente que intentas obtener, usa `getOrNull()` o `getMutableOrNull()`.

{% hint style="warning" %}
**📔 Nota**: Evita usar `getOrNull()` o `getMutableOrNull()` si es posible, ya que estas funciones realizan comprobaciones adicionales y, por lo tanto, son menos eficientes que `.get()` y `getMutable()`.
{% endhint %}

```ts
//  getOrNull
const transformOrNull = Transform.getOrNull(myEntity)

//  getMutableOrNull
const mutableTransformOrNull = Transform.getMutableOrNull(myEntity)
```

Si el componente que intentas obtener no existe en la entidad:

* `get()` y `getMutable()` devuelven un error.
* `getOrNull()` y `getMutableOrNull()` devuelven `Null`.

## Eliminar un componente de una entidad

Para eliminar un componente de una entidad, usa el método `deleteFrom()` del tipo de componente.

```ts
Transform.deleteFrom(myEntity)
```

Si intentas eliminar un componente que no existe en la entidad, esta acción no generará ningún error.

{% hint style="warning" %}
**📔 Nota**: Para eliminar todos los componentes de una entidad a la vez, consulta [esta sección](#remove-entities)
{% endhint %}

## Comprobar si existe un componente

Puedes comprobar si una entidad tiene una instancia de un componente determinado usando el `has()` función. Esta función devuelve *true* si el componente está presente, y *false* si no lo está. Esto puede resultar muy útil para usarlo en la lógica condicional de tu escena.

```ts
const hasTransform = Transform.has(myEntity)
```

{% hint style="info" %}
**💡 Consejo**: También puedes [consultar los componentes](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/querying-components.md) para obtener una lista completa de las entidades que tienen un componente específico o un conjunto concreto de componentes. No recorras manualmente todas las entidades de la escena para comprobar cada una con `has()`, ya que ese enfoque es mucho menos eficiente.
{% endhint %}

## Comprobar los cambios en un componente

Usa la función `onChange` para ejecutar una función de callback cada vez que cambien los valores del componente de una entidad determinada. Funciona con cualquier componente y es un atajo excelente para que el código sea más legible.

La función de callback puede incluir un parámetro de entrada que contenga el nuevo estado del componente.

```ts
Transform.onChange(cubeEntity, (newTransform) => {
	if (!newTransform) return
	console.log(
		'Cube position changed: ',
		newTransform.position,
		newTransform.rotation
	)
})

VisibilityComponent.onChange(cubeEntity, (newVisibilityComponent) => {
	if (!newVisibilityComponent) return
	console.log('Cube visibility changed: ', newVisibilityComponent.visible)
})
```

Si se elimina el componente de la entidad, la función se llama con una entrada de tipo `undefined`.

{% hint style="info" %}
**💡 Consejo**: La función `.onChange()` funciona tanto con los componentes nativos del SDK como con los [componentes personalizados](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/custom-components.md) definidos por el creador.
{% endhint %}

## Obtener las entidades secundarias

Para acceder a todas las entidades que son descendientes directas de una entidad principal, usa `getEntitiesWithParent`. Recibe como argumentos `engine` y la entidad `parent` y devuelve una lista de todas las entidades que tienen esa entidad específica como entidad principal. Ten en cuenta que solo devuelve descendientes directas, no descendientes de otras entidades secundarias.

```ts
import { getEntitiesWithParent } from '@dcl/sdk/ecs'

const children = getEntitiesWithParent(engine, myEntity)
for (const child of children) {
   // procesar cada entidad secundaria
}
```

Para acceder, en cambio, a todos los descendientes de una entidad, sin importar cuán anidada esté, usa la función `getComponentEntityTree()`. En lugar de recorrer manualmente la jerarquía nivel por nivel, esta función devuelve una lista plana de todos los descendientes, fácil de recorrer. También filtra la lista para incluir solo las entidades que tienen un componente determinado o una lista de componentes.

```ts
import { getComponentEntityTree } from '@dcl/sdk/ecs'

export function main() {
	// Create a parent entity with nested children
	const parentEntity = engine.addEntity()
	Transform.create(parentEntity, {
		position: Vector3.create(8, 0, 8),
	})

	// ... assume the parent has multiple children and grandchildren

	// Itera sobre todos los descendientes de la entidad principal
	for (const descendantEntity of getComponentEntityTree(
		engine,
		parentEntity,
		Transform
	)) {
		// Accede a cada entidad descendiente
		const transform = Transform.get(descendantEntity)
		console.log('Descendant position:', transform.position)
	}
}
```

La función `getComponentEntityTree` recibe tres parámetros:

* `engine`: La instancia del motor que ejecuta las entidades
* `entity`: La entidad raíz desde la que comenzar
* `component`: El componente por el que se filtra (normalmente `Transform` para jerarquías espaciales)

La función devuelve un generador que produce cada entidad descendiente de la estructura del árbol. En los resultados solo se incluyen las entidades que tienen el componente especificado.

Puedes combinar esto con otras comprobaciones de componentes para encontrar entidades específicas en tu jerarquía:

```ts
// Busca todos los descendientes con un nombre específico
for (const descendantEntity of getComponentEntityTree(
	engine,
	parentEntity,
	Transform
)) {
	const name = Name.getOrNull(descendantEntity)
	if (name && name.value === 'targetEntity') {
		console.log('Found target entity:', descendantEntity)
	}
}
```

## Entidades reservadas

Algunos ID de entidad están reservados para entidades especiales que existen en cada escena. Se puede acceder a ellas mediante los siguientes alias:

* `engine.RootEntity`
* `engine.PlayerEntity`
* `engine.CameraEntity`

{% hint style="warning" %}
**📔 Nota**: Evita hacer referencia a estas entidades antes de que se inicialicen. Para evitar este problema, haz referencia a ellas en la función `main()` o en un sistema.
{% endhint %}

## La entidad raíz

Todas las entidades de la escena son hijas de `engine.RootEntity`, directa o indirectamente.

Esta entidad no tiene un componente Transform, pero se utiliza para gestionar varios componentes que representan ajustes más globales, como el control del [skybox](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/skybox-control.md), [la posición del cursor](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/user-data.md#check-the-players-cursor-position), o las [dimensiones de la pantalla](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/ui-2d/ui-positioning.md#responsive-ui-size).

## La entidad del jugador

La entidad `engine.PlayerEntity` representa el avatar del jugador.

Obtén el componente `Transform` del jugador para obtener su posición y rotación actuales; consulta [los datos del usuario](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/user-data.md). El Transform del jugador es de solo lectura. Para modificarlo, utiliza `movePlayerTo()` función, [más información](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/avatares/move-player.md).

También puedes adjuntar objetos al jugador configurándolos como hijos de esta Entity, aunque [Attach to Player](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/entity-positioning.md#attach-an-entity-to-an-avatar) suele ser la mejor opción para eso.

## La Entity de la cámara

La `engine.CameraEntity` Entity representa la cámara del jugador.

Obtén el `Transform` Component de la cámara para obtener su posición y rotación. El Transform de esta Entity también es de solo lectura. Para modificar el ángulo o la posición de la cámara, usa una [Virtual camera](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/camera.md#using-virtual-cameras).

También puedes obtener el `CameraMode` Component para saber si el jugador está usando la cámara en primera o tercera persona. Consulta [modo de cámara](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/user-data.md#check-the-players-camera-mode).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/entities-components.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
