Refactor palette addon

common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteFactory.java

@@ -8,7 +8,6 @@
 package com.dfsek.terra.addons.palette;
 
 import com.dfsek.terra.addons.palette.palette.PaletteImpl;
-import com.dfsek.terra.addons.palette.palette.PaletteLayerHolder;
 import com.dfsek.terra.api.Platform;
 import com.dfsek.terra.api.config.ConfigFactory;
 import com.dfsek.terra.api.world.chunk.generation.util.Palette;
@@ -17,10 +16,6 @@ import com.dfsek.terra.api.world.chunk.generation.util.Palette;
 public class PaletteFactory implements ConfigFactory<PaletteTemplate, Palette> {
     @Override
     public Palette build(PaletteTemplate config, Platform platform) {
-        PaletteImpl palette = new PaletteImpl(config.getNoise());
+        return new PaletteImpl(config.getPalette(), config.getDefaultSampler());
-        for(PaletteLayerHolder layer : config.getPalette()) {
-            palette.add(layer.getLayer(), layer.getSize(), layer.getSampler());
-        }
-        return palette;
     }
 }

common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteTemplate.java

@@ -23,7 +23,7 @@ import com.dfsek.terra.api.noise.NoiseSampler;
 public class PaletteTemplate implements AbstractableTemplate {
     @Value("sampler")
     @Default
-    private @Meta NoiseSampler noise = NoiseSampler.zero();
+    private @Meta NoiseSampler defaultSampler = NoiseSampler.zero();
 
     @Value("id")
     @Final
@@ -40,7 +40,7 @@ public class PaletteTemplate implements AbstractableTemplate {
         return palette;
     }
 
-    public NoiseSampler getNoise() {
+    public NoiseSampler getDefaultSampler() {
-        return noise;
+        return defaultSampler;
     }
 }

common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteImpl.java

@@ -15,73 +15,45 @@ import com.dfsek.terra.api.noise.NoiseSampler;
 import com.dfsek.terra.api.util.collection.ProbabilityCollection;
 import com.dfsek.terra.api.world.chunk.generation.util.Palette;
 
-
 /**
  * A class representation of a "slice" of the world.
  * Used to get a section of blocks, based on the depth at which they are found.
  */
 public class PaletteImpl implements Palette {
-    private final List<PaletteLayer> pallet = new ArrayList<>();
+    private final PaletteLayer[] layers;
-    private final NoiseSampler sampler;
 
-    public PaletteImpl(NoiseSampler sampler) {
+    public PaletteImpl(List<PaletteLayerHolder> layers, NoiseSampler defaultSampler) {
-        this.sampler = sampler;
+        List<PaletteLayer> layerArray = new ArrayList<>();
-    }
 
-    public Palette add(ProbabilityCollection<BlockState> m, int layers, NoiseSampler sampler) {
+        for (PaletteLayerHolder holder : layers) {
-        for(int i = 0; i < layers; i++) {
+            PaletteLayer layer;
-            pallet.add(new PaletteLayer(m, sampler));
+            ProbabilityCollection<BlockState> materials = holder.getLayer();
+            NoiseSampler sampler = holder.getSampler() == null ? defaultSampler : holder.getSampler();
+            layer = new PaletteLayer(materials, sampler);
+            for (int i = 0; i < holder.getSize(); i++)
+                layerArray.add(layer);
         }
-        return this;
+
+        this.layers = layerArray.toArray(new PaletteLayer[0]);
     }
 
     @Override
     public BlockState get(int layer, double x, double y, double z, long seed) {
-        PaletteLayer paletteLayer;
+        int idx = layer < layers.length ? layer : layers.length - 1;
-        if(layer > this.getSize()) paletteLayer = this.getLayers().get(this.getLayers().size() - 1);
+        return layers[idx].get(x, y, z, seed);
-        else {
-            List<PaletteLayer> pl = getLayers();
-            if(layer >= pl.size()) paletteLayer = pl.get(pl.size() - 1);
-            else paletteLayer = pl.get(layer);
-        }
-        NoiseSampler paletteSampler = paletteLayer.getSampler();
-        return paletteLayer.get(paletteSampler == null ? sampler : paletteSampler, x, y, z, seed);
     }
 
-
+    static class PaletteLayer {
-    public int getSize() {
-        return pallet.size();
-    }
-
-    public List<PaletteLayer> getLayers() {
-        return pallet;
-    }
-
-    /**
-     * Class representation of a layer of a BlockPalette.
-     */
-    public static class PaletteLayer {
         private final NoiseSampler sampler;
         private final ProbabilityCollection<BlockState> collection;
 
-        /**
-         * Constructs a PaletteLayerHolder with a ProbabilityCollection of materials and a number of layers.
-         *
-         * @param type    The collection of materials to choose from.
-         * @param sampler Noise sampler to use
-         */
         public PaletteLayer(ProbabilityCollection<BlockState> type, NoiseSampler sampler) {
             this.sampler = sampler;
             this.collection = type;
         }
 
-        public BlockState get(NoiseSampler random, double x, double y, double z, long seed) {
+        public BlockState get(double x, double y, double z, long seed) {
-            return this.collection.get(random, x, y, z, seed);
+            return this.collection.get(sampler, x, y, z, seed);
         }
-
-        public NoiseSampler getSampler() {
-            return sampler;
-        }
-
     }
 }