Ajout des Evenement Journalier (Pêche Miraculeuse, Moisson Dorée, Nuit Terrifiante, ...)

src/main/java/fr/openmc/api/datapacks/OMCDatapack.java

@@ -1,9 +1,12 @@
 package fr.openmc.api.datapacks;
 
 import fr.openmc.api.datapacks.injectors.PackMetadataInjector;
+import fr.openmc.core.OMCPlugin;
+import fr.openmc.core.utils.FilesUtils;
 import io.papermc.paper.plugin.bootstrap.BootstrapContext;
 import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents;
 import lombok.Getter;
+import org.bukkit.Bukkit;
 
 import java.io.IOException;
 import java.net.URI;
@@ -19,37 +22,102 @@ public class OMCDatapack {
     private final String namespace;
     private final Set<DatapackInjector> injectors = new HashSet<>();
 
+    public final String ID_DATAPACK_INJECTED = "openmc-injected";
+    private final String ID_TEMP_DATAPACK_FOLDER = "datapacks-openmc";
+
     public OMCDatapack(String packName, String namespace) {
         this.packName = packName;
         this.namespace = namespace;
     }
 
-    public void build(BootstrapContext context) throws IOException {
-        Path tempDir = Files.createTempDirectory("datapacks-openmc");
+    public void buildBootstrap(BootstrapContext context, boolean generateFiles) throws IOException {
+        Path dir;
+
+        if (generateFiles) {
+            dir = context.getDataDirectory().resolve(ID_TEMP_DATAPACK_FOLDER);
+
+            FilesUtils.deleteDirectory(dir.toFile());
+            Files.createDirectories(dir);
+        } else {
+            dir = Files.createTempDirectory(ID_TEMP_DATAPACK_FOLDER);
+        }
 
-        runInjector(tempDir, new PackMetadataInjector());
+        runInjector(dir, new PackMetadataInjector());
 
         for (DatapackInjector injector : injectors) {
-            runInjector(tempDir, injector);
+            runInjector(dir, injector);
         }
 
         context.getLifecycleManager().registerEventHandler(LifecycleEvents.DATAPACK_DISCOVERY.newHandler(
                 event -> {
                     try {
-                        URI uri = tempDir.toUri();
+                        URI uri = dir.toUri();
 
-                        event.registrar().discoverPack(uri, "openmc-injected");
+                        event.registrar().discoverPack(uri, ID_DATAPACK_INJECTED);
                     } catch (IOException e) {
                         throw new RuntimeException(e);
                     }
                 }
         ));
     }
 
+    /**
+     * Dangeureux à utiliser, veillez bien que serveur restart apres, car les registres nms de minecraft
+     * (pas reloadable, ex worldgen/biome et worldgen/..) ne peuvent pas etre reload. et donc vous pourrez pas acceder à vos valeures
+     * @param onBuilded execute une action lorsque le datapack est build (par ex redemarrer le serveur si y'a des registres pas reloadable affecté)
+     * @throws IOException
+     */
+    public void buildRuntime(Runnable onBuilded) throws IOException {
+        Path dir = OMCPlugin.getInstance().getServer()
+                .getLevelDirectory()
+                .resolve("datapacks")
+                .resolve(ID_TEMP_DATAPACK_FOLDER);
+
+        cleanupRumtime();
+        Files.createDirectories(dir);
+
+        runInjector(dir, new PackMetadataInjector());
+
+        for (DatapackInjector injector : injectors) {
+            runInjector(dir, injector);
+        }
+
+        Bukkit.getScheduler().runTaskLater(OMCPlugin.getInstance(), onBuilded, 20L);
+    }
+
+    public void cleanupBootstrap(BootstrapContext context) throws IOException {
+        Path dataDir = context.getDataDirectory().toFile()
+                .toPath()
+                .toAbsolutePath()
+                .normalize(); // * ex /home/container/plugins/OpenMC
+
+        Path serverRoot = dataDir.getParent()   // * plugins/
+                .getParent();  // * /container
+
+        Path dir = serverRoot
+                .resolve("world") // * /container/world
+                .resolve("datapacks") // * /container/datapacks
+                .resolve(ID_TEMP_DATAPACK_FOLDER);
+        FilesUtils.deleteDirectory(dir.toFile());
+    }
+
+    public void cleanupRumtime() throws IOException {
+        Path dir = OMCPlugin.getInstance().getServer().getLevelDirectory()
+                .resolve("datapacks")
+                .resolve(ID_TEMP_DATAPACK_FOLDER);
+        FilesUtils.deleteDirectory(dir.toFile());
+    }
+
     public void addInjector(DatapackInjector injector) {
         injectors.add(injector);
     }
 
+    public void addInjector(Iterable<DatapackInjector> injectors) {
+        for (DatapackInjector injector : injectors) {
+            addInjector(injector);
+        }
+    }
+
     private static void runInjector(Path datapackRoot, DatapackInjector injector) {
         injector.inject(datapackRoot.toFile());
     }

src/main/java/fr/openmc/api/datapacks/builders/BiomeBuilder.java

@@ -0,0 +1,183 @@
+package fr.openmc.api.datapacks.builders;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import lombok.Getter;
+
+import java.util.function.Consumer;
+
+/**
+ * Exemple simple d'un biome:
+ * {
+ *   "attributes": {},
+ *   "carvers": [],
+ *   "creature_spawn_probability": 0.03,
+ *   "downfall": 0,
+ *   "effects": {
+ *     "foliage_color": "#9e814d",
+ *     "grass_color": "#90814d",
+ *     "water_color": "#3f76e4",
+ *     "dry_foliage_color": "",
+ *     "grass_color_modifier": "none"
+ *   },
+ *   "features": [],
+ *   "has_precipitation": false,
+ *   "spawn_costs": {},
+ *   "spawners": {},
+ *   "temperature": 2
+ * }
+ */
+public final class BiomeBuilder {
+    private JsonObject attributes = new JsonObject();
+    private final JsonArray carvers = new JsonArray();
+    @Getter
+    private final JsonObject effects = new JsonObject();
+    private final JsonArray features = new JsonArray();
+    private final JsonObject spawnCosts = new JsonObject();
+    private final JsonObject spawners = new JsonObject();
+    private String temperatureModifier = "none";
+    private Double creatureSpawnProbability = 0.03;
+    private Float downfall = 0.5f;
+    private Float temperatures = 0.5f;
+    private Boolean hasPrecipitation = true;
+
+    public BiomeBuilder attributes(EnvironnementAttributeBuilder builder) {
+        this.attributes = builder.getOutputData();
+        return this;
+    }
+
+    public BiomeBuilder carver(String id) {
+        this.carvers.add(id);
+        return this;
+    }
+
+    public BiomeBuilder features(JsonElement id) {
+        this.features.add(id);
+        return this;
+    }
+
+    public BiomeBuilder temperatureModifier(String id) {
+        this.temperatureModifier =id;
+        return this;
+    }
+
+    public BiomeBuilder creatureSpawnProbability(Double value) {
+        this.creatureSpawnProbability=value;
+        return this;
+    }
+
+    public BiomeBuilder downfall(Float value) {
+        this.downfall=value;
+        return this;
+    }
+
+    public BiomeBuilder effects(Consumer<JsonObject> builder) {
+        JsonObject obj = new JsonObject();
+        builder.accept(obj);
+        for (var entry : obj.entrySet()) {
+            this.effects.add(entry.getKey(), entry.getValue());
+        }
+        return this;
+    }
+
+    public BiomeBuilder waterColor(String color) {
+        this.effects.addProperty("water_color", color);
+        return this;
+    }
+
+    public BiomeBuilder grassColor(String color) {
+        this.effects.addProperty("grass_color", color);
+        return this;
+    }
+
+    public BiomeBuilder foliageColor(String color) {
+        this.effects.addProperty("foliage_color", color);
+        return this;
+    }
+
+    public BiomeBuilder dryFoliageColor(String color) {
+        this.effects.addProperty("dry_foliage_color", color);
+        return this;
+    }
+
+    public BiomeBuilder waterColor(Integer color) {
+        this.effects.addProperty("water_color", color);
+        return this;
+    }
+
+    public BiomeBuilder grassColor(Integer color) {
+        this.effects.addProperty("grass_color", color);
+        return this;
+    }
+
+    public BiomeBuilder foliageColor(Integer color) {
+        this.effects.addProperty("foliage_color", color);
+        return this;
+    }
+
+    public BiomeBuilder dryFoliageColor(Integer color) {
+        this.effects.addProperty("dry_foliage_color", color);
+        return this;
+    }
+
+    /**
+     * Set la grass color modifier
+     * @param id none, dark_forest, swamp
+     * @return le builder
+     */
+    public BiomeBuilder grassColorModifier(String id) {
+        this.effects.addProperty("grass_color_modifier", id);
+        return this;
+    }
+
+    public BiomeBuilder spawnCosts(Consumer<JsonObject> builder) {
+        JsonObject obj = new JsonObject();
+        builder.accept(obj);
+        for (var entry : obj.entrySet()) {
+            this.spawnCosts.add(entry.getKey(), entry.getValue());
+        }
+        return this;
+    }
+
+    public BiomeBuilder spawnCosts(JsonObject spawnCosts) {
+        for (var entry : spawnCosts.entrySet()) {
+            this.spawnCosts.add(entry.getKey(), entry.getValue());
+        }
+        return this;
+    }
+
+    public BiomeBuilder spawners(JsonObject spawners) {
+        for (var entry : spawners.entrySet()) {
+            this.spawners.add(entry.getKey(), entry.getValue());
+        }
+        return this;
+    }
+
+    public BiomeBuilder temperatures(Float value) {
+        this.temperatures=value;
+        return this;
+    }
+
+    public BiomeBuilder hasPrecipitation(Boolean bool) {
+        this.hasPrecipitation=bool;
+        return this;
+    }
+
+    public JsonObject toJson() {
+        JsonObject json = new JsonObject();
+        if (attributes != null) json.add("attributes", attributes);
+        if (temperatureModifier != null) json.addProperty("temperature_modifier", temperatureModifier);
+        if (creatureSpawnProbability != null) json.addProperty("creature_spawn_probability", creatureSpawnProbability);
+        if (carvers != null) json.add("carvers", carvers);
+        if (downfall != null) json.addProperty("downfall", downfall);
+        if (effects != null) json.add("effects", effects);
+        if (features != null) json.add("features", features);
+        if (hasPrecipitation != null) json.addProperty("has_precipitation", hasPrecipitation);
+        if (spawnCosts != null) json.add("spawn_costs", spawnCosts);
+        if (spawners != null) json.add("spawners", spawners);
+        if (temperatures != null) json.addProperty("temperature", temperatures);
+
+        return json;
+    }
+}