En mi último tutorial, se construyó un juego de plataformas usando Phaser y baldosa. En las dos siguientes tutoriales vamos a añadir contenido a este juego, por lo que es más completa. En este tutorial, se añadirá el siguiente contenido:


  • niveles más grandes, y dos de ellos, por lo que podemos utilizar la función de multinivel se implementó en el último tutorial.
  • enemigos más inteligentes, que no caen desde las plataformas.
  • Un nuevo enemigo, que sigue el jugador cuando se acerque a la puntuación it.Player, que se incrementará cuando los enemigos de muertes del jugador o monedas de cobro revertido.
  • Un puesto de control, por lo que si el jugador muere después de alcanzarla, será reaparición en la posición de punto de control.

    En este tutorial, es necesario que haya terminado el último tutorial, ya que vamos a seguir a partir del código que ya escribimos.

    Tabla de contenidos

    Aprender Phaser mediante la construcción de 15 juegos

    Si usted quiere dominar Phaser y aprender cómo publicar juegos Phaser como juegos nativas para iOS y Android se sienten libres para comprobar Zenva En línea En este supuesto The Complete el juego para móvil Curso de Desarrollo – Construir 15 juegos.

    archivos de código fuente

    Puede descargar los archivos de código fuente tutorial aquí.

    Juego Unidos

    En este tutorial, vamos a utilizar los mismos estados de la última:


    • Estado de arranque:. Carga un archivo JSON con la información de nivel y comienza la carga del Estado
    • Cargando Estado:. Cargas de todos los recursos del juego, e inicia el Estado Nivel
    • baldosa Estado:. Crea el mapa y todos los objetos del juego

      El código de arranque y carga de los estados son exactamente los mismos que antes, así que voy a omitirlos. Por otra parte, el código de baldosa Estado tuvo algunos cambios. Algunos de esos cambios son necesarios debido al nuevo contenido añadido al juego y se explicará a lo largo del tutorial. Sin embargo, hay un cambio que se hizo para hacer el código más simple, y voy a explicar ahora.

      En el tutorial anterior, tuvimos un método “create_object” que utiliza una caja de conmutación para crear instancias de la prefabricada correcta. Para evitar tener que añadir otra condición para cada caso prefabricado creamos, nosotros lo cambiará para usar un objeto que se asigna cada tipo prefabricada a su constructor, como se muestra a continuación:
      var Platformer = Platformer || {}; Platformer.TiledState = function () { «utilizar estricta»; Phaser.State.call (this); this.prefab_classes = { «jugador»: Platformer.Player.prototype.constructor, «ground_enemy»: Platformer.GroundEnemy.prototype.constructor, «flying_enemy»: Platformer.FlyingEnemy.prototype.constructor, «running_enemy»: Platformer.RunningEnemy.prototype .constructor, «objetivo»: Platformer.Goal.prototype.constructor, «puesto de control»: Platformer.Checkpoint.prototype.constructor, «moneda»: Platformer.Coin.prototype.constructor, «puntuación»: Platformer.Score.prototype.constructor };}; Platformer.TiledState.prototype = Object.create (Phaser.State.prototype); Platformer.TiledState.prototype.constructor = Platformer.TiledState; Platformer.TiledState.prototype.init = function (level_data) { «uso estricto» ; tileset_index var; this.level_data = level_data; this.scale.scaleMode = Phaser.ScaleManager.SHOW_ALL; this.scale.pageAlignHorizontally = true; this.scale.pageAlignVertically = true; sistema de física this.game.physics.startSystem (Phaser.Physics.ARCADE) // empezar; this.game.physics.arcade.gravity.y = 1,000; // crear el mapa y establecer conjunto de baldosas this.map = this.game.add.tilemap (level_data.map.key); tileset_index = 0; this.map.tilesets.forEach (función (conjunto de baldosas) {this.map.addTilesetImage (tileset.name, level_data.map.tilesets [tileset_index]); tileset_index + = 1;}, this);}; Platformer.TiledState.prototype .Create = function () { «utilizar estricta»; GROUP_NAME var, object_layer, collision_tiles; // crear capas de mapa this.layers = {}; this.map.layers.forEach (función (capa) {this.layers [layer.name] = this.map.createLayer (layer.name), si (layer.properties.collision) {// collision_tiles capa colisión = [] ; layer.data.forEach (function (data_row) {// encontrar azulejos usados ​​en la capa de data_row.forEach (function (teja) {// Comprobar si se trata de un índice de baldosas válido y no está ya en la lista si (teja. índice> 0 && collision_tiles.indexOf (tile.index) === -1) {collision_tiles.push (tile.index);}}, esto);}, this); this.map.setCollision (collision_tiles, es cierto, capa .name);}}, this); // cambiar el tamaño del mundo para ser el tamaño de las this.layers capa actuales [this.map.layer.name] .resizeWorld (); // crear grupos this.groups = {}; this.level_data.groups.forEach (function (GROUP_NAME) {this.groups [GROUP_NAME] = this.game.add.group ();}, this); this.prefabs = {}; para (object_layer en this.map.objects) {if (this.map.objects.hasOwnProperty (object_layer)) {// crear capa de objetos this.map.objects [object_layer] .forEach (this.create_object, este); }} This.game.camera.follow (this.prefabs.player);}; Platformer.TiledState.prototype.create_object = función (objeto) { «utilizar estricta»; posición var, prefabricada; coordenadas inicia // baldosa en la posición de la esquina inferior izquierda = { «x»: object.x + (this.map.tileHeight / 2), «y»: object.y – (this.map.tileHeight / 2)}; // crear el objeto de acuerdo con su tipo si (this.prefab_classes.hasOwnProperty (object.type)) {prefabricadas = new this.prefab_classes [object.type] (Esto, de posición, object.properties); } this.prefabs [object.name] = prefabricada;}; Platformer.TiledState.prototype.restart_level = function () { «utilizar estricta»; // reiniciar el juego sólo si no se ha alcanzado el punto de control si (this.prefabs.checkpoint.checkpoint_reached) {this.prefabs.player.x = this.prefabs.checkpoint.x; this.prefabs.player.y = this.prefabs.checkpoint.y; } Else {this.game.state.restart (verdadero, falso, this.level_data); }}; 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107varPlatformer = Platformer || {}; Platformer.TiledState = function () { «uso estricto»; Phaser.State.call (this); this.prefab_classes = { «jugador»: Platformer.Player.prototype.constructor, «ground_enemy»: Platformer.GroundEnemy.prototype.constructor, «flying_enemy»: Platformer.FlyingEnemy.prototype.constructor, «running_enemy»: Platformer.RunningEnemy.prototype.constructor, «objetivo»: Platformer.Goal.prototype.constructor, «puesto de control «: Platformer.Checkpoint.prototype.constructor,» moneda «: Platformer.Coin.prototype.constructor,» puntuación «: Platformer.Score.prototype.constructor};}; Platformer.TiledState.prototype = Object.create (Phaser.State .prototype); Platformer.TiledState.prototype.constructor = Platformer.TiledState; Platformer.TiledState.prototype.init = function (level_data) { «utilizar estricta»; vartileset_index; this.level_d ATA = level_data; this.scale.scaleMode = Phaser.ScaleManager.SHOW_ALL; this.scale.pageAlignHorizontally = true; this.scale.pageAlignVertically = true; // iniciar systemthis.game.physics.startSystem la física (Phaser.Physics.ARCADE) ; this.game.physics.arcade.gravity.y = 1,000; // crear el mapa y conjunto tilesetthis.map = this.game.add.tilemap (level_data.map.key); tileset_index = 0; this.map.tilesets. forEach (función (conjunto de baldosas) {this.map.addTilesetImage (tileset.name, level_data.map.tilesets [tileset_index]); tileset_index + = 1;}, this);}; Platformer.TiledState.prototype.create = function () { «utilizar estricta»; vargroup_name, object_layer, collision_tiles; // crear layersthis.layers mapa = {}; this.map.layers.forEach (función (capa) {this.layers [layer.name] = this.map.createLayer ( layer.name), si (layer.properties.collision) {// layercollision_tiles colisión = []; layer.data.forEach (function (data_row) {// encontrar azulejos usados ​​en la layerdata_row.forEach (función (teja) {/ / comprobar si se trata de un índice de baldosas válido y no está ya en la listif (tile.index> 0 && collision_ tiles.indexOf (tile.index) === -1) {collision_tiles.push (tile.index);}}, esto);}, this); this.map.setCollision (collision_tiles, cierto, layer.name); }}, this); // cambiar el tamaño del mundo para ser el tamaño de las layerthis.layers actuales [this.map.layer.name] .resizeWorld (); // crear groupsthis.groups = {}; this.level_data.groups .forEach (function (GROUP_NAME) {this.groups [GROUP_NAME] = this.game.add.group ();}, this); this.prefabs = {}; para (inthis.map.objects object_layer) {if (esto .map.objects.hasOwnProperty (object_layer)) {// crear objectsthis.map.objects capa [object_layer] .forEach (this.create_object, este);}} this.game.camera.follow (this.prefabs.player); }; Platformer.TiledState.prototype.create_object = función (objeto) { «utilizar estricta»; varposition, prefabricada; // coordenadas azulejos comienza en el cornerposition inferior izquierda = { «x»: object.x + (this.map.tileHeight / 2), «y»: object.y- (this.map.tileHeight / 2)}; // crear el objeto de acuerdo con su typeif (this.prefab_classes.hasOwnProperty (object.type)) {prefabricada = newthis.prefab_classes [object .type] (este, p OSICIÓN, object.properties);} this.prefabs [object.name] = prefabricada;}; Platformer.TiledState.prototype.restart_level = function () { «uso estricto»; // reiniciar el juego sólo si el puesto de control no era reachedif (this.prefabs.checkpoint.checkpoint_reached) {this.prefabs.player.x = this.prefabs.checkpoint.x; this.prefabs.player.y = this.prefabs.checkpoint.y;} else {this.game.state .restart (verdadero, falso, this.level_data);}};

      Tenga en cuenta que, en el constructor TiledState creamos un objeto con todos los tipos prefabricados y sus constructores correspondientes. Por lo tanto, en el método “create_object” podemos llamar al constructor correcta utilizando la propiedad type del objeto de mapa. Esto sólo es posible porque todas las casas prefabricadas utilizan el mismo constructor. Por lo tanto, si ha creado sus casas prefabricadas con diferentes constructores se pueden cambiar para tener el mismo constructor, o seguir usando la estrategia caja de conmutación, como en el tutorial anterior. Recuerde que todo el código que muestro aquí se basa en mi preferencia, y se debe escribir de la manera que piensa que es mejor.

      Nuevos niveles

      Estos son los dos niveles que he creado para este tutorial. Siéntase libre para crear su propietaria, se trata de añadir diferentes azulejos y enemigos. En esos nuevos mapas, existen ya las nuevas casas prefabricadas voy a explicar más adelante en el tutorial, allí, es, sin embargo, algo que me gustaría para mostrar por primera vez.

      level1 nivel 2

      En el primer nivel, he añadido un puente entre dos plataformas, como se puede ver en la imagen. Este sprite de puente es más pequeño que el azulejo, y quería su caja de colisión a ser más pequeñas también. Por lo tanto, he tenido que añadir un nuevo juego de fichas utilizando la misma imagen, pero el juego de cuadros de diferentes tamaños de baldosas. El tamaño de la baldosa utilizado fue de 35 píxeles de ancho y 11 píxeles de altura con 1 margen de pixel y el espaciamiento (como se muestra a continuación). También es posible insertar el puente como un objeto, no una baldosa, pero he encontrado de esta manera más fácil.

      small_tiles

      Además, el aviso que divide la capa de fondo en dos: el cielo y el fondo. Esto se hizo para añadir un poco de fondo de la decoración, al igual que los signos al principio y al final del nivel.

      Más inteligente enemigo

      cambiará nuestro enemigo por lo que cambiar de dirección si llega al borde de la plataforma. La idea es comprobar si la siguiente posición de tierra está ocupada por una ficha y, si no es así, cambiar la dirección enemigo. Para encontrar esta posición siguiente planta tenemos que calcular sus coordenadas x e y. La coordenada y es sólo el enemigo y parte inferior más 1, ya que es la coordenada inmediatamente debajo del enemigo. La coordenada x depende de la dirección del enemigo. Por lo tanto, será el enemigo coordenada x más el ancho de baldosas, si el enemigo se mueve a la derecha, o menos ancho de baldosas si el enemigo se mueve hacia la izquierda.

      Para comprobar si una posición es ocupada por una ficha, vamos a utilizar el método tilemap “getTileWordlXY”, que devuelve el objeto de baldosas de una capa en una posición dada (para más información, consulte la documentación Phaser: http: // Phaser .IO / docs / 2.4.3 / Phaser.Tilemap.html). Si el método devuelve un azulejo, sabemos que el enemigo no está en el borde de la plataforma, sin embargo, por lo que puede mantenerse en movimiento. Si se devuelve un valor nulo, el enemigo debe cambiar la dirección para evitar caer. En este código, el método “switch_direction” es el código que ya teníamos en el prefabricada Enemigo, que se acaba de mudar a una función (se puede comprobar en el código fuente).
      var Platformer = Platformer || {}; Platformer.GroundEnemy = function (game_state, posición, propiedades) { «utilizar estricta»; Platformer.Enemy.call (Esto, game_state, posición, propiedades);}; Platformer.GroundEnemy.prototype = Object.create (Platformer.Enemy.prototype); Platformer.GroundEnemy.prototype.constructor = Platformer.GroundEnemy; Platformer.GroundEnemy. prototype.update = function () { «utilizar estricta»; Platformer.Enemy.prototype.update.call (this); si (this.body.blocked.down && this.has_tile_to_walk ()) {this.switch_direction (); }}; Platformer.GroundEnemy.prototype.has_tile_to_walk = function () { «utilizar estricta»; dirección var, position_to_check, mapa, next_tile; dirección = (this.body.velocity.x <0)? -1: 1; // verificación si la siguiente posición tiene una position_to_check tile = nuevo Phaser.Point (this.x + (dirección * this.game_state.map.tileWidth), this.bottom + 1); MAP = this.game_state.map; // getTileWorldXY devuelve el azulejo en una posición dada next_tile = map.getTileWorldXY (position_to_check.x, position_to_check.y, map.tileWidth, map.tileHeight, "colisión"); volver next_tile == null;!}; 123456789101112131415161718192021222324252627282930varPlatformer = Platformer || {}; Platformer.GroundEnemy = function (game_state, la posición, propiedades) { "utilizar estricta"; Platformer.Enemy.call (esto, game_state, la posición, propiedades); }; Platformer.GroundEnemy.prototype = Object.create (Platformer.Enemy.prototype); Platformer.GroundEnemy.prototype.constructor = Platformer.GroundEnemy; Platformer.GroundEnemy.prototype.update = function () { "utilizar estricta"; Platformer. Enemy.prototype.update.call (este), si (this.body.blocked.down && this.has_tile_to_walk ()) {this.switch_direction ();}}; Platformer.GroundEnemy.prototype.has_tile_to_walk = function () {" utilizar estricta "; vardirection, position_to_check, mapa, next_tile; dirección = (this.body.velocity.x <0) - 1: 1; // verificación si la siguiente posición tiene una tileposition_to_check = newPhaser.Point (this.x + ( dirección * this.game_state.map.tileWidth), this.bottom + 1); MAP = this.game_state.map; // getTileWorldXY devuelve el azulejo en un dado positionnext_tile = map.getTileWorldXY (position_to_che ck.x, position_to_check.y, map.tileWidth, map.tileHeight, "colisión"); returnnext_tile == null;!};

      Nueva enemigo

      Además, se añadirá un enemigo con el siguiente comportamiento:


      • Si el jugador está fuera de un rango de detección, actuará como un enemigo regular.
      • Si el jugador está dentro de un rango de detección, además de aumentar su velocidad e ir en la dirección del jugador.

        Para hacer eso, vamos a crear una nueva prefabricada que se extiende la GroundEnemy prefabricada. Además de todas las propiedades regulares enemigas, que tendrá una distancia de detección y una velocidad de marcha. En el método de actualización, comprobamos si el jugador está dentro del rango de detección. Si es así, el enemigo cambie su velocidad a la velocidad de carrera y sigue el jugador. De lo contrario, simplemente llama al método update GroundEnemy.

        Para comprobar si el jugador está dentro del rango de detección, se calcula la distancia entre el jugador y enemigos x posiciones. Si el valor absoluto de esta distancia es menor que la distancia de detección y tanto el jugador como inferior enemigo Y posiciones son los mismos (lo que significa que está de pie en el mismo terreno), el enemigo detecte el reproductor.
        var Platformer = Platformer || {}; Platformer.RunningEnemy = function (game_state, posición, propiedades) { «utilizar estricta»; Platformer.GroundEnemy.call (esto, game_state, la posición, propiedades); this.detection_distance = + properties.detection_distance; this.running_speed = + properties.running_speed;}; Platformer.RunningEnemy.prototype = Object.create (Platformer.GroundEnemy.prototype); Platformer.RunningEnemy.prototype.constructor = Platformer.RunningEnemy; Platformer.RunningEnemy.prototype.update = function ( ) { «utilizar estricta»; dirección var; this.game_state.game.physics.arcade.collide (esto, this.game_state.layers.collision); si (this.detect_player ()) {// jugador es el rango de detección en el interior, correr hacia ella dirección = (this.game_state.prefabs.player.x puntuación del jugador < / h2>

        La puntuación del jugador se incrementará cada vez que mata a un enemigo o recoger una moneda. Para esto, hay que añadir una propiedad puntuación al Enemigo prefabricada y crear una casa prefabricada de la moneda, de la siguiente manera.
        var Platformer = Platformer || {}; Platformer.Coin = function (game_state, posición, propiedades) { «utilizar estricta»; Platformer.Prefab.call (esto, game_state, la posición, propiedades); this.score = + properties.score; this.game_state.game.physics.arcade.enable (this); = This.body.immovable verdaderos; this.body.allowGravity = false; this.anchor.setTo (0,5);}; Platformer.Coin.prototype = Object.create (Platformer.Prefab.prototype); Platformer.Coin.prototype.constructor = Platformer.Coin; Platformer.Coin.prototype.update = function ( ) { «utilizar estricta»; this.game_state.game.physics.arcade.collide (esto, this.game_state.layers.collision); this.game_state.game.physics.arcade.overlap (esto, this.game_state.groups.players, this.collect_coin, null, este);}; Platformer.Coin.prototype.collect_coin = función (moneda, jugador) { «uso estricto»; // moneda de matar y aumentar la cuenta this.kill (); player.score + = this.score;}; 123456789101112131415161718192021222324252627282930varPlatformer = Platformer || {}; Platformer.Coin = function (game_state, posición, propiedades) { «utilizar estricta»; Platformer.Prefab.call (Esto, game_state, posición, propiedades ); this.score = + properties.score; this.game_state.game.physics.arcade.enable (this); this.body.immovable = true; this.body.allowGravity = false; this.anchor.setTo (0,5) ;}; Platformer.Coin.prototype = Object.create (Platformer.Prefab.prototype); Platformer.Coin.prototype.constructor = Platformer.Coin; Platformer.Coin.prototype.update = function () { «utilizar estricta»; esta .game_state.game.physics.arcade.collide (esto, this.game_state.layers.collision); this.game_state.game.physics.arcade.overlap (esto, this.game_state.groups.players, this.collect_coin, null, este);}; Platformer.Coin.prototype.collect_coin = función (moneda, jugador) { «utilizar estricta»; // moneda kill y aumentar scorethis.kill (); player.score + = this.score;};

        por el asesinato enemigo, sólo tenemos que aumentar la puntuación del jugador en el “hit_enemy” método, mientras que para la recogida de monedas, comprobamos los solapamientos entre el jugador y las monedas, y aumentar la puntuación del jugador de acuerdo a la puntuación de la moneda. Para no perder de vista el jugador puntuación, vamos a añadir una propiedad puntuación en el jugador también.
        var Platformer = Platformer || {}; Platformer.Player = function (game_state, posición, propiedades) { «utilizar estricta»; Platformer.Prefab.call (esto, game_state, la posición, propiedades); this.walking_speed = + properties.walking_speed; this.jumping_speed = + properties.jumping_speed; this.bouncing = + properties.bouncing; this.score = 0; this.game_state.game.physics.arcade.enable (this); this.body.collideWorldBounds = true; this.animations.add ( «pie», [0, 1, 2, 1], 6, true); this.frame = 3; this.anchor.setTo (0,5); this.cursors = this.game_state.game.input.keyboard.createCursorKeys ();}; Platformer.Player.prototype = Object.create (Platformer.Prefab.prototype); Platformer.Player.prototype.constructor = Platformer.Player; Platformer .Player.prototype.update = function () { «utilizar estricta»; this.game_state.game.physics.arcade.collide (esto, this.game_state.layers.collision); this.game_state.game.physics.arcade.overlap (esto, this.game_state.groups.enemies, this.hit_enemy, null, este); si (this.cursors.right.isDown && this.body.velocity.x> = 0) {// movimiento correcto this.body.velocity.x = this.walking_speed; this.animations.play ( «pie»); this.scale.setTo (-1, 1); } Else if (this.cursors.left.isDown && this.body.velocity.x <= 0) {// mover hacia la izquierda this.body.velocity.x = -this.walking_speed; this.animations.play ( "pie"); this.scale.setTo (1, 1); } Else {// parada this.body.velocity.x = 0; this.animations.stop (); this.frame = 3; } // saltar sólo si tocando una baldosa si (this.cursors.up.isDown && this.body.blocked.down) {this.body.velocity.y = -this.jumping_speed; } // muere si toque el extremo de la pantalla si (this.bottom> = this.game_state.game.world.height) {this.game_state.restart_level (); }}; Platformer.Player.prototype.hit_enemy = function (jugador, enemigo) { «use strict»; // si el jugador está por encima del enemigo, el enemigo está muerto, de lo contrario el jugador muere si (enemy.body.touching.up) {this.score + = enemy.score; enemy.kill (); player.y – = this.bouncing; } Else {this.game_state.restart_level (); }}; 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970varPlatformer = Platformer || {}; Platformer.Player = función (game_state, posición, propiedades) { «utilizar estricta»; Platformer.Prefab.call (esto, game_state, la posición, propiedades); this.walking_speed = + inmuebles .walking_speed; this.jumping_speed = + properties.jumping_speed; this.bouncing = + properties.bouncing; this.score = 0; this.game_state.game.physics.arcade.enable (this); this.body.collideWorldBounds = true; this.animations.add ( «pie», [0,1,2,1], 6, true); this.frame = 3; this.anchor.setTo (0,5); this.cursors = this.game_state.game. input.keyboard.createCursorKeys ();}; Platformer.Player.prototype = Object.create (Platformer.Prefab.prototype); Platformer.Player.prototype.constructor = Platformer.Player; Platformer.Player.prototype.update = function () { «utilizar estricta»; this.game_state.game.physics.arcade.collide (esto, this.game_state.layers.collision); this.game_state.game.physics.arcade.overlap (esto, this.game_ state.groups.enemies, this.hit_enemy, null, esta), si (this.cursors.right.isDown && this.body.velocity.x> = 0) {// movimiento correcto this.body.velocity.x = esto. walking_speed; this.animations.play ( «pie»); this.scale.setTo (-1,1);} elseif (this.cursors.left.isDown && this.body.velocity.x <= 0) {// movimiento izquierda this.body.velocity.x = -this.walking_speed; this.animations.play ( "pie"); this.scale.setTo (1,1);} else {// stopthis.body.velocity.x = 0 ; this.animations.stop (); this.frame = 3;} // Saltar sólo si tocar un tileif (this.cursors.up.isDown && this.body.blocked.down) {this.body.velocity.y = - this.jumping_speed;} // muere si toque el extremo de la screenif (this.bottom> = this.game_state.game.world.height) {this.game_state.restart_level ();}}; Platformer.Player.prototype.hit_enemy = function (jugador, enemigo) { «utilizar estricta»; // si el jugador está por encima del enemigo, el enemigo está muerto, de lo contrario el jugador diesif (enemy.body.touching.up) {this.score + = enemy.score; enemy.kill (); player.y- = this.bouncing;} else {this.game_state.restart_level ();}};

        Para mostrar el resultado en la pantalla, creamos una casa prefabricada de puntuación, que se extiende Phaser.Text en lugar de Phaser.Sprite. Tenga en cuenta que se extiende Phaser.Text Phaser.Sprite también, por lo que nuestra todavía prefabricada es un sprite Phaser. Esta puntuación prefabricada debe fijarse a la cámara, por lo que no se moverá con el jugador y en el método de actualización que va a cambiar su texto a ser equivalente a la puntuación actual del jugador.
        var Platformer = Platformer || {}; Platformer.Score = function (game_state, posición, propiedades) { «utilizar estricta»; Phaser.Text.call (esto, game_state.game, position.x, position.y, properties.text); this.game_state = game_state; this.game_state.groups [properties.group] .add (this); this.fixedToCamera = true;}; Platformer.Score.prototype = Object.create (Phaser.Text.prototype); Platformer.Score.prototype.constructor = Platformer.Score; Platformer.Score.prototype.update = function () { » utilizar estricta «; // actualizar el texto a la puntuación actual jugador This.Text = «Puntuación:» + this.game_state.prefabs.player.score;}; 123456789101112131415161718192021varPlatformer = Plataformas || {}; Platformer.Score = función (game_state, posición, propiedades) { «utilizar estricta»; Phaser.Text.call (esto, game_state.game, position.x, position.y, properties.text); this.game_state = game_state; this.game_state.groups [properties.group] .add (esto ); this.fixedToCamera = true;}; Platformer.Score.prototype = Object.create (Phaser.Text.prototype); Platformer.Score.prototype.constructor = Platformer.Score; Platformer.Score.prototype.update = function () { «uso estricto»; // actualización de texto para el jugador actual scorethis.text = «puntuación:» + this.game_state.prefabs.player.score;};

        Este es un ejemplo de la puntuación en nuestro juego. Inténtelo usted mismo!

        puntuación

        Checkpoint

        Nuestro punto de control será simple, si el jugador muere después de tocar el punto de control, que se regeneran en la posición de puesto de control en lugar de su posición inicial. Para ello, vamos a añadir una casa prefabricada punto de control que comprueba si hay superposición con el jugador, y si eso ocurre, establecer una variable de punto de control en true. Por lo tanto, en el método “restart_level” de TiledState (presentado anteriormente) que ahora comprobar si se ha alcanzado el punto de control. Si es así, nosotros apenas Re el jugador a la posición de puesto de control, en lugar de reiniciar el nivel.
        var Platformer = Platformer || {}; Platformer.Checkpoint = function (game_state, posición, propiedades) { «utilizar estricta»; Platformer.Prefab.call (esto, game_state, la posición, propiedades); this.checkpoint_reached = false; this.game_state.game.physics.arcade.enable (this); this.anchor.setTo (0,5);}; Platformer.Checkpoint.prototype = Object.create (Platformer.Prefab.prototype); Platformer.Checkpoint.prototype.constructor = Platformer.Checkpoint; Platformer.Checkpoint.prototype.update = function ( ) { «utilizar estricta»; this.game_state.game.physics.arcade.collide (esto, this.game_state.layers.collision); this.game_state.game.physics.arcade.overlap (esto, this.game_state.groups.players, this.reach_checkpoint, null, este);}; Platformer.Checkpoint.prototype.reach_checkpoint = function () { «utilizar estricta»; se alcanzó // puesto de control this.checkpoint_reached = true;}; 123456789101112131415161718192021222324252627varPlatformer = Platformer || {}; Platformer.Checkpoint = function (game_state, posición, propiedades) { «utilizar estricta»; Platformer.Prefab.call (esto, game_state, posición , propiedades); this.checkpoint_reached = false; this.game_state.game.physics.arcade.enable (this); this.anchor.setTo (0,5);}; Platformer.Checkpoint.prototype = Object.create (Platformer.Prefab. prototipo); Platformer.Checkpoint.prototype.constructor = Platformer.Checkpoint; Platformer.Checkpoint.prototype.update = function () { «uso estricto»; this.game_state.game.physics.arcade.collide (esto, this.game_state. layers.collision); this.game_state.game.physics.arcade.overlap (esto, this.game_state.groups.players, this.reach_checkpoint, null, este);}; Platformer.Checkpoint.prototype.reach_checkpoint = function () { «uso estricto»; // puesto de control fue reachedthis.checkpoint_reached = true;};

        Este es un ejemplo del punto de control en nuestro juego. Inténtelo usted mismo!

        punto de control

        Acabado del juego

        Ahora que tenemos todo el código del juego, sólo tenemos que añadir las propiedades prefabricadas en nuestro mapa de baldosa, como lo hicimos en el último tutorial, y el juego de trabajo está trabajando!

        Mostrar los niveles que ha creado, y dígame su opinión acerca de este tutorial. En el siguiente tutorial, vamos a añadir vida a nuestro jugador, algunos artículos y un nivel de jefe, así que dime si tiene alguna sugerencia, también!

        Mensajes relacionados
        HTML5 desarrollo del juego con Phaser

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *