> 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/interactividad/eventos-de-button/system-based-events.md).

# Eventos basados en Systems

Aprende cómo manejar los clics de los usuarios en tu escena.

Si tu Scene tiene varias Entities similares que se activan mediante la misma lógica, puedes escribir un único System que itere sobre todas ellas y describa ese comportamiento una sola vez. Esta también es la opción más eficiente y más [orientada a los datos](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/data-oriented-programming.md) .

También puedes usar un System para detectar [eventos de entrada globales](#global-input-events), para que la Scene reaccione cada vez que se pulsa una tecla, sin tener en cuenta hacia dónde apunta el cursor del jugador.

Si solo quieres hacer clic o pulsar un botón en una única Entity para activarla, la forma más sencilla es usar el enfoque [Registrar un Callback](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/register-callback.md) .

Para definir una lógica personalizada más específica, quizá quieras trabajar con los datos sin procesar y usar el enfoque [Avanzado](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/advanced-button-events.md) .

Para que una Entity sea interactiva, debe tener un [Collider](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/colliders.md). Consulta [obstáculos](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/click-events.md#obstacles) para obtener más detalles. Esto también se aplica a los eventos de clic por proximidad.

## Uso de un System

Comprueba si hay eventos de botones ejecutando una de las funciones auxiliares del espacio de nombres de entrada `inputSystem` en cada tick dentro de un [System](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/systems.md).

Por ejemplo, el siguiente System usa la función `inputSystem.isTriggered()` para comprobar si se hizo clic con el puntero. En cada tick, comprueba si se pulsó el botón. Si `inputSystem.isTriggered()` devuelve *true*, el System ejecuta una lógica personalizada en respuesta.

```ts
engine.addSystem(() => {
	if (inputSystem.isTriggered(InputAction.IA_POINTER, PointerEventType.PET_DOWN)) {
		// Logic in response to button press
	}
})
```

Las siguientes funciones auxiliares están disponibles en el espacio de nombres `inputSystem` y se pueden llamar de forma similar en cada tick:

* `inputSystem.isTriggered`: Devuelve true si se produjo una acción de entrada desde el último tick.
* `inputSystem.isPressed`: Devuelve true si se está manteniendo pulsada una entrada. Devolverá true en cada tick hasta que se suelte el botón.
* `inputSystem.getInputCommand`: Devuelve un objeto con datos sobre la acción de entrada.

Consulta las secciones siguientes para obtener más detalles sobre cada una.

Al gestionar eventos de botones en una Entity, proporciona siempre feedback al jugador para que sepa que puede interactuar con ella. Si añades el componente `PointerEvents` a una Entity, los jugadores verán una indicación al pasar el cursor sobre ella. Consulta [Mostrar feedback](#show-feedback) para aprender a añadir indicaciones al pasar el cursor sobre Entities interactivas.

### Eventos de entrada globales

Usa `inputSystem.isTriggered` para detectar eventos de pulsación y liberación de botones en cualquiera de las entradas que sigue el SDK.

```ts
engine.addSystem(() => {
	if (
		inputSystem.isTriggered(InputAction.IA_POINTER, PointerEventType.PET_DOWN)
	) {
		// Logic in response to button press
	}
})
```

El ejemplo anterior comprueba si se pulsó el botón, independientemente de dónde esté el puntero o de qué entidades pueda haber en su trayectoria.

`inputSystem.isTriggered()` devuelve *true* solo si se pulsó el botón indicado durante el tick actual del bucle del juego. Si no se pulsó el botón o ya estaba pulsado desde el tick anterior, devuelve *false*.

{% hint style="warning" %}
**📔 Nota**: el jugador debe estar dentro de los límites de la escena para que se detecte el evento del puntero. Además, el cursor del jugador debe estar bloqueado; no se detectan las pulsaciones realizadas con el cursor libre.

Todas las entidades con las que quieras interactuar deben tener tanto un componente [`PointerEvents` como un](#show-feedback) y un [collider](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/colliders.md).
{% endhint %}

La función `inputSystem.isTriggered` acepta los siguientes argumentos obligatorios:

* `InputAction`: qué entrada se debe escuchar, como valor del `InputAction` enum. Consulta [Botones del puntero](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/click-events.md#pointer-buttons) para ver las opciones compatibles.
* `PointerEventType`: qué tipo de evento se debe escuchar, como valor del `PointerEventType` enum. Consulta [Tipos de eventos del puntero](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/click-events.md#types-of-pointer-events) para ver las opciones compatibles.

### Activar una entidad

Para detectar eventos de botón al apuntar a una entidad específica, pasa un tercer argumento opcional a `inputSystem.isTriggered` para especificar con qué entidad se debe comprobar.

```ts
// Give entity a PointerEvents component
PointerEvents.create(myEntity, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_PRIMARY,
				showFeedback: false,
			},
		},
	],
})

// create system
engine.addSystem(() => {
	if (
		inputSystem.isTriggered(
			InputAction.IA_POINTER,
			PointerEventType.PET_DOWN,
			myEntity
		)
	) {
		// Logic in response to button press on myEntity
	}
})
```

El ejemplo anterior comprueba en cada tick si se pulsó con el botón del puntero (el botón izquierdo del ratón) una entidad específica definida directamente en el código.

La función `inputSystem.isTriggered` acepta los siguientes argumentos:

* `InputAction`: qué entrada se debe escuchar, como valor del `InputAction` enum. Consulta [Botones del puntero](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/click-events.md#pointer-buttons) para ver las opciones compatibles.
* `PointerEventType`: qué tipo de evento se debe escuchar, como valor del `PointerEventType` enum. Consulta [Tipos de eventos del puntero](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/click-events.md#types-of-pointer-events) para ver las opciones compatibles.
* `Entity` *(opcional)*: en qué entidad se deben comprobar estos eventos. Si no se proporciona ningún valor, comprobará las pulsaciones globales del botón, independientemente de dónde estuviera apuntando el cursor del jugador.

Ten en cuenta que en este ejemplo también añadimos un componente `PointerEvents` a la entidad con la que queremos interactuar. Este paso es necesario: sin este componente, ninguna de las funciones de `inputSystem`. Consulta [Mostrar comentarios](#show-feedback) para obtener más información sobre el `PointerEvents` componente.

{% hint style="warning" %}
**📔 Nota**: y un [collider](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/colliders.md). Consulta [obstáculos](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/click-events.md#obstacles) para obtener más información.
{% endhint %}

Si hay varias entidades con las que el jugador puede interactuar de la misma manera, considera usar `inputSystem.getInputCommand`. Este comando devuelve información sobre un comando de clic global, incluido el ID de la entidad. Puedes usarlo para ejecutar una sola función que gestione todas las entidades.

```ts
engine.addSystem(() => {
	const result = inputSystem.getInputCommand(
		InputAction.IA_POINTER,
		PointerEventType.PET_DOWN
	)
	if (result) {
		if (result.hit?.entityId === myEntity) {
			// handle click
		}
	}
})
```

{% hint style="warning" %}
**📔 Nota**: todas las entidades con las que quieras interactuar deben tener tanto un [`PointerEvents` componente](#show-feedback) como un [collider](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/colliders.md).
{% endhint %}

Consulta [Datos de la acción de entrada](#data-from-input-action) para obtener más información. Este método también te proporciona datos más detallados sobre el impacto del evento de puntero.

### Soltar el botón del ratón

También puedes comprobar si se producen eventos de soltar el botón de manera muy similar, usando `PointerEventType.PET_UP`.

```ts
engine.addSystem(() => {
	if (
		inputSystem.isTriggered(
			InputAction.IA_POINTER,
			PointerEventType.PET_UP,
			myEntity
		)
	) {
		// Logic in response to button up while pointing at myEntity
	}
})
```

{% hint style="warning" %}
**📔 Nota**: al comprobar los eventos de soltar el botón en una entidad específica, no se tiene en cuenta dónde apuntaba el cursor cuando se pulsó el botón. Solo se considera dónde apunta el cursor cuando se suelta el botón.

Ten en cuenta también que la entidad debe tener tanto un [`PointerEvents` componente](#show-feedback) como un [collider](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/colliders.md).
{% endhint %}

### Comprobar si hay botones pulsados

Comprueba si se está manteniendo pulsado un botón usando `inputSystem.isPressed()` dentro de un sistema.

```ts
engine.addSystem(() => {
	if (inputSystem.isPressed(InputAction.IA_POINTER)) {
		// Logic in response to button being held down
	}
})
```

`inputSystem.isPressed()` devuelve *true* si se está manteniendo pulsado el botón, independientemente de cuándo se haya pulsado o de dónde apunte el cursor del jugador. De lo contrario, devuelve *false*.

La `inputSystem.isPressed` función recibe un único argumento:

* `InputAction`: qué entrada se debe escuchar, como valor del `InputAction` enum. Consulta [Botones del puntero](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/click-events.md#pointer-buttons) para ver las opciones compatibles.

### Gestionar varias entidades

Si tu escena tiene varias entidades a las que afectan los eventos de puntero de la misma manera, tiene sentido escribir un sistema que itere sobre todas ellas.

```ts
engine.addSystem(() => {
	const activatedEntites = engine.getEntitiesWith(PointerEvents)
	for (const [entity] of activatedEntites) {
		if (
			inputSystem.isTriggered(
				InputAction.IA_POINTER,
				PointerEventType.PET_DOWN,
				entity
			)
		) {
			// Logic in response to interacting with an entity
		}
	}
})
```

Este ejemplo usa una [consulta de componentes](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/querying-components.md) para iterar sobre todas las entidades que tienen un componente `PointerEvents` . Luego comprueba cada una de estas entidades con `inputSystem.isTriggered`, iterando sobre ellas una por una. Si se detecta una acción de entrada en alguna de estas entidades, ejecuta una lógica personalizada.

En lugar de iterar sobre *todas* las entidades con un componente `PointerEvents` en un único sistema, puedes escribir distintos sistemas para gestionar entidades que deban comportarse de manera diferente. El enfoque recomendado consiste en marcar los distintos tipos de entidades con [componentes personalizados](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/custom-components.md) específicos e iterar sobre ellos en sistemas separados.

```ts
engine.addSystem(() => {
	const activatedDoors = engine.getEntitiesWith(IsDoor, PointerEvents)
	for (const [entity] of activatedDoors) {
		if (
			inputSystem.isTriggered(
				InputAction.IA_POINTER,
				PointerEventType.PET_DOWN,
				entity
			)
		) {
			openDoor(entity)
		}
	}
})

engine.addSystem(() => {
	const pickedUpGems = engine.getEntitiesWith(IsGem, PointerEvents)
	for (const [entity] of pickedUpGems) {
		if (
			inputSystem.isTriggered(
				InputAction.IA_POINTER,
				PointerEventType.PET_DOWN,
				entity
			)
		) {
			pickUp(entity)
		}
	}
})
```

Este ejemplo tiene un sistema que itera sobre todas las entidades que tienen un componente personalizado llamado `IsDoor` y otro que itera sobre todas las entidades que tienen un componente personalizado llamado `isGem`. En ambos sistemas, comprueba cada entidad coincidente para ver si se activó con el botón del puntero.

Esta forma de organizar el código de tu escena está muy [orientada a los datos](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/data-oriented-programming.md) y debería permitir un uso muy eficiente de los recursos de memoria.

\## Varios botones en una entidad

Al usar helpers como `pointerEventsSystem.onPointerDown`, cada entidad solo puede tener un tipo de evento. No puedes registrar dos eventos de botón diferentes. Esta limitación no existe al usar eventos basados en sistemas. Por ejemplo, aquí hay una entidad con la que los jugadores pueden interactuar pulsando E y F, y cada tecla activa una funcionalidad diferente.

```ts
    engine.addSystem(() => {
        if (inputSystem.isTriggered(InputAction.IA_PRIMARY, PointerEventType.PET_DOWN, myEntity)) {
            // react to E
        }
        if (inputSystem.isTriggered(InputAction.IA_SECONDARY, PointerEventType.PET_DOWN, myEntity)) {
            // react to F
        }
    })
```

## Mostrar comentarios

Para mostrar sugerencias de UI al apuntar a una entidad, usa las propiedades del componente `PointerEvents` de la entidad.

```ts
// crear entidad
const myEntity = engine.addEntity()

// añadir un componente PointerEvents a la entidad
PointerEvents.create(myEntity, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_POINTER,
			},
		},
	],
})
```

Cada vez que el cursor del jugador apunte a los colliders de esta entidad, la UI mostrará una indicación al pasar el cursor para señalar que se puede interactuar con la entidad. Consulta las secciones siguientes para ver qué puedes configurar.

{% hint style="warning" %}
**📔 Nota**: El componente  `PointerEvents` solo se encarga de mostrar la respuesta visual al pasar el cursor. Para gestionar los eventos de los botones con lógica personalizada, consulta [Using-a-system](#using-a-system).
{% endhint %}

El componente  `PointerEvents` requiere al menos una definición de evento de puntero. Cada definición de evento de puntero se puede configurar con lo siguiente:

* `eventType`: Tipo de evento que se escuchará, como valor del enum  `PointerEventType` . Consulta [Tipos de eventos de puntero](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/click-events.md#types-of-pointer-events) para ver las opciones compatibles.
* `eventInfo`: Un objeto que puede contener los siguientes campos:
  * `button` (*obligatorio*): Entrada que se escuchará, como valor del enum  `InputAction` . Consulta [Botones del puntero](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/click-events.md#pointer-buttons) para ver las opciones compatibles.
  * `hoverText` *(opcional)*: Texto que se mostrará en la indicación al pasar el cursor. De forma predeterminada, es «Interact».
  * `showFeedback` *(opcional)*: Si es false, se ocultan tanto la indicación al pasar el cursor como el resaltado del borde de esta entidad. *true* de forma predeterminada.
  * `showHighlight` *(opcional)*: Si es true, los jugadores verán el resaltado del borde al pasar el cursor sobre la entidad. *true* de forma predeterminada. Este valor solo se tiene en cuenta si  `showFeedback` es  *true*.
  * `maxDistance` *(opcional)*: La distancia máxima a la que el  **avatar** del jugador puede estar de la entidad y aun así interactuar con ella, en metros. El valor predeterminado es  *10 metros*. Consulta [Distancia máxima](#max-distance).
  * `maxCameraDistance` *(opcional)*: A qué distancia puede estar la **cámara activa** de la entidad y seguir interactuando con ella, en metros. No se establece de forma predeterminada. Consulta [Distancia máxima](#max-distance).
  * `priority` *(opcional)* : Qué entidad prevalece cuando hay varias superpuestas. Los valores más altos tienen prioridad. *0* de forma predeterminada.

Un solo `PointerEvents` component puede contener varias definiciones de eventos de puntero, que pueden detectar distintos eventos para distintos botones. Cada entidad solo puede tener *un* `PointerEvents` component, pero este puede incluir varios objetos en su array `pointerEvents` , uno por cada evento al que responder.

```ts
PointerEvents.create(NPCEntity, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_POINTER,
				hoverText: 'Greet',
			},
		},
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_PRIMARY,
				hoverText: 'Choke',
			},
		},
		{
			eventType: PointerEventType.PET_UP,
			eventInfo: {
				button: InputAction.IA_PRIMARY,
				hoverText: 'Stop Choke',
			},
		},
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_SECONDARY,
				hoverText: 'Give gem',
			},
		},
	],
})
```

Los jugadores verán varias etiquetas, una por cada evento de puntero, dispuestas radialmente alrededor del cursor.

El siguiente ejemplo combina el uso de `PointerEvents` para mostrar indicaciones al pasar el cursor, junto con un sistema que gestiona la acción del jugador mediante lógica personalizada.

```ts
// crear entidad
const myEntity = engine.addEntity()

// give the entity hover feedback
PointerEvents.create(myEntity, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_POINTER,
				hoverText: 'Open',
			},
		},
	],
})

// handle click events on the entity
engine.addSystem(() => {
	if (
		inputSystem.isTriggered(
			InputAction.IA_POINTER,
			PointerEventType.PET_DOWN,
			myEntity
		)
	) {
		// Custom logic in response to an input action
	}
})
```

### Respuesta al pasar el cursor

Cuando un jugador pasa el cursor sobre un elemento que tiene un componente `PointerEvents` , verá lo siguiente:

* Un contorno resaltado en la entidad
* Una indicación cerca del cursor con un icono del botón que debe pulsar y el texto «Interactuar».

Estos elementos se pueden activar o desactivar y personalizar.

La respuesta visual al pasar el cursor sobre la UI muestra un icono distinto según la entrada que selecciones en el campo `button` . En PC, muestra un icono con una `E` para `InputAction.IA_PRIMARY`, una `F` para `InputAction.IA_SECONDARY`y un ratón para `InputAction.IA_POINTER`.

Cambia el texto modificando el valor de `hoverText` . Procura que sea breve, para que se lea rápidamente y no resulte demasiado intrusivo en la pantalla.

```ts
// crear entidad
const chest = engine.addEntity()

// añadir un componente PointerEvents a la entidad
PointerEvents.create(chest, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_POINTER,
				hoverText: 'Open',
			},
		},
	],
})
```

En el ejemplo anterior, el evento de puntero incluye un valor para `hoverText`. Este campo define la cadena que se muestra en la UI mientras el jugador apunta a la entidad. De forma predeterminada, esta cadena dice *Interactuar*.

{% hint style="info" %}
**💡 Consejo**: La cadena `hoverText` debe describir la acción que se realiza al interactuar. Por ejemplo: `Open`, `Activate`, `Grab`, `Select`. Estas cadenas deben ser lo más breves posible para no distraer demasiado al jugador.
{% endhint %}

Si una entidad tiene varios eventos de puntero, las indicaciones al pasar el cursor de cada uno se muestran radialmente alrededor del cursor.

El `hoverText` de un evento de puntero `.UP` solo se muestra mientras el jugador mantiene presionada la tecla correspondiente y apunta a la entidad.

Si una entidad tiene tanto un evento de puntero `DOWN` como un evento de puntero `UP` la indicación de la acción `DOWN` se muestra mientras el botón no está presionado. La indicación cambia a la del evento `UP` solo cuando se presiona el botón y mientras permanezca presionado.

```ts
// crear entidad
const entity = engine.addEntity()

// añadir un componente PointerEvents a la entidad
PointerEvents.create(entity, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_POINTER,
				hoverText: 'Drag',
			},
		},
		{
			eventType: PointerEventType.PET_UP,
			eventInfo: {
				button: InputAction.IA_POINTER,
				hoverText: 'Drop',
			},
		},
	],
})
```

Para ocultar la indicación al pasar el cursor, pero dejar el resaltado del contorno, establece el valor de `hoverText` en "".

```ts
// crear entidad
const chest = engine.addEntity()

// añadir un componente PointerEvents a la entidad
PointerEvents.create(chest, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_POINTER,
				hoverText: '',
			},
		},
	],
})
```

Para ocultar el resaltado del contorno, pero dejar la indicación al pasar el cursor, establece `showHighlight` en *false*.

```ts
// crear entidad
const chest = engine.addEntity()

// añadir un componente PointerEvents a la entidad
PointerEvents.create(chest, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_POINTER,
				hoverText: 'Open door',
				showHighlight: false,
			},
		},
	],
})
```

Para ocultar tanto la indicación al pasar el cursor como el resaltado del contorno, establece `showFeedback` en *false*. Al hacerlo, el cursor no muestra iconos, texto ni resaltado del contorno. También puedes quitar el componente `PointerEvents` de la entidad.

```ts
// crear entidad
const chest = engine.addEntity()

// añadir un componente PointerEvents a la entidad
PointerEvents.create(chest, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_POINTER,
				showFeedback: false,
			},
		},
	],
})
```

### Distancia máxima

Algunas entidades pueden estar diseñadas para que solo se pueda interactuar con ellas a corta distancia. Si un jugador está demasiado lejos de una entidad, la indicación al pasar el cursor no se mostrará junto al cursor.

De forma predeterminada, solo se puede hacer clic en las entidades cuando el **avatar** del jugador está a menos de *10 metros* de la entidad. Puedes cambiar ese rango configurando la `maxDistance` propiedad de un evento de puntero.

```ts
// crear entidad
const myEntity = engine.addEntity()

// añadir un componente PointerEvents a la entidad
PointerEvents.create(myEntity, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_POINTER,
				maxDistance: 6,
			},
		},
	],
})

// implement a system to handle the pointer event
engine.addSystem(() => {
	// fetch data about the pointer event
	const cmd = inputSystem.getInputCommand(
		InputAction.IA_POINTER,
		PointerEventType.PET_DOWN,
		myEntity
	)

	// check if the click was close enough
	if (cmd && cmd.hit && cmd.hit.length < 6) {
		// do something
	}
})
```

El ejemplo anterior establece la distancia máxima para las sugerencias al pasar el cursor en *6 metros*. Asegúrate de que la lógica que gestiona las acciones de entrada también siga las mismas reglas. Consulta [Datos de una acción de entrada](#data-from-input-action) para saber cómo obtener la distancia de una acción de entrada.

`maxDistance` se mide desde el **avatar**del jugador, por lo que funciona igual en primera y tercera persona.

Para limitar la interacción según la distancia a la que se encuentra la **cámara activa** en su lugar, usa `maxCameraDistance`. Si configuras ambos valores, basta con que se cumpla cualquiera de las dos comprobaciones. Consulta [Límites de distancia](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/register-callback.md#distance-limits) para ver todas las reglas.

{% hint style="warning" %}
**📔 Nota**: `maxPlayerDistance` es un alias obsoleto de `maxDistance`. Ambos miden la distancia desde el avatar, así que usa `maxDistance` en las escenas nuevas.
{% endhint %}

## Sugerencias personalizadas avanzadas

El `PointerEvents` componente añade fácilmente sugerencias de UI cuando el cursor del jugador empieza a pasar sobre una entidad. En general, es conveniente que las sugerencias se comporten de forma coherente con lo que los jugadores están acostumbrados a ver en otras escenas de Decentraland. Sin embargo, en algunos casos quizá quieras indicar de una manera personalizada que algo es interactivo. Por ejemplo, podrías reproducir un sonido sutil cuando el jugador empiece a pasar el cursor sobre la entidad. También podrías mostrar un resplandor alrededor de la entidad mientras el cursor esté encima y ocultarlo cuando deje de estarlo. Asimismo, podrías usarlo para mecánicas de juego específicas.

Usa la `inputSystem.isTriggered()` función junto con los eventos `PointerEventType.PET_HOVER_ENTER` y `PointerEventType.PET_HOVER_LEAVE` para ejecutar comportamientos personalizados cada vez que el cursor del jugador empiece a apuntar al Collider de la entidad y cada vez que deje de apuntar a él.

El siguiente ejemplo agranda las entidades hasta un tamaño de *1.5* cuando el cursor empieza a apuntar a su Collider y las devuelve a un tamaño de *1* cuando el cursor deja de apuntar a ellas.

```ts
engine.addSystem(() => {
	const meshEntities = engine.getEntitiesWith(MeshRenderer)
	for (const [entity] of meshEntities) {
		if (
			inputSystem.isTriggered(
				InputAction.IA_POINTER,
				PointerEventType.PET_HOVER_ENTER,
				entity
			)
		) {
			Transform.getMutable(entity).scale = Vector3.create(1.5, 1.5, 1.5)
		}

		if (
			inputSystem.isTriggered(
				InputAction.IA_POINTER,
				PointerEventType.PET_HOVER_LEAVE,
				entity
			)
		) {
			Transform.getMutable(entity).scale = Vector3.create(1, 1, 1)
		}
	}
})
```

{% hint style="warning" %}
**📔 Nota**: todas las entidades con las que quieras interactuar deben tener tanto un [`PointerEvents` componente](#show-feedback) como un [collider](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/colliders.md).
{% endhint %}

## Eventos de proximidad

Comprueba si se pulsan los botones de proximidad independientemente de hacia dónde apunte el cursor usando `PET_DOWN` en una Entity que use `InteractionType.PROXIMITY`. Establece el campo `interactionType` en la definición del evento de puntero, junto a `eventInfo`, para indicar que el evento se basa en la proximidad.

Consulta [**Eventos de proximidad**](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/eventos-de-button/proximity-events.md) para obtener más detalles, incluidas las funciones auxiliares disponibles.

```ts
PointerEvents.create(myEntity, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_DOWN,
			eventInfo: {
				button: InputAction.IA_PRIMARY,
				hoverText: 'Press E',
				maxDistance: 5
			},
			interactionType: InteractionType.PROXIMITY,
		},
	],
})

engine.addSystem(() => {
	if (inputSystem.isTriggered(InputAction.IA_PRIMARY, PointerEventType.PET_DOWN, myEntity)) {
		console.log('Player pressed button near entity')
	}
})
```

Con funciones auxiliares como `pointerEventsSystem.onProximityDown`, una Entity puede tener a la vez un controlador de cursor y uno de proximidad, y se ejecutarán ambas funciones de callback. Lo que no puede hacer es registrar dos botones diferentes para el mismo controlador. Los eventos basados en Systems no tienen ninguna de estas limitaciones: se define una entrada por cada comportamiento. Por ejemplo, aquí hay una Entity con la que se puede interactuar apuntándole con el cursor y pulsando E, o acercándose a ella y pulsando E sin apuntarle con el cursor.

```ts
	PointerEvents.create(myEntity, {
        pointerEvents: [
            {
                eventType: PointerEventType.PET_DOWN,
                eventInfo: {
                    button: InputAction.IA_POINTER,
                    hoverText: 'Hacer clic',
                    maxDistance: 15,
                },
                interactionType: InteractionType.CURSOR,
            },
            {
                eventType: PointerEventType.PET_DOWN,
                eventInfo: {
                    button: InputAction.IA_PRIMARY,
                    hoverText: 'Press E',
                    maxDistance: 15,
                },
                interactionType: InteractionType.PROXIMITY,
            },
        ],
    })
    
    engine.addSystem(() => {
        if (inputSystem.isTriggered(InputAction.IA_POINTER, PointerEventType.PET_DOWN, myEntity)) {
            console.log('Player clicked at entity')
        }
        if (inputSystem.isTriggered(InputAction.IA_PRIMARY, PointerEventType.PET_DOWN, myEntity)) {
            console.log('Player pressed button near entity')
        }
    })
```

También puedes usar `inputSystem.isTriggered()` con los tipos de evento `PET_PROXIMITY_ENTER` y `PET_PROXIMITY_LEAVE` para reaccionar cuando un jugador entra en el rango de proximidad de una Entity o sale de él. Esto resulta útil para mostrar información adicional en las Entities que se activan por proximidad; por ejemplo, reproducir un sonido o una animación.

Para que esto funcione, la Entity debe tener un componente `PointerEvents` con el tipo de evento de proximidad correspondiente definido.

```ts
PointerEvents.create(myEntity, {
	pointerEvents: [
		{
			eventType: PointerEventType.PET_PROXIMITY_ENTER,
			eventInfo: {
				button: InputAction.IA_POINTER,
				maxDistance: 5,
			},
		},
		{
			eventType: PointerEventType.PET_PROXIMITY_LEAVE,
			eventInfo: {
				button: InputAction.IA_POINTER,
				maxDistance: 5,
				showFeedback: false,
			},
		},
	],
})

engine.addSystem(() => {
	if (inputSystem.isTriggered(InputAction.IA_POINTER, PointerEventType.PET_PROXIMITY_ENTER, myEntity)) {
		console.log('Player entered proximity')
	}
	if (inputSystem.isTriggered(InputAction.IA_POINTER, PointerEventType.PET_PROXIMITY_LEAVE, myEntity)) {
		console.log('Player left proximity')
	}
})
```

## Datos de una acción de entrada

Obtén datos de una acción de entrada, como el botón que se pulsó, la Entity alcanzada, la dirección y la longitud del rayo, etc. Consulta ([Consulta la documentación](https://github.com/decentraland/docs/tree/main/README.md)) para ver una descripción de todos los datos disponibles.

Para obtener estos datos, usa `inputSystem.getInputCommand`. Esta función devuelve la estructura de datos completa con información sobre el evento de entrada.

```ts
engine.addSystem(() => {
	const cmd = inputSystem.getInputCommand(
		InputAction.IA_POINTER,
		PointerEventType.PET_DOWN,
		myEntity
	)
	if (cmd) {
		console.log(cmd.hit?.entityId)
	}
})
```

Si no hay ninguna acción de entrada que coincida con la consulta, `inputSystem.getInputCommand` devuelve *null*. Asegúrate de gestionar este caso en tu lógica.

### Distancia máxima de clic

Para establecer una distancia máxima, de modo que solo se pueda hacer clic en una Entity a corta distancia, obtén la `hit.length` propiedad de los datos del evento.

```ts
// implement a system to handle the pointer event
engine.addSystem(() => {
	// fetch data about the pointer event
	const cmd = inputSystem.getInputCommand(
		InputAction.IA_POINTER,
		PointerEventType.PET_DOWN,
		myEntity
	)

	// check if the click was close enough
	if (cmd && cmd.hit && cmd.hit.length < 6) {
		// do something
	}
})
```

{% hint style="warning" %}
**📔 Nota**: Si ignoras los eventos que ocurren a gran distancia, asegúrate de establecer el parámetro `maxDistance` en el componente `PointerEvents` para que el comportamiento sea coherente.
{% endhint %}

### Diferentes Meshes dentro de un modelo

A menudo, *.glTF* los modelos 3D están formados por varios Meshes, cada uno con un nombre interno propio. Todos los eventos de botón incluyen información sobre qué Mesh específico se ha seleccionado, así que puedes usar esta información para activar diferentes comportamientos de clic en cada caso.

Para ver cómo se llaman los Meshes dentro del modelo, debes abrir el modelo 3D con una herramienta de edición, como [Blender](https://www.blender.org/) por ejemplo.

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

{% hint style="info" %}
**💡 Consejo**: También puedes averiguar el nombre del Mesh seleccionado registrándolo y consultándolo en la consola.
{% endhint %}

Accedes a la propiedad `meshName` como parte del objeto `hit` , que devuelve el evento de clic.

En el ejemplo siguiente, tenemos un modelo de una casa que incluye un Mesh llamado `firePlace`. Queremos encender la chimenea solo cuando se seleccione el Mesh correspondiente.

```ts
engine.addSystem(() => {
	const cmd = inputSystem.getInputCommand(
		InputAction.IA_POINTER,
		PointerEventType.PET_DOWN,
		myEntity
	)
	if (cmd && cmd.hit?.meshName === 'firePlace') {
		// light fire
	}
})
```

{% hint style="warning" %}
**📔 Nota**: Esto solo se aplica a los eventos basados en Pointer, no a los eventos basados en proximidad, ya que en ese caso todos los Meshes del modelo podrían estar al mismo tiempo cerca del jugador.
{% endhint %}


---

# 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/interactividad/eventos-de-button/system-based-events.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.
