public static int getBlacklistBiomeIDWithinRange(World world, int x, int z, int radius) {
    FRLog.debug("Checking Biomes...");
    float reciprocalRootOf2 = 0.70710678f;
    int adjRadius = Math.round(radius * reciprocalRootOf2);
    BlockPos pos = new BlockPos(x, 64, z);
    EnumFacing[] NSEW = EnumFacing.values();

    int biomeID = world.getBiomeGenForCoords(pos).biomeID;
    if (CommonUtils.isIDInList(biomeID, biomeIDBlacklist)) return biomeID;

    for (EnumFacing fd : NSEW) {
      for (int i = radius; i > 0; i = i - 2) {
        biomeID = world.getBiomeGenForCoords(pos.offset(fd, i)).biomeID;
        if (CommonUtils.isIDInList(biomeID, biomeIDBlacklist)) return biomeID;
      }
    }

    for (int ns = 0; ns < 2; ns++)
      for (int ew = 2; ew < 4; ew++)
        for (int r = adjRadius; r > 0; r = r - 2) {
          biomeID = world.getBiomeGenForCoords(pos.offset(NSEW[ns], r).offset(NSEW[ew], r)).biomeID;
          if (CommonUtils.isIDInList(biomeID, biomeIDBlacklist)) return biomeID;
        }

    return -1;
  }
  @Override
  public void processCommand(ICommandSender icommandsender, String[] astring) {

    ArrayList<ChunkCoordinates> ccListsb = new ArrayList<ChunkCoordinates>();
    ArrayList<ChunkCoordinates> ccListdb = new ArrayList<ChunkCoordinates>();
    boolean sameBiome;
    int offset = 1;
    ChunkCoordinates cc = icommandsender.getPlayerCoordinates();
    EntityPlayerMP player = getCommandSenderAsPlayer(icommandsender);

    World w = player.worldObj;
    BiomeGenBase bg = w.getBiomeGenForCoords(cc.posX, cc.posZ);

    sameBiome = true;

    int olddb, newdb;

    newdb = 0;

    while (sameBiome == true) {

      olddb = newdb;

      for (int i = -offset; i <= offset; i++) {
        for (int j = -offset; j <= offset; j++) {
          if (w.getBiomeGenForCoords(cc.posX + i, cc.posZ + j) == bg) {
            ccListsb.add(new ChunkCoordinates(cc.posX + i, 0, cc.posZ + j));
          } else {
            ccListdb.add(new ChunkCoordinates(cc.posX + i, 0, cc.posZ + j));
          }
        }
      }

      newdb = ccListdb.size();

      if ((newdb - olddb >= offset * 8 || offset == 512)) {
        System.out.println("" + ccListsb.size());
        sameBiome = false;
      } else {
        ccListdb.clear();
        ccListsb.clear();
      }

      offset++;
    }

    for (int j = 0; j < ccListsb.size(); j++) {
      for (int i = 0; i < 256; i++) {
        if (w.blockExists(ccListsb.get(j).posX, i, ccListsb.get(j).posZ))
          w.destroyBlock(ccListsb.get(j).posX, i, ccListsb.get(j).posZ, false);
      }
    }

    System.out.println("Done");
  }
  void displayPlayers() {
    Main.server
        .mc_server
        .getCommandManager()
        .executeCommand(Main.server.mc_server, "say Localisation des joueurs:");

    for (World world : Main.server.mc_server.worldServers) {
      for (Object obj : world.playerEntities) {
        EntityPlayer p = (EntityPlayer) obj;
        int x = (int) p.posX;
        int y = (int) p.posY;
        int z = (int) p.posZ;
        String biom = world.getBiomeGenForCoords(x, z).biomeName;
        Main.server
            .mc_server
            .getCommandManager()
            .executeCommand(
                Main.server.mc_server,
                "say "
                    + p.getCommandSenderName()
                    + ": X:"
                    + x
                    + " Y:"
                    + y
                    + " Z:"
                    + z
                    + " Biom: "
                    + biom);
      }
    }
  }
  @Override
  public void generate(
      Random rand,
      int chunkX,
      int chunkZ,
      World world,
      IChunkProvider chunkGenerator,
      IChunkProvider chunkProvider) {
    chunkX = chunkX << 4;
    chunkZ = chunkZ << 4;
    final BiomeGenBase biome = world.getBiomeGenForCoords(chunkX, chunkZ);

    if (BiomeSettings.GREENSWAMP.getBiome().isPresent()
            && biome == BiomeSettings.GREENSWAMP.getBiome().get()
        || BiomeSettings.MOUNTAINRIDGE.getBiome().isPresent()
            && biome == BiomeSettings.MOUNTAINRIDGE.getBiome().get()
        || BiomeSettings.REDWOODLUSH.getBiome().isPresent()
            && biome == BiomeSettings.REDWOODLUSH.getBiome().get()
        || BiomeSettings.WOODLANDS.getBiome().isPresent()
            && biome == BiomeSettings.WOODLANDS.getBiome().get())
      for (int i = 0; i < 2; i++) {
        final int x = chunkX + rand.nextInt(16) + 8;
        final int y = rand.nextInt(128);
        final int z = chunkZ + rand.nextInt(16) + 8;
        leafPileGen.generate(world, rand, x, y, z);
      }
  }
  @Override
  public void generate(
      Random random,
      int chunkX,
      int chunkZ,
      World world,
      IChunkProvider chunkGenerator,
      IChunkProvider chunkProvider) {
    BiomeGenBase biome = world.getBiomeGenForCoords(chunkX * 16, chunkZ * 16);
    BiomeDictionary.Type[] types = BiomeDictionary.getTypesForBiome(biome);

    if (types.length == 1 && types[0] == BiomeDictionary.Type.PLAINS) {
      int flaxPlants = 0;
      while (random.nextFloat() < 0.8f && flaxPlants < 10) flaxPlants++;

      for (int flower = 0; flower < flaxPlants; ++flower) {
        int x = chunkX * 16 + random.nextInt(16) + 8;
        int z = chunkZ * 16 + random.nextInt(16) + 8;
        int y = random.nextInt(world.getHeightValue(x, z) + 32);

        plantGen.func_150550_a(YGCBlocks.flaxPlant, 7 - (random.nextFloat() < 0.1f ? 1 : 0));
        plantGen.generate(world, random, x, y, z);
      }
    }
  }
  private void runGenerator(
      WorldGenerator generator,
      World world,
      Random rand,
      int chunk_X,
      int chunk_Z,
      int chanceToSpawn,
      int minHeight,
      int maxHeight) {

    if (minHeight < 0 || maxHeight > 256 || minHeight > maxHeight)
      throw new IllegalArgumentException("FUUUUUUUUUCK YOU STEVEN!!!");
    /*"Illegal Height Arguments for WorldGenerator" side note: who's steven?*/

    int heightDiff = maxHeight - minHeight + 1;
    for (int i = 0; i < chanceToSpawn; i++) {
      int x = chunk_X * 16 + rand.nextInt(16);
      int y = minHeight + rand.nextInt(heightDiff);
      int z = chunk_Z * 16 + rand.nextInt(16);
      // generator.generate(world, rand, new BlockPos(x, y, z));
      if (world
          .getBiomeGenForCoords(new BlockPos(x, y, z))
          .equals(biomeCrystal.getBiome(configFile.BIOMECRYSTALBLACK))) {
        generator.generate(world, rand, new BlockPos(x, y, z));
      }
    }
  }
  @Override
  public void func_149878_d(World world, int x, int y, int z, Random rand) {
    if (world.isRemote || !TerrainGen.saplingGrowTree(world, rand, x, y, z)) return;

    int meta = damageDropped(world.getBlockMetadata(x, y, z));
    world.setBlockToAir(x, y, z);

    switch (meta) {
      case 1:
        if (MineFactoryReloadedWorldGen.generateSacredSpringRubberTree(world, rand, x, y, z))
          return;
        break;
      case 2:
        if (MineFactoryReloadedWorldGen.generateMegaRubberTree(world, rand, x, y, z, false)) return;
        break;
      case 3:
        if (new WorldGenMassiveTree().setSloped(true).generate(world, rand, x, y, z)) return;
        break;
      default:
      case 0:
        BiomeGenBase b = world.getBiomeGenForCoords(x, z);
        if (b != null && b.biomeName.toLowerCase().contains("mega"))
          if (rand.nextInt(50) == 0)
            if (MineFactoryReloadedWorldGen.generateMegaRubberTree(world, rand, x, y, z, true))
              return;
        if (treeGen.growTree(world, rand, x, y, z)) return;
        break;
    }
    world.setBlock(x, y, z, this, meta, 4);
  }
  public boolean genHive(World world, Random rand, int chunkX, int chunkZ, Hive hive) {
    if (hive.genChance() * Config.getBeehivesRate() < rand.nextFloat() * 100.0f) {
      return false;
    }

    int worldX = chunkX * 16;
    int worldZ = chunkZ * 16;

    BiomeGenBase biome = world.getBiomeGenForCoords(worldX, worldZ);
    EnumHumidity humidity = EnumHumidity.getFromValue(biome.rainfall);

    if (!hive.isGoodBiome(biome) || !hive.isGoodHumidity(humidity)) {
      return false;
    }

    for (int tries = 0; tries < 4; tries++) {
      int x = worldX + rand.nextInt(16);
      int z = worldZ + rand.nextInt(16);

      if (tryGenHive(world, x, z, hive)) {
        return true;
      }
    }

    return false;
  }
  /**
   * Generates Ore in a specific pattern
   *
   * @param only if true only the listed bioms else not the listed Bioms
   */
  public void generateIt(
      Random random,
      int chunkX,
      int chunkZ,
      World world,
      IChunkProvider chunkGenerator,
      IChunkProvider chunkProvider,
      Block ID,
      Block target,
      String[] bioms,
      boolean only,
      int tries) {

    boolean nosucsess;
    int trieCount = 0;
    BiomeGenBase b = world.getBiomeGenForCoords(chunkX, chunkZ);
    int yRandom;
    int zRandom;
    int xRandom;

    if (isBiom(bioms, b.biomeName) == only) {
      do {
        zRandom = random.nextInt(16);
        xRandom = random.nextInt(16);

        int S1 = world.getTopSolidOrLiquidBlock(xRandom + chunkX * 16, zRandom + chunkZ * 16);

        if (S1 > 19) {
          yRandom = random.nextInt(S1 - 19);
        } else {
          yRandom = 2;
        }

        int x = chunkX * 16 + xRandom;
        int y = yRandom;
        int z = chunkZ * 16 + zRandom;

        if (world.getBlock(x, y, z).isReplaceableOreGen(world, x, y, z, target)
            && world.getBlock(x, y - 1, z).isReplaceableOreGen(world, x, y - 1, z, target)
            && world.getBlock(x + 1, y, z).isReplaceableOreGen(world, x, y, z, target)
            && world.getBlock(x + 1, y - 1, z).isReplaceableOreGen(world, x, y, z, target)) {

          world.setBlock(x, y, z, ID);
          world.setBlock(x, y - 1, z, ID);
          world.setBlock(x + 1, y, z, ID);
          world.setBlock(x + 1, y - 1, z, ID);
          nosucsess = false;
          LogHelper.debug(
              "Generated " + ID.getLocalizedName() + " at " + " X: " + x + " Y: " + y + " Z: " + z);
        } else {
          nosucsess = true;
          trieCount++;
          LogHelper.debug("Had no sucess,try :" + trieCount + "/" + tries);
        }

      } while (nosucsess && trieCount < tries);
    }
  }
