> 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/escenas-sdk7/interactividad/deprecated-functions.md).

# Funciones obsoletas

Las siguientes funciones son todas obsoletas y deben evitarse. Siguen funcionando, pero en el futuro podría dejar de darles soporte. Todos estos ejemplos incluyen enlaces a formas alternativas de obtener la misma información o conseguir los mismos resultados.

## El jugador entra o sale de scene

{% hint style="warning" %}
**📔 Nota**: La `onEnterSceneObservable` y `onLeaveSceneObservable` están obsoletos en SDK 7.x. Usa `onEnterScene` en su lugar, ver [El jugador entra o sale de scene](/creator/content-creator-es/escenas-sdk7/interactividad/event-listeners.md#player-enters-or-leaves-scene).
{% endhint %}

Cada vez que un avatar entra o sale de los parcels de land que componen tu scene, o se teletransporta hacia dentro o hacia fuera, esto crea un evento al que puedes suscribirte. Este evento lo activan todos los avatares, incluido el del jugador.

```ts
import {
	onEnterSceneObservable,
	onLeaveSceneObservable,
} from '@dcl/sdk/observables'

onEnterSceneObservable.add((player) => {
	console.log('el jugador entró en la scene: ', player.userId)
})

onLeaveSceneObservable.add((player) => {
	console.log('el jugador salió de la scene: ', player.userId)
})
```

{% hint style="warning" %}
**📔 Nota**: Este evento solo responde a los jugadores que se están renderizando localmente. En scenes grandes donde el tamaño de la scene supera el rango visual, es posible que los jugadores que entren en la esquina opuesta no se registren. Si el número de jugadores en la región supera las capacidades de una island en los servidores de Decentraland, los jugadores que no compartan la misma island tampoco son visibles y estos eventos tampoco los rastrean.
{% endhint %}

Los observables `onEnterScene` y `onLeaveScene` importados desde `'@dcl/sdk/observables'` también están obsoletos. Las funciones correctas se llaman igual, pero se importan desde `'@dcl/sdk/src/players'` en su lugar. En el ejemplo de abajo puedes ver ambas variantes, primero la versión obsoleta y luego la correcta.

```ts
// OBSOLETO - importado desde observables
import { onEnterScene, onLeaveScene } from '@dcl/sdk/observables'

onEnterScene.add((player) => {
	console.log('el jugador entró en la scene: ', player.userId)
})

onLeaveScene.add((player) => {
	console.log('el jugador salió de la scene: ', player.userId)
})

// ACTUAL - importado como una función del jugador
import { onEnterScene, onLeaveScene } from '@dcl/sdk/src/players'

export function main() {
	onEnterScene((player) => {
		if (!player) return
		console.log('ENTRÓ EN LA SCENE', player)
	})

	onLeaveScene((userId) => {
		if (!userId) return
		console.log('SALIÓ DE LA SCENE', userId)
	})
}
```

## El jugador se conecta o se desconecta

{% hint style="warning" %}
**📔 Nota**: La `getConnectedPlayers` función y el `onPlayerConnectedObservable` y `onPlayerDisconnectedObservable` están obsoletos en SDK 7.x. Usa `onEnterScene` en su lugar, ver [El jugador entra o sale de scene](/creator/content-creator-es/escenas-sdk7/interactividad/event-listeners.md#player-enters-or-leaves-scene). Cada scene es ahora una isla de comms distinta, por lo que estar conectado o estar en la misma scene es lo mismo.
{% endhint %}

Obtén la lista completa de jugadores actualmente conectados desde `getConnectedPlayers`.

```ts
import { getConnectedPlayers } from '~system/Players'

executeTask(async () => {
	let connectedPlayers = await getConnectedPlayers({})
	connectedPlayers.players.forEach((player) => {
		console.log('el jugador ya estaba aquí: ', player.userId)
	})
})
```

Cada vez que otro jugador empieza o deja de ser renderizado por el engine local, esto crea un evento al que puedes suscribirte. Los jugadores pueden o no estar en la misma scene que tú, pero deben estar dentro del rango visual (no necesariamente a la vista). El `onPlayerConnectedObservable` detecta tanto cuando un jugador se conecta por primera vez cerca o se acerca lo suficiente para estar dentro del rango visual, como cuando el `onPlayerDisconnectedObservable` detecta cuando un jugador termina su sesión o se aleja demasiado.

```ts
import {
	onPlayerConnectedObservable,
	onPlayerDisconnectedObservable,
} from '@dcl/sdk/observables'

onPlayerConnectedObservable.add((player) => {
	console.log('el jugador entró: ', player.userId)
})

onPlayerDisconnectedObservable.add((player) => {
	console.log('el jugador salió: ', player.userId)
})
```

Ten en cuenta que, si otros jugadores ya se están renderizando en los alrededores antes de que el jugador cargue tu scene, este evento no notificará a la scene recién cargada de los jugadores que ya existían. Si necesitas hacer un seguimiento de todos los jugadores actuales, puedes consultar los jugadores existentes al cargar la scene y luego escuchar este evento para obtener actualizaciones.

## Consultar todos los jugadores en scene

{% hint style="warning" %}
**📔 Nota**: La `getPlayersInScene` función está obsoleta en SDK 7.x. En su lugar, recorre todos los jugadores con un `PlayerIdentityData` component. Ver [Obtener todos los jugadores](/creator/content-creator-es/escenas-sdk7/interactividad/user-data.md#fetch-all-players).
{% endhint %}

También puedes obtener la lista completa de jugadores que actualmente están en tu scene y se están renderizando llamando a `getPlayersInScene()`.

```ts
import { getPlayersInScene } from '~system/Players'

executeTask(async () => {
	let connectedPlayers = await getPlayersInScene({})
	connectedPlayers.players.forEach((player) => {
		console.log('el jugador ya estaba aquí: ', player.userId)
	})
})
```

## El jugador reproduce una animación

{% hint style="warning" %}
**📔 Nota**: La `onPlayerExpressionObservable` evento está obsoleto en SDK 7.x. Usa el `AvatarEmoteCommand` component en su lugar, ver [El jugador reproduce una animación](/creator/content-creator-es/escenas-sdk7/interactividad/event-listeners.md#player-plays-animation).
{% endhint %}

Cada vez que el jugador hace un emote (baile, aplauso, saludo, etc.), puedes detectar este evento.

```ts
import { onPlayerExpressionObservable } from '@dcl/sdk/observables'

onPlayerExpressionObservable.add(({ expressionId }) => {
	console.log('Expresión: ', expressionId)
})
```

El evento incluye la siguiente información:

* expressionId: Nombre del emote realizado (es decir: *wave*, *clap*, *kiss*)

{% hint style="warning" %}
**📔 Nota**: Este evento se activa cada vez que el jugador hace un emote y la scene está cargada. El jugador podría estar en una scene cercana cuando esto ocurra.
{% endhint %}

## El jugador cambia el profile

{% hint style="warning" %}
**📔 Nota**: La `onProfileChanged` evento está obsoleto en SDK 7.x. Usa el `AvatarEquippedData` component en su lugar, ver [El jugador cambia el profile](/creator/content-creator-es/escenas-sdk7/interactividad/event-listeners.md#player-changes-profile).
{% endhint %}

Cada vez que el jugador hace un cambio en su profile, se llama al `onProfileChanged` evento. Estos cambios pueden incluir ponerse diferentes wearables, cambiar el nombre, la descripción, activar experiencias portables, etc.

```ts
import { onProfileChanged } from '@dcl/sdk/observables'

onProfileChanged.add((profileData) => {
	console.log('Los datos del propio profile son ', profileData)
})
```

Los datos del evento solo incluyen el ID del jugador y un número de versión para el profile de ese avatar, según el servidor catalyst. Cada vez que se propaga un cambio, el número de versión aumenta en 1.

Cuando se active este evento, entonces puedes usar [getUserData()](/creator/content-creator-es/escenas-sdk7/interactividad/user-data.md#get-player-data) función para obtener la última versión de esta información, incluida la lista de wearables que lleva puestos el jugador. Es posible que necesites añadir un pequeño retraso antes de llamar a `getUserData()` para asegurarte de que la versión que devuelve esta función esté actualizada.

{% hint style="info" %}
**💡 Consejo**: Al probar en preview con el explorer web heredado, para evitar usar un avatar aleatorio, ejecuta la scene en el navegador conectado con tu wallet de Metamask.
{% endhint %}

{% hint style="warning" %}
**📔 Nota**: Este evento solo se activa por cambios en el jugador actual, no por cambios en los profiles de otros jugadores cercanos.
{% endhint %}

## La scene terminó de cargarse

{% hint style="warning" %}
**📔 Nota**: La `onSceneReadyObservable` evento está obsoleto desde SDK v7.x. Esta función ya no es relevante. Puedes asegurarte de que algo se ejecute después de que la scene termine de cargarse ejecutándolo dentro de la `Main()` función. Ver [Ciclo de vida de Scene](/creator/content-creator-es/escenas-sdk7/primeros-pasos/coding-scenes.md#scene-lifecycle)
{% endhint %}

Cuando la scene termina de cargarse, se llama a `onSceneReadyObservable` Esto funciona tanto si el jugador carga directamente en la scene como si se acerca a la scene desde otro lugar. Cuando todo el contenido de la scene ha terminado su carga inicial, incluidos los modelos pesados, etc., se llama a este evento.

```ts
import { onSceneReadyObservable } from '@dcl/sdk/observables'

onSceneReadyObservable.add(() => {
	console.log('SCENE CARGADA')
})
```

## Métodos de datos del jugador obsoletos

{% hint style="warning" %}
**📔 Nota**: La `getUserData()` y `getPlayerData()` funciones están obsoletas desde SDK v7.4.x. Usa `getPlayer()` en su lugar. Ver [Datos del usuario](/creator/content-creator-es/escenas-sdk7/interactividad/user-data.md#get-user-data).
{% endhint %}

Para obtener información del jugador actual que está ejecutando la scene, usa `getUserData()`.

El ejemplo de abajo importa el `~system/UserIdentity` namespace y ejecuta `getUserData()`.

```ts
import { getUserData } from '~system/UserIdentity'

executeTask(async () => {
	let userData = await getUserData({})
	console.log(userData.data)
})
```

Puedes obtener datos de otros jugadores que estén cerca llamando a `getPlayerData()`, pasando el id de una cuenta de Decentraland.

```ts
import { getPlayerData } from '~system/Players'

executeTask(async () => {
	let userData = await getPlayerData({ userId: '0x….' })
	console.log(userData)
})
```

Ambos `getUserData()` y `getPlayerData()` devuelven la misma estructura de datos disponible a través de la API de contenido. Ver [Datos de cualquier jugador](/creator/content-creator-es/escenas-sdk7/interactividad/user-data.md#data-from-any-player)

`getPlayerData()` solo puede obtener datos de jugadores que estén cerca en ese momento. No tienen que estar necesariamente en la misma scene, pero sí en rango visual; esto se debe a que esta información se obtiene del engine local que está renderizando estos avatares. Para probar esto en preview, abre una segunda pestaña e inicia sesión con una cuenta diferente.

{% hint style="warning" %}
**📔 Nota**: Los IDs de usuario deben ir siempre en minúsculas. Si copias una dirección de wallet, asegúrate de que todos los caracteres estén en minúsculas.
{% endhint %}

Las `getUserPublicKey()` y `getUserAccount()` funciones también están obsoletas. Usa `getPlayer()` en su lugar. Ver [Datos del usuario](/creator/content-creator-es/escenas-sdk7/interactividad/user-data.md#get-user-data).

## Obtener hora del skybox

{% hint style="warning" %}
**📔 Nota**: La `getDecentralandTime()` función está obsoleta desde SDK v7.x.x. Usa `getWorldTime()` en su lugar. Ver [Obtener hora de Decentraland](/creator/content-creator-es/escenas-sdk7/interactividad/runtime-data.md#get-decentraland-time).
{% endhint %}

```ts
import { getDecentralandTime } from '~system/EnvironmentApi'

executeTask(async () => {
	let time = await getDecentralandTime({})
	console.log(time)
})
```

## Obtener realm

{% hint style="warning" %}
**📔 Nota**: La `getCurrentRealm()` función está obsoleta desde SDK v7.x.x. Usa `getRealm()` en su lugar. Ver [Obtener datos del Realm](/creator/content-creator-es/escenas-sdk7/interactividad/runtime-data.md#get-realm-data).
{% endhint %}

```ts
import { getCurrentRealm } from '~system/EnvironmentApi'

async function fetchPlayerData() {
	const playerRealm = await getCurrentRealm({})

	console.log(playerRealm.currentRealm?.domain)
}

fetchPlayerData()
```

## Está en modo preview

{% hint style="warning" %}
**📔 Nota**: La `isPreviewMode()` función está obsoleta desde SDK v7.x.x. Usa `getRealm()` en su lugar, que contiene una `preview` propiedad. Ver [Obtener datos del Realm](/creator/content-creator-es/escenas-sdk7/interactividad/runtime-data.md#get-realm-data).
{% endhint %}

```ts
import { isPreviewMode } from '~system/EnvironmentApi'

executeTask(async () => {
	const { isPreview } = await isPreviewMode({})

	if (isPreview) {
		console.log('Ejecutando en preview')
	}
})
```

## El jugador hace clic en otro jugador

Cada vez que el jugador hace clic en otro jugador, puedes detectar un evento.

```ts
import { onPlayerClickedObservable } from '@dcl/sdk/observables'

onPlayerClickedObservable.add((clickEvent) => {
	console.log('Se hizo clic en ', clickEvent.userId, ' detalles: ', clickEvent.ray)
})
```

{% hint style="warning" %}
**📔 Nota**: La `onPlayerClickedObservable` evento está obsoleto desde SDK v7.x. Las versiones futuras permitirán un enfoque más [orientado a datos](/creator/content-creator-es/escenas-sdk7/arquitectura/data-oriented-programming.md), basado en consultar datos regularmente en lugar de eventos.

Como alternativa, puedes adjuntar un collider invisible al jugador y detectar los clics contra este.
{% endhint %}

{% hint style="warning" %}
**📔 Nota**: Tanto el jugador que hace clic como el jugador sobre el que se hace clic deben estar dentro de los parcels de la scene. Este listener solo detecta eventos del jugador actual haciendo clic sobre otros jugadores, no los clics realizados por otros jugadores.
{% endhint %}

El evento incluye los siguientes datos:

* `userId`: El id del jugador sobre el que se hizo clic
* `ray`: Datos sobre el ray trazado por el clic
  * `direction`: *Vector3* Un Vector3 normalizado que representa la dirección desde el punto de origen del clic hasta el punto de impacto del clic.
  * `distance`: *number* La distancia en metros desde el punto de origen hasta el punto de impacto.
  * `origin`: *Vector3* El punto de origen del clic, la posición del jugador que hizo el clic, relativa a la scene.

{% hint style="info" %}
**💡 Consejo**: El comportamiento predeterminado al hacer clic en otro jugador es abrir el pasaporte del jugador, donde puedes ver información adicional sobre ese jugador, añadirlo como amigo, etc. Puedes desactivar la apertura de esta UI para que no interfiera con la experiencia que quieras construir añadiendo un [Avatar Modifier Area](/creator/content-creator-es/escenas-sdk7/interactividad/player-avatar.md#avatar-modifier-areas).
{% endhint %}

## El jugador bloquea/desbloquea el cursor

{% hint style="warning" %}
**📔 Nota**: La `onPointerLockedStateChange` evento se eliminó en SDK v7.x; ya no está disponible. Ver [escuchadores de eventos](/creator/content-creator-es/escenas-sdk7/interactividad/event-listeners.md#player-locks-or-unlocks-cursor) para la alternativa actual.
{% endhint %}

Los jugadores pueden alternar entre dos modos de cursor: *modo de cursor bloqueado* para controlar la cámara o *modo de cursor desbloqueado* para mover el cursor libremente sobre la UI.

Los jugadores desbloquean el cursor haciendo clic en el *botón derecho del mouse* o pulsando la tecla *Esc* y vuelven a bloquear el cursor haciendo clic en cualquier parte de la pantalla.

Para reaccionar cada vez que un jugador alterna entre estos dos modos, usa la `onChange` función en el `PointerLock` component, ver [escuchadores de eventos](/creator/content-creator-es/escenas-sdk7/interactividad/event-listeners.md#player-locks-or-unlocks-cursor).

## El jugador cambia de realm o island

Los jugadores en decentraland existen en *realms*separados, y en *islands* separadas dentro de cada realm. Los jugadores en diferentes realms o islands no pueden verse, interactuar ni chatear entre ellos, incluso si están de pie sobre los mismos parcels.

Cada vez que el jugador cambia de realms o island, se llama al `onRealmChangedObservable` evento.

```ts
import { onRealmChangedObservable } from '@dcl/sdk/observables'

onRealmChangedObservable.add((realmChange) => {
	console.log('EL JUGADOR CAMBIÓ DE ISLAND A ', realmChange.room)
})
```

{% hint style="warning" %}
**📔 Nota**: La `onRealmChangedObservable` evento está obsoleto desde SDK v7.x. Las versiones futuras permitirán un enfoque más [orientado a datos](/creator/content-creator-es/escenas-sdk7/arquitectura/data-oriented-programming.md), basado en consultar datos regularmente en lugar de eventos.
{% endhint %}

Este evento incluye los siguientes campos:

* **serverName**: *string*; El nombre del servidor Catalyst.
* **room**: *string*; El nombre de la island.
* **displayName**: *string*; El nombre del servidor Catalyst seguido de una *-* y el nombre de la island. Por ejemplo `unicorn-x011`.
* **domain**: *string*; La URL del servidor Catalyst que se está usando.

A medida que los jugadores se mueven por el mapa, pueden cambiar de island para agruparse con aquellos jugadores que ahora están más cerca de ellos. Las islands también desplazan sus límites dinámicamente para acomodar un grupo manejable de personas en cada una. Así que, incluso si un jugador permanece quieto, podría cambiar de island a medida que otros entren y salgan de las scenes circundantes.

Si tu scene depende de un [servidor de terceros](/creator/content-creator-es/escenas-sdk7/networking/third-party-servers.md) para sincronizar cambios entre jugadores en tiempo real, entonces quizá quieras compartir datos solo entre jugadores que estén agrupados en el mismo realm+island, así que es una buena práctica cambiar las rooms en el servidor de terceros cada vez que los jugadores cambien de island.

## Funciones de crypto

{% hint style="warning" %}
**📔 Nota**: Las funciones `requirePayment()`, `signMessage()`, `convertMessageToObject()` están obsoletas. Usa la `sendAsync()` función en su lugar. Ver [operaciones blockchain de la scene](/creator/content-creator-es/escenas-sdk7/blockchain/scene-blockchain-operations.md). También hay libraries que pueden ayudar a simplificar algunos casos de uso comunes con estas funciones.
{% endhint %}

## Eventos de video

{% hint style="warning" %}
**📔 Nota**: La `onVideoEvent` evento está obsoleto en SDK v7.x. Ver [escuchadores de eventos](/creator/content-creator-es/escenas-sdk7/media/video-playing.md#video-events) para una alternativa no obsoleta.
{% endhint %}

Cuando un video cambia su estado de reproducción, el `onVideoEvent` observable recibe un evento.

```ts
onVideoEvent.add((data) => {
	console.log('Nuevo evento de video ', data)
})
```

La entrada de un evento de video contiene las siguientes propiedades:

* `videoClipId` ( *string*): El ID de la entidad que cambió de estado.
* `componentId` (*string*): El ID de la entidad que cambió de estado.
* `currentOffset` (*number*): El valor actual de la propiedad `seek` en el video. Este valor muestra los segundos transcurridos desde el inicio original del video. *-1* de forma predeterminada.
* `totalVideoLength` (*number* ): La duración en segundos de todo el video. *-1* si la duración es desconocida.
* `videoStatus`: El valor del nuevo estado de video de la `VideoTexture`, expresado como un valor del `VideoStatus` enum. Este enum puede contener los siguientes valores posibles:
* `VideoStatus.NONE` = 0,
* `VideoStatus.ERROR` = 1,
* `VideoStatus.LOADING` = 2,
* `VideoStatus.READY` = 3,
* `VideoStatus.PLAYING` = 4,
* `VideoStatus.BUFFERING` = 5


---

# 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 dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.decentraland.org/creator/content-creator-es/escenas-sdk7/interactividad/deprecated-functions.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.