Servicio mundo

mundo.pieza(id: string): Pieza

const torre = mundo.pieza('torre');

mundo.existe(id: string): boolean

if (!mundo.existe(`pad-${o.id}`)) continue;

mundo.piezas(etiqueta?: string): Pieza[]

const losas = azar.mezclar(mundo.piezas('losa'));

mundo.crear(def: PiezaDef): Pieza

const moneda = mundo.crear({
  forma: 'cilindro',
  posicion: [azar.entre(-10, 10), 1, azar.entre(-10, 10)],
  rotacion: [90, 0, 0],
  tamano: [0.9, 0.16, 0.9],
  material: { color: 'ambar', acabado: 'brillante' },
  solida: false,
  etiquetas: ['moneda']
});

mundo.eliminar(pieza: Pieza | string): void

function quitarFugaz(cristal: Pieza): void {
  const haz = cristal.datos.haz as string;
  if (mundo.existe(haz)) mundo.eliminar(haz);
  cristal.eliminar();
}

mundo.zona(id: string): Zona

mundo.zona(`zona-${id}`).activa = false;

mundo.zonas(etiqueta?: string): Zona[]

mundo.aparicion(id: string): { id; posicion; rotacionY }

mundo.apariciones(): Aparicion[]

mundo.alTocar(selector: Selector, fn: (pieza: Pieza, jugador: Jugador) => void): void

mundo.alTocar('#trampolin', (_p, j) => j.impulsar([0, 20, 0]));

mundo.alDejarDeTocar(selector: Selector, fn: (pieza: Pieza, jugador: Jugador) => void): void

mundo.alDejarDeTocar('#placa', (placa) => (placa.material = 'gris'));

mundo.alEntrar(selector: Selector, fn: (zona: Zona, jugador: Jugador) => void): void

mundo.alEntrar('tesoro', (_zona, j) => juego.terminar({ resultado: 'victoria', puntaje: 1, de: j }));

mundo.alSalir(selector: Selector, fn: (zona: Zona, jugador: Jugador) => void): void

mundo.alSalir('zona-segura', (_zona, j) => interfaz.mensaje(interfaz.t('cuidado'), { para: j, tipo: 'peligro' }));

mundo.rayo(origen: Vec3, direccion: Vec3, distanciaMaxima: number): { pieza: Pieza | null; punto: Vec3; distancia: number } | null

for (const j of jugadores.todos()) {
  const p = j.posicion;
  const hacia: [number, number, number] = [p[0] - ojo[0], p[1] + 1 - ojo[1], p[2] - ojo[2]];
  const distancia = Math.hypot(hacia[0], hacia[1], hacia[2]);
  const impacto = mundo.rayo(ojo, hacia, distancia);
  j.datos.visto = impacto === null || impacto.distancia > distancia - 0.6;
}

mundo.mientrasToca(selector: Selector, fn: (pieza: Pieza, jugador: Jugador, dt: number) => void): void

// Lava: quita vida mientras se pisa. dt siempre vale 1/60.
mundo.mientrasToca('#lava', (_lava, j, dt) => { j.datos.vida = (j.datos.vida as number) - 10 * dt; });

mundo.alChocar(selector: Selector, fn: (pieza: Pieza, otra: Pieza) => void): void

// Una pelota (pieza dinamica con "rebote": 0.8) toca el arco.
mundo.alChocar('pelota', (_pelota, otra) => { if (otra.tiene('arco')) juego.registro('gol'); });

mundo.piezasEn(centro: Vec3, radioOTamano: number | Vec3, etiqueta?: string): Pieza[]

// Explosion: todo lo que haya a 4 unidades con la etiqueta "caja".
mundo.alTocar('bomba', (bomba) => {
  for (const caja of mundo.piezasEn(bomba.posicion, 4, 'caja')) caja.impulsar([0, 12, 0]);
  bomba.eliminar();
});

mundo.jugadoresEn(centro: Vec3, radio: number): Jugador[]

mundo.grupo(nombre: string): Grupo

