Merge remote-tracking branch 'origin/ver/6.6.0' into dev/7.0-2

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());
-        for(PaletteLayerHolder layer : config.getPalette()) {
-            palette.add(layer.getLayer(), layer.getSize(), layer.getSampler());
-        }
-        return palette;
+        return new PaletteImpl(config.getPalette(), config.getDefaultSampler());
     }
 }

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() {
-        return noise;
+    public NoiseSampler getDefaultSampler() {
+        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 NoiseSampler sampler;
+    private final PaletteLayer[] layers;
 
-    public PaletteImpl(NoiseSampler sampler) {
-        this.sampler = sampler;
-    }
+    public PaletteImpl(List<PaletteLayerHolder> layers, NoiseSampler defaultSampler) {
+        List<PaletteLayer> layerArray = new ArrayList<>();
 
-    public Palette add(ProbabilityCollection<BlockState> m, int layers, NoiseSampler sampler) {
-        for(int i = 0; i < layers; i++) {
-            pallet.add(new PaletteLayer(m, sampler));
+        for (PaletteLayerHolder holder : layers) {
+            PaletteLayer layer;
+            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;
-        if(layer > this.getSize()) paletteLayer = this.getLayers().get(this.getLayers().size() - 1);
-        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);
+        int idx = layer < layers.length ? layer : layers.length - 1;
+        return layers[idx].get(x, y, z, seed);
     }
 
-
-    public int getSize() {
-        return pallet.size();
-    }
-
-    public List<PaletteLayer> getLayers() {
-        return pallet;
-    }
-
-    /**
-     * Class representation of a layer of a BlockPalette.
-     */
-    public static class PaletteLayer {
+    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) {
-            return this.collection.get(random, x, y, z, seed);
+        public BlockState get(double x, double y, double z, long seed) {
+            return this.collection.get(sampler, x, y, z, seed);
         }
-
-        public NoiseSampler getSampler() {
-            return sampler;
-        }
-
     }
 }

common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/ProbabilityCollectionLoader.java

@@ -43,23 +43,27 @@ public class ProbabilityCollectionLoader implements TypeLoader<ProbabilityCollec
             AnnotatedType generic = pType.getAnnotatedActualTypeArguments()[0];
             if(o instanceof Map) {
                 Map<Object, Object> map = (Map<Object, Object>) o;
+                if (map.size() == 1) {
+                    Object onlyKey = map.keySet().iterator().next();
+                    return new ProbabilityCollection.Singleton<>(configLoader.loadType(generic, onlyKey, depthTracker));
+                }
                 for(Map.Entry<Object, Object> entry : map.entrySet()) {
                     collection.add(configLoader.loadType(generic, entry.getKey(), depthTracker.entry((String) entry.getKey())),
                         configLoader.loadType(Integer.class, entry.getValue(), depthTracker.entry((String) entry.getKey())));
                 }
             } else if(o instanceof List) {
-                List<Map<Object, Object>> map = (List<Map<Object, Object>>) o;
-                if(map.size() == 1) {
-                    Map<Object, Object> entry = map.get(0);
-                    if(entry.size() == 1) {
-                        for(Object value : entry.keySet()) {
+                List<Map<Object, Object>> list = (List<Map<Object, Object>>) o;
+                if(list.size() == 1) {
+                    Map<Object, Object> map = list.getFirst();
+                    if(map.size() == 1) {
+                        for(Object value : map.keySet()) {
                             return new ProbabilityCollection.Singleton<>(configLoader.loadType(generic, value, depthTracker));
                         }
                     }
                 }
-                for(int i = 0; i < map.size(); i++) {
-                    Map<Object, Object> l = map.get(i);
-                    for(Entry<Object, Object> entry : l.entrySet()) {
+                for(int i = 0; i < list.size(); i++) {
+                    Map<Object, Object> map = list.get(i);
+                    for(Entry<Object, Object> entry : map.entrySet()) {
                         if(entry.getValue() == null) throw new LoadException("No probability defined for entry \"" + entry.getKey() + "\"",
                             depthTracker);
                         Object val = configLoader.loadType(generic, entry.getKey(), depthTracker.index(i).entry((String) entry.getKey()));