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

# Funciones obsoletas

Funciones heredadas

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

## El jugador entra o sale de la scene

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

Siempre que un avatar entre o salga de los parcels de land que forman tu scene, o teletransporte dentro o fuera, esto crea un evento al que puedes escuchar. Este evento lo activan todos los avatars, 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 event solo responde a los players que se están renderizando localmente en este momento. En scenes grandes donde el tamaño de la scene supera el rango visual, puede que no se registren los players que entran por la esquina opuesta. Si el número de players en la región supera las capacidades de un island en los servers de Decentraland, los players que no comparten el mismo island tampoco son visibles y estos events tampoco los rastrean.
{% endhint %}

Los observables `onEnterScene` y `onLeaveScene` importados desde `'@dcl/sdk/observables'` también están obsoletos. Las funciones correctas tienen el mismo nombre, 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, 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 de player
import { onEnterScene, onLeaveScene } from '@dcl/sdk/src/players'

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

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

## El jugador se conecta o desconecta

{% hint style="warning" %}
**📔 Nota**: El `getConnectedPlayers` function y el `onPlayerConnectedObservable` y `onPlayerDisconnectedObservable` los eventos están obsoletos en SDK 7.x. Usa `onEnterScene` en su lugar, consulta [El jugador entra o sale de la scene](/creator/content-creator-es/scenes-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 players actualmente conectados con `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 player empieza o deja de ser renderizado por el engine local, esto crea un event al que puedes escuchar. Los players 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 player se conecta cerca por primera vez o se aproxima lo suficiente para estar dentro del rango visual; asimismo, el `onPlayerDisconnectedObservable` detecta cuando un player finaliza su sesión o se aleja demasiado.

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

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

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

Ten en cuenta que si otros players ya se están renderizando en los alrededores antes de que el player haya cargado tu scene, este event no notificará a la scene recién cargada sobre los players ya existentes. Si necesitas llevar un seguimiento de todos los players actuales, puedes consultar los players existentes al cargar la scene y luego escuchar este event para las actualizaciones.

## Consultar todos los players en la scene

{% hint style="warning" %}
**📔 Nota**: El `getPlayersInScene` function está obsoleta en SDK 7.x. En su lugar, itera sobre todos los players con un `PlayerIdentityData` component. Consulta [Obtener todos los players](/creator/content-creator-es/scenes-sdk7/interactividad/user-data.md#fetch-all-players).
{% endhint %}

También puedes obtener la lista completa de players que están actualmente 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**: El `onPlayerExpressionObservable` event está obsoleto en SDK 7.x. Usa el `AvatarEmoteCommand` component en su lugar, consulta [El jugador reproduce una animación](/creator/content-creator-es/scenes-sdk7/interactividad/event-listeners.md#player-plays-animation).
{% endhint %}

Siempre que el player reproduzca un emote (baile, aplauso, saludo, etc.), puedes detectar este event.

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

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

El event incluye la siguiente información:

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

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

## El jugador cambia el perfil

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

Cada vez que el player hace un cambio en su perfil, se llama al `onProfileChanged` event. Estos cambios pueden incluir ponerse wearables distintos, cambiar el nombre, la descripción, activar experiencias portátiles, etc.

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

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

Los datos del event incluyen solo el ID del player y un número de versión para el perfil 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 activa este event, entonces puedes usar [getUserData()](/creator/content-creator-es/scenes-sdk7/interactividad/user-data.md#get-player-data) function para obtener la versión más reciente de esta información, incluida la lista de wearables que lleva puesto el player. Puede que necesites añadir un pequeño retraso antes de llamar a `getUserData()` para asegurarte de que la versión que devuelve esta function esté actualizada.

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

{% hint style="warning" %}
**📔 Nota**: Este event solo se activa por cambios en el player actual, no por cambios en los perfiles de otros players cercanos.
{% endhint %}

## La scene terminó de cargarse

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

Cuando la scene termina de cargarse, se llama a la `onSceneReadyObservable` Esto funciona tanto si el player entra directamente a la scene como si camina hasta la scene desde otro lugar. Cuando todo el contenido de la scene ha terminado su carga inicial, incluidos modelos pesados, etc., se llama a este event.

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

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

## Métodos de datos de player obsoletos

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

Para obtener información del player actual que ejecuta 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 players 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 content API. Consulta [Datos de cualquier player](/creator/content-creator-es/scenes-sdk7/interactividad/user-data.md#data-from-any-player)

`getPlayerData()` solo puedes obtener datos de players que estén actualmente cerca. No tienen por qué estar necesariamente en la misma scene, pero sí dentro del rango visual, porque esta información se obtiene del local engine que está renderizando estos avatars. 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 estar 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()` functions también están obsoletas. Usa por favor `getPlayer()` en su lugar. Consulta [Datos de usuario](/creator/content-creator-es/scenes-sdk7/interactividad/user-data.md#get-user-data).

## Obtener la hora del skybox

{% hint style="warning" %}
**📔 Nota**: El `getDecentralandTime()` function está obsoleta desde SDK v7.x.x. Usa `getWorldTime()` en su lugar. Consulta [Obtener la hora de Decentraland](/creator/content-creator-es/scenes-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**: El `getCurrentRealm()` function está obsoleta desde SDK v7.x.x. Usa `getRealm()` en su lugar. Consulta [Obtener datos del realm](/creator/content-creator-es/scenes-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()
```

## Es el modo preview

{% hint style="warning" %}
**📔 Nota**: El `isPreviewMode()` function está obsoleta desde SDK v7.x.x. Usa `getRealm()` en su lugar, que contiene una `preview` propiedad. Consulta [Obtener datos del realm](/creator/content-creator-es/scenes-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 player hace clic en otro player

Siempre que el player haga clic en otro player, puedes detectar un event.

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

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

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

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

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

El event incluye los siguientes datos:

* `userId`: El id del player en 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 player que hizo el clic, relativa a la scene.

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

## El player bloquea/desbloquea el cursor

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

Los players 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 players desbloquean el cursor haciendo clic en el *botón derecho del mouse* o presionando la *Esc* tecla, y vuelven a bloquear el cursor haciendo clic en cualquier parte de la pantalla.

Para reaccionar cada vez que un player cambia entre estos dos modos, usa la `onChange` function en el `PointerLock` component, consulta [Listeners de eventos](/creator/content-creator-es/scenes-sdk7/interactividad/event-listeners.md#player-locks-or-unlocks-cursor).

## El player cambia de realm o island

Los players en Decentraland existen en *realms*y en *islands* separadas dentro de cada realm. Los players en distintos realms o islands no pueden verse, interactuar ni chatear entre sí, incluso si están en los mismos parcels.

Cada vez que el player cambia de realm o island, se llama al `onRealmChangedObservable` event.

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

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

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

Este event 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 un *-* y el nombre de la island. Por ejemplo `unicorn-x011`.
* **domain**: *string*; La URL al servidor catalyst que se está usando.

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

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

## Funciones de cripto

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

## Eventos de video

{% hint style="warning" %}
**📔 Nota**: El `onVideoEvent` event está obsoleto desde SDK v7.x. Consulta [Listeners de eventos](/creator/content-creator-es/scenes-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 event.

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

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

* `videoClipId` ( *string*): El ID de la entity que cambió de estado.
* `componentId` (*string*): El ID de la entity que cambió de estado.
* `currentOffset` (*number*): El valor actual de la `seek` property del video. Este valor muestra los segundos transcurridos desde el inicio original del video. *-1* por defecto.
* `totalVideoLength` (*number* ): La duración en segundos de todo el video. *-1* si se desconoce la duración.
* `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/scenes-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.