Generación de mazmorras

Dungeon Generation consiste en manipular el proceso de población de fragmentos para obligar al juego a generar mazmorras en ubicaciones específicas. Generar mazmorras puede ser interesante si quieres muchas mazmorras en la misma ubicación y, al mismo tiempo, tienes la posibilidad de elegir la ubicación y el tipo de mafia.

Contenido

• 1 El concepto de generación Spawner
• 2 Población en trozos y semilla en trozos
  • 2.1 La creación de Chunk
  • 2.2 El trozo de población
    • 2.2.1 La semilla en trozos
    • 2.2.2 Generación de mazmorras
• 3 Creación de spawner
  • 3.1 Condición de bloque
    • 3.1.1 Generación de mazmorras:
      • 3.1.1.1 Generación de piso
      • 3.1.1.2 generación de cofres y ubicación del desove

El concepto de generación Spawner

La generación Spawner utiliza el hecho de que el juego no genera las mazmorras al mismo tiempo que genera los bloques. En realidad, la generación se compone de dos pasos, primero el juego generará el bloque, como piedra, tierra, arena, etc.haciendo el aspecto global del trozo. En el segundo paso, el juego agregará minerales, lava y lagos de agua, y árboles, por ejemplo, este paso se llama "población de fragmentos", ya que es el paso que agrega vida al fragmento. También generará todas las estructuras del juego, la última estructura en el supramundo que se está generando son las mazmorras.

La generación de la mazmorra depende de la semilla del fragmento y también de los bloques que se encuentran en la ubicación donde se intenta colocar la mazmorra. Tener un mod o herramienta para predecir las ubicaciones de aparición de las mazmorras y construir la estructura conveniente para la generación obligará al juego a generar mazmorras en el proceso de población.

Construir la estructura en un trozo despoblado requiere que el jugador esté lejos del trozo, por eso se requiere un dispositivo que coloque bloques lejos del jugador, se utilizan máquinas voladoras o puentes de pistones para este propósito. Construir la máquina que empuja una determinada estructura en trozos descargados en ubicaciones precisas es la parte más tediosa de Spawner Generation. Finalmente, una vez que se coloca la estructura, el juego poblará el fragmento cuando el jugador se acerque lo suficiente al fragmento y, si la ubicación y la estructura son correctas, creará una mazmorra.

Población en trozos y semilla en trozos

La creación de Chunk

Durante la primera fase de generación, cuando se crea el trozo, el juego genera la piedra, la tierra, la arena, las cuevas, el agua y la lava (observe que la lava en el nivel y ~ 11 se genera durante este paso mientras que la lava los lagos y lagos de agua se generan durante la población).

La gran población

Durante este paso, las estructuras, lagos, mazmorras y finalmente la decoración del terreno (árboles, hierba, minerales, granito ...) se agregan al fragmento.

