En el tutorial anterior hemos procedimiento generado un calabozo con varias habitaciones, lo que permite a nuestro héroe para navegar a través de él. En este tutorial, vamos a llenar esas habitaciones con obstáculos, enemigos y añadir una salida, por lo que el héroe puede salir de la mazmorra.

Los siguientes temas serán cubiertos en este tutorial:


  • Una estrategia para salas de procedimiento pueblan con objetos
  • Rellenar las habitaciones de las mazmorras con azulejos de obstáculos
  • Rellenar las habitaciones de las mazmorras con los enemigos
  • Adición de una salida en una habitación por lo que el jugador puede salir de la mazmorra
  • Bloqueo de las puertas de la sala hasta que todos los enemigos han sido derrotados

    Para leer este tutorial, es importante que usted está familiarizado con los conceptos siguientes:


    • Javascript y conceptos orientados a objetos.
    • conceptos básicos Phaser, tales como: estados, sprites, los grupos y la física de arcade
    • Creación de mapas con baldosa

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

      I modificado algunos activos (imágenes y mapas), por lo que le recomiendo que los descargue de nuevo, incluso los tiene desde el tutorial anterior.

      Estrategia para incrementar las habitaciones

      Dado un objeto y sus dimensiones (anchura y altura) tenemos que encontrar una región libre en la sala que se ajuste al objeto. Lo hacemos mirando regiones aleatorias con las dimensiones del objeto hasta que encontremos uno que es gratuito. Dado que la mayor parte de la sala es libre, este proceso suele ser rápido.

      El método “find_free_region” a continuación pertenece a la clase de habitaciones y es responsable de hacer eso. Se ejecuta un bucle que comienza por la búsqueda de una posición aleatoria que será el centro de la región. Luego, añadir las coordenadas de las otras posiciones que serán ocupadas por el objeto, de acuerdo con sus dimensiones. Por último, se comprueba si toda la región está libre. Si es así, hemos terminado. De lo contrario, sigue funcionando el bucle.
      ProceduralGeneration.Room.prototype.find_free_region = function (size_in_tiles) { «utilizar estricta»; var center_tile, región, x_coordinate, coordenada_y, initial_x_coordinate, initial_y_coordinate; do {// Escoja al azar de coordenadas a ser el centro de la región center_tile = nuevo Phaser.Point (this.game_state.game.rnd.between (2, (this.game_state.game.world.width / this.tile_dimensions.x ) – 3), this.game_state.game.rnd.between (2, (this.game_state.game.world.height / this.tile_dimensions.y) – 3)); región = [center_tile]; initial_x_coordinate = center_tile.x – Math.floor (size_in_tiles.x / 2); initial_y_coordinate = center_tile.y – Math.floor (size_in_tiles.y / 2); // añadir todas las coordenadas de la región, con base en su tamaño para (x_coordinate = initial_x_coordinate; x_coordinate el método “is_free” iterar a través de todas las coordenadas y comprobar la propiedad “población”. Esta propiedad se inicia tan vacía y se llena cada vez que se añade un objeto a la habitación. Por lo tanto, si hay otro objeto en esa posición, el método devolverá que la región no es libre.

      Los datos de población

      almacenará la población en un archivo JSON como la de abajo. Puede utilizar el mismo, siempre en el código fuente o crear el suyo propio. Lo importante es que este archivo se describen dos tipos de población: azulejos y casas prefabricadas. Para cada uno, también puede definir diferentes tipos (por ejemplo, puede agregar enemigos y elementos prefabricados en la sección). Para simplificar el tutorial, solamente he añadido un tipo de baldosas y prefabricada. Por último, para cada baldosa tipo que debe definir la capa que va a utilizar, el número mínimo y máximo de objetos que se van a crear, los posibles tamaños y posibles baldosas. Por otra parte, para cada tipo prefabricada debe definir el número mínimo y máximo de los objetos y las posibles casas prefabricadas.
      { «baldosas»: { «obstáculos»: { «capa»: «colisión», «número»: { «min»: 3, «max»: 5}, «tamaños»: [{ «x»: 1, » y «: 1}, {» x «: 1, «y»: 2}, {» x «: 1, «y»: 3}, {» x «: 2, «y»: 1}, {» x «: 3, «y»: 1}], «possible_tiles»: [10]}}, «prefabricados»: { «enemigos»: { «número»: {» min «: 1, «max»: 3} «possible_prefabs»: [{ «prefabricada»: «enemigas», «propiedades»: { «textura»: «enemy_image», «grupo»: «los enemigos»}}]}}} 123456789101112131415161718192021 { «baldosas»: { «obstáculos «: {» capa «:» colisión » «número»: { «min»: 3, «max»: 5}, «tamaños»: [{ «x»: 1, «y»: 1}, {» x «: 1,» y «: 2}, {» x «: 1,» y «: 3}, {» x «: 2,» y «: 1}, {» x «: 3,» y» : 1}], «possible_tiles»: [10]}}, «prefabricados»: { «enemigos»: { «número»: { «min»: 1, «max»: 3}, «possible_prefabs»: [{» prefabricada «:» enemigo», «propiedades»: { «textura»: «enemy_image», «grupo»: «los enemigos»}}]}}}

      el archivo JSON población se cargará en el DungeonState, ya que se ser utilizado durante la generación mazmorra.
      ProceduralGeneration.DungeonState.prototype.preload = function () { «utilizar estricta»; // cargar el this.load.text archivo JSON población ( «población», «activos / niveles / population.json»);}; 12345ProceduralGeneration.DungeonState.prototype.preload = function () { «utilizar estricta»; // carga JSON la población filethis.load.text ( «población», «activos / niveles / population.json»);};

      Rellenar con habitaciones obstáculo azulejos

      Vamos a empezar por llenar las habitaciones con azulejos de obstáculos. Cada obstáculo utilizará un índice de mosaico al azar (de una lista de los azulejos) y tendrá unas dimensiones al azar (de una lista de posibles tamaños).

      El código siguiente muestra el método de “populate_tiles”. Para cada baldosa, se escoge aleatoriamente un índice de baldosas, un tamaño (disponibles a partir de los datos de población) y se encuentra en una región libre. A continuación, añade todas las coordenadas de esta región a un objeto “baldosas” y para la población. El objeto “baldosas” será leído por el RoomState añadir las fichas en el juego.
      ProceduralGeneration.Room.prototype.populate_tiles = función (number_of_tiles, capa, possible_tiles, possible_sizes) { «uso estricto»; Índice var, baldosas, REGION_SIZE, región, coordinate_index; para (index = 0; index el método “populate” de la clase de habitaciones se muestra a continuación. En primer lugar, se inicializa la propiedad “población” como vacío, de manera que todas las coordenadas son inicialmente libres. A continuación, se itera a través de todos los obstáculos en los datos de población crearlos. Para cada obstáculo, se elige un número aleatorio de obstáculos y llamar al método “populate_tiles”.
      ProceduralGeneration.Room.prototype.populate = función (población) { «utilizar estricta»; NUMBER_OF_ROWS var, number_of_columns, ROW_INDEX, índice_columna, tile_type, number_of_tiles, prefab_type, number_of_prefabs; NUMBER_OF_ROWS = this.game_state.game.world.height / this.tile_dimensions.y; number_of_columns = this.game_state.game.world.width / this.tile_dimensions.x; // inicializar el objeto población como vacío para (ROW_INDEX = 0; ROW_INDEX <= NUMBER_OF_ROWS; ROW_INDEX + = 1) {this.population.push ([]); para (índice_columna = 0; índice_columna <= number_of_columns; índice_columna + = 1) {this.population [ROW_INDEX] [índice_columna] = null; }} // llenar la habitación con azulejos de (tile_type en population.tiles) {if (population.tiles.hasOwnProperty (tile_type)) {// elegir un número aleatorio de azulejos number_of_tiles = this.game_state.game.rnd.between ( population.tiles [tile_type] .number.min, population.tiles [tile_type] .number.max); // crear los this.populate_tiles azulejos (number_of_tiles, population.tiles [tile_type] .layer, population.tiles [tile_type] .possible_tiles, population.tiles [tile_type] .sizes); }}}; 1234567891011121314151617181920212223ProceduralGeneration.Room.prototype.populate = función (población) { "uso estricto"; varnumber_of_rows, number_of_columns, ROW_INDEX, índice_columna, tile_type, number_of_tiles, prefab_type, number_of_prefabs; NUMBER_OF_ROWS = this.game_state.game.world.height / this.tile_dimensions.y; number_of_columns = this.game_state.game.world.width / this.tile_dimensions.x; // inicializar el objeto población como emptyfor (ROW_INDEX = 0; ROW_INDEX <= NUMBER_OF_ROWS; ROW_INDEX + = 1) {this.population .push ([]); for (índice_columna = 0; índice_columna <= number_of_columns; índice_columna + = 1) {this.population [ROW_INDEX] [índice_columna] = null;}} // poblar la habitación con tilesfor (inpopulation.tiles tile_type) {if (population.tiles.hasOwnProperty (tile_type)) {// recoger un número aleatorio de tilesnumber_of_tiles = this.game_state.game.rnd.between (population.tiles [tile_type] .number.min, population.tiles [tile_type]. number.max); // crear los tilesthis.populate_tiles (number_of_tiles, population.tiles [tile_type] .layer, population.tiles [Tile_type] .possible_tiles, population.tiles [tile_type] .sizes);}}};

      Tenemos que cambiar el método “generate_dungeon” en la clase de mazmorras para cargar los datos de población y poblar las habitaciones, como se muestra a continuación.
      // cargar los datos de la población de la población archivo JSON = JSON.parse (this.game_state.game.cache.getText ( «población»)); // iterar a través de salas de conectar y rellenarlas created_rooms.forEach (function (habitación) {room.neighbor_coordinates (). ForEach (function (coordenadas) {if (this.grid [coordinate.row] [coordinate.column]) {habitación .Conectar (coordinate.direction, this.grid [coordinate.row] [coordinate.column]);}}, this); // pueblan la room.populate habitación (población);}, this); 12345678910111213 // cargar el datos de población del filepopulation JSON = JSON.parse (this.game_state.game.cache.getText ( «población»)); // iterar a través de salas para conectar y poblar themcreated_rooms.forEach (function () {room.neighbor_coordinates ambiente () .forEach (function (coordenadas) {if (this.grid [coordinate.row] [coordinate.column]) {room.connect (coordinate.direction, this.grid [coordinate.row] [coordinate.column]);}} , this); // poblar el roomroom.populate (población);}, this);

      Ahora, tenemos que añadir el siguiente código al final del método “crear” en RoomState. Este código se repetirá a través de todas las fichas en el “baldosas” objeto y llamar al método “putTile” de Phaser.Tilemap para cada uno. Este método nos permite añadir nuevas fichas para un mapa de baldosa previamente cargada (se puede obtener más información en la documentación Phaser). Hay otro cambio muy importante que tiene que hacer en esta clase. En el tutorial anterior de esta serie, nos propusimos la colisión de capas sólo para las baldosas porque las capas. Desde ahora vamos a añadir nuevas baldosas de una capa ya creada, tenemos que cambiar el código para establecer la colisión para todos los azulejos, como se muestra a continuación.
      // añadir azulejos a la sala de this.room.tiles.forEach (function (teja) {this.map.putTile (tile.tile, tile.position.x, tile.position.y, tile.layer);}, este ); // 1234 azulejos añadir a los roomthis.room.tiles.forEach (function (teja) {this.map.putTile (tile.tile, tile.position.x, tile.position.y, tile.layer);} , este); // 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) {// colisión capa this.map. setCollisionByExclusion ([- 1], es cierto, layer.name);}}, this); 12345678 // crear mapa layersthis.layers = {}; this.map.layers.forEach (función (capa) {this.layers [capa .name] = this.map.createLayer (layer.name), si (layer.properties.collision) {// colisión layerthis.map.setCollisionByExclusion ([- 1], es cierto, layer.name);}}, esto) ;.

      puede que ya intentar jugar la demo con los obstáculos

      obstáculos

      habitaciones poblar con enemigos

      Rellenar las habitaciones con los enemigos será muy similar a como lo hicimos con obstáculos, pero hay que guardar la información prefabricada en lugar de azulejos. Además, para simplificar el código que vamos a asumir todas las casas prefabricadas ocupan un solo azulejo.

      El código siguiente muestra el método de “populate_prefabs”. En lugar de escoger un índice de mosaico al azar, que recoge una casa prefabricada al azar, y se encuentra una región aleatoria con el tamaño de una sola baldosa (que se traduce en una posición aleatoria). Luego se agrega el nombre prefabricada, tipo, posición y propiedades de un objeto “prefabricada”, que será leído por RoomState también.
      ProceduralGeneration.Room.prototype.populate_prefabs = función (number_of_prefabs, possible_prefabs_data) { «uso estricto»; índice var, prefab_data, prefabricada, tile_position, la posición, las propiedades; para (index = 0; index hay que añadir en el método de “poblar” el código para agregar las casas prefabricadas. De manera similar a lo que hicimos con los azulejos, que iterar a través de todos los datos de población prefabricadas, elegimos un número aleatorio de casas prefabricadas y llamamos al método “populate_prefabs”.
      // pueblan la habitación con casas prefabricadas para (prefab_type en population.prefabs) {if (population.prefabs.hasOwnProperty (prefab_type)) {// recoger un número aleatorio de casas prefabricadas number_of_prefabs = this.game_state.game.rnd.between (población. prefabricados [prefab_type] .number.min, population.prefabs [prefab_type] .number.max); // crear las casas prefabricadas this.populate_prefabs (number_of_prefabs, population.prefabs [prefab_type] .possible_prefabs); }} // 123456789 llenar la habitación con prefabsfor (inpopulation.prefabs prefab_type) {if (population.prefabs.hasOwnProperty (prefab_type)) {// escoger un número al azar de prefabsnumber_of_prefabs = this.game_state.game.rnd.between (población. prefabricadas [prefab_type] .number.min, population.prefabs [prefab_type] .number.max); // crear las prefabsthis.populate_prefabs (number_of_prefabs, population.prefabs [prefab_type] .possible_prefabs);}}

      Por último, añadimos el siguiente fragmento de código para el método de “crear” en RoomState, por lo que crea las casas prefabricadas después de añadir los azulejos de obstáculos. Este código simplemente pasa a través de todas las casas prefabricadas añadido y crear ellos utilizando su método “create_prefab”.
      // Añadir prefabs a la this.room.prefabs.forEach habitación (function (prefabricadas) {new_prefab = new this.prefab_classes [prefab.prefab] (esto, prefab.name, prefab.position, prefab.properties);}, este ); 1234 prefabs // añadir a la roomthis.room.prefabs.forEach (función (prefabricadas) {new_prefab = newthis.prefab_classes [prefab.prefab] (esto, prefab.name, prefab.position, prefab.properties);}, esto);

      para poder verificar si todo funciona por ahora, usted tiene que crear una casa prefabricada enemigo por lo que la demostración se puede ejecutar, como se muestra a continuación. Recuerda que cada vez que se crea una nueva prefabricada debe agregarlo a la propiedad “prefab_classes” en RoomState. A estas alturas ya se puede intentar jugar la demo con los enemigos también.
      var ProceduralGeneration = ProceduralGeneration || {}; ProceduralGeneration.Enemy = function (game_state, nombre, posición, propiedades) { «utilizar estricta»; ProceduralGeneration.Prefab.call (esto, game_state, nombre, posición, propiedades); this.anchor.setTo (0,5); this.game_state.game.physics.arcade.enable (this); this.body.immovable = true;}; ProceduralGeneration.Enemy.prototype = Object.create (ProceduralGeneration.Prefab.prototype); ProceduralGeneration.Enemy.prototype.constructor = ProceduralGeneration.Enemy; 1234567891011121314varProceduralGeneration = ProceduralGeneration || {}; ProceduralGeneration.Enemy = función (game_state, nombre, posición, propiedades) { «uso estricto»; ProceduralGeneration.Prefab.call (esto, game_state, nombre, posición, propiedades); this.anchor.setTo (0,5); this.game_state.game.physics .arcade.enable (this); this.body.immovable = true;}; ProceduralGeneration.Enemy.prototype = Object.create (ProceduralGeneration.Prefab.prototype); ProceduralGeneration.Enemy.prototype.constructor = ProceduralGeneration.Enemy;

      Adición de la salida mazmorra

      Antes de añadir la salida, debemos crear su prefabricada, como se muestra a continuación. La salida prefabricada simplemente comprueba si hay colisiones con el héroe y, si detecta uno, se reinicia la demo llamando al DungeonState de nuevo.
      var ProceduralGeneration = ProceduralGeneration || {}; ProceduralGeneration.Exit = function (game_state, nombre, posición, propiedades) { «utilizar estricta»; ProceduralGeneration.Prefab.call (esto, game_state, nombre, posición, propiedades); this.anchor.setTo (0,5); this.direction = properties.direction; this.game_state.game.physics.arcade.enable (this); this.body.immovable = true;}; ProceduralGeneration.Exit.prototype = Object.create (ProceduralGeneration.Prefab.prototype); ProceduralGeneration.Exit.prototype.constructor = ProceduralGeneration.Exit; ProceduralGeneration.Exit.prototype.update = function () { «utilizar estricta»; this.game_state.game.physics.arcade.collide (esto, this.game_state.groups.heroes, this.reach_exit, null, este);}; ProceduralGeneration.Exit.prototype.reach_exit = function () { «utilizar estricta»; si (this.game_state.groups.enemies.countLiving () === 0) {// reiniciar el this.game_state.game.state.start juego ( «DungeonState», verdadero, falso, 10); }}; 1234567891011121314151617181920212223242526272829varProceduralGeneration = ProceduralGeneration || {}; ProceduralGeneration.Exit = function (game_state, nombre, posición, propiedades) { «utilizar estricta»; ProceduralGeneration.Prefab.call (Esto, game_state, nombre, posición, propiedades); esto. anchor.setTo (0,5); this.direction = properties.direction; this.game_state.game.physics.arcade.enable (this); this.body.immovable = true;}; ProceduralGeneration.Exit.prototype = Object.create ( ProceduralGeneration.Prefab.prototype); ProceduralGeneration.Exit.prototype.constructor = ProceduralGeneration.Exit; ProceduralGeneration.Exit.prototype.update = function () { «utilizar estricta»; this.game_state.game.physics.arcade.collide (esto, this.game_state.groups.heroes, this.reach_exit, null, este);}; ProceduralGeneration.Exit.prototype.reach_exit = function () { «utilizar estricta», si (this.game_state.groups.enemies.countLiving () = == 0) {// reinicie el gamethis.game_state.game.state.start ( «DungeonState», verdadero, falso, 10);}};

      Vamos a añadir la salida de la mazmorra de la ro más alejado om desde la inicial. Para ello, hay que cambiar el método de “generate_dungeon” para realizar un seguimiento de la habitación principal, como se muestra a continuación. Al rellenar una habitación, se calcula su distancia a la habitación inicial y guardar la coordenada de la que está más. Entonces, después de poblar todas las habitaciones le sumamos la salida a la habitación con la sala de cota final.
      max_distance_to_initial_room = 0; // iterar a través de salas de conectar y rellenarlas created_rooms.forEach (function (habitación) {room.neighbor_coordinates (). ForEach (function (coordenadas) {if (this.grid [coordinate.row] [coordinate.column]) {habitación .Conectar (coordinate.direction, this.grid [coordinate.row] [coordinate.column]);}}, this); // pueblan la room.populate habitación (población); // mide la distancia a la habitación inicial distance_to_initial_room = Math.abs (room.coordinate.column – initial_room_coordinate.x) + Math.abs (room.coordinate.row – initial_room_coordinate.y), si (distance_to_initial_room> max_distance_to_initial_room) {final_room_coordinate.x = room.coordinate.column; final_room_coordinate.y = room.coordinate.row;}}, este); this.grid [final_room_coordinate.y] [final_room_coordinate.x] .populate_prefabs (1, [{prefabricada: «salida», propiedades: {textura: «exit_image», grupo: «salidas»}}]); 1234567891011121314151617181920max_distance_to_initial_room = 0; / / iterar a través de salas para conectar y poblar themcreated_rooms.forEach (function (habitación) {room.neighbor_coordinates (). forEach (function (coordenadas) {if (this.grid [coordinate.row] [coordinate.column]) {room.connect (coordinate.direction, this.grid [coordinate.row] [coordinate.column]);}}, this); // poblar el roomroom.populate (población); // mide la distancia a la roomdistance_to_initial_room inicial = Math.abs ( room.coordinate.column-initial_room_coordinate.x) + Math.abs (room.coordinate.row-initial_room_coordinate.y), si (distance_to_initial_room> max_distance_to_initial_room) {final_room_coordinate.x = room.coordinate.column; final_room_coordinate.y = room.coordinate .row;}}, this); this.grid [final_room_coordinate.y] [final_room_coordinate.x] .populate_prefabs (1, [{prefabricada: «salida», propiedades: {textura: «EXI t_image», grupo: » salidas»}}]);

      Trate de jugar la demo ahora y la búsqueda de la salida

      enemigos

      enemigos de extinción

      Nuestro héroe todavía no puede derrotar a cualquier enemigo, por lo que debe agregar código para hacer eso. Dado que este no es el foco de este tutorial, sólo hará que el héroe mata al enemigo cuando se superponen, como se muestra a continuación. Para un juego real podría agregar las estadísticas de ataque y defensa y calcular el daño en base a ellos. Siéntase libre para mejorar el código con el fin de hacer algo divertido.
      var ProceduralGeneration = ProceduralGeneration || {}; ProceduralGeneration.Enemy = function (game_state, nombre, posición, propiedades) { «utilizar estricta»; ProceduralGeneration.Prefab.call (esto, game_state, nombre, posición, propiedades); this.anchor.setTo (0,5); this.game_state.game.physics.arcade.enable (this); this.body.immovable = true;}; ProceduralGeneration.Enemy.prototype = Object.create (ProceduralGeneration.Prefab.prototype); ProceduralGeneration.Enemy.prototype.constructor = ProceduralGeneration.Enemy; ProceduralGeneration.Enemy.prototype.update = function () { «utilizar estricta»; this.game_state.game.physics.arcade.overlap (esto, this.game_state.groups.heroes, this.kill, null, este);}; 12345678910111213141516171819varProceduralGeneration = ProceduralGeneration || {}; ProceduralGeneration.Enemy = function (game_state, nombre , la posición, propiedades) { «uso estricto»; ProceduralGeneration.Prefab.call (esto, game_state, nombre, posición, propiedades); this.anchor.setTo (0,5); this.game_state.game.physics.arcade.enable (esto ); this.body.immovable = true;}; ProceduralGeneration.Enemy.prototype = Object.create (ProceduralGeneration.Prefab.prototype); ProceduralGeneration.Enemy.prototype.constructor = ProceduralGeneration.Enemy; ProceduralGeneration.Enemy.prototype.update = function () { «use strict»; this.game_state.game.physics.arcade.overlap (esto, this.game_state.groups.heroes, this.kill, null, this);};

      Ahora que nuestra derrota héroe puede enemigos, hay que bloquear las habitaciones (y la salida) hasta que todos los enemigos en esa habitación han sido vencidos. Para hacer eso, basta con comprobar si el grupo no tiene enemigos objetos vivos en los métodos “reach_exit” “enter_door” y, como se muestra a continuación.
      ProceduralGeneration.Door.prototype.enter_door = function () { «utilizar estricta»; next_room var; si (this.game_state.groups.enemies.countLiving () === 0) {// encontrar la siguiente habitación utilizando la dirección de la puerta next_room = this.game_state.room.neighbors [this.direction]; // estado de arranque espacio a la habitación de al lado this.game_state.game.state.start ( «BootState», verdadero, falso, «activos / niveles / room_level.json», «RoomState», {habitación: next_room}); }}; 12345678910ProceduralGeneration.Door.prototype.enter_door = function () { «use strict»; varnext_room; si (this.game_state.groups.enemies.countLiving () === 0) {// encontrar la otra habitación utilizando la puerta directionnext_room = this.game_state.room.neighbors [this.direction]; // estado de arranque espacio para el siguiente roomthis.game_state.game.state.start ( «BootState», verdadero, falso, «activos / niveles / room_level.json» , «RoomState», {habitación: next_room});}}; ProceduralGeneration.Exit.prototype.reach_exit = function () { «utilizar estricta»; si (this.game_state.groups.enemies.countLiving () === 0) {// reiniciar el this.game_state.game.state.start juego ( «DungeonState», verdadero, falso, 10); }}; 1234567ProceduralGeneration.Exit.prototype.reach_exit = function () { «utilizar estricta», si (this.game_state.groups.enemies.countLiving () === 0) {// reinicie el gamethis.game_state.game.state .start ( «DungeonState», verdadero, falso, 10);}};.

      Ahora, usted puede intentar jugar la demo de nuevo y comprobar si puede encontrar la salida mazmorra

      Y con esto concluye nuestra serie de tutoriales sobre el contenido del procedimiento generado. Hágamelo saber sus opiniones en la sección de comentarios!

      Mensajes relacionados
      salida > <img src =

Deja una respuesta

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