move modules to better directory structure

common/addons/config-flora/build.gradle.kts

@@ -0,0 +1,59 @@
+import com.dfsek.terra.configureCompilation
+import com.dfsek.terra.configureDependencies
+
+plugins {
+    `java-library`
+    `maven-publish`
+    idea
+}
+
+configureCompilation()
+configureDependencies()
+
+group = "com.dfsek.terra.common"
+
+dependencies {
+    "shadedApi"(project(":common:api"))
+
+    "shadedApi"("org.apache.commons:commons-rng-core:1.3")
+    "shadedApi"("commons-io:commons-io:2.4")
+
+    "shadedApi"("com.dfsek:Paralithic:0.3.2")
+    "shadedApi"("com.dfsek:Tectonic:1.4.0")
+    "shadedApi"("net.jafama:jafama:2.3.2")
+    "shadedApi"("org.yaml:snakeyaml:1.27")
+    "shadedApi"("org.ow2.asm:asm:9.0")
+    "shadedApi"("commons-io:commons-io:2.6")
+
+    "shadedApi"("com.googlecode.json-simple:json-simple:1.1.1")
+    "shadedApi"("org.yaml:snakeyaml:1.27")
+
+    "compileOnly"("com.google.guava:guava:30.0-jre")
+
+    "testImplementation"("com.google.guava:guava:30.0-jre")
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("mavenJava") {
+            artifact(tasks["sourcesJar"])
+            artifact(tasks["jar"])
+        }
+    }
+
+    repositories {
+        val mavenUrl = "https://repo.codemc.io/repository/maven-releases/"
+        val mavenSnapshotUrl = "https://repo.codemc.io/repository/maven-snapshots/"
+
+        maven(mavenUrl) {
+            val mavenUsername: String? by project
+            val mavenPassword: String? by project
+            if (mavenUsername != null && mavenPassword != null) {
+                credentials {
+                    username = mavenUsername
+                    password = mavenPassword
+                }
+            }
+        }
+    }
+}

common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraAddon.java

@@ -0,0 +1,30 @@
+package com.dfsek.terra.addons.flora;
+
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.addon.TerraAddon;
+import com.dfsek.terra.api.addon.annotations.Addon;
+import com.dfsek.terra.api.addon.annotations.Author;
+import com.dfsek.terra.api.addon.annotations.Version;
+import com.dfsek.terra.api.event.EventListener;
+import com.dfsek.terra.api.event.events.config.ConfigPackPreLoadEvent;
+import com.dfsek.terra.api.injection.annotations.Inject;
+import com.dfsek.terra.api.registry.exception.DuplicateEntryException;
+import com.dfsek.terra.api.world.generator.GenerationStageProvider;
+
+@Addon("core-flora-config")
+@Author("Terra")
+@Version("0.1.0")
+public class FloraAddon extends TerraAddon implements EventListener {
+    @Inject
+    private TerraPlugin main;
+
+    @Override
+    public void initialize() {
+        main.getEventManager().registerListener(this, this);
+    }
+
+    public void onPackLoad(ConfigPackPreLoadEvent event) throws DuplicateEntryException {
+        event.getPack().registerConfigType(new FloraConfigType(event.getPack()), "FLORA", 2);
+        event.getPack().getOrCreateRegistry(GenerationStageProvider.class).register("FLORA", pack -> new FloraPopulator(main));
+    }
+}

common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraConfigType.java

@@ -0,0 +1,39 @@
+package com.dfsek.terra.addons.flora;
+
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.config.ConfigFactory;
+import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.api.config.ConfigType;
+import com.dfsek.terra.api.registry.OpenRegistry;
+import com.dfsek.terra.api.world.Flora;
+
+import java.util.function.Supplier;
+
+public class FloraConfigType implements ConfigType<FloraTemplate, Flora> {
+    private final FloraFactory factory = new FloraFactory();
+    private final ConfigPack pack;
+
+    public FloraConfigType(ConfigPack pack) {
+        this.pack = pack;
+    }
+
+    @Override
+    public FloraTemplate getTemplate(ConfigPack pack, TerraPlugin main) {
+        return new FloraTemplate();
+    }
+
+    @Override
+    public ConfigFactory<FloraTemplate, Flora> getFactory() {
+        return factory;
+    }
+
+    @Override
+    public Class<Flora> getTypeClass() {
+        return Flora.class;
+    }
+
+    @Override
+    public Supplier<OpenRegistry<Flora>> registrySupplier() {
+        return pack.getRegistryFactory()::create;
+    }
+}

common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraFactory.java

@@ -0,0 +1,17 @@
+package com.dfsek.terra.addons.flora;
+
+import com.dfsek.terra.addons.flora.flora.TerraFlora;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.config.ConfigFactory;
+import com.dfsek.terra.api.world.Flora;
+
+public class FloraFactory implements ConfigFactory<FloraTemplate, Flora> {
+    @Override
+    public TerraFlora build(FloraTemplate config, TerraPlugin main) {
+        /*PaletteImpl palette = new NoisePalette(new WhiteNoiseSampler(2403), false);
+        for(PaletteLayerHolder layer : config.getFloraPalette()) {
+            palette.add(layer.getLayer(), layer.getSize(), layer.getSampler());
+        }*/
+        return new TerraFlora(null, config.doPhysics(), config.isCeiling(), config.getIrrigable(), config.getSpawnable(), config.getReplaceable(), config.getRotatable(), config.getMaxPlacements(), config.getSearch(), config.isSpawnBlacklist(), config.getIrrigableOffset(), main);
+    }
+}

common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraPopulator.java

@@ -0,0 +1,57 @@
+package com.dfsek.terra.addons.flora;
+
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.profiler.ProfileFrame;
+import com.dfsek.terra.api.world.Chunk;
+import com.dfsek.terra.api.world.TerraWorld;
+import com.dfsek.terra.api.world.World;
+import com.dfsek.terra.api.world.generator.TerraGenerationStage;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Populates Flora
+ */
+public class FloraPopulator implements TerraGenerationStage {
+    private final TerraPlugin main;
+
+    public FloraPopulator(TerraPlugin main) {
+        this.main = main;
+    }
+
+    @SuppressWarnings("try")
+    @Override
+    public void populate(@NotNull World world, @NotNull Chunk chunk) {
+        TerraWorld tw = main.getWorld(world);
+        try(ProfileFrame ignore = main.getProfiler().profile("flora")) {
+            /*
+            if(tw.getConfig().disableFlora()) return;
+
+            if(!tw.isSafe()) return;
+            BiomeProvider provider = tw.getBiomeProvider();
+            Map<Vector2, List<FloraLayer>> layers = new HashMap<>();
+            for(int x = 0; x < 16; x++) {
+                for(int z = 0; z < 16; z++) {
+                    UserDefinedBiome biome = (UserDefinedBiome) provider.getBiome((chunk.getX() << 4) + x, (chunk.getZ() << 4) + z);
+                    Vector2 l = new Vector2(x, z);
+                    layers.put(l, biome.getConfig().getFlora());
+                }
+            }
+
+            Random random = PopulationUtil.getRandom(chunk);
+
+            int iter = 0;
+            boolean finished = false;
+            while(!finished) {
+                finished = true;
+                for(Map.Entry<Vector2, List<FloraLayer>> entry : layers.entrySet()) {
+                    if(entry.getValue().size() <= iter) continue;
+                    finished = false;
+                    FloraLayer layer = entry.getValue().get(iter);
+                    if(layer.getDensity() >= random.nextDouble() * 100D) layer.place(chunk, entry.getKey());
+                }
+                iter++;
+            }
+            */
+        }
+    }
+}

common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraTemplate.java

@@ -0,0 +1,108 @@
+package com.dfsek.terra.addons.flora;
+
+import com.dfsek.tectonic.annotations.Abstractable;
+import com.dfsek.tectonic.annotations.Default;
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.terra.addons.flora.flora.TerraFlora;
+import com.dfsek.terra.api.config.AbstractableTemplate;
+import com.dfsek.terra.api.util.collection.MaterialSet;
+
+@SuppressWarnings({"FieldMayBeFinal", "unused"})
+public class FloraTemplate implements AbstractableTemplate {
+    @Value("id")
+    private String id;
+
+    @Value("spawnable")
+    @Abstractable
+    private MaterialSet spawnable;
+
+    @Value("spawn-blacklist")
+    @Abstractable
+    @Default
+    private boolean spawnBlacklist = false;
+
+
+    @Value("replaceable")
+    @Abstractable
+    @Default
+    private MaterialSet replaceable = MaterialSet.empty();
+
+    @Value("irrigable")
+    @Abstractable
+    @Default
+    private MaterialSet irrigable = null;
+
+    @Value("rotatable")
+    @Abstractable
+    @Default
+    private MaterialSet rotatable = MaterialSet.empty();
+
+    @Value("physics")
+    @Abstractable
+    @Default
+    private boolean doPhysics = false;
+
+    @Value("ceiling")
+    @Abstractable
+    @Default
+    private boolean ceiling = false;
+
+    @Value("search")
+    @Default
+    @Abstractable
+    private TerraFlora.Search search = TerraFlora.Search.UP;
+
+    @Value("max-placements")
+    @Default
+    @Abstractable
+    private int maxPlacements = -1;
+
+    @Value("irrigable-offset")
+    @Abstractable
+    @Default
+    private int irrigableOffset;
+
+    public int getIrrigableOffset() {
+        return irrigableOffset;
+    }
+
+    public TerraFlora.Search getSearch() {
+        return search;
+    }
+
+    public int getMaxPlacements() {
+        return maxPlacements;
+    }
+
+    public MaterialSet getReplaceable() {
+        return replaceable;
+    }
+
+    public MaterialSet getSpawnable() {
+        return spawnable;
+    }
+
+    public MaterialSet getIrrigable() {
+        return irrigable;
+    }
+
+    public String getID() {
+        return id;
+    }
+
+    public boolean doPhysics() {
+        return doPhysics;
+    }
+
+    public boolean isCeiling() {
+        return ceiling;
+    }
+
+    public boolean isSpawnBlacklist() {
+        return spawnBlacklist;
+    }
+
+    public MaterialSet getRotatable() {
+        return rotatable;
+    }
+}

common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/TerraFlora.java

@@ -0,0 +1,138 @@
+package com.dfsek.terra.addons.flora.flora;
+
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.block.state.properties.base.Properties;
+import com.dfsek.terra.api.block.state.properties.enums.Direction;
+import com.dfsek.terra.api.util.collection.MaterialSet;
+import com.dfsek.terra.api.util.Range;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.Chunk;
+import com.dfsek.terra.api.world.Flora;
+import com.dfsek.terra.api.world.World;
+import com.dfsek.terra.api.world.generator.Palette;
+import net.jafama.FastMath;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Random;
+
+public class TerraFlora implements Flora {
+    private final Palette floraPalette;
+    private final boolean physics;
+    private final boolean ceiling;
+
+    private final MaterialSet irrigable;
+
+    private final MaterialSet spawnable;
+    private final MaterialSet replaceable;
+
+    private final MaterialSet testRotation;
+
+    private final int maxPlacements;
+
+    private final Search search;
+
+    private final boolean spawnBlacklist;
+
+    private final int irrigableOffset;
+
+    private final TerraPlugin main;
+
+    public TerraFlora(Palette floraPalette, boolean physics, boolean ceiling, MaterialSet irrigable, MaterialSet spawnable, MaterialSet replaceable, MaterialSet testRotation, int maxPlacements, Search search, boolean spawnBlacklist, int irrigableOffset, TerraPlugin main) {
+        this.floraPalette = floraPalette;
+        this.physics = physics;
+        this.testRotation = testRotation;
+        this.spawnBlacklist = spawnBlacklist;
+        this.ceiling = ceiling;
+        this.irrigable = irrigable;
+        this.spawnable = spawnable;
+        this.replaceable = replaceable;
+        this.maxPlacements = maxPlacements;
+        this.search = search;
+        this.irrigableOffset = irrigableOffset;
+        this.main = main;
+    }
+
+    @Override
+    public List<Vector3> getValidSpawnsAt(Chunk chunk, int x, int z, Range range) {
+        int size = floraPalette.getSize();
+        Vector3 current = new Vector3(x, search.equals(Search.UP) ? range.getMin() : range.getMax(), z);
+        List<Vector3> blocks = new ArrayList<>();
+        int cx = chunk.getX() << 4;
+        int cz = chunk.getZ() << 4;
+        for(int y : range) {
+            if(y > 255 || y < 0) continue;
+            current = current.add(0, search.equals(Search.UP) ? 1 : -1, 0);
+            if((spawnBlacklist != spawnable.contains(chunk.getBlock(current.getBlockX(), current.getBlockY(), current.getBlockZ()).getBlockType())) && isIrrigated(current.clone().add(cx, irrigableOffset, cz), chunk.getWorld()) && valid(size, current.clone().add(cx, 0, cz), chunk.getWorld())) {
+                blocks.add(current.clone());
+                if(maxPlacements > 0 && blocks.size() >= maxPlacements) break;
+            }
+        }
+        return blocks;
+    }
+
+    private boolean valid(int size, Vector3 block, World world) {
+        for(int i = 0; i < size; i++) { // Down if ceiling, up if floor
+            if(block.getY() + 1 > 255 || block.getY() < 0) return false;
+            block.add(0, ceiling ? -1 : 1, 0);
+            if(!replaceable.contains(world.getBlockData(block).getBlockType())) return false;
+        }
+        return true;
+    }
+
+    private boolean isIrrigated(Vector3 b, World world) {
+        if(irrigable == null) return true;
+        return irrigable.contains(world.getBlockData(b.getBlockX() + 1, b.getBlockY(), b.getBlockZ()).getBlockType())
+                || irrigable.contains(world.getBlockData(b.getBlockX() - 1, b.getBlockY(), b.getBlockZ()).getBlockType())
+                || irrigable.contains(world.getBlockData(b.getBlockX(), b.getBlockY(), b.getBlockZ() + 1).getBlockType())
+                || irrigable.contains(world.getBlockData(b.getBlockX(), b.getBlockY(), b.getBlockZ() - 1).getBlockType());
+    }
+
+
+    @Override
+    public boolean plant(Vector3 location, World world) {
+        boolean doRotation = testRotation.size() > 0;
+        int size = floraPalette.getSize();
+        int c = ceiling ? -1 : 1;
+
+        EnumSet<Direction> faces = doRotation ? getFaces(location.clone().add(0, c, 0), world) : EnumSet.noneOf(Direction.class);
+        if(doRotation && faces.size() == 0) return false; // Don't plant if no faces are valid.
+
+        for(int i = 0; FastMath.abs(i) < size; i += c) { // Down if ceiling, up if floor
+            int lvl = (FastMath.abs(i));
+            BlockState data = floraPalette.get((ceiling ? lvl : size - lvl - 1), location.getX(), location.getY(), location.getZ()).clone();
+            if(doRotation) {
+                Direction oneFace = new ArrayList<>(faces).get(new Random(location.getBlockX() ^ location.getBlockZ()).nextInt(faces.size())); // Get random face.
+
+                data.setIfPresent(Properties.DIRECTION, oneFace.opposite())
+                        .setIfPresent(Properties.NORTH, faces.contains(Direction.NORTH))
+                        .setIfPresent(Properties.SOUTH, faces.contains(Direction.SOUTH))
+                        .setIfPresent(Properties.EAST, faces.contains(Direction.EAST))
+                        .setIfPresent(Properties.WEST, faces.contains(Direction.WEST));
+            }
+            world.setBlockData(location.clone().add(0, i + c, 0), data, physics);
+        }
+        return true;
+    }
+
+    private EnumSet<Direction> getFaces(Vector3 b, World world) {
+        EnumSet<Direction> faces = EnumSet.noneOf(Direction.class);
+        test(faces, Direction.NORTH, b, world);
+        test(faces, Direction.SOUTH, b, world);
+        test(faces, Direction.EAST, b, world);
+        test(faces, Direction.WEST, b, world);
+        return faces;
+    }
+
+    private void test(EnumSet<Direction> faces, Direction f, Vector3 b, World world) {
+        if(testRotation.contains(world.getBlockData(b.getBlockX() + f.getModX(), b.getBlockY() + f.getModY(), b.getBlockZ() + f.getModZ()).getBlockType()))
+            faces.add(f);
+    }
+
+    public enum Search {
+        UP,
+        DOWN
+    }
+}