public void poblar (IChunkProvider chunkProvider, int chunkX, int chunkZ) {int posx = chunkX * 16; int posz = chunkZ * 16; BlockPos blockPos = nuevo BlockPos (posx, 0, posz); BiomeGenBase bioma = this.worldObj.getBiomeGenForCoords (blockPos.add (16, 0, 16)); this.rand.setSeed (this.worldObj.getSeed ()); long j = this.rand.nextLong () / 2L * 2L + 1L; long k = this.rand.nextLong () / 2L * 2L + 1L; this.rand.setSeed ((long) chunkX * j + (long) chunkZ * k ^ this.worldObj.getSeed ()); if (--- && this.mapFeaturesEnabled) {this.mineshaftGenerator.gen (---); // intento de generación del pozo de mina} if (--- && this.mapFeaturesEnabled) {this.villageGenerator.gen (---); // intento de generación de aldea} if (--- && this.mapFeaturesEnabled) {this.strongholdGenerator.gen (---); // intento de generación más fuerte} if (--- && this.mapFeaturesEnabled) {this.scaptedFeatureGenerator.gen (---); // intento de generación del templo} if (- && this.mapFeaturesEnabled) {this.oceanMonument.gen (---); // intento de generación de oceanmonument} int x; int y; int z; if (bioma! = BiomeGenBase.desert && biome! = BiomeGenBase.desertHills && --- && this.rand.nextInt (4) == 0) {x = this.rand.nextInt (16) + 8; y = this.rand.nextInt (256); z = this.and.nextInt (16) + 8; (new WorldGenLakes (Blocks.water)). generate (this.worldObj, this.rand, blockPos.add (x, y, z)); } if (--- && this.rand.nextInt (8) == 0) {x = this.rand.nextInt (16) + 8; y = this.rand.nextInt (this.and.nextInt (248) + 8); z = this.and.nextInt (16) + 8; if (y <63 || this.rand.nextInt (10) {(new WorldGenLakes (Blocks.lava)). generate (this.worldObj, this.rand, blockPos.add (var14, var15, var16));}} if (---) {for (int i = 0; i <8; ++ i) {x = this.rand.nextInt (16) + 8; y = this.rand.nextInt (256); z = this .rand.nextInt (16) + 8; (new WorldGenDungeons ()). generate (this.worldObj, this.rand, blockPos.add (x, y, z)); // dungeon Generation.}} biome.worldDecoration ( this.worldObj, this.rand, new BlockPos (posx, 0, posz)); // también hacer otras cosas: agregar animales, nieve y hielo)}

La semilla del trozo

La generación utiliza un generador pseudoaleatorio, llamado RNG (el generador de números aleatorios de Java). Un generador pseudoaleatorio es un generador que generará los mismos números de la misma semilla. los números no tendrán vínculos entre ellos, pero si tomas la misma semilla obtendrás los mismos números aleatorios, es por eso que de la misma semilla obtienes el mismo mundo en Minecraft. Cada vez que se llama a la función aleatoria, generará una semilla de necesidad a partir de la anterior y generará un número aleatorio.

En el juego, cada trozo tiene un valor de semilla aleatorio asociado con el fin de colocar estructuras, decoraciones y lagos al azar. El valor aleatorio se calcula así:

this.rand.setSeed (this.worldObj.getSeed ()); long j = this.rand.nextLong () / 2L * 2L + 1L; long k = this.rand.nextLong () / 2L * 2L + 1L; this.rand.setSeed ((long) chunkX * j + (long) chunkZ * k ^ this.worldObj.getSeed ());

Cada vez que se genera una estructura, llamará a la función aleatoria para colocar bloques o generar coordenadas, por ejemplo. Si tomamos la generación de lagos de agua, podemos ver que las funciones this.rand.nextInt (rango) se llaman sistemáticamente cuando intenta colocar lagos de agua:

if (bioma! = BiomeGenBase.desert && biome! = BiomeGenBase.desertHills && --- && this.rand.nextInt (4) == 0) {x = this.rand.nextInt (16) + 8; y = this.rand.nextInt (256); z = this.and.nextInt (16) + 8; (new WorldGenLakes (Blocks.water)). generate (this.worldObj, this.rand, blockPos.add (x, y, z)); }

Si lo comparamos con la generación de la estructura, podemos ver que no se llama a ninguna función aleatoria:

if (--- && this.mapFeaturesEnabled) {this.mineshaftGenerator.gen (---); // intento de generación del pozo de mina} if (--- && this.mapFeaturesEnabled) {this.villageGenerator.gen (---); // intento de generación de aldea} if (--- && this.mapFeaturesEnabled) {this.strongholdGenerator.gen (---); // intento de generación más fuerte} if (--- && this.mapFeaturesEnabled) {this.scaptedFeatureGenerator.gen (---); // intento de generación del templo} if (- && this.mapFeaturesEnabled) {this.oceanMonument.gen (---); // intento de generación de oceanmonument}

Cada estructura (pozo de mina, aldea, antiguo fuerte, templo y monumento oceánico) no modificará el valor aleatorio cuando no se generen, sin embargo, si se generan, modificarán la semilla aleatoria de una manera que no es realmente predecible por un simple tercero. party tool sin utilizar una gran parte del código de generación del juego (por ejemplo, las estructuras dependen de los biomas, de las cuevas ...).

LakeGenerator modifica la semilla aleatoria, pero las llamadas aleatorias no dependen de otra cosa que la semilla aleatoria. Las llamadas aleatorias durante la generación del lago se simplificarán de la siguiente manera (nota: el valor aleatorio no se copia, por eso modificará el original):

public boolean generate (World worldIn, Random random) {int randomrange = random.nextInt (4) + 4; for (int i = 0; i <randomrange; ++ i) {double var7 = random.nextDouble (); double var9 = random.nextDouble (); double var11 = random.nextDouble (); double var13 = random.nextDouble (); double var15 = random.nextDouble (); double var17 = random.nextDouble (); } devuelve verdadero; }

Generación de mazmorras

Después de la estructura y la generación del lago, ocurrirá el proceso de generación de mazmorras. Dado que las coordenadas se generan a partir de la semilla de fragmentos aleatorios, significa que cada paso que sucedió antes tendrá un impacto en las coordenadas de la mazmorra.

Para predecir la coordenada de mazmorra / desove, es necesario utilizar un mod o un script que emule las llamadas aleatorias anteriores para obtener la semilla correcta.

para (int i = 0; i <8; ++ i) {x = this.rand.nextInt (16) + 8; y = this.rand.nextInt (256); z = this.and.nextInt (16) + 8; (new WorldGenDungeons ()). generate (this.worldObj, this.rand, blockPos.add (x, y, z)); }

Por defecto, el número de veces que el generador intenta construir una mazmorra es 8. Eso significa que el número máximo de reproductores por fragmento puede ser mayor que 8. (Con el generador de Minecraft personalizado puedes elegir el número máximo de mazmorras por fragmento).

Aquí hay una captura de pantalla de todas las posiciones probadas por el código de generación para colocar algunos generadores. Se obtuvo usando una versión modificada de Minecraft y los rectángulos del mismo color representan una mazmorra no generada ubicada en el mismo fragmento.

Creación de spawner

Condición de bloque

La primera parte del código que genera las mazmorras es asegurarse de que las mazmorras no se generen en todas partes. Cuando vemos mazmorras en cuevas, podemos ver que la mazmorra nunca está cerrada y tampoco está nunca en el medio de la cueva, sino en un área excavada en la pared con una abertura.

Primero, cuando se llama a la función de generación de mazmorras, se creará el tamaño de la mazmorra a partir de la semilla aleatoria, el tamaño en -x y x es el mismo, y el tamaño en z y -z es el mismo, y puede ser 3 o 4.

int sizeX = random.nextInt (2) + 3; int minX = -sizeX; int maxX = tamañoX; int sizeZ = random.nextInt (2) + 3; int minZ = -sizeZ; int maxZ = tamañoZ;

Como resultado, el tamaño de una mazmorra puede ser 9x7, 7x9, 9x9 o 7x7, 49 bloques ^ 2, 63 bloques ^ 2 u 81 bloques ^ 2

Hay 3 condiciones que deben cumplirse para que se pueda colocar la mazmorra:

• La ubicación debe tener un piso de bloque sólido del mismo tamaño que la mazmorra.
• La ubicación debe tener un techo a 3 bloques encima del generador con el mismo tamaño de la mazmorra.

• Las paredes deben tener una abertura de entre 1 y 5 bloques. Se considera que un muro está presente siempre que haya al menos un bloque en el extremo de la mazmorra en el mismo nivel y de la mazmorra o en el bloque superior.

-Lana magenta: lana necesaria para contar como piso y techo.

-Lana celeste: lana que se necesita para las paredes, solo cuentan las 2 primeras capas y al menos 1 cuenta como pared.

-Lana rosa: apertura de bloques de aire.

-Lana blanca: bloques neutrales: esos bloques no impiden que se genere la mazmorra.

Generación de mazmorras:

Cuando la posición marcada sea correcta, el juego generará los bloques de la mazmorra y vaciará los bloques de la mazmorra (los bloques que no son un techo, un piso o una pared).

Los bloques de pared se convertirán en bloques de adoquines, los bloques del techo permanecerán sin cambios y la piedra cubierta de musgo se colocará al azar.

Generación de piso

Para que el juego intente colocar una piedra cubierta de musgo o un adoquín, debe tener un bloque sólido debajo, la colocación de la piedra cubierta de musgo / adoquín está determinada por el valor aleatorio del trozo, por lo que significa que el valor aleatorio del chunk se puede controlar manipulando el número de bloques debajo de los bloques del piso. De esa manera, se puede elegir la cantidad correcta de bloques para obtener el generador de mods correcto (que se genera al final), además, podemos manipular las coordenadas de la siguiente mazmorra en el fragmento modificando el valor aleatorio usando los bloques del piso. .

else if (worldIn.getBlockState (blockpos1) .getMaterial (). isSolid () && worldIn.getBlockState (blockpos1) .getBlock ()! = Blocks.chest) {if (i4 == -1 && rand.nextInt (4)! = 0) {worldIn.setBlockState (blockpos1, Blocks.mossy_cobblestone.getDefaultState (), 2); } else {worldIn.setBlockState (blockpos1, Blocks.cobblestone.getDefaultState (), 2); }

generación de cofres y colocación del desove

El número máximo de cofres por mazmorra es 2, por cada cofre intentará colocarlo 3 veces. para cada intento, se genera una ubicación aleatoria dentro de la mazmorra, (eso también significa que el valor aleatorio se cambia cada vez que se genera una coordenada), y luego se prueba si la ubicación es correcta, el cofre se coloca solo si solo tiene 1 bloque macizo adyacente. Por lo tanto, los cofres no se pueden generar en el medio de la mazmorra, sino también en las esquinas, ya que el cofre tendría 2 bloques adyacentes.

En 1.8, la generación de cofres modifica el valor aleatorio, dando más posibilidades, sin embargo en 1.9 desde que se introdujo el botín, ya no lo hace, es por eso que considerar la generación de cofres ahora es inútil, porque no tendrá ningún impacto en el valor aleatorio .

En 1.8, la generación de cofres se puede usar para cambiar el valor aleatorio del fragmento aún más, ofreciendo así más posibilidades, pero dado que las tablas de botín se introdujeron en 1.9, solo se da 1 valor aleatorio como argumento para la generación de cofres. Sin embargo, el bloque de paredes no necesita estar conectado con el piso, lo que significa que el juego no puede generar los cofres, cambiando el valor aleatorio tanto como sea posible ya que el juego intentará generar los cofres.