# Funciones obsoletas

Las siguientes funciones son heredadas y deben evitarse. Aún funcionan, 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**: El `onEnterSceneObservable` y `onLeaveSceneObservable` los eventos están obsoletos en SDK 7.x. Usa `onEnterScene` en su lugar, ver [El jugador entra o sale de la escena](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/event-listeners#player-enters-or-leaves-scene).
{% endhint %}

Siempre que un avatar entra o sale de los parcelas de tierra que componen tu escena, o teleporta dentro o fuera, se crea un evento al que puedes suscribirte. Este evento es activado por todos los avatares, incluido el del jugador.

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

onEnterSceneObservable.add((player) => {
	console.log('player entered scene: ', player.userId)
})

onLeaveSceneObservable.add((player) => {
	console.log('player left scene: ', player.userId)
})
```

{% hint style="warning" %}
**📔 Nota**: Este evento solo responde a jugadores que se estén renderizando localmente. En escenas grandes donde el tamaño excede el alcance visual, los jugadores que entren por la esquina opuesta pueden no estar registrados. Si el número de jugadores en la región excede las capacidades de una isla en los servidores de Decentraland, los jugadores que no comparten la misma isla no son visibles y tampoco son rastreados por estos eventos.
{% endhint %}

Los observables `onEnterScene` y `onLeaveScene` importado 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 abajo puedes ver ambas variaciones, primero la versión obsoleta, luego la correcta.

```ts
// DEPRECATED - imported from observables
import { onEnterScene, onLeaveScene } from '@dcl/sdk/observables'

onEnterScene.add((player) => {
	console.log('player entered scene: ', player.userId)
})

onLeaveScene.add((player) => {
	console.log('player left scene: ', player.userId)
})

// CURRENT - imported as a player function
import { onEnterScene, onLeaveScene } from '@dcl/sdk/src/players'

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

	onLeaveScene((userId) => {
		if (!userId) return
		console.log('LEFT SCENE', userId)
	})
}
```

## Jugador se conecta o desconecta

{% hint style="warning" %}
**📔 Nota**: El `getConnectedPlayers` función y el `onPlayerConnectedObservable` y `onPlayerDisconnectedObservable` los eventos están obsoletos en SDK 7.x. Usa `onEnterScene` en su lugar, ver [El jugador entra o sale de la escena](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/event-listeners#player-enters-or-leaves-scene). Cada escena ahora es una isla de comunicaciones distinta, por lo que es lo mismo estar conectado que estar en la misma escena.
{% 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('player was already here: ', player.userId)
	})
})
```

Siempre que otro jugador comienza o deja de ser renderizado por el motor local, se crea un evento al que puedes suscribirte. Los jugadores pueden o no estar en la misma escena que tú, pero deben estar dentro del alcance visual (no necesariamente a la vista). El `onPlayerConnectedObservable` detecta tanto cuando un jugador se conecta recientemente cerca o se acerca lo suficiente para estar en el alcance visual, del mismo modo que 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('player entered: ', player.userId)
})

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

Ten en cuenta que si otros jugadores ya se estaban 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 ya existentes. Si necesitas llevar un registro de todos los jugadores actuales, puedes consultar los jugadores existentes al cargar la escena y luego escuchar este evento para actualizaciones.

## Consultar todos los jugadores en la escena

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

También puedes obtener la lista completa de jugadores que actualmente están 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('player was already here: ', player.userId)
	})
})
```

## El jugador reproduce una animación

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

Siempre que el jugador reproduce un emote (baila, aplaude, saluda, etc.), puedes detectar este evento.

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

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

El evento incluye la siguiente información:

* expressionId: Nombre del emote realizado (p. ej.: *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 %}

## Jugador cambia el perfil

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

Siempre que el jugador realiza un cambio en su perfil, se llama al evento `onProfileChanged` . Estos cambios pueden incluir ponerse wearables diferentes, cambiar el nombre, la descripción, activar experiencias portátiles, etc.

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

onProfileChanged.add((profileData) => {
	console.log('Own profile data is ', 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()](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/user-data#get-player-data) función para obtener la versión más reciente de esta información, incluida la lista de wearables que el jugador tiene puestos. Puede que necesites añadir una pequeña demora antes de llamar a `getUserData()` para asegurar que la versión que esta función devuelve esté actualizada.

{% hint style="info" %}
**💡 Tip**: 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 Metamask.
{% endhint %}

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

## Escena terminó de cargar

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

Cuando la escena termina de cargar, se llama a `onSceneReadyObservable` . Esto funciona tanto si el jugador carga directamente en la escena, como si el jugador 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('SCENE LOADED')
})
```

## Métodos de datos de jugador obsoletos

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

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

El ejemplo 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)
})
```

Ambas `getUserData()` y `getPlayerData()` devuelven la misma estructura de datos disponible a través de la API de contenido. Ver [Datos de cualquier jugador](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/user-data#data-from-any-player)

`getPlayerData()` solo se puede obtener datos de jugadores que estén actualmente cerca. No tienen que estar necesariamente en la misma escena, pero sí en alcance visual, eso es porque esta información se obtiene desde el motor local que está renderizando esos 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 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 %}

El `getUserPublicKey()` y `getUserAccount()` las funciones también están obsoletas. Por favor usa `getPlayer()` en su lugar. Ver [Datos del usuario](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/user-data#get-user-data).

## Obtener tiempo del skybox

{% hint style="warning" %}
**📔 Nota**: El `getDecentralandTime()` la función está obsoleta desde SDK v7.x.x. Usa `getWorldTime()` en su lugar. Ver [Obtener Decentraland Time](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/runtime-data#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()` la función está obsoleta desde SDK v7.x.x. Usa `getRealm()` en su lugar. Ver [Obtener datos del Realm](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/runtime-data#get-realm-data).
{% endhint %}

```ts
import { getCurrentRealm } from '@decentraland/EnvironmentAPI'

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

	console.log(playerRealm.domain)
}

fetchPlayerData()
```

## Es modo preview

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

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

executeTask(async () => {
	const preview: boolean = await isPreviewMode({})

	if (preview) {
		console.log('Running in preview')
	}
})
```

## Jugador hace clic en otro jugador

Siempre que el jugador haga clic en otro jugador, puedes detectar un evento.

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

onPlayerClickedObservable.add((clickEvent) => {
	console.log('Clicked ', clickEvent.userId, ' details: ', clickEvent.ray)
})
```

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

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

{% hint style="warning" %}
**📔 Nota**: Tanto el jugador que realiza el clic como el jugador clicado deben estar dentro de los 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 clicado
* `ray`: Datos sobre el rayo 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`: *número* 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 escena.

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

## El jugador bloquea/desbloquea el cursor

{% hint style="warning" %}
**📔 Nota**: El `onPointerLockedStateChange` el evento está obsoleto desde SDK v7.x. Ver [Listeners de eventos](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/event-listeners#player-locks-or-unlocks-cursor) para una alternativa no obsoleta.
{% endhint %}

Los jugadores pueden cambiar 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 el *Botón derecho del ratón* o presionando la *Esc* tecla, y bloquean de nuevo el cursor haciendo clic en cualquier parte de la pantalla.

Este `onPointerLockedStateChange` evento se activa cada vez que un jugador cambia entre estos dos modos, mientras está cerca de la escena.

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

onPointerLockedStateChange.add(({ locked }) => {
	if (locked) {
		console.log('Pointer has been locked')
	} else {
		console.log('Pointer has been unlocked')
	}
})
```

{% hint style="warning" %}
**📔 Nota**: Este evento se dispara incluso si el jugador no está parado directamente dentro de la escena.
{% endhint %}

## Jugador cambia de realm o isla

Los jugadores en Decentraland existen en *realms*, y en *islands* separadas dentro de cada realm. Los jugadores en diferentes realms o islands no pueden verse, interactuar o chatear entre sí, incluso si están sobre los mismos parcelas.

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

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

onRealmChangedObservable.add((realmChange) => {
	console.log('PLAYER CHANGED ISLAND TO ', realmChange.room)
})
```

{% hint style="warning" %}
**📔 Nota**: El `onRealmChangedObservable` el evento está obsoleto desde SDK v7.x. Versiones futuras permitirán un enfoque más [orientado a datos](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/data-oriented-programming), 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 un *-* y el nombre de la isla. Por ejemplo `unicorn-x011`.
* **domain**: *string*; La URL del servidor catalyst en uso.

A medida que los jugadores se mueven por el mapa, pueden cambiar de isla para agruparse con aquellos jugadores que ahora están más cerca. Las islas también ajustan sus fronteras dinámicamente para acomodar un grupo manejable de personas en cada una. Así que incluso si un jugador permanece inmóvil, 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](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/redes/authoritative-servers) para sincronizar cambios entre jugadores en tiempo real, es posible que desees compartir datos solo entre jugadores que estén agrupados en el mismo realm+island, por lo que es buena práctica cambiar de sala en el servidor de terceros cada vez que los jugadores cambien de island.

## Funciones cripto

{% hint style="warning" %}
**📔 Nota**: Las funciones `requirePayment()`, `signMessage()`, `convertMessageToObject()` están obsoletas. Usa la función `sendAsync()` en su lugar. Ver [Operaciones blockchain de la escena](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/deprecated-functions). También existen librerías que pueden ayudar a simplificar algunos casos de uso comunes con estas funciones.
{% endhint %}

## Eventos de video

{% hint style="warning" %}
**📔 Nota**: El `onVideoEvent` el evento está obsoleto desde SDK v7.x. Ver [Listeners de eventos](https://docs.decentraland.org/creator/content-creator-es/media/video-playing#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) => {
	log('New Video Event ', 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` (*número*): El valor actual de la propiedad `seek` en el video. Este valor muestra los segundos desde el inicio original del video. *-1* por defecto.
* `totalVideoLength` (*número* ): La duración en segundos de todo el video. *-1* si la duración es desconocida.
* `videoStatus`: El valor del nuevo estado del video del `VideoTexture`, expresado como un valor del enum `VideoStatus` . 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