Otra Clasificación

Videojuegos tipo Shooters

Son uno de los géneros más populares del mercado porque, casi desde que el videojuego es videojuego, los jugadores se han dedicado a disparar a cosas (de hecho, el primer juego, Spacewar, era una batalla entre dos naves que se disparaban la una a la otra). En este sentido, es muy importante diferenciar entre dos grandes categorías de juegos de disparos que varían en algo tan sencillo como la cámara.

Shooters en primera persona

Como su nombre indica, son juegos en los que no vemos al personaje principal sino que la cámara nos pone en la piel de esa persona. A su favor tenemos un aumento del realismo a costa de perder información de contexto, ya que es más complicado saber qué sucede alrededor nuestro. Call of Duty es el mayor ejemplo de este género aunque sus ramificaciones llegan hasta confines muy recónditos. Destiny probablemente sea el FPS que mejor ha sabido estirar su vida, con una campaña que se extiende durante años.

Shooters en tercera persona

Juegos como Gears of War en su día popularizaron este género hasta cotas inusitadas. Hoy en día, el juego de acción en tercera persona suele tener algo más que mecánicas de disparos. Piensa en Uncharted, God of War o Spider-Man. Cada uno lanza alguna idea adicional al género: mecánicas de plataformeo, solución de puzles, combate táctico, mundos abiertos… Pero el nexo de unión entre todos ellos sigue siendo el mismo, disparar a todo lo que se menea con la cámara al hombro.

Juegos de rol

La explosión en popularidad de Dungeons & Dragons en los setenta no tardó en desplazarse hacia los videojuegos unos años más tarde. Pero no fue hasta que las máquinas fueron capaces de mover gráficos complejos cuando el juego de rol abandonó el reino de la imaginación y se asentó del todo en nuestros televisores.

Videojuegos Action-RPG

Quizá el ejemplo más conocido durante la última década sea The Elder Scrolls V: Skyrim. El juego de rol de acción reemplaza la figura del máster con una trama más o menos escrita de antemano y calcula las tiradas de dados en tiempo real de manera que se asemeja más a un juego de acción que a una aventura de rol. En este género podríamos hablar también de los souls-like, subgénero nacido a raíz de Dark Souls y cuya última acepción destacada es Elden Ring, y que son juegos en los que destacan aspectos como la narrativa embebida, el combate táctico y una dificultad más elevada de lo habitual. Tampoco podemos olvidar los MMO, quizá algo de capa caída en la actualidad, pero que durante años fueron un fenómeno de masas gracias a títulos como World of Warcraft.

JRPG

Al juego de rol por turnos se le acostumbra con la sigla J por delante ya que ha sido en Japón donde ha tenido más aceptación. Sagas ya legendarias como Final Fantasy han popularizado una forma de entender el rol que varía respecto a su hermano en que los combates se realizan por turnos, de manera que el jugador no depende tanto de su pericia con el mano y sí de tomar decisiones con tiempo y conociendo los pros y los contras de cada uno de los miembros del equipo.

Videojuegos tipo estrategia

El género más cercano al juego de tablero. El uso de cámaras cenitales o elevadas ya es una declaración de intenciones de lo que pretende replicar. En este sentido hay que diferenciar entre la apuesta más cercana al juego de mesa, la estrategia por turnos, o la versión más frenética, que transcurre en tiempo real, y en la que prima la pericia a la hora de tomar decisiones.

Estrategia en tiempo real

Juegos como Starcraft o Total War han jugado con el concepto de trasladar enormes batallas de figuritas al entorno virtual. No solo eso, sino que han obligado a los jugadores a ponerse en la piel de grandes estrategas del campo de batalla para tomar decisiones en cuestión de segundos que afectan al desarrollo de una batalla. Ojo, porque no toda estrategia en tiempo real tiene por qué ser bélica. En este campo también podríamos hablar de juegos de gestión, o tycoons (Two Point Hospital, Rollercoaster Tycoon), y también de city builders, como Cities:Skylines, con temáticas tan diversas como la gestión hospitalaria, de un parque de atracciones o de una ciudad.

Estrategia por turnos

La traslación más fidedigna del concepto del juego de mesa. Títulos como Civilization han llevado hasta el extremo el concepto de “solo un turno más”, aunque ello implique irse a la cama a las tantas de la madrugada y despertar al día siguiente con ojeras. Existen algunos títulos que juegan de manera deliberada con ambos subgéneros: Football Manager te pone en la piel de un manager durante el día a día (y cada día es un turno) pero te obliga a gestionar los partidos en tiempo real, como si de un entrenador real se tratara.

Videojuegos de tipo plataformas

Los títulos de plataformas son los que mejor han aguantado el paso del tiempo. De hecho, los plataformas en 2D son, probablemente, el único género que haya aguantado intacto la transición de las consolas en 2D (hasta los 16 bits) a las 3D (a partir de la primera PlayStation).

Plataformas en 2D

Super Mario Bros. es el mejor ejemplo, pero tenemos títulos a patadas en este subgénero. La idea es sencilla: abrirse paso de un punto A a un punto B saltando por el escenario y acabando con los enemigos. Los más habituales suelen ser de scroll lateral (la pantalla se mueve de izquierda a derecha) aunque también los hay de scroll vertical (de abajo a arriba)

Plataformas en 3D

Super Mario 64 fue el primer exponente de un género quizá no tan popular como su hermano mayor pero que ha dado grandes joyas con los años. La idea es la misma que en los juegos en 2D pero aprovechando la tercera dimensión: los escenarios ganan en profundidad y las posibilidades se multiplican. Nintendo ha sido quien mejor ha explotado el concepto, como lo demuestra el genial Super Mario 3D World, pero títulos como Crash Bandicoot también supieron exprimirlo años atrás.

Videojuegos tipo Metroidvania

La palabra viene de la fusión de Metroid y Castlevania y viene a referirse a juegos de plataformas en 2D en los que la acción transcurre en un mapa bastante grande que se va desbloqueando a medida que el personaje mejora y adquiere nuevas habilidades. Con ellas, puede acceder a nuevas zonas del mapa por lo que se premia la exploración. Juegos como Blasphemous o Hollow Knight lo han explotado recientemente.

Roguelike (y roguelite)

El nombre del género lo acuñó Rogue, un juego de exploración de mazmorras de principios de los ochenta que se basaba en premisas muy básicas: los mapas de cada partida se generaban de manera procedural, la muerte enviaba al jugador al principio de la partida obligándole a empezar de nuevo y este perdía todas las armas y tesoros que hubiera acumulado por el camino. En la actualidad, el término más exacto para referirse a estos juegos es roguelite, ya que títulos como Hades o Dead Cells sí que permiten trasladar el progreso del jugador de una partida a otra.

MOBAs

En realidad son una subcategoría dentro de la estrategia en tiempo real, pero la desmesurada popularidad de League of Legends lo ha colocado entre los géneros más populares. Sus siglas responden a Massive Online Battle Arena y, en el caso de League of Legends, responden a un juego en el que dos equipos formados por varios jugadores se enfrentan para controlar el territorio del enemigo. Para ello, se valen de equipos en los que entre unos 3 o 5 jugadores controlan a algunos personajes de manera individual (cada uno con sus habilidades únicas) mientras tienen el apoyo de otros luchadores controlados por el ordenador.

Simuladores

Uno de los mayores atractivos del videojuego es la capacidad de simular situaciones que a duras penas se pueden vivir en la vida real, que serían demasiado costosas o que requerirían de un entrenamiento y unas herramientas que no disponemos. Pero el videojuego se ha encargado de romper barreras: simuladores de vuelo (Microsoft Flight Simulator), de conducción (desde Project CARS hasta Gran Turismo), deportivos (FIFA), hasta simuladores de granja (Farming Simulator) se han abierto paso en los últimos años. ¿Dónde reside su éxito? En esa fina línea entre la simulación pura y dura y la diversión que, en el fondo, es a lo que aspira un videojuego. Como en todo, hay diferentes grados en esta categoría por lo que podemos toparnos con títulos muy cercanos a la vida real y otros que apuestan por una aproximación más laxa.

