> 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 heredadas 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 escena

{% hint style="warning" %}
**📔 Nota**: La `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 escena](/creator/content-creator-es/scenes-sdk7/interactividad/event-listeners.md#player-enters-or-leaves-scene).
{% endhint %}

Cada vez que un avatar entra o sale de las parcelas de terreno que componen tu escena, o se teletransporta dentro o fuera, esto crea un evento al que puedes suscribirte. Este evento se activa para todos los avatares, incluido el del jugador.

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

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

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

{% hint style="warning" %}
**📔 Nota**: Ten en cuenta que este evento solo responde a los jugadores que se están renderizando localmente en este momento. En escenas grandes donde el tamaño de la escena supera el rango visual, es posible que los jugadores que entren por la esquina opuesta no se registren. Si el número de jugadores en la región supera las capacidades de una isla en los servidores de Decentraland, los jugadores que no compartan la misma isla tampoco serán visibles ni serán rastreados por estos eventos.
{% 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 y luego la correcta.

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

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

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

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

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

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

## El jugador se conecta o se desconecta

{% hint style="warning" %}
**📔 Nota**: La `getConnectedPlayers` y la `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 escena](/creator/content-creator-es/scenes-sdk7/interactividad/event-listeners.md#player-enters-or-leaves-scene)Cada escena es ahora una isla de comunicaciones distinta, por lo que es lo mismo estar conectado o estar en la misma escena.
{% endhint %}

Obtén la lista completa de los jugadores actualmente conectados mediante `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 motor local, esto crea un evento al que puedes suscribirte. Los jugadores pueden estar o no en la misma escena 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 en rango visual; de la misma manera, el `onPlayerDisconnectedObservable` detecta cuando un jugador termina su sesión o se aleja mucho.

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

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

onPlayerDisconnectedObservable.add((player) => {
	console.log('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 escena, este evento no notificará a la escena recién cargada sobre los jugadores que ya existían. Si necesitas llevar un registro de todos los jugadores actuales, puedes consultar a los jugadores existentes al cargar la escena y luego escuchar este evento para las actualizaciones.

## Consultar todos los jugadores en la escena

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

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

Cada vez que el jugador reproduce 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 escena está cargada. El jugador podría estar en una escena cercana cuando esto ocurra.
{% endhint %}

## El jugador cambia de perfil

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

Cada vez que el jugador realiza un cambio en su perfil, el `onProfileChanged` evento se llama. Estos cambios pueden incluir ponerse distintos Wearables, 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 de mi perfil son ', profileData)
})
```

Los datos del evento incluyen solo el ID del jugador 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 evento, puedes usar entonces la [getUserData()](/creator/content-creator-es/scenes-sdk7/interactividad/user-data.md#get-player-data) función para obtener la versión más reciente de esta información, incluida la lista de wearables que lleva puesto el jugador. Puede que necesites añadir una pequeña demora 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 explorador web heredado, para evitar usar un avatar aleatorio, ejecuta la escena 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 perfiles de otros jugadores cercanos.
{% endhint %}

## La escena ha terminado de cargarse

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

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

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

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

## Métodos obsoletos de datos del jugador

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

Para obtener información del jugador actual que está ejecutando la escena, 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. Consulta [Datos de cualquier jugador](/creator/content-creator-es/scenes-sdk7/interactividad/user-data.md#data-from-any-player)

`getPlayerData()` solo pueden obtener datos de jugadores que estén cerca en ese momento. No tienen que estar necesariamente en la misma escena, pero sí dentro del rango visual, porque esta información se obtiene del motor 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 siempre deben estar en minúsculas. Si copias una dirección de wallet, asegúrate de que todos los caracteres estén en minúsculas.
{% endhint %}

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

## Obtener la hora del skybox

{% hint style="warning" %}
**📔 Nota**: La `getDecentralandTime()` la función 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**: La `getCurrentRealm()` la función está obsoleta desde SDK v7.x.x. Usa `getRealm()` en su lugar. Consulta [Obtener datos de 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()
```

## Está en modo preview

{% hint style="warning" %}
**📔 Nota**: La `isPreviewMode()` la función está obsoleta desde SDK v7.x.x. Usa `getRealm()` en su lugar, que contiene una `preview` propiedad. Consulta [Obtener datos de 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('Ejecutándose 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('Clic en ', clickEvent.userId, ' details: ', clickEvent.ray)
})
```

{% hint style="warning" %}
**📔 Nota**: La `onPlayerClickedObservable` el evento está obsoleto desde SDK v7.x. Las versiones futuras 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 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 las parcelas de la escena. Este listener solo detecta eventos del jugador actual haciendo clic en 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
  * `dirección`: *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 clic, relativa a la escena.

{% 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 quieres crear añadiendo un [Avatar Modifier Area](/creator/content-creator-es/scenes-sdk7/interactividad/avatares/modifier-areas.md).
{% endhint %}

## El jugador bloquea/desbloquea el cursor

{% hint style="warning" %}
**📔 Nota**: La `onPointerLockedStateChange` el evento 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 jugadores pueden alternar entre dos modos de cursor: *cursor bloqueado* modo para controlar la cámara o *cursor desbloqueado* modo para mover el cursor libremente sobre la UI.

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

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

## El jugador cambia de realm o isla

Los jugadores en Decentraland existen en *realms*, y en *islas* dentro de cada realm. Los jugadores de diferentes realms o islas no pueden verse, interactuar ni chatear entre sí, incluso si están parados sobre las mismas parcelas.

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

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

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

{% hint style="warning" %}
**📔 Nota**: La `onRealmChangedObservable` el evento está obsoleto desde SDK v7.x. Las versiones futuras 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 eventos.
{% endhint %}

Este evento incluye los siguientes campos:

* **serverName**: *string*; El nombre del servidor catalyst.
* **room**: *string*; El nombre de la isla.
* **displayName**: *string*; El nombre del servidor catalyst seguido de una *-* y el nombre de la isla. 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 isla para agruparse con los jugadores que ahora les quedan más cerca. Las islas también desplazan sus bordes dinámicamente para ajustarse a un grupo manejable de personas en cada una. Así, aunque un jugador permanezca quieto, podría cambiar de isla a medida que otros entran y salen de las escenas circundantes.

Si tu escena depende de un [servidor de terceros](/creator/content-creator-es/scenes-sdk7/networking/third-party-servers.md) para sincronizar cambios entre jugadores en tiempo real, entonces quizá quieras compartir datos solo entre jugadores agrupados en el mismo realm+isla, por lo que es una buena práctica cambiar de room en el servidor de terceros cada vez que los jugadores cambian de isla.

## Funciones de criptografía

{% hint style="warning" %}
**📔 Nota**: Las funciones `requirePayment()`, `signMessage()`, `convertMessageToObject()` están obsoletas. Usa la `sendAsync()` función en su lugar. Consulta [Operaciones blockchain de la escena](/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 funciones.
{% endhint %}

## Eventos de video

{% hint style="warning" %}
**📔 Nota**: La `onVideoEvent` el evento está obsoleto en SDK v7.x. Consulta [Listeners de eventos](/creator/content-creator-es/scenes-sdk7/media/video-playing.md#video-events) 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 Entity que cambió de estado.
* `componentId` (*string*): El ID de la Entity que cambió de estado.
* `currentOffset` (*number*): El valor actual de la `seek` propiedad del video. Este valor muestra los segundos transcurridos desde el inicio original del video. *-1* por defecto.
* `totalVideoLength` (*number* ): La duración total del video en segundos. *-1* si la duración es desconocida.
* `videoStatus`: El valor para el 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 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/deprecated-functions.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.