class="kw">package com.hypixel.hytale.server.core.universe.world.worldgen.provider;

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.codec.validation.validator.RangeRefValidator;
class="kw">import com.hypixel.hytale.math.vector.Transform;
class="kw">import com.hypixel.hytale.protocol.Color;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
class="kw">import com.hypixel.hytale.server.core.asset.util.ColorParseUtil;
class="kw">import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.GeneratedBlockChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.GeneratedChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.GeneratedEntityChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.IWorldGen;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.WorldGenLoadException;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.WorldGenTimingsCollector;
class="kw">import it.unimi.dsi.fastutil.longs.Long2FloatFunction;
class="kw">import java.util.Arrays;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.function.LongPredicate;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class FlatWorldGenProvider class="kw">implements IWorldGenProvider {
   class="kw">public class="kw">static class="kw">final String ID = "Flat";
   class="kw">public class="kw">static class="kw">final BuilderCodec<FlatWorldGenProvider> CODEC = BuilderCodec.<FlatWorldGenProvider>builder(
         FlatWorldGenProvider.class, FlatWorldGenProvider::new
      )
      .documentation("A world generation provider that generates a flat world with defined layers.")
      .<Color>append(new KeyedCodec<>("Tint", ProtocolCodecs.COLOR), (var0, var1) -> var0.tint = var1, var0 -> var0.tint)
      .documentation("The tint to set for all chunks that are generated.")
      .add()
      .<FlatWorldGenProvider.Layer[]>append(
         new KeyedCodec<>("Layers", new ArrayCodec<>(FlatWorldGenProvider.Layer.CODEC, FlatWorldGenProvider.Layer[]::new)),
         (var0, var1) -> var0.layers = var1,
         var0 -> var0.layers
      )
      .documentation("The list of layers to add to the world.")
      .addValidator(Validators.nonNull())
      .add()
      .build();
   class="kw">public class="kw">static class="kw">final Color DEFAULT_TINT = new Color((byte)91, (byte)-98, (byte)40);
   class="kw">private Color tint = DEFAULT_TINT;
   class="kw">private FlatWorldGenProvider.Layer[] layers;

   class="kw">public FlatWorldGenProvider() {
      this.layers = new FlatWorldGenProvider.Layer[]{new FlatWorldGenProvider.Layer(0, 1, Environment.UNKNOWN.getId(), "Soil_Grass")};
   }

   class="kw">public FlatWorldGenProvider(Color var1, FlatWorldGenProvider.Layer[] var2) {
      this.tint = var1;
      this.layers = var2;
   }

   @Nonnull
   @Override
   class="kw">public IWorldGen getGenerator() class="kw">throws WorldGenLoadException {
      int var1 = ColorParseUtil.colorToARGBInt(this.tint);

      for (FlatWorldGenProvider.Layer var5 : this.layers) {
         if (var5.from >= var5.to) {
            throw new WorldGenLoadException("Failed to load 'Flat' WorldGen config, 'To' must be greater than 'From': " + var5);
         }

         var5.from = Math.max(var5.from, 0);
         var5.to = Math.min(var5.to, 320);
         if (var5.environment != null) {
            int var6 = Environment.getAssetMap().getIndex(var5.environment);
            if (var6 == Integer.MIN_VALUE) {
               throw new WorldGenLoadException("Unknown key! " + var5.environment);
            }

            var5.environmentId = var6;
         } else {
            var5.environmentId = 0;
         }

         if (var5.blockType != null) {
            int var7 = BlockType.getAssetMap().getIndex(var5.blockType);
            if (var7 == Integer.MIN_VALUE) {
               throw new WorldGenLoadException("Unknown key! " + var5.blockType);
            }

            var5.blockId = var7;
         } else {
            var5.blockId = 0;
         }
      }

      class="kw">return new FlatWorldGenProvider.FlatWorldGen(this.layers, var1);
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "FlatWorldGenProvider{tint=" + this.tint + ", layers=" + Arrays.toString(this.layers) + "}";
   }