Exemple #10
0
  // 現在地のバイオームを確認。
  // 複数のクラスで利用するので、ここにまとめた。
  public static BiomeGenBase checkCurrentBiome(World world, EntityPlayer player) {
    BiomeGenBase biome = BiomeGenBase.plains;

    int x = MathHelper.floor_double(player.posX);
    int y = MathHelper.floor_double(player.posY);
    int z = MathHelper.floor_double(player.posZ);

    biome = world.getBiomeGenForCoords(x, z);

    return biome;
  }
  @Override
  public void generate(
      Random random,
      int chunkX,
      int chunkZ,
      World world,
      IChunkProvider chunkGenerator,
      IChunkProvider chunkProvider) {
    chunkX = chunkX << 4;
    chunkZ = chunkZ << 4;
    final BiomeGenBase biome = world.getBiomeGenForCoords(chunkX, chunkX);

    if (BiomeManager.marsh.isPresent() && biome == BiomeManager.marsh.get())
      generateMarsh(random, chunkX, chunkZ, world);
  }
  @Override
  public void randomDisplayTick(World world, int x, int y, int z, Random rand) {
    super.randomDisplayTick(world, x, y, z, rand);

    if (world.getTotalWorldTime() % 100 == 0
        && world.getBiomeGenForCoords(x, z) == AdvancedRocketryBiomes.stormLandsBiome) {
      FxSystemElectricArc.spawnArc(world, x + 0.5f, y + 0.5f, z + 0.5f, .3, 7);
      world.playSound(
          x,
          y,
          z,
          "advancedrocketry:ElectricShockSmall",
          .7f,
          0.975f + world.rand.nextFloat() * 0.05f,
          false);
    }
  }
  @Override
  public void updateTick(World world, int x, int y, int z, Random rand) {
    super.updateTick(world, x, y, z, rand);

    if (!world.isRemote
        && Configuration.electricPlantsSpawnLightning
        && world.isRaining()
        && world.getBiomeGenForCoords(x, z) == AdvancedRocketryBiomes.stormLandsBiome) {
      int lightningX = x + rand.nextInt(24) - 12;
      int lightningZ = z + rand.nextInt(24) - 12;
      world.addWeatherEffect(
          new EntityLightningBolt(
              world,
              lightningX,
              world.getTopSolidOrLiquidBlock(lightningX, lightningZ),
              lightningZ));
    }
  }
  private void decorateHivesDebug(World world, int chunkX, int chunkZ, List<Hive> hives) {
    int worldX = chunkX * 16;
    int worldZ = chunkZ * 16;
    BiomeGenBase biome = world.getBiomeGenForCoords(worldX, worldZ);
    EnumHumidity humidity = EnumHumidity.getFromValue(biome.rainfall);

    for (int x = 0; x < 16; x++) {
      for (int z = 0; z < 16; z++) {
        Collections.shuffle(hives, world.rand);
        for (Hive hive : hives) {
          if (!hive.isGoodBiome(biome) || !hive.isGoodHumidity(humidity)) {
            continue;
          }

          tryGenHive(world, worldX + x, worldZ + z, hive);
        }
      }
    }
  }
  private void convertToRainbowForest(World world, int x, int y, int z) {
    int rx = ReikaRandomHelper.getRandomPlusMinus(x, 32);
    int rz = ReikaRandomHelper.getRandomPlusMinus(z, 32);

    if (world.checkChunksExist(rx, 0, rz, rx, 255, rz)) {
      int r = 3;
      for (int i = -r; i <= r; i++) {
        for (int k = -r; k <= r; k++) {
          int dx = rx + i;
          int dz = rz + k;
          BiomeGenBase biome = world.getBiomeGenForCoords(dx, dz);
          int id = biome.biomeID;
          if (id != DyeTrees.forest.biomeID) {
            ReikaWorldHelper.setBiomeForXZ(world, dx, dz, DyeTrees.forest);
          }
        }
      }
    }
  }
  private void fightEerie(World world, int x, int y, int z) {
    int rx = ReikaRandomHelper.getRandomPlusMinus(x, 32);
    int rz = ReikaRandomHelper.getRandomPlusMinus(z, 32);

    if (world.checkChunksExist(rx, 0, rz, rx, 255, rz)) {
      int r = 3;
      for (int i = -r; i <= r; i++) {
        for (int k = -r; k <= r; k++) {
          int dx = rx + i;
          int dz = rz + k;
          BiomeGenBase biome = world.getBiomeGenForCoords(dx, dz);
          int id = biome.biomeID;
          if (id == ThaumBlockHandler.getInstance().eerieBiomeID) {
            BiomeGenBase natural = ReikaWorldHelper.getNaturalGennedBiomeAt(world, dx, dz);
            if (natural != null) {
              ReikaWorldHelper.setBiomeForXZ(world, dx, dz, natural);
            }
          }
        }
      }
    }
  }
  private void convertPureNodeMagic(World world, int x, int y, int z) {
    int rx = ReikaRandomHelper.getRandomPlusMinus(x, 64);
    int rz = ReikaRandomHelper.getRandomPlusMinus(z, 64);

    if (world.checkChunksExist(rx, 0, rz, rx, 255, rz)) {
      int r = 3;
      for (int i = -r; i <= r; i++) {
        for (int k = -r; k <= r; k++) {
          int dx = rx + i;
          int dz = rz + k;
          BiomeGenBase biome = world.getBiomeGenForCoords(dx, dz);
          int id = biome.biomeID;
          if (id == ThaumBlockHandler.getInstance().magicBiomeID) {
            BiomeGenBase natural = ReikaWorldHelper.getNaturalGennedBiomeAt(world, dx, dz);
            if (natural != null && DyeTrees.isRainbowForest(natural)) {
              ReikaWorldHelper.setBiomeForXZ(world, dx, dz, natural);
            }
          }
        }
      }
    }
  }
  @Override
  public HashMap getDetails(World world, Object obj, boolean additional) {

    Vec3 location = (Vec3) obj;

    HashMap response = new HashMap();

    int x = (int) location.xCoord;
    int y = (int) location.yCoord;
    int z = (int) location.zCoord;

    response.put("Dimension", world.getWorldInfo().getDimension());
    response.put("Biome", world.getBiomeGenForCoords(x, z).biomeName);
    response.put("LightLevel", world.getBlockLightValue(x, y, z));
    response.put("Raining", world.isRaining());
    response.put("Thundering", world.isThundering());
    response.put("Daytime", world.isDaytime());
    response.put("MoonPhase", world.getMoonPhase());
    response.put("CelestialAngle", world.getCelestialAngle(1.0F));

    return response;
  }
  private boolean tryGenHive(World world, int x, int z, Hive hive) {

    int y = hive.getYForHive(world, x, z);

    if (y < 0) {
      return false;
    }

    if (!hive.canReplace(world, x, y, z)) {
      return false;
    }

    BiomeGenBase biome = world.getBiomeGenForCoords(x, z);
    EnumTemperature temperature = EnumTemperature.getFromValue(biome.getFloatTemperature(x, y, z));
    if (!hive.isGoodTemperature(temperature)) {
      return false;
    }

    if (!hive.isValidLocation(world, x, y, z)) {
      return false;
    }

    return setHive(world, x, y, z, hive);
  }
 @Override
 protected boolean canPerform(World world, int x, int y, int z) {
   return y < MAXY
       && ReikaBiomeHelper.isOcean(world.getBiomeGenForCoords(x, z))
       && this.isOceanFloor(world, x, y, z);
 }
  @Override
  public void populate(int chunkX, int chunkZ) {
    BlockFalling.fallInstantly = true;

    int worldX = chunkX * 16;
    int worldZ = chunkZ * 16;
    BlockPos blockPos = new BlockPos(worldX, 0, worldZ);
    Biome biome = worldObj.getBiomeGenForCoords(blockPos.add(16, 0, 16));
    BiomeDecorator decorator = biome.theBiomeDecorator;
    int worldHeight = worldObj.provider.getActualHeight();

    ForgeEventFactory.onChunkPopulate(true, this, worldObj, rand, chunkX, chunkZ, false);

    int x, y, z;

    if (CavelandConfig.generateLakes) {
      if (TerrainGen.populate(this, worldObj, rand, chunkX, chunkZ, false, EventType.LAKE)) {
        x = rand.nextInt(16) + 8;
        y = rand.nextInt(worldHeight - 16);
        z = rand.nextInt(16) + 8;

        lakeWaterGen.generate(worldObj, rand, blockPos.add(x, y, z));
      }

      if (rand.nextInt(30) == 0
          && TerrainGen.populate(this, worldObj, rand, chunkX, chunkZ, false, EventType.LAVA)) {
        x = rand.nextInt(16) + 8;
        y = rand.nextInt(worldHeight / 2);
        z = rand.nextInt(16) + 8;

        lakeLavaGen.generate(worldObj, rand, blockPos.add(x, y, z));
      }
    }

    MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Pre(worldObj, rand, blockPos));

    MinecraftForge.ORE_GEN_BUS.post(new OreGenEvent.Pre(worldObj, rand, blockPos));

    for (CaveVein vein : CavelandConfig.veinManager.getCaveVeins()) {
      vein.generateVeins(worldObj, rand, blockPos);
    }

    MinecraftForge.ORE_GEN_BUS.post(new OreGenEvent.Post(worldObj, rand, blockPos));

    for (int i = 0; i < 10; ++i) {
      x = rand.nextInt(16) + 8;
      y = rand.nextInt(worldHeight - 10);
      z = rand.nextInt(16) + 8;

      acresiaGen.generate(worldObj, rand, blockPos.add(x, y, z));
    }

    for (int i = 0; i < 15; ++i) {
      x = rand.nextInt(16) + 8;
      y = rand.nextInt(worldHeight / 2 - 10) + worldHeight / 2;
      z = rand.nextInt(16) + 8;

      acresiaGen.generate(worldObj, rand, blockPos.add(x, y, z));
    }

    if (TerrainGen.decorate(worldObj, rand, blockPos, Decorate.EventType.SHROOM)) {
      for (int i = 0; i < 5; ++i) {
        x = rand.nextInt(16) + 8;
        y = rand.nextInt(worldHeight - 10);
        z = rand.nextInt(16) + 8;

        decorator.mushroomBrownGen.generate(worldObj, rand, blockPos.add(x, y, z));
      }

      for (int i = 0; i < 5; ++i) {
        x = rand.nextInt(16) + 8;
        y = rand.nextInt(worldHeight - 10);
        z = rand.nextInt(16) + 8;

        decorator.mushroomRedGen.generate(worldObj, rand, blockPos.add(x, y, z));
      }
    }

    if (BiomeDictionary.isBiomeOfType(biome, Type.SANDY)) {
      if (TerrainGen.decorate(worldObj, rand, blockPos, Decorate.EventType.CACTUS)) {
        for (int i = 0; i < 80; ++i) {
          x = rand.nextInt(16) + 8;
          y = rand.nextInt(worldHeight - 5);
          z = rand.nextInt(16) + 8;

          decorator.cactusGen.generate(worldObj, rand, blockPos.add(x, y, z));
        }
      }

      if (TerrainGen.decorate(worldObj, rand, blockPos, Decorate.EventType.DEAD_BUSH)) {
        for (int i = 0; i < 10; ++i) {
          x = rand.nextInt(16) + 8;
          y = rand.nextInt(worldHeight - 5);
          z = rand.nextInt(16) + 8;

          deadBushGen.generate(worldObj, rand, blockPos.add(x, y, z));
        }
      }
    } else {
      if (TerrainGen.decorate(worldObj, rand, blockPos, Decorate.EventType.FLOWERS)) {
        for (int i = 0; i < 8; ++i) {
          x = rand.nextInt(16) + 8;
          y = rand.nextInt(worldHeight - 5);
          z = rand.nextInt(16) + 8;

          decorator.yellowFlowerGen.generate(worldObj, rand, blockPos.add(x, y, z));
        }
      }

      for (int i = 0; i < 18; ++i) {
        x = rand.nextInt(16) + 8;
        y = rand.nextInt(worldHeight - 5);
        z = rand.nextInt(16) + 8;

        biome.getRandomWorldGenForGrass(rand).generate(worldObj, rand, blockPos.add(x, y, z));
      }

      if (TerrainGen.decorate(worldObj, rand, blockPos, Decorate.EventType.TREE)) {
        WorldGenAbstractTree treeGen = null;

        if (BiomeDictionary.isBiomeOfType(biome, Type.JUNGLE)) {
          treeGen =
              new WorldGenTreesPerverted(
                  false, 4 + rand.nextInt(7), BlockPlanks.EnumType.JUNGLE, true);
        } else if (BiomeDictionary.isBiomeOfType(biome, Type.FOREST)
            || !BiomeDictionary.isBiomeOfType(biome, Type.PLAINS)
            || rand.nextInt(10) == 0) {
          if (BiomeDictionary.isBiomeOfType(biome, Type.COLD)) {
            treeGen = new WorldGenSpruceTreePerverted(false);
          } else if (rand.nextInt(3) == 0) {
            treeGen = new WorldGenBirchTreePerverted(false, false);
          } else {
            treeGen = new WorldGenTreesPerverted(false, 3, BlockPlanks.EnumType.OAK, true);
          }
        }

        if (treeGen != null) {
          for (int i = 0; i < 80; ++i) {
            x = rand.nextInt(16) + 8;
            y = rand.nextInt(worldHeight);
            z = rand.nextInt(16) + 8;

            BlockPos pos = blockPos.add(x, y, z);

            if (treeGen.generate(worldObj, rand, pos)) {
              treeGen.generateSaplings(worldObj, rand, pos);
            }
          }

          for (int i = 0; i < 60; ++i) {
            x = rand.nextInt(16) + 8;
            y = 8 + rand.nextInt(5);
            z = rand.nextInt(16) + 8;

            BlockPos pos = blockPos.add(x, y, z);

            if (treeGen.generate(worldObj, rand, pos)) {
              treeGen.generateSaplings(worldObj, rand, pos);
            }
          }
        }
      }

      if (decorator.generateLakes) {
        if (BiomeDictionary.isBiomeOfType(biome, Type.WATER)) {
          if (TerrainGen.decorate(worldObj, rand, blockPos, Decorate.EventType.LAKE_WATER)) {
            for (int i = 0; i < 150; ++i) {
              x = rand.nextInt(16) + 8;
              y = rand.nextInt(rand.nextInt(worldHeight - 16) + 10);
              z = rand.nextInt(16) + 8;

              liquidWaterGen.generate(worldObj, rand, blockPos.add(x, y, z));
            }
          }
        } else {
          if (TerrainGen.decorate(worldObj, rand, blockPos, Decorate.EventType.LAKE_WATER)) {
            for (int i = 0; i < 100; ++i) {
              x = rand.nextInt(16) + 8;
              y = rand.nextInt(rand.nextInt(worldHeight - 16) + 10);
              z = rand.nextInt(16) + 8;

              liquidWaterGen.generate(worldObj, rand, blockPos.add(x, y, z));
            }
          }

          if (TerrainGen.decorate(worldObj, rand, blockPos, Decorate.EventType.LAKE_LAVA)) {
            for (int i = 0; i < 20; ++i) {
              x = rand.nextInt(16) + 8;
              y = rand.nextInt(worldHeight / 2);
              z = rand.nextInt(16) + 8;

              liquidLavaGen.generate(worldObj, rand, blockPos.add(x, y, z));
            }
          }
        }
      }
    }

    MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Post(worldObj, rand, blockPos));

    ForgeEventFactory.onChunkPopulate(false, this, worldObj, rand, chunkX, chunkZ, false);

    BlockFalling.fallInstantly = false;
  }
  public void generate(int i, int k) {
    int volcCenterX = i;
    int volcCenterZ = k;
    int steepnessMod =
        worldObj.getBiomeGenForCoords(i, k) == BiomeGenTropicraft.tropics
            ? LAND_STEEPNESS_MOD
            : OCEAN_STEEPNESS_MOD;

    long seed =
        (long) volcCenterX * 341873128712L
            + (long) volcCenterZ * 132897987541L
            + worldObj.getWorldInfo().getSeed()
            + (long) 4291726;
    Random rand = new Random(seed);

    int radiusX = rand.nextInt(MAX_RADIUS - MIN_RADIUS) + MIN_RADIUS;
    int radiusZ = rand.nextInt(MAX_RADIUS - MIN_RADIUS) + MIN_RADIUS;

    int[] heightmap = new int[(radiusX * 2) * (radiusZ * 2)];

    // System.out.println(radius);

    for (int x = -radiusX; x < radiusX; x++) {
      for (int z = -radiusZ; z < radiusZ; z++) {
        for (int y = 127; y > 0; y--) {
          int blockID = getBlock(x + i, y, z + k, null);
          if (blockID == Block.sand.blockID
              || blockID == Block.dirt.blockID
              || blockID == Block.grass.blockID) {
            heightmap[(x + radiusX) * (radiusZ * 2) + (z + radiusZ)] = y;
            break;
          }
          if (y < 30) {
            heightmap[(x + radiusX) * (radiusZ * 2) + (z + radiusZ)] = y;
            break;
          }
        }
      }
    }

    NoiseModule volcNoise = new Gradient(seed, 1, 1);
    volcNoise.amplitude = 0.6;
    for (int x = -radiusX; x < radiusX; x++) {
      for (int z = -radiusZ; z < radiusZ; z++) {
        float relativeX = ((x + i) - volcCenterX);
        float relativeZ = ((z + k) - volcCenterZ);

        float distanceSquared =
            ((relativeX / radiusX) * (relativeX / radiusX)
                + (relativeZ / radiusZ) * (relativeZ / radiusZ));

        float perlin =
            (float) volcNoise.getNoise(relativeX * 0.05 + 0.0001, relativeZ * 0.05 + 0.0001) + 1;
        double volcanoHeight = steepnessMod / (distanceSquared) * perlin - steepnessMod - 1;
        int groundHeight = heightmap[(x + radiusX) * (radiusZ * 2) + (z + radiusZ)];
        if (distanceSquared < 1) {
          for (int y = CHUNK_SIZE_Y; y > 0; y--) {
            if (volcanoHeight + groundHeight < CALDERA_CUTOFF) {
              if (volcanoHeight + groundHeight <= VOLCANO_TOP) {
                if (y <= volcanoHeight + groundHeight && y >= groundHeight) {
                  placeBlock(x + i, y, z + k, TropicraftBlocks.chunkOHead.blockID, null);
                }
              } else {
                if (y <= VOLCANO_TOP) {
                  placeBlock(x + i, y, z + k, TropicraftBlocks.chunkOHead.blockID, null);
                }
              }
            } else {
              if (y == VOLCANO_CRUST && rand.nextInt(CRUST_HOLE_CHANCE) != 0) {
                placeBlock(x + i, y, z + k, TropicraftBlocks.chunkOHead.blockID, null);
              }
              if (y <= LAVA_LEVEL) {
                placeBlock(x + i, y, z + k, Block.lavaStill.blockID, null);
              }
            }
          }
        }
      }
    }
    System.out.println("Done");
  }
  /**
   * second Part of Structure generating, this for example places Spiderwebs, Mob Spawners, it
   * closes Mineshafts at the end, it adds Fences...
   */
  public boolean addComponentParts(
      World par1World, Random par2Random, StructureBoundingBox par3StructureBoundingBox) {
    BiomeGenBase biomegenbase =
        par1World.getBiomeGenForCoords(this.getXWithOffset(3, 5), this.getZWithOffset(3, 5));
    this.fillWithBlocks(
        par1World,
        par3StructureBoundingBox,
        -1,
        -1,
        0,
        5,
        5,
        6,
        Block.stone.blockID,
        Block.stone.blockID,
        false);
    this.fillWithBlocks(
        par1World,
        par3StructureBoundingBox,
        -1,
        5,
        0,
        5,
        5,
        6,
        biomegenbase.topBlock,
        biomegenbase.topBlock,
        false);
    this.fillWithRandomizedBlocks(
        par1World,
        par3StructureBoundingBox,
        0,
        0,
        0,
        4,
        4,
        6,
        false,
        par2Random,
        StructureSkyStrongholdPieces.getStrongholdStones());
    this.placeDoor(par1World, par2Random, par3StructureBoundingBox, this.doorType, 1, 1, 0);
    this.placeDoor(par1World, par2Random, par3StructureBoundingBox, EnumDoor.OPENING, 1, 1, 6);
    this.fillWithBlocks(
        par1World,
        par3StructureBoundingBox,
        3,
        1,
        2,
        3,
        1,
        4,
        Block.stoneBrick.blockID,
        Block.stoneBrick.blockID,
        false);
    this.placeBlockAtCurrentPosition(
        par1World, Block.stoneSingleSlab.blockID, 5, 3, 1, 1, par3StructureBoundingBox);
    this.placeBlockAtCurrentPosition(
        par1World, Block.stoneSingleSlab.blockID, 5, 3, 1, 5, par3StructureBoundingBox);
    this.placeBlockAtCurrentPosition(
        par1World, Block.stoneSingleSlab.blockID, 5, 3, 2, 2, par3StructureBoundingBox);
    this.placeBlockAtCurrentPosition(
        par1World, Block.stoneSingleSlab.blockID, 5, 3, 2, 4, par3StructureBoundingBox);
    int i;

    for (i = 2; i <= 4; ++i) {
      this.placeBlockAtCurrentPosition(
          par1World, Block.stoneSingleSlab.blockID, 5, 2, 1, i, par3StructureBoundingBox);
    }

    if (!this.hasMadeChest) {
      i = this.getYWithOffset(2);
      int j = this.getXWithOffset(3, 3);
      int k = this.getZWithOffset(3, 3);

      if (par3StructureBoundingBox.isVecInside(j, i, k)) {
        this.hasMadeChest = true;
        this.generateStructureChestContents(
            par1World,
            par3StructureBoundingBox,
            par2Random,
            3,
            2,
            3,
            ChestGenHooks.getItems(STRONGHOLD_CORRIDOR, par2Random),
            ChestGenHooks.getCount(STRONGHOLD_CORRIDOR, par2Random));
      }
    }
    return true;
  }
  public void spawnStructure(String type, Vector3f pos) throws ScriptErrorException {
    final Chunk chk = _world.getChunkFromBlockCoords((int) pos.getX(), (int) pos.getZ());
    BiomeGenBase biome = _world.getBiomeGenForCoords((int) pos.getX(), (int) pos.getZ());
    if (type.toLowerCase() == "village") {
      if (MapGenVillage.villageSpawnBiomes instanceof AbstractList) {
        MapGenVillage.villageSpawnBiomes = new ArrayList(MapGenVillage.villageSpawnBiomes);
      }
      boolean added = false;
      if (!MapGenVillage.villageSpawnBiomes.contains(biome)) {
        MapGenVillage.villageSpawnBiomes.add(biome);
        added = true;
      }
      MapGenVillage vilGen =
          new MapGenVillage() {
            @Override
            protected boolean canSpawnStructureAtCoords(int par1, int par2) {
              return par1 == chk.xPosition && par2 == chk.zPosition;
            }
          };
      vilGen.generate(
          _world.getChunkProvider(), _world, chk.xPosition, chk.zPosition, new byte[] {});
      for (int var11 = chk.xPosition - 8; var11 <= chk.xPosition + 8; ++var11) {
        for (int var12 = chk.zPosition - 8; var12 <= chk.zPosition + 8; ++var12) {
          vilGen.generateStructuresInChunk(_world, _world.rand, var11, var12);
        }
      }
      if (added) {
        MapGenVillage.villageSpawnBiomes.remove(biome);
      }
    } else if (type.toLowerCase() == "stronghold") {
      if (MapGenStronghold.allowedBiomes instanceof AbstractList) {
        MapGenStronghold.allowedBiomes = new ArrayList(MapGenStronghold.allowedBiomes);
      }
      boolean added = false;
      if (!MapGenStronghold.allowedBiomes.contains(biome)) {
        MapGenStronghold.allowedBiomes.add(biome);
        added = true;
      }
      MapGenStronghold strGen =
          new MapGenStronghold() {
            @Override
            protected boolean canSpawnStructureAtCoords(int par1, int par2) {
              return par1 == chk.xPosition && par2 == chk.zPosition;
            }

            @Override
            protected List getCoordList() {
              return new ArrayList();
            }
          };
      strGen.generate(
          _world.getChunkProvider(), _world, chk.xPosition, chk.zPosition, new byte[] {});
      for (int var11 = chk.xPosition - 8; var11 <= chk.xPosition + 8; ++var11) {
        for (int var12 = chk.zPosition - 8; var12 <= chk.zPosition + 8; ++var12) {
          strGen.generateStructuresInChunk(_world, _world.rand, var11, var12);
        }
      }
      if (added) {
        MapGenStronghold.allowedBiomes.remove(biome);
      }
    } else if (type.toLowerCase() == "netherfort") {
      MapGenNetherBridge strGen =
          new MapGenNetherBridge() {
            @Override
            protected boolean canSpawnStructureAtCoords(int par1, int par2) {
              return par1 == chk.xPosition && par2 == chk.zPosition;
            }

            @Override
            protected List getCoordList() {
              return new ArrayList();
            }
          };
      strGen.generate(
          _world.getChunkProvider(), _world, chk.xPosition, chk.zPosition, new byte[] {});
      for (int var11 = chk.xPosition - 8; var11 <= chk.xPosition + 8; ++var11) {
        for (int var12 = chk.zPosition - 8; var12 <= chk.zPosition + 8; ++var12) {
          strGen.generateStructuresInChunk(_world, _world.rand, var11, var12);
        }
      }
    } else {
      // no mineshafts sorry, it has the bad tendancy to crash the client
      throw new ScriptErrorException("type needs to be village, stronghold or mineshaft");
    }
  }
 @Override
 public boolean areCoordsValidForGeneration(World world, BlockPos pos, Random rand) {
   if (!(world.getBiomeGenForCoords(pos) instanceof BiomeGenFrozenTundra) || pos.getY() < 36)
     return false;
   return super.areCoordsValidForGeneration(world, pos, rand) && this.getRarity(200);
 }
 public String getBiome(Vector3f pos) {
   return _world.getBiomeGenForCoords((int) pos.getX(), (int) pos.getZ()).biomeName;
 }
  @Override
  public List<SpawnListEntry> getPossibleCreatures(EnumCreatureType creatureType, BlockPos pos) {
    Biome biome = worldObj.getBiomeGenForCoords(pos);

    return biome.getSpawnableList(creatureType);
  }
  public void generateSurface(World world, Random random, int chunkX, int chunkZ) {

    if (AbyssalCraft.generateDarklandsStructures) {
      for (int k = 0; k < 2; k++) {
        int RandPosX = chunkX + random.nextInt(5);
        int RandPosY = random.nextInt(75);
        int RandPosZ = chunkZ + random.nextInt(5);
        new AChouse1().generate(world, random, new BlockPos(RandPosX, RandPosY, RandPosZ));
      }

      for (int k = 0; k < 2; k++) {
        int RandPosX = chunkX + random.nextInt(5);
        int RandPosY = random.nextInt(75);
        int RandPosZ = chunkZ + random.nextInt(5);
        new AChouse2().generate(world, random, new BlockPos(RandPosX, RandPosY, RandPosZ));
      }

      for (int k = 0; k < 2; k++) {
        int RandPosX = chunkX + random.nextInt(5);
        int RandPosY = random.nextInt(75);
        int RandPosZ = chunkZ + random.nextInt(5);
        new ACplatform1().generate(world, random, new BlockPos(RandPosX, RandPosY, RandPosZ));
      }

      for (int k = 0; k < 2; k++) {
        int RandPosX = chunkX + random.nextInt(5);
        int RandPosY = random.nextInt(75);
        int RandPosZ = chunkZ + random.nextInt(5);
        new ACplatform2().generate(world, random, new BlockPos(RandPosX, RandPosY, RandPosZ));
      }

      for (int k = 0; k < 2; k++) {
        int RandPosX = chunkX + random.nextInt(5);
        int RandPosY = random.nextInt(75);
        int RandPosZ = chunkZ + random.nextInt(5);
        new ACscion1().generate(world, random, new BlockPos(RandPosX, RandPosY, RandPosZ));
      }

      for (int k = 0; k < 2; k++) {
        int RandPosX = chunkX + random.nextInt(5);
        int RandPosY = random.nextInt(75);
        int RandPosZ = chunkZ + random.nextInt(5);
        new ACscion2().generate(world, random, new BlockPos(RandPosX, RandPosY, RandPosZ));
      }
    }

    if (AbyssalCraft.generateCoraliumOre) {
      for (int rarity = 0; rarity < 3; rarity++) {
        int veinSize = 2 + random.nextInt(2);
        int x = chunkX + random.nextInt(16);
        int y = random.nextInt(40);
        int z = chunkZ + random.nextInt(16);
        if (BiomeDictionary.isBiomeOfType(
            world.getBiomeGenForCoords(new BlockPos(x, 0, z)), Type.SWAMP))
          new WorldGenMinable(ACBlocks.coralium_ore.getDefaultState(), veinSize)
              .generate(world, random, new BlockPos(x, y, z));
      }

      for (int rarity = 0; rarity < 6; rarity++) {
        int veinSize = 4 + random.nextInt(2);
        int x = chunkX + random.nextInt(16);
        int y = random.nextInt(40);
        int z = chunkZ + random.nextInt(16);
        if (BiomeDictionary.isBiomeOfType(
                world.getBiomeGenForCoords(new BlockPos(x, 0, z)), Type.OCEAN)
            && world.getBiomeGenForCoords(new BlockPos(x, 0, z)) != Biomes.DEEP_OCEAN)
          new WorldGenMinable(ACBlocks.coralium_ore.getDefaultState(), veinSize)
              .generate(world, random, new BlockPos(x, y, z));
        if (world.getBiomeGenForCoords(new BlockPos(x, 0, z)) == Biomes.DEEP_OCEAN)
          new WorldGenMinable(ACBlocks.coralium_ore.getDefaultState(), veinSize)
              .generate(world, random, new BlockPos(x, y - 20, z));
      }
    }

    if (AbyssalCraft.generateNitreOre)
      for (int rarity = 0; rarity < 3; rarity++) {
        int veinSize = 4 + random.nextInt(2);
        int x = chunkX + random.nextInt(16);
        int y = random.nextInt(30);
        int z = chunkZ + random.nextInt(16);

        new WorldGenMinable(ACBlocks.nitre_ore.getDefaultState(), veinSize)
            .generate(world, random, new BlockPos(x, y, z));
      }

    if (AbyssalCraft.generateShoggothLairs)
      for (int i = 0; i < 1; i++) {
        int x = chunkX + random.nextInt(16);
        int z = chunkZ + random.nextInt(16);
        if (BiomeDictionary.isBiomeOfType(
                world.getBiomeGenForCoords(new BlockPos(x, 0, z)), Type.SWAMP)
            || BiomeDictionary.isBiomeOfType(
                    world.getBiomeGenForCoords(new BlockPos(x, 0, z)), Type.RIVER)
                && !BiomeDictionary.isBiomeOfType(
                    world.getBiomeGenForCoords(new BlockPos(x, 0, z)), Type.OCEAN))
          if (random.nextInt(100) == 0)
            new StructureShoggothPit()
                .generate(world, random, world.getHeight(new BlockPos(x, 0, z)));
      }
  }
  @Override
  public boolean displaceIfPossible(World world, BlockPos pos) {

    if (!world.isRemote) {
      if (!world.provider.isSurfaceWorld()) {
        if (world.getBlockState(pos).getBlock() == Blocks.WATER
            && AbyssalCraft.shouldSpread == false) return false;
        if (world.getBlockState(pos).getMaterial().isLiquid()
            && world.getBlockState(pos).getBlock() != this
            && world.getBlockState(pos).getBlock() != ACBlocks.liquid_antimatter)
          world.setBlockState(pos, getDefaultState());
        if (AbyssalCraft.breakLogic == true
            && world
                .getBlockState(new BlockPos(pos.getX(), pos.getY() + 1, pos.getZ()))
                .getMaterial()
                .isLiquid()
            && world.getBlockState(new BlockPos(pos.getX(), pos.getY() + 1, pos.getZ())).getBlock()
                != this
            && world.getBlockState(new BlockPos(pos.getX(), pos.getY() + 1, pos.getZ())).getBlock()
                != ACBlocks.liquid_antimatter)
          world.setBlockState(
              new BlockPos(pos.getX(), pos.getY() + 1, pos.getZ()), getDefaultState());
      } else {
        if (BiomeDictionary.isBiomeOfType(world.getBiomeGenForCoords(pos), Type.OCEAN)
            && world.getBlockState(pos).getBlock() == this)
          if (AbyssalCraft.destroyOcean) world.setBlockState(pos, getDefaultState());
          else world.setBlockState(pos, Blocks.COBBLESTONE.getDefaultState());

        if (AbyssalCraft.shouldSpread) {
          if (world.getBlockState(pos).getMaterial().isLiquid()
              && world.getBlockState(pos).getBlock() != this
              && world.getBlockState(pos).getBlock() != ACBlocks.liquid_antimatter)
            world.setBlockState(pos, getDefaultState());
          if (AbyssalCraft.breakLogic == true
              && world
                  .getBlockState(new BlockPos(pos.getX(), pos.getY() + 1, pos.getZ()))
                  .getMaterial()
                  .isLiquid()
              && world
                      .getBlockState(new BlockPos(pos.getX(), pos.getY() + 1, pos.getZ()))
                      .getBlock()
                  != this
              && world
                      .getBlockState(new BlockPos(pos.getX(), pos.getY() + 1, pos.getZ()))
                      .getBlock()
                  != ACBlocks.liquid_antimatter)
            world.setBlockState(
                new BlockPos(pos.getX(), pos.getY() + 1, pos.getZ()), getDefaultState());
        }
      }
      if (dusts.contains(world.getBlockState(pos))
          && world.getBlockState(pos) != ACBlocks.abyssal_nitre_ore.getDefaultState()
          && world.getBlockState(pos) != ACBlocks.abyssal_coralium_ore)
        if (oresToBlocks(OreDictionary.getOres("oreSaltpeter")).contains(world.getBlockState(pos)))
          world.setBlockState(pos, ACBlocks.abyssal_nitre_ore.getDefaultState());
        else world.setBlockState(pos, ACBlocks.abyssal_coralium_ore.getDefaultState());
      else if (metalloids.contains(world.getBlockState(pos))
          && !metals.contains(world.getBlockState(pos)))
        if (oresToBlocks(OreDictionary.getOres("oreIron")).contains(world.getBlockState(pos)))
          world.setBlockState(pos, ACBlocks.abyssal_iron_ore.getDefaultState());
        else if (oresToBlocks(OreDictionary.getOres("oreGold")).contains(world.getBlockState(pos)))
          world.setBlockState(pos, ACBlocks.abyssal_gold_ore.getDefaultState());
        else if (oresToBlocks(OreDictionary.getOres("oreTin")).contains(world.getBlockState(pos)))
          world.setBlockState(pos, ACBlocks.abyssal_tin_ore.getDefaultState());
        else if (oresToBlocks(OreDictionary.getOres("oreCopper"))
            .contains(world.getBlockState(pos)))
          world.setBlockState(pos, ACBlocks.abyssal_copper_ore.getDefaultState());
        else world.setBlockState(pos, ACBlocks.liquified_coralium_ore.getDefaultState());
      else if (gems.contains(world.getBlockState(pos))
          && world.getBlockState(pos) != ACBlocks.abyssal_diamond_ore.getDefaultState())
        if (oresToBlocks(OreDictionary.getOres("oreDiamond")).contains(world.getBlockState(pos)))
          world.setBlockState(pos, ACBlocks.abyssal_diamond_ore.getDefaultState());
        else world.setBlockState(pos, ACBlocks.pearlescent_coralium_ore.getDefaultState());
      else if (stones.contains(world.getBlockState(pos)))
        if (BiomeDictionary.isBiomeOfType(world.getBiomeGenForCoords(pos), Type.OCEAN)) {
          if (world.getBlockState(pos).getBlock() != Blocks.COBBLESTONE)
            world.setBlockState(pos, ACBlocks.abyssal_stone.getDefaultState());
        } else world.setBlockState(pos, ACBlocks.abyssal_stone.getDefaultState());
      else if (bricks.contains(world.getBlockState(pos)))
        world.setBlockState(pos, ACBlocks.abyssal_stone_brick.getDefaultState());
    }
    return super.displaceIfPossible(world, pos);
  }
  @Override
  public boolean generate(World world, Random rand, BlockPos start) {
    int widthOff = width / 2;
    start = new BlockPos(start.getX() - widthOff, start.getY(), start.getZ() - widthOff);

    int heightOff = height / 2 + 1;

    while (start.getY() > heightOff && world.isAirBlock(start))
      start = new BlockPos(start.getX(), start.getY() - 1, start.getZ());
    --heightOff;
    if (start.getY() <= heightOff) return false;

    start = new BlockPos(start.getX(), start.getY() - heightOff, start.getZ());
    boolean[] spawnBlock = new boolean[width * width * height];

    int W = width - 1, H = height - 1;

    for (int i = 0, e = rand.nextInt(4) + 4; i < e; ++i) {
      double xSize = rand.nextDouble() * 6.0D + 3.0D;
      double ySize = rand.nextDouble() * 4.0D + 2.0D;
      double zSize = rand.nextDouble() * 6.0D + 3.0D;
      double xCenter = rand.nextDouble() * (width - xSize - 2.0D) + 1.0D + xSize / 2.0D;
      double yCenter = rand.nextDouble() * (height - ySize - 4.0D) + 2.0D + ySize / 2.0D;
      double zCenter = rand.nextDouble() * (width - zSize - 2.0D) + 1.0D + zSize / 2.0D;

      for (int x = 1; x < W; ++x) {
        for (int z = 1; z < W; ++z) {
          for (int y = 1; y < H; ++y) {
            double xDist = (x - xCenter) / (xSize / 2.0D);
            double yDist = (y - yCenter) / (ySize / 2.0D);
            double zDist = (z - zCenter) / (zSize / 2.0D);
            double dist = xDist * xDist + yDist * yDist + zDist * zDist;

            if (dist < 1.0D) spawnBlock[(x * width + z) * height + y] = true;
          }
        }
      }
    }

    int x;
    int y;
    int z;

    for (x = 0; x < width; ++x) {
      for (z = 0; z < width; ++z) {
        for (y = 0; y < height; ++y) {
          boolean flag =
              spawnBlock[(x * width + z) * height + y]
                  || ((x < W && spawnBlock[((x + 1) * width + z) * height + y])
                      || (x > 0 && spawnBlock[((x - 1) * width + z) * height + y])
                      || (z < W && spawnBlock[(x * width + (z + 1)) * height + y])
                      || (z > 0 && spawnBlock[(x * width + (z - 1)) * height + y])
                      || (y < H && spawnBlock[(x * width + z) * height + (y + 1)])
                      || (y > 0 && spawnBlock[(x * width + z) * height + (y - 1)]));

          if (flag) {
            if (y >= heightOff) {
              BlockPos pos = new BlockPos(start.getX() + x, start.getY() + y, start.getZ() + z);
              Material material = world.getBlockState(pos).getBlock().getMaterial();
              if (material.isLiquid()) return false;
            } else {
              if (!canGenerateInBlock(
                  world, start.getX() + x, start.getY() + y, start.getZ() + z, genBlock)) {
                return false;
              }
            }
          }
        }
      }
    }

    for (x = 0; x < width; ++x) {
      for (z = 0; z < width; ++z) {
        for (y = 0; y < height; ++y) {
          if (spawnBlock[(x * width + z) * height + y]) {
            if (y < heightOff)
              generateBlock(
                  world, start.getX() + x, start.getY() + y, start.getZ() + z, genBlock, cluster);
            else if (canGenerateInBlock(
                world, start.getX() + x, start.getY() + y, start.getZ() + z, genBlock))
              generateBlock(world, start.getX() + x, start.getY() + y, start.getZ() + z, gapBlock);
          }
        }
      }
    }

    for (x = 0; x < width; ++x) {
      for (z = 0; z < width; ++z) {
        for (y = 0; y < height; ++y) {
          if (spawnBlock[(x * width + z) * height + y]
              && world
                  .getBlockState(
                      new BlockPos(start.getX() + x, start.getY() + y - 1, start.getZ() + z))
                  .getBlock()
                  .equals(Blocks.dirt)
              && world
                      .getBlockState(
                          new BlockPos(start.getX() + x, start.getY() + y, start.getZ() + z))
                      .getBlock()
                      .getLightValue()
                  > 0) {
            BiomeGenBase bgb =
                world.getBiomeGenForCoords(new BlockPos(start.getX() + x, 0, start.getZ() + z));
            // world.setBlock(start.getX() + x, start.getY() + y - 1, start.getZ() + z,
            // bgb.topBlock, bgb.field_150604_aj, 2);
            world.setBlockState(
                new BlockPos(start.getX() + x, start.getY() + y - 1, start.getZ() + z),
                bgb.topBlock
                    .getBlock()
                    .getStateFromMeta(bgb.topBlock.getBlock().getMetaFromState(bgb.topBlock)));
          }
        }
      }
    }

    if (outlineBlock != null) {
      for (x = 0; x < width; ++x) {
        for (z = 0; z < width; ++z) {
          for (y = 0; y < height; ++y) {
            boolean flag =
                !spawnBlock[(x * width + z) * height + y]
                    && ((x < W && spawnBlock[((x + 1) * width + z) * height + y])
                        || (x > 0 && spawnBlock[((x - 1) * width + z) * height + y])
                        || (z < W && spawnBlock[(x * width + (z + 1)) * height + y])
                        || (z > 0 && spawnBlock[(x * width + (z - 1)) * height + y])
                        || (y < H && spawnBlock[(x * width + z) * height + (y + 1)])
                        || (y > 0 && spawnBlock[(x * width + z) * height + (y - 1)]));

            if (flag
                && (solidOutline | y < heightOff || rand.nextInt(2) != 0)
                && (totalOutline
                    || world
                        .getBlockState(
                            new BlockPos(start.getX() + x, start.getY() + y, start.getZ() + z))
                        .getBlock()
                        .getMaterial()
                        .isSolid())) {
              generateBlock(
                  world, start.getX() + x, start.getY() + y, start.getZ() + z, outlineBlock);
            }
          }
        }
      }
    }
    System.out.println("gen at " + start.getX() + "," + start.getY() + "," + start.getZ());
    return true;
  }