// Las piezas con "grupo": "puerta" en la escena se mueven juntas.
const puerta = mundo.grupo('puerta');

mundo.crearZona(def: ZonaDef): Zona

// Una zona de premio que aparece en un lugar nuevo cada vez.
const zona = mundo.crearZona({ id: 'premio', forma: 'esfera', posicion: [5, 1, 5], tamano: [3, 3, 3], datos: { puntos: 5 } });

mundo.mapa(id: string): Mapa

// Abre un paso: borra tres baldosas del piso.
const nivel = mundo.mapa('nivel');

mundo.mapas(): Mapa[]

mundo.mapas();

mundo.luz(id: string): Luz

mundo.luces(): Luz[]

// Anochece en 20 segundos y se encienden los faroles (luces con "id" en la escena).
reloj.despues(30, () => {
  mundo.ambiente({ cielo: 'noche', luzAmbiente: 0.25, sol: { intensidad: 0.1 }, niebla: { desde: 10, hasta: 60 } }, 20);
  for (const luz of mundo.luces()) luz.encendida = true;
  sonido.ruido({ duracion: 3, filtro: 600, volumen: 0.4, ataque: 1 });
});

mundo.crearLuz(def: LuzDef): Luz

const faro = mundo.crearLuz({ id: 'faro', posicion: [0, 8, 0], color: 'ambar', intensidad: 3, alcance: 30 });

mundo.ambiente(cambios: { cielo?, luzAmbiente?, sol?, niebla? }, duracion?: number): void   // día y noche, tormenta

// Anochece en 20 segundos y se encienden los faroles (luces con "id" en la escena).
reloj.despues(30, () => {
  mundo.ambiente({ cielo: 'noche', luzAmbiente: 0.25, sol: { intensidad: 0.1 }, niebla: { desde: 10, hasta: 60 } }, 20);
  for (const luz of mundo.luces()) luz.encendida = true;
  sonido.ruido({ duracion: 3, filtro: 600, volumen: 0.4, ataque: 1 });
});

mundo.modelo(id: string): ModeloDelJuego

mundo.modelo('robot');  // { id, tamano, clips: [{ nombre, duracion }], triangulos }

mundo.modelos(): string[]

mundo.modelos();  // ids de los modelos del juego

mundo.crearModelo(modelo: string, def: ModeloEnMundo): Pieza

const robot = mundo.crearModelo('robot', { id: 'r1', posicion: [0, 0.9, 5], escala: 1 });  // pieza a tamaño natural

pieza.tiene(etiqueta: string): boolean

// Una pelota (pieza dinamica con "rebote": 0.8) toca el arco.
mundo.alChocar('pelota', (_pelota, otra) => { if (otra.tiene('arco')) juego.registro('gol'); });

pieza.etiquetar(etiqueta: string): void

for (const trampa of losas.slice(0, 3)) trampa.etiquetar('peligro');     // tres trampas distintas cada partida

pieza.desetiquetar(etiqueta: string): void

const semaforo = mundo.pieza('semaforo-corredor');
// ...
reloj.despues(0.3, () => semaforo.desetiquetar('recien-verde'));

pieza.moverA(destino: Vec3, opciones: { duracion: number; suavizado?: 'lineal' | 'suave'; vaiven?: boolean; espera?: number; alLlegar?: () => void }): void

// Ida y vuelta para siempre.
mundo.pieza('plataforma').moverA([0, 0, 20], { duracion: 3, vaiven: true, espera: 0.5 });

pieza.girar(gradosPorSegundo: Vec3): void

for (let i = 0; i < 12; i++) {
  const moneda = mundo.crear({
    forma: 'cilindro',
    posicion: [azar.entre(-10, 10), 1, azar.entre(-10, 10)],
    rotacion: [90, 0, 0],
    tamano: [0.9, 0.16, 0.9],
    material: { color: 'ambar', acabado: 'brillante' },
    solida: false,
    etiquetas: ['moneda']
  });
  moneda.girar([0, 160, 0]);
}

pieza.detener(): void

for (const p of publico) {
  p.pieza.detener();
  p.pieza.posicion = p.base;
}

pieza.impulsar(velocidad: Vec3): void

for (const caja of mundo.piezasEn(bomba.posicion, 4, 'caja')) caja.impulsar([0, 12, 0]);

pieza.alTocar(fn: (jugador: Jugador) => void): void

pieza.eliminar(): void

mundo.alTocar('#botas', (botas, j) => { botas.eliminar(); j.saltosExtra = 1; j.rapidez = 11; });

pieza.reproducir(clip: string, opciones?: OpcionesClip): void

const robot = mundo.crearModelo('robot', { id: 'r1', posicion: [0, 0.9, 5], escala: 1 });  // pieza a tamaño natural
// ...
robot.reproducir('saludar', { repetir: false, mezcla: 0.2, velocidad: 1 });  // desde el principio

pieza.pararAnimacion(mezcla?: number): void

const robot = mundo.crearModelo('robot', { id: 'r1', posicion: [0, 0.9, 5], escala: 1 });  // pieza a tamaño natural
// ...
robot.pararAnimacion(0.3);  // vuelve al reposo mezclando 0,3 s

pieza.alTerminarClip(fn: (clip: string) => void): void

const robot = mundo.crearModelo('robot', { id: 'r1', posicion: [0, 0.9, 5], escala: 1 });  // pieza a tamaño natural
// ...
robot.alTerminarClip((clip) => robot.reproducir('quieto'));  // solo clips que no se repiten

grupo.piezas(): Pieza[]

grupo.mover(delta: Vec3): void

grupo.moverA(destino: Vec3, opciones: OpcionesMover): void

// Las piezas con "grupo": "puerta" en la escena se mueven juntas.
const puerta = mundo.grupo('puerta');
// ...
mundo.alTocar('boton', () => puerta.moverA([0, 6, 10], { duracion: 1.5 }));

grupo.girarY(grados: number, pivote?: Vec3): void   // gira el conjunto alrededor de un eje vertical

grupo.detener(): void

grupo.etiquetar(etiqueta: string): void

grupo.desetiquetar(etiqueta: string): void

grupo.eliminar(): void

luz.eliminar(): void

zona.tiene(etiqueta: string): boolean

zona.jugadores(): Jugador[]

jugadores.alAccion('accion', (j) => {
  if (ascensorOcupado || !mundo.zona('zona-ascensor').jugadores().includes(j)) return;
  subirAscensor();
});

zona.actores(): Actor[]

zona.eliminar(): void

mundo.alEntrar('premio', (z, j) => { j.puntos += z.datos.puntos as number; z.eliminar(); });

mapa.leer(columna: number, fila: number, capa?: number | string): string | null

const nivel = mundo.mapa('nivel');  // falla con un mensaje claro si no existe
// ...
nivel.leer(3, 2);  // '=' o null. Tercer parámetro: capa (número o id); por defecto, la primera que no es fondo

mapa.poner(columna: number, fila: number, baldosa: string | null, capa?: number | string): void

mundo.alTocar('#vida', (vida, j) => {
  vida.eliminar();
  // Abre un paso: borra tres baldosas del piso.
  const nivel = mundo.mapa('nivel');
  for (let c = 9; c <= 11; c++) nivel.poner(c, 5, null);
  sonido.tocar('poder', { para: j });
});

mapa.celdaEn(punto: Vec3): { columna: number; fila: number }

const nivel = mundo.mapa('nivel');  // falla con un mensaje claro si no existe
// ...
nivel.celdaEn(jugador.posicion);  // { columna, fila }

mapa.centro(columna: number, fila: number): Vec3

const nivel = mundo.mapa('nivel');  // falla con un mensaje claro si no existe
// ...
nivel.centro(3, 2);  // Vec3 del centro de la celda

mapa.buscar(baldosa: string, capa?: number | string): { columna: number; fila: number }[]

const nivel = mundo.mapa('nivel');  // falla con un mensaje claro si no existe
// ...
nivel.buscar('^');  // todas las celdas con esa baldosa

mapa.colision(columna: number, fila: number): ColisionBaldosa

const nivel = mundo.mapa('nivel');  // falla con un mensaje claro si no existe
// ...
nivel.colision(3, 2);  // 'plataforma', 'ninguna', ...

terreno.bloques(): string[]

terreno.biomas(): string[]

terreno.info(bloque: string): InfoBloque

export const terreno = mundo.terreno;
// ...
const info = terreno.info(id);

terreno.bloque(x: number, y: number, z: number): string

terreno.poner(x: number, y: number, z: number, bloque: string, por?: Jugador): boolean

terreno.romper(x: number, y: number, z: number, por?: Jugador): string

terreno.llenar(desde: Vec3, hasta: Vec3, bloque: string): number

terreno.altura(x: number, z: number): number

terreno.suelo(x: number, z: number): number

terreno.bioma(x: number, z: number): string

terreno.clima(x: number, z: number): { temperatura: number; humedad: number }

terreno.buscarBioma(bioma: string, desde: Vec3, radio?: number): Vec3 | null

terreno.buscarBloque(bloque: string, desde: Vec3, radio?: number, alto?: number): Vec3 | null

terreno.rayo(origen: Vec3, direccion: Vec3, distancia: number): BloqueApuntado | null

terreno.ruido(x: number, z: number, escala?: number, canal?: number): number

terreno.alRomper(fn: (cambio: CambioDeBloque) => void): void

terreno.alPoner(fn: (cambio: CambioDeBloque) => void): void

terreno.alGenerar(fn: (trozo: { x: number; z: number }) => void): void

terreno.guardar(jugador: Jugador): { bloques: number; bytes: number }

terreno.restaurar(jugador: Jugador): number

terreno.borrarGuardado(jugador: Jugador): void

terreno.regenerar(semilla: number): void

juego.cadaCuadro(() => {
  for (const j of jugadores.todos()) {
    const a = j.apuntaBloque(5);
    interfaz.marcarBloque(a ? a.posicion : null, {}, j);
    if (a && j.pulsa('primaria')) terreno.romper(a.posicion[0], a.posicion[1], a.posicion[2], j);
  }
});
jugadores.alAccion('secundaria', (j) => {
  const a = j.apuntaBloque(5);
  if (a) terreno.poner(a.vecino[0], a.vecino[1], a.vecino[2], 'tabla', j);
});

import { juego, mundo } from '@greengames/sdk';

juego.alIniciar(() => {
  mundo.alTocar('#moneda', (moneda, j) => {      // todas las piezas con la etiqueta "moneda"
    moneda.eliminar();
    j.puntos++;
  });
  mundo.alTocar('boton-rojo', (boton) => {        // la pieza con id "boton-rojo"
    boton.material = { color: 'verde', acabado: 'neon' };
    mundo.pieza('puerta').solida = false;
    mundo.pieza('puerta').visible = false;
  });
  mundo.alDejarDeTocar('#placa', (placa) => (placa.material = 'gris'));
});

import { azar, juego, mundo } from '@greengames/sdk';

juego.alIniciar(() => {
  for (let i = 0; i < 12; i++) {
    const moneda = mundo.crear({
      forma: 'cilindro',
      posicion: [azar.entre(-10, 10), 1, azar.entre(-10, 10)],
      rotacion: [90, 0, 0],
      tamano: [0.9, 0.16, 0.9],
      material: { color: 'ambar', acabado: 'brillante' },
      solida: false,
      etiquetas: ['moneda']
    });
    moneda.girar([0, 160, 0]);
  }
});

import { juego, mundo, reloj } from '@greengames/sdk';

juego.alIniciar(() => {
  // Ida y vuelta para siempre.
  mundo.pieza('plataforma').moverA([0, 0, 20], { duracion: 3, vaiven: true, espera: 0.5 });
  // Una vez, con aviso al llegar.
  mundo.pieza('puente').moverA([0, 0, 8], { duracion: 1.5, alLlegar: () => juego.registro('puente listo') });
});

// A mano, cuadro a cuadro: una pieza en órbita. Se asigna un vector nuevo.
juego.cadaCuadro(() => {
  const a = reloj.ahora * 2;
  mundo.pieza('satelite').posicion = [Math.cos(a) * 5, 3, Math.sin(a) * 5];
});

import { interfaz, juego, mundo } from '@greengames/sdk';

juego.alIniciar(() => {
  mundo.alEntrar('#control', (zona, j) => {
    j.aparicion = zona.id;                         // hay una aparición con el mismo id que la zona
    interfaz.mensaje(interfaz.t('control'), { para: j, tipo: 'exito' });
  });
  mundo.alSalir('zona-segura', (_zona, j) => interfaz.mensaje(interfaz.t('cuidado'), { para: j, tipo: 'peligro' }));
  mundo.alEntrar('meta', (_zona, j) => juego.terminar({ resultado: 'victoria', puntaje: j.puntos, de: j }));
});

import { juego, jugadores, mundo } from '@greengames/sdk';

// ¿La torre ve al jugador? Un rayo desde la torre hasta su pecho: si choca antes con una pieza, está oculto.
juego.cadaCuadro(() => {
  const ojo: [number, number, number] = [0, 6, 0];
  for (const j of jugadores.todos()) {
    const p = j.posicion;
    const hacia: [number, number, number] = [p[0] - ojo[0], p[1] + 1 - ojo[1], p[2] - ojo[2]];
    const distancia = Math.hypot(hacia[0], hacia[1], hacia[2]);
    const impacto = mundo.rayo(ojo, hacia, distancia);
    j.datos.visto = impacto === null || impacto.distancia > distancia - 0.6;
  }
});

import { juego, mundo } from '@greengames/sdk';

juego.alIniciar(() => {
  // Las piezas con "grupo": "puerta" en la escena se mueven juntas.
  const puerta = mundo.grupo('puerta');
  mundo.alTocar('boton', () => puerta.moverA([0, 6, 10], { duracion: 1.5 }));

  // Explosion: todo lo que haya a 4 unidades con la etiqueta "caja".
  mundo.alTocar('bomba', (bomba) => {
    for (const caja of mundo.piezasEn(bomba.posicion, 4, 'caja')) caja.impulsar([0, 12, 0]);
    bomba.eliminar();
  });

  // Una pelota (pieza dinamica con "rebote": 0.8) toca el arco.
  mundo.alChocar('pelota', (_pelota, otra) => { if (otra.tiene('arco')) juego.registro('gol'); });

  // Lava: quita vida mientras se pisa. dt siempre vale 1/60.
  mundo.mientrasToca('#lava', (_lava, j, dt) => { j.datos.vida = (j.datos.vida as number) - 10 * dt; });
});

import { juego, mundo, reloj, sonido } from '@greengames/sdk';

juego.alIniciar(() => {
  // Anochece en 20 segundos y se encienden los faroles (luces con "id" en la escena).
  reloj.despues(30, () => {
    mundo.ambiente({ cielo: 'noche', luzAmbiente: 0.25, sol: { intensidad: 0.1 }, niebla: { desde: 10, hasta: 60 } }, 20);
    for (const luz of mundo.luces()) luz.encendida = true;
    sonido.ruido({ duracion: 3, filtro: 600, volumen: 0.4, ataque: 1 });
  });
  const faro = mundo.crearLuz({ id: 'faro', posicion: [0, 8, 0], color: 'ambar', intensidad: 3, alcance: 30 });
  reloj.cada(0.5, () => (faro.encendida = !faro.encendida));

  // Una zona de premio que aparece en un lugar nuevo cada vez.
  const zona = mundo.crearZona({ id: 'premio', forma: 'esfera', posicion: [5, 1, 5], tamano: [3, 3, 3], datos: { puntos: 5 } });
  mundo.alEntrar('premio', (z, j) => { j.puntos += z.datos.puntos as number; z.eliminar(); });
  juego.registro('zona creada', zona.id);
});