   class="kw">private class="kw">static class FlatWorldGen class="kw">implements IWorldGen {
      class="kw">private class="kw">final FlatWorldGenProvider.Layer[] layers;
      class="kw">private class="kw">final int tintId;

      class="kw">public FlatWorldGen(FlatWorldGenProvider.Layer[] var1, int var2) {
         this.layers = var1;
         this.tintId = var2;
      }

      @Nullable
      @Override
      class="kw">public WorldGenTimingsCollector getTimings() {
         class="kw">return null;
      }

      @Nonnull
      @Override
      class="kw">public Transform[] getSpawnPoints(int var1) {
         class="kw">return new Transform[]{new Transform(0.0, 81.0, 0.0)};
      }

      @Nonnull
      @Override
      class="kw">public CompletableFuture<GeneratedChunk> generate(int var1, long var2, int var4, int var5, LongPredicate var6, Long2FloatFunction var7) {
         GeneratedBlockChunk var8 = new GeneratedBlockChunk(var2, var4, var5);

         for (int var9 = 0; var9 < 32; var9++) {
            for (int var10 = 0; var10 < 32; var10++) {
               var8.setTint(var9, var10, this.tintId);
            }
         }

         for (FlatWorldGenProvider.Layer var12 : this.layers) {
            for (int var13 = 0; var13 < 32; var13++) {
               for (int var14 = 0; var14 < 32; var14++) {
                  for (int var15 = var12.from; var15 < var12.to; var15++) {
                     var8.setBlock(var13, var15, var14, var12.blockId, 0, 0);
                     var8.setEnvironment(var13, var15, var14, var12.environmentId);
                  }

                  var8.setTint(var13, var14, this.tintId);
               }
            }
         }

         class="kw">return CompletableFuture.completedFuture(new GeneratedChunk(var8, new GeneratedEntityChunk(), GeneratedChunk.makeSections()));
      }
   }

   class="kw">public class="kw">static class Layer {
      class="kw">public class="kw">static class="kw">final BuilderCodec<FlatWorldGenProvider.Layer> CODEC = BuilderCodec.<FlatWorldGenProvider.Layer>builder(
            FlatWorldGenProvider.Layer.class, FlatWorldGenProvider.Layer::new
         )
         .documentation("A layer of blocks for a given range.")
         .<Integer>append(new KeyedCodec<>("From", Codec.INTEGER), (var0, var1) -> var0.from = var1, var0 -> var0.from)
         .documentation("The Y coordinate (inclusive) to start placing blocks at.")
         .add()
         .<Integer>append(new KeyedCodec<>("To", Codec.INTEGER), (var0, var1) -> var0.to = var1, var0 -> var0.to)
         .documentation("The Y coordinate (exclusive) to stop placing blocks at.")
         .addValidator(new RangeRefValidator<>("1/From", null, false))
         .add()
         .<String>append(new KeyedCodec<>("BlockType", Codec.STRING), (var0, var1) -> var0.blockType = var1, var0 -> var0.blockType)
         .documentation("The type of block that will be used for all blocks placed at this layer.")
         .addValidator(BlockType.VALIDATOR_CACHE.getValidator())
         .add()
         .<String>append(new KeyedCodec<>("Environment", Codec.STRING), (var0, var1) -> var0.environment = var1, var0 -> var0.environment)
         .documentation("The environment to set for every block placed.")
         .addValidator(Environment.VALIDATOR_CACHE.getValidator())
         .add()
         .build();
      class="kw">public int from = Integer.MIN_VALUE;
      class="kw">public int to = Integer.MAX_VALUE;
      class="kw">public String environment;
      class="kw">public String blockType;
      class="kw">public int environmentId;
      class="kw">public int blockId;

      class="kw">public Layer() {
      }

      class="kw">public Layer(int var1, int var2, String var3, String var4) {
         this.from = var1;
         this.to = var2;
         this.environment = var3;
         this.blockType = var4;
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "Layer{from=" + this.from + ", to=" + this.to + ", environment='" + this.environment + "', blockType=" + this.blockType + "}";
      }
   }
}