Videojuegos de puzles

Aunque títulos como Monument Valley los han popularizado en formatos móviles, los podemos encontrar en todo tipo de plataformas. Un buen ejemplo de ello es Captain Toad Treasure Tracker para Wii U y Switch. En el juego de puzles prima la resolución de problemas complejos utilizando la materia gris. Uno de los ejemplos más refrescantes de los últimos años es Baba is You, título que intenta retorcer el género y lo hace de manera más que satisfactoria.

Videojuegos de aventuras

Fueron el género estrella en PC entre mediados de los ochenta y principios de los noventa pero cayeron en el olvido. Las aventuras de texto y aventuras gráficas eran juegos donde primaba la narrativa y la resolución de puzles. Juegos como Monkey Island o Grim Fandango moldearon un género que comenzó a perder fuelle cuando la narrativa comenzó a integrarse en otros géneros (lo hablamos al final de este texto). En la actualidad es un nicho que tiene un público muy fiel y que todavía nos ofrece joyas, como Thimbleweed Park.

Sandbox

El concepto de sandbox puro y duro es difícil de disociar de ciertos juegos. Porque aunque títulos como Grand Theft Auto han popularizado el término, lo cierto es que no acaban de apegarse del todo a sus normas. El sandbox puro y duro es aquel juego que no tiene reglas, que ofrece un espacio abierto para que el jugador haga lo que quiera (dentro de unos ciertos límites) pero donde no existe una presión para cumplir unos objetivos. Es el jugador el que determina qué quiere hacer y cómo quiere hacerlo. Minecraft o el modo sandbox de Kerbal Space Program podrían ser dos buenos ejemplos. O un Grand Theft Auto si pasamos por completo de la narrativa y nos dedicamos a vivir nuestra vida en cualquiera de sus ciudades como más nos apetezca.

                                    <!DOCTYPE html>
                                    <html lang="es">
                                    <head>
                                        <meta charset="UTF-8">
                                        <meta http-equiv="X-UA-Compatible" content="IE=edge">
                                        <meta name="viewport" content="width=device-width, initial-scale=1.0">
                                        <title>Base 01</title>
                                        <link rel="stylesheet" href="css/styles.css">
                                    </head>
                                    <body>
                                        
                                    <div id="container">

                                    </div>
                                        <script src="js/phaser.min.js"></script>
                                        <script src="js/script.js"></script>
                                    </body>
                                    </html>
                                

                            *{
                                margin: 0;
                                padding: 0;
                            }
                            body{
                                background-color: #2c3e50;
                            }
                            
                            
                        

					const config={
						width:1920,//ancho
						height:761,//alto
						scale: { // para establecer responsive
							mode: Phaser.Scale.FIT,
							autoCenter: Phaser.Scale.CENTER_BOTH,
							parent:"container" // es el contenedor id creado en el html
						},
						backgroundColor:"#9b59b6",//color de fondo
						type:Phaser.AUTO,// permite al motor de juegos detectar automáticamente la mejor opción 
						                    entre renderizado en Canvas o WebGL
						scene:{ //escenas
							preload:preload, // se encarga de cargar estos recursos (imágenes, audio, spritesheets, etc.)
							create:create,// se utiliza para crear los elementos visuales del juego
							update:update,// se utiliza para actualizar el estado del juego

						},
						physics:{
							default:'arcade',//se utiliza para especificar el motor de física
							arcade:{
								gravity:{y:0},
								gravitx:{x:0},
								debug:false
							}
						}    
					}
					let game = new Phaser.Game(config) // se instancia el objeto game
									
					

					function preload(){


					}
					function create(){
						
					}
					function update(){
						

					}
					
					
							
                        

                    function preload(){
                        this.load.image('logo', 'assets/logo.png');  
                    }
                    function create(){
                        this.add.image(400, 300, 'logo');
                    }  
                        

let asteroide;
let asteroides;
function preload(){ 
    this.load.image('fondo','assets/img/f10h.png');
    this.load.image('asteroide1','assets/img/a1.png');
    this.load.image('asteroide2','assets/img/a2.png');
    this.load.image('asteroide3','assets/img/a3.png');
    this.load.image('asteroide4','assets/img/a4.png');
    this.load.image('asteroide5','assets/img/a5.png');
    this.load.image('asteroide6','assets/img/a6.png');
    this.load.image('asteroide7','assets/img/a7.png');
    this.load.image('asteroide8','assets/img/a8.png');  
}
function create(){

	this.add.image(0, 0,'fondo').setOrigin(0);
	// crea el arreglo
	asteroides=['asteroide1','asteroide2','asteroide3','asteroide4','asteroide5','asteroide6','asteroide7','asteroide8'];
	this.time.addEvent({
		delay:900,// cada 900milesegungos
		loop:true,// que el loop sea infinito (false)
		callback:()=>{
			let aste	=asteroides[Phaser.Math.Between(0,7)]// selecciona un asteroide del arreglo
			let posX 	=Phaser.Math.Between(30,1900); // crea la posicion en x que va de 
			let Tam 	=Phaser.Math.FloatBetween(0.2, 0.6)//para cambiar los tamaños
			let graX	=Phaser.Math.FloatBetween(-5, 5)//afecta la gravedad en x
			let graY	=Phaser.Math.FloatBetween(10, 50)//afecta la gravedad en y
			asteroide   =this.physics.add.image(posX,100,aste).setScale(Tam) // crea el asteroide
			asteroide.setCollideWorldBounds(true); //permite que colisione
			asteroide.body.setGravity(graX, graY); //le asigna la gravedad diferente a cada asteroide
			asteroide.setBounce(Tam);//establece los valores de rebote en un objeto 
		}
	})
	
	
}					

this.physics.add.collider(player, asteroide, eliminaAsteroide, null, this)
		
function eliminaAsteroide(player, asteroide){
	if(asteroide.active){
		player.puntos++;
		textoPuntos.setText("Puntos: "+player.puntos)
		captura.play();
		asteroide.setActive(false);
		asteroide.setVisible(false);
		if(player.puntos>=numAsteParaGanar){
			sonidoGanaste.play();
			this.add.image(game.config.width/2,game.config.height/2,'ganaste').setDepth(1).setVisible(true);
			this.add.text(game.config.width/2-100,game.config.height/2+150, "F5 para Reiniciar",
			{ font: '30px Arial Bold', fill: '#FBFBAC' });
			game.scene.pause("default") 
		} 
	} 
}
				

				let lastFired=0;
				
				function preload(){ 
					this.load.image('bullet', 'assets/img/bala.png');
				}
				
				function create(){
					
					bullets=this.bullets = this.add.group({
        					classType: Bullet,
        					maxSize: 10,// determina cuantas balas pueden salir
        					runChildUpdate: true
    					});
					
				}
				function update(){
					// si es con las flechas  si es con WASD debe ir en la W
					// donde van los movimientos
					if(cursors.up.isDown && time > lastFired){
						const Bullet = this.bullets.get();
						if (Bullet){
							Bullet.fire(player.x, player.y);
							lastFired = time + 250;
						}
						this.physics.add.existing(Bullet);

					}
				}
				
				// esta funcion va al final debajo del preload
				class Bullet extends Phaser.GameObjects.Image{
					constructor (scene){
						super(scene, 0, 0, 'bullet');// imagen que se usara para la bala
						this.speed = Phaser.Math.GetSpeed(800, 1);// establece la velocidad en este caso 1500 pix en un segundo
					}
					fire (x, y){
						this.setScale(0.1)// tamaño de la bala
						this.setPosition(x, y);// posicion de la bala, donde esta el player
						this.setActive(true);
						this.setVisible(true);
						this.setDepth(0);// se coloca detras
					}
					update (time, delta){
						this.y -= this.speed * delta;
						if (this.y < -50){ 
							this.setActive(false);
							this.setVisible(false);
						}
					}
				}
				
				

					
						let disparo;
						
						function preload(){
    						
							this.load.audio('disparo','assets/sonidos/disparos.mp3');
						}
						
						function create(){
    						
							disparo = this.sound.add('disparo');
							
						}
						function update(time, delta){   
							
							if(cursors.up.isDown && time > lastFired){
								const Bullet = this.bullets.get();
								if (Bullet){
									disparo.play()
									Bullet.fire(player.x, player.y);
									lastFired = time + 250;
								}
							this.physics.add.existing(Bullet);
							}
							
						}
					
					

						let nodriza;
						function preload(){ 					
							this.load.spritesheet('nodrizaAni','assets/sptite/nodriza01Sprite.png',{frameWidth:700.6, frameHeight:143})
						}

						function create(){
							nodriza   = this.add.sprite(game.config.width/2-200,20,'nodrizaAni').setDepth(1).setScale(0.57).setOrigin(0);


							// animaciones
							this.anims.create({
									key:'nodrizaVolando',
									frames:this.anims.generateFrameNumbers('nodrizaAni',{frames:[0,1,2]}),
									frameRate:3,
									repeat:-1
							})


							// cuando la animacion es constante no depende de las acciones del jugador
							nodriza.play('nodrizaVolando');
						}
					

						let explosion;
						
						function preload(){ 					
							this.load.spritesheet('explosion','assets/sptite/explosion01.png',{frameWidth:120, frameHeight:85})
						}
						
						function create(){
							explosion = this.add.sprite(game.config.width/2,game.config.height/2,'explosion').setDepth(1).setVisible(false);
							
							
							
							 this.anims.create({
								key:'explosion',
								frames:this.anims.generateFrameNumbers('explosion',{frames:[0,1,2,3,4]}),
								frameRate:12,
								repeat:false
							})
						}
						
						
						function eliminaAsteroide(bullets, asteroide){
	
							explosion = this.add.sprite(asteroide.x,asteroide.y,'explosion').setDepth(1);
							explosion.play('explosion');
							
						}
					

						let player;
						
						function preload(){ 					
							this.load.spritesheet('player','assets/sptite/pla02Sprite.png',{frameWidth:150, frameHeight:120})
						}
						
						function create(){
							player = this.physics.add.sprite(game.config.width/2,game.config.height-70,'player').setDepth(1).setScale(0.21); 
						
							 this.anims.create({
								key:'volando',
								frames:this.anims.generateFrameNumbers('player',{frames:[0,1,2,3]}),
								frameRate:10,
								repeat:-1
							})
						}
						
						function update(time, delta){  
							if  (cursors.left.isDown) {
								player.setVelocityX(-velocidad); 
							    player.play('volando');       
							} else if (cursors.right.isDown) {
								player.setVelocityX(velocidad);  
							    player.play('volando');     
							} else {
								player.setVelocityX(0);
							}
						}
						
					

						let player;
						let cursors;
						let velCorre=300;
						let velSalto=600;
						let sonSalto;// para agregar un sonido al saltar
						function preload(){
						 	this.physics.world.setBoundsCollision(true,true,true,true);// se agrega al principio del preload
							
							// sonidos
							this.load.audio('sonSalto','assetes/sonidos/salto.mp3');
							
							// quieto, todas las imagenes cuando el player esta quieto o detenido
							this.load.image('Idle1','assetes/player3/Idle__000.png');
							this.load.image('Idle2','assetes/player3/Idle__001.png');
							this.load.image('Idle3','assetes/player3/Idle__002.png');
							this.load.image('Idle4','assetes/player3/Idle__003.png');
							this.load.image('Idle5','assetes/player3/Idle__004.png');
							this.load.image('Idle6','assetes/player3/Idle__005.png');
							this.load.image('Idle7','assetes/player3/Idle__006.png');
							this.load.image('Idle8','assetes/player3/Idle__007.png');
							this.load.image('Idle9','assetes/player3/Idle__008.png');
							this.load.image('Idle10','assetes/player3/Idle__009.png');
							
							// camina o corre y asi se agregan todas las imagenes
							this.load.image('Run00','assetes/player3/Run__000.png');
							this.load.image('Run01','assetes/player3/Run__001.png');
							this.load.image('Run02','assetes/player3/Run__002.png');
							this.load.image('Run03','assetes/player3/Run__003.png');
							this.load.image('Run04','assetes/player3/Run__004.png');
							this.load.image('Run05','assetes/player3/Run__005.png');
							this.load.image('Run06','assetes/player3/Run__006.png');
							this.load.image('Run07','assetes/player3/Run__007.png');
							this.load.image('Run08','assetes/player3/Run__008.png');
							this.load.image('Run09','assetes/player3/Run__009.png');
							
							// saltar
							this.load.image('Jump0','assetes/player3/Jump__000.png');
							this.load.image('Jump1','assetes/player3/Jump__001.png');
							this.load.image('Jump2','assetes/player3/Jump__002.png');
							this.load.image('Jump3','assetes/player3/Jump__003.png');
							this.load.image('Jump4','assetes/player3/Jump__004.png');
							this.load.image('Jump5','assetes/player3/Jump__005.png');
							this.load.image('Jump6','assetes/player3/Jump__006.png');
							this.load.image('Jump7','assetes/player3/Jump__007.png');
							this.load.image('Jump8','assetes/player3/Jump__008.png');
							this.load.image('Jump9','assetes/player3/Jump__009.png');

							
						}
						
						function create(){	
							//sonidos
    						sonSalto = this.sound.add('sonSalto');
							
							//player
							player=this.physics.add.sprite(100,game.config.height-300,'Idle1'); 
							// Importante destacar "this.physics.add.sprite"
    						player.setCollideWorldBounds(true); // para las colisiones
    						cursors = this.input.keyboard.createCursorKeys(); // para manejar el movimiento
							
							
							// animaciones
							this.anims.create({//quieto
								key: 'quieto',
								frames: [
								  { key: 'Idle1' },
								  { key: 'Idle2' },
								  { key: 'Idle3' },
								  { key: 'Idle4' },
								  { key: 'Idle5' },
								  { key: 'Idle6' },
								  { key: 'Idle7' },
								  { key: 'Idle8' },
								  { key: 'Idle9' },
								  { key: 'Idle10' },
								  // añaade cada imagen a utilizar en la animación como un objeto dentro de un array
								],
								frameRate: 12,
								repeat: -1,
							});
							
							this.anims.create({//caminar o correr
								key: 'caminar',
								frames: [
								  { key: 'Run00' },
								  { key: 'Run01' },
								  { key: 'Run02' },
								  { key: 'Run03' },
								  { key: 'Run04' },
								  { key: 'Run05' },
								  { key: 'Run06' },
								  { key: 'Run07' },
								  { key: 'Run08' },
								  { key: 'Run09' },
								  // añaade cada imagen a utilizar en la animación como un objeto dentro de un array
								],
								frameRate: 12,
								repeat: -1,
							});
							this.anims.create({// saltar
								key: 'saltar',
								frames: [
								  { key: 'Jump0' },
								  { key: 'Jump1' },
								  { key: 'Jump2' },
								  { key: 'Jump3' },
								  { key: 'Jump4' },
								  { key: 'Jump5' },
								  { key: 'Jump6' },
								  { key: 'Jump7' },
								  { key: 'Jump8' },
								  { key: 'Jump9' },
								  // añaade cada imagen a utilizar en la animación como un objeto dentro de un array
								],
								frameRate: 12,
								repeat: -1,
							});
						
						}
						function update(){
							// Controla el movimiento del player
							if (cursors.left.isDown) {
								player.setVelocityX(-velCorre);
								player.setFlip(true)// sirve para voltear la imagen del player
								player.play('caminar',true) // aqui se llama a la animacion 'caminar'   
							} else if (cursors.right.isDown) {
								player.setVelocityX(velCorre);
								player.setFlip(false)
								player.play('caminar',true)// animar
							}else {
								player.setVelocityX(0);
								player.play('quieto',true)
							}

							if (cursors.up.isDown) {//animacion para saltar
								player.play('saltar',true)//animacion para saltar
								if(player.body.touching.down){// para que salte solo si esta tocando el suelo
									player.setVelocityY(-velSalto); // Velocidad hacia arriba para el salto
									sonSalto.play(); //sonido de saltar 
								}   
							}
						}
					

					function preload(){
						this.load.image("fondo","assetes/brownNature/BackgroundGradient.png")
						this.load.image("tiles","assetes/brownNature/Tiles 64x64/Tiles_64x64.png")

					}
					function create(){	
					   this.add.image(0,0,'fondo').setOrigin(0); 
					   const mundo =[

						[42,43,39,-1,-1,-1,-1,-1,42,43,39,-1,-1,-1,-1,-1,42,43,39,-1],
						[-1,-1,-1,-1,41,40,38,-1,-1,-1,-1,-1,-1,-1,-1,-1],
						[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,41,40,39,-1],
						[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
						[24,25,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,45, 0,-1,-1],
						[4 ,4 ,24,25,-1,-1,-1,-1,-1,-1,-1,-1,44,-1,-1,-1],
						[4 ,4 ,4 ,4 ,24,25,-1,-1,-1,-1,-1,-1,44,-1,-1,-1],
						[22 ,22 ,0 ,22 ,22,22,22, 0, 22,-1,-1,21, 0, 0, 0, 62],
						[-1,-1,23,-1,-1,-1,-1,23,-1,-1,-1,-1,-1,-1,-1,-1]

					   ]
					   const map = this.make.tilemap({data:mundo, tileWidth:64, tileHeight:64})
					   const tiles = map.addTilesetImage("tiles")
					   //const layer = map.createLayer(0,tiles,0,0);
					   const layer =  map.createLayer(0,tiles, 0, 0);
					}

					

				let player;
				let vcaminar=200;
				let vsaltar=650;
				let cursors;
				let mapa;
				let plataforma;
				let fondo;
				let camara;
				let piso;
				
				function preload(){
					this.physics.world.setBoundsCollision(true,true,true,true);// se agrega al principio del preload
				
					this.load.image('tiles','assets/tiles/pixel3/tiles_packed.png');
					this.load.tilemapTiledJSON('tilemap','assets/tiles/pixel3/games.json')
					
					....
					
					
					
				function create(){	
					map = this.make.tilemap({ key: 'tilemap' });// nombre interno que le daremos al mundo
					const tileset  = map.addTilesetImage('mundo', 'tiles')// nombre que le dimos al conjunto de patrones
					const tileset2 = map.addTilesetImage('cielo', 'fondo')// nombre que le dimos al conjunto de patrones
					map.createLayer('cielo', tileset2,0,0);// nombre que le dimos a la capa
					plataforma  = map.createLayer('plataformas', tileset,0,0);// nombre que le dimos a la capa
					plataforma.setCollisionByProperty({ colisiones:true });// nombre que le dimos al atributo 
					
					....
					// jugador
						player=this.physics.add.sprite(500,50,'idle00').setOrigin(0).setScale(0.3);
						player.setCollideWorldBounds(true);
						player.setSize(90, 250); // Ajusta la caja de colisión del sprite 
						cursors = this.input.keyboard.createCursorKeys(); // se le asigna el objeto
						
					// colisiones 
    					this.physics.add.collider(player, plataforma)
						
					// camara
						camara = this.cameras.main;// Obtén una referencia a la cámara principal
						camara.startFollow(player);
						camara.setZoom(1.5);