Ajout du support des fichiers lang

.gitignore

@@ -29,8 +29,7 @@ atlassian-ide-plugin.xml
 # BlueJ files
 *.ctxt
 
-# Package Files #
-*.jar
+# Package Files
 *.war
 *.nar
 *.ear
@@ -133,4 +132,5 @@ spigot.yml
 .factorypath
 .project
 .settings/
-bin/
+bin/
+!libs/

build.gradle

@@ -8,13 +8,32 @@ version = '0.1-SNAPSHOT'
 
 repositories {
     mavenCentral()
+    // * ItemsAdder
+    maven {url "https://maven.devs.beer/"}
+    // * GeyserMC
+    maven {url "https://repo.opencollab.dev/main/"}
 }
 
 dependencies {
     paperweight.paperDevBundle "${minecraftVersion}.build.${paperVersion}"
 
+    // Dependancies
+    compileOnly "beer.devs:itemsadder-api:${itemsAdderVersion}"
+    compileOnly "org.geysermc.geyser:api:${geyserApiVersion}"
+
     compileOnly files("libs/OpenMC.jar")
     implementation "org.jetbrains:annotations:${jetbrainsAnnotationsVersion}"
     compileOnly "org.projectlombok:lombok:${lombokVersion}"
     annotationProcessor "org.projectlombok:lombok:${lombokVersion}"
+}
+
+processResources {
+    filteringCharset = 'UTF-8'
+
+    def pluginProps = ["version": version, "minecraftVersion": minecraftVersion]
+    inputs.properties(pluginProps)
+
+    filesMatching('paper-plugin.yml') {
+        expand(pluginProps)
+    }
 }

gradle.properties

@@ -6,5 +6,8 @@ minecraftVersion = 26.2
 paperVersion = 118-stable
 
 # Dependencies versions
+itemsAdderVersion = 4.0.18-beta-10
+geyserApiVersion = 2.10.0-SNAPSHOT
+
 jetbrainsAnnotationsVersion = 26.1.0
 lombokVersion = 1.18.46

src/main/java/fr/openmc/riftengine/core/RiftPlugin.java

@@ -1,17 +1,77 @@
 package fr.openmc.riftengine.core;
 
 import fr.openmc.core.bootstrap.integration.OMCLogger;
+import fr.openmc.riftengine.core.converter.ConverterManager;
+import lombok.Getter;
+import lombok.Setter;
 import org.bukkit.plugin.java.JavaPlugin;
+import org.geysermc.event.Event;
+import org.geysermc.geyser.api.GeyserApi;
+import org.geysermc.geyser.api.event.EventRegistrar;
+import org.geysermc.geyser.api.event.bedrock.SessionLoadResourcePacksEvent;
+import org.geysermc.geyser.api.pack.PackCodec;
+import org.geysermc.geyser.api.pack.ResourcePack;
+import org.geysermc.geyser.api.pack.option.PriorityOption;
 
-public class RiftPlugin extends JavaPlugin {
+import java.nio.file.Path;
+import java.util.function.Consumer;
+
+public class RiftPlugin extends JavaPlugin implements EventRegistrar {
+    @Getter
+    private static RiftPlugin instance;
+
+    @Getter
+    @Setter
+    private static ResourcePack resourcePack;
+
+    private ConverterManager converterManager;
 
     @Override
     public void onEnable() {
+        instance = this;
+
+        // * Registries internal
+        RiftRegistry.initAll();
+
+        // * Managers
+        converterManager = new ConverterManager(this);
+        updateBedrockResourcePack();
+
+        // * Listeners
+        registerEvent(SessionLoadResourcePacksEvent.class, this::onLoadResourcePacks);
+
         OMCLogger.info("RiftEngine activé!");
     }
 
     @Override
     public void onDisable() {
+        RiftRegistry.stopAll();
+
         OMCLogger.info("RiftEngine désactivé!");
     }
+
+    public void updateBedrockResourcePack() {
+        try {
+            Path generatedBedrockPack = converterManager.generateConvertedPack();
+            resourcePack = ResourcePack.builder(PackCodec.path(generatedBedrockPack)).build();
+        } catch (Exception e) {
+            throw new RuntimeException("Erreur lors de la génération du resourcepack bedrock", e);
+        }
+    }
+
+    public void onLoadResourcePacks(SessionLoadResourcePacksEvent event) {
+        ResourcePack pack = RiftPlugin.getResourcePack();
+
+        OMCLogger.infoFormatted("RiftEngine pack = " + pack);
+
+        if (pack == null) return;
+
+        event.register(pack, PriorityOption.HIGHEST);
+
+        OMCLogger.successFormatted("RiftEngine: pack registered !");
+    }
+
+    public <T extends Event> void registerEvent(Class<T> listenerClass, Consumer<T> handler) {
+        GeyserApi.api().eventBus().subscribe(this, listenerClass, handler);
+    }
 }

src/main/java/fr/openmc/riftengine/core/RiftRegistry.java

@@ -0,0 +1,71 @@
+package fr.openmc.riftengine.core;
+
+import fr.openmc.core.bootstrap.features.types.HasListeners;
+import fr.openmc.core.bootstrap.integration.OMCLogger;
+import fr.openmc.core.bootstrap.registries.LifecycleRegistry;
+import fr.openmc.core.bootstrap.registries.RegistryContext;
+import fr.openmc.core.bootstrap.registries.RegistryLoadingType;
+import fr.openmc.core.features.events.contents.dailyevents.DailyEventsRegistry;
+import fr.openmc.core.features.events.contents.weeklyevents.WeeklyEventsRegistry;
+import fr.openmc.core.registry.ambient.CustomAmbientRegistry;
+import fr.openmc.core.registry.enchantments.CustomEnchantmentRegistry;
+import fr.openmc.core.registry.items.CustomItemRegistry;
+import fr.openmc.core.registry.lootboxes.CustomLootboxRegistry;
+import fr.openmc.core.registry.loottable.CustomLootTableRegistry;
+import fr.openmc.core.registry.mobs.CustomMobRegistry;
+import fr.openmc.riftengine.core.registry.mapping.MappingRegistry;
+import io.papermc.paper.plugin.bootstrap.BootstrapContext;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@SuppressWarnings("UnstableApiUsage")
+public final class RiftRegistry {
+    // * Registre globaux
+    public static MappingRegistry MAPPINGS;
+
+    private static final List<LifecycleRegistry> LOADED = new ArrayList<>();
+
+    private static final List<RegistryContext> ALL = List.of(
+            new RegistryContext(
+                    () -> MAPPINGS = new MappingRegistry(),
+                    RegistryLoadingType.RUNTIME)
+    );
+
+    private RiftRegistry() {}
+
+    public static void initAll() {
+        for (RegistryContext ctx : RiftRegistry.ALL) {
+            if (isNotTyped(ctx, RegistryLoadingType.RUNTIME)) continue;
+
+            LifecycleRegistry r = load(ctx);
+
+            r.init();
+            OMCLogger.successFormatted("Registre {} chargé pendant le runtime", r.getClass().getSimpleName());
+        }
+    }
+
+    public static void stopAll() {
+        for (LifecycleRegistry r : LOADED) {
+            r.stop();
+            OMCLogger.successFormatted("Registre {} stoppé", r.getClass().getSimpleName());
+        }
+        LOADED.clear();
+    }
+
+    private static LifecycleRegistry load(RegistryContext ctx) {
+        LifecycleRegistry registry = ctx.registry().get();
+        LOADED.add(registry);
+        return registry;
+    }
+
+    private static boolean isNotTyped(RegistryContext ctx, RegistryLoadingType type) {
+        return Arrays.stream(ctx.loadingTypes()).noneMatch(t -> t == type);
+    }
+
+    private static boolean isTyped(RegistryContext ctx, RegistryLoadingType type) {
+        return Arrays.stream(ctx.loadingTypes()).anyMatch(t -> t == type);
+    }
+}

src/main/java/fr/openmc/riftengine/core/converter/ConverterManager.java

@@ -0,0 +1,75 @@
+package fr.openmc.riftengine.core.converter;
+
+import fr.openmc.core.bootstrap.integration.OMCLogger;
+import fr.openmc.riftengine.core.RiftPlugin;
+import fr.openmc.riftengine.core.converter.writers.PackWriter;
+import fr.openmc.riftengine.core.converter.writers.manifest.ManifestWriter;
+import fr.openmc.riftengine.core.converter.writers.manifest.PackIdentity;
+import fr.openmc.riftengine.core.converter.writers.translations.TranslationInjector;
+import fr.openmc.riftengine.core.utils.ZipUtils;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ConverterManager {
+
+    private final RiftPlugin plugin;
+
+    private final List<PackWriter> writers = new ArrayList<>();
+    private final PackIdentity identity;
+
+    public ConverterManager(RiftPlugin plugin) {
+        this.plugin = plugin;
+        try {
+            identity = PackIdentity.loadOrCreate(plugin);
+            writers.addAll(List.of(
+                    new ManifestWriter(identity),
+                    new TranslationInjector()
+            ));
+        } catch (Exception e) {
+            throw new RuntimeException("Erreur lors d'initialisation du ConverterManager", e);
+        }
+    }
+
+    /**
+     * Prends un pack java et le convertit en pack bedrock
+     */
+    public Path generateConvertedPack() throws IOException {
+        Path javaPackPath = getJavaPackPath(RiftPlugin.getInstance());
+
+        Path outputDir = plugin.getDataFolder().toPath().resolve("output");
+        Files.createDirectories(outputDir);
+
+        Path workDir = outputDir.resolve("internal");
+        Path javaExtractDir = workDir.resolve("java");
+        Path bedrockBuildDir = workDir.resolve("bedrock");
+        Files.createDirectories(bedrockBuildDir);
+
+        ZipUtils.unzip(javaPackPath, javaExtractDir);
+
+        for (PackWriter writer : writers) {
+            writer.write(bedrockBuildDir, javaExtractDir);
+        }
+
+        Path outputPack = outputDir.resolve("bedrock_pack.mcpack");
+        Files.deleteIfExists(outputPack);
+        ZipUtils.zip(bedrockBuildDir, outputPack);
+
+        OMCLogger.successFormatted("Pack bedrock généré : " + outputPack);
+        return outputPack;
+    }
+
+    public static Path getJavaPackPath(JavaPlugin plugin) {
+        File pluginsDir = plugin.getDataFolder().getParentFile(); // * root/plugins/
+        File itemsAdderDir = new File(pluginsDir, "ItemsAdder"); // * root/plugins/ItemsAdder
+        File outputDir = new File(itemsAdderDir, "output"); // * root/plugins/ItemsAdder/output
+        File generatedDir = new File(outputDir, "generated.zip"); // * root/plugins/ItemsAdder/output/generated.zip
+
+        return generatedDir.toPath();
+    }
+}

src/main/java/fr/openmc/riftengine/core/converter/writers/PackWriter.java

@@ -0,0 +1,8 @@
+package fr.openmc.riftengine.core.converter.writers;
+
+import java.io.IOException;
+import java.nio.file.Path;
+
+public interface PackWriter {
+    void write(Path bedrockRootPath, Path javaRootPath) throws IOException;
+}

src/main/java/fr/openmc/riftengine/core/converter/writers/manifest/ManifestWriter.java

@@ -0,0 +1,43 @@
+package fr.openmc.riftengine.core.converter.writers.manifest;
+
+import fr.openmc.riftengine.core.converter.writers.PackWriter;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public class ManifestWriter implements PackWriter {
+
+    private final PackIdentity identity;
+
+    public ManifestWriter(PackIdentity identity) {
+        this.identity = identity;
+    }
+
+    @Override
+    public void write(Path bedrockRootPath, Path javaRootPath) throws IOException {
+        String manifest = """
+            {
+              "format_version": 2,
+              "header": {
+                "name": "RiftPack",
+                "description": "Généré par RiftEngine à partir de celui de Java",
+                "uuid": "%s",
+                "version": [1, 0, 0],
+                "min_engine_version": [26, 44, 0]
+              },
+              "modules": [
+                {
+                  "type": "resources",
+                  "uuid": "%s",
+                  "version": [1, 0, 0]
+                }
+              ]
+            }
+            """.formatted(identity.headerUuid(), identity.moduleUuid());
+
+        Files.writeString(bedrockRootPath.resolve("manifest.json"), manifest, StandardCharsets.UTF_8);
+
+    }
+}

src/main/java/fr/openmc/riftengine/core/converter/writers/manifest/PackIdentity.java

@@ -0,0 +1,48 @@
+package fr.openmc.riftengine.core.converter.writers.manifest;
+
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.UUID;
+
+public class PackIdentity {
+
+    private final UUID headerUuid;
+    private final UUID moduleUuid;
+
+    private PackIdentity(UUID headerUuid, UUID moduleUuid) {
+        this.headerUuid = headerUuid;
+        this.moduleUuid = moduleUuid;
+    }
+
+    public UUID headerUuid() {
+        return headerUuid;
+    }
+
+    public UUID moduleUuid() {
+        return moduleUuid;
+    }
+
+    public static PackIdentity loadOrCreate(JavaPlugin plugin) throws IOException {
+        File file = new File(plugin.getDataFolder(), "pack-identity.yml");
+        YamlConfiguration config = YamlConfiguration.loadConfiguration(file);
+
+        boolean changed = false;
+        if (!config.contains("header-uuid")) {
+            config.set("header-uuid", UUID.randomUUID().toString());
+            changed = true;
+        }
+        if (!config.contains("module-uuid")) {
+            config.set("module-uuid", UUID.randomUUID().toString());
+            changed = true;
+        }
+        if (changed) config.save(file);
+
+        return new PackIdentity(
+            UUID.fromString(config.getString("header-uuid")),
+            UUID.fromString(config.getString("module-uuid"))
+        );
+    }
+}