Functions obsoletas

Functions heredadas

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

📔 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.

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.

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)
})

📔 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.

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.

// 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

📔 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. Cada scene es ahora una isla de comms distinta, por lo que estar conectado o estar en la misma scene es lo mismo.

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

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.

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

📔 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.

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

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

📔 Nota: La onPlayerExpressionObservable evento está obsoleto en SDK 7.x. Usa el AvatarEmoteCommand component en su lugar, ver El jugador reproduce una animación.

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

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)

📔 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.

El jugador cambia el profile

📔 Nota: La onProfileChanged evento está obsoleto en SDK 7.x. Usa el AvatarEquippedData component en su lugar, ver El jugador cambia el profile.

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.

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() 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.

💡 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.

📔 Nota: Este evento solo se activa por cambios en el jugador actual, no por cambios en los profiles de otros jugadores cercanos.

La scene terminó de cargarse

📔 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

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.

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

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

Métodos de datos del jugador obsoletos

📔 Nota: La getUserData() y getPlayerData() funciones están obsoletas desde SDK v7.4.x. Usa getPlayer() en su lugar. Ver Datos del usuario.

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().

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.

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

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.

📔 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.

Las getUserPublicKey() y getUserAccount() funciones también están obsoletas. Usa getPlayer() en su lugar. Ver Datos del usuario.

Obtener hora del skybox

📔 Nota: La getDecentralandTime() función está obsoleta desde SDK v7.x.x. Usa getWorldTime() en su lugar. Ver Obtener hora de Decentraland.

import { getDecentralandTime } from '~system/EnvironmentApi'

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

Obtener realm

📔 Nota: La getCurrentRealm() función está obsoleta desde SDK v7.x.x. Usa getRealm() en su lugar. Ver Obtener datos del Realm.

import { getCurrentRealm } from '~system/EnvironmentApi'

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

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

fetchPlayerData()

Está en modo preview

📔 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.

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.

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

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

📔 Nota: La onPlayerClickedObservable evento está obsoleto desde SDK v7.x. Las versiones futuras permitirán un enfoque más orientado a datos, basado en consultar datos regularmente en lugar de eventos.

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

📔 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.

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.

💡 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.

El jugador bloquea/desbloquea el cursor

📔 Nota: La onPointerLockedStateChange evento se eliminó en SDK v7.x; ya no está disponible. Ver escuchadores de eventos para la alternativa actual.

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.

El jugador cambia de realm o island

Los jugadores en decentraland existen en realmsseparados, 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.

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

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

📔 Nota: La onRealmChangedObservable evento está obsoleto desde SDK v7.x. Las versiones futuras permitirán un enfoque más orientado a datos, basado en consultar datos regularmente en lugar de eventos.

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

📔 Nota: Las funciones requirePayment(), signMessage(), convertMessageToObject() están obsoletas. Usa la sendAsync() función en su lugar. Ver operaciones blockchain de la scene. También hay libraries que pueden ayudar a simplificar algunos casos de uso comunes con estas funciones.

Eventos de video

📔 Nota: La onVideoEvent evento está obsoleto en SDK v7.x. Ver escuchadores de eventos para una alternativa no obsoleta.

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

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