Ajout du support des Blocks sur bedrock

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

@@ -0,0 +1,63 @@
+package fr.openmc.riftengine.core;
+
+import fr.openmc.core.bootstrap.integration.OMCLogger;
+
+public enum RiftLog {
+    RIFT_DISABLE("RiftEngine désactivé", LogType.INFO),
+    RIFT_PACK_INFO("Pack chargé avec succès (pack={})", LogType.INFO),
+    REGISTRY_LOADED("Registre {} chargé pendant le runtime", LogType.SUCCESS),
+    REGISTRY_DISABLE("Registre {} stoppé", LogType.SUCCESS),
+
+    IMAGE_NOT_FOUND("Image introuvable pour {} dans le path {} (skip)", LogType.ERROR),
+    ERROR_READING("Erreur de lecture pour {} (skip) : ", LogType.ERROR),
+    ICON_TYPE_NOT_RECOGNIZED("Icon type {} : n'est pas reconnu", LogType.ERROR),
+    DETECTED_AS_MENU_GUI("Glyph {} detécté comme MENU_GUI, il ne sera donc pas en glyph, vu que les menus sont géré autrement", LogType.WARN),
+    ICON_SKIPPED("Image manquante pour {} emoji(s)/icon(s) sur {}.", LogType.INFO),
+    DETECTED_AS("{} ({}x{}) détecté comme {}", LogType.INFO),
+    SYMBOL_KEY_NOT_FOUND("Clé {} introuvable dans {}.", LogType.WARN),
+    NUMBER_GLYPH_REGISTERED("{}/{} glyphs enregistré", LogType.INFO),
+
+    ITEM_NOT_RESOURCE("Item {} : n'a pas de best resources", LogType.WARN),
+    RESOURCE_NOT_FOUND("Item {} : a aucune resource", LogType.WARN)
+    ;
+
+    public static void logBanner(String pluginVersion, String server, String javaVersion) {
+        OMCLogger.info("\u001B[1;35m██████╗ ██╗███████╗████████╗    \u001B[0;95mRIFT v{}\u001B[0m", pluginVersion);
+        OMCLogger.info("\u001B[1;35m██╔══██╗██║██╔════╝╚══██╔══╝    \u001B[0;90mPaper {}\u001B[0m", server);
+        OMCLogger.info("\u001B[1;95m██████╔╝██║█████╗     ██║       \u001B[0;90mJava  {}\u001B[0m", javaVersion);
+        OMCLogger.info("\u001B[1;95m██╔══██╗██║██╔══╝     ██║   \u001B[0m");
+        OMCLogger.info("\u001B[1;35m██║  ██║██║██║        ██║   \u001B[0m");
+        OMCLogger.info("\u001B[1;95m╚═╝  ╚═╝╚═╝╚═╝        ╚═╝   \u001B[0m");
+        OMCLogger.info("");
+    }
+
+    private enum LogType {
+        WARN,
+        ERROR,
+        DEBUG,
+        INFO,
+        SUCCESS
+    }
+
+    private final String message;
+    private final LogType type;
+
+    RiftLog(String message, LogType type) {
+        this.message = message;
+        this.type = type;
+    }
+
+    public void send(Object... args) {
+        if (type == LogType.WARN) {
+            OMCLogger.warnFormatted(message, args);
+        } else if (type == LogType.ERROR) {
+            OMCLogger.errorFormatted(message, args);
+        } else if (type == LogType.DEBUG) {
+            OMCLogger.debug(message, args);
+        } else if (type == LogType.INFO) {
+            OMCLogger.infoFormatted(message, args);
+        } else if (type == LogType.SUCCESS) {
+            OMCLogger.successFormatted(message, args);
+        }
+    }
+}

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

@@ -8,7 +8,9 @@
 import fr.openmc.riftengine.core.registry.glyphs.GlyphsRegistry;
 import lombok.Getter;
 import lombok.Setter;
+import org.bukkit.Bukkit;
 import org.bukkit.event.Listener;
+import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.geysermc.event.Event;
 import org.geysermc.geyser.api.GeyserApi;
@@ -24,6 +26,7 @@
 import java.util.List;
 import java.util.function.Consumer;
 
+// todo: clean les writer et tt qui néccesite du Yml a adapter au max avec nos YmlUtils dans le plugin OpenMC
 public class RiftPlugin extends JavaPlugin implements EventRegistrar {
     @Getter
     private static RiftPlugin instance;
@@ -46,6 +49,8 @@ public class RiftPlugin extends JavaPlugin implements EventRegistrar {
     @Override
     public void onEnable() {
         instance = this;
+        logLoadMessage(this);
+
         try {
             riftConfig = new RiftConfig(this, this.getConfig());
         } catch (IOException e) {
@@ -71,16 +76,14 @@ public void onEnable() {
         }
 
         GlyphsRegistry glyphsRegistry = RiftRegistry.GLYPHS;
-        OMCLogger.info("RiftEngine activé!");
-        OMCLogger.infoFormatted(glyphsRegistry.size() + "/" + glyphsRegistry.maxSize() + " glyphs enregistré");
-        OMCLogger.infoFormatted("Glyphs : " + glyphsRegistry.values());
+        RiftLog.NUMBER_GLYPH_REGISTERED.send(glyphsRegistry.size(), glyphsRegistry.maxSize());
     }
 
     @Override
     public void onDisable() {
         RiftRegistry.stopAll();
 
-        OMCLogger.info("RiftEngine désactivé!");
+        RiftLog.RIFT_DISABLE.send();
     }
 
     public void updateBedrockResourcePack() {
@@ -95,13 +98,11 @@ public void updateBedrockResourcePack() {
     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 enregistré !");
+        RiftLog.RIFT_PACK_INFO.send(pack);
     }
 
     public void registerListener(Listener... listeners) {
@@ -112,4 +113,38 @@ public void registerListener(Listener... listeners) {
     public <T extends Event> void registerEvent(Class<T> listenerClass, Consumer<T> handler) {
         GeyserApi.api().eventBus().subscribe(this, listenerClass, handler);
     }
+
+    public static void logLoadMessage(RiftPlugin plugin) {
+        RiftLog.logBanner(
+                plugin.getPluginMeta().getVersion(),
+                Bukkit.getName() + " " + Bukkit.getVersion(),
+                System.getProperty("java.version")
+        );
+
+        for (String dependency : plugin.getPluginMeta().getPluginDependencies()) {
+            logPluginStatus(dependency, false);
+        }
+
+        for (String dependency : plugin.getPluginMeta().getPluginSoftDependencies()) {
+            logPluginStatus(dependency, true);
+        }
+    }
+
+    /**
+     * Log l'état d'une dépendance (requise ou optionnelle).
+     *
+     * @param name Nom du plugin dépendance
+     * @param optional True si la dépendance est optionnelle
+     */
+    private static void logPluginStatus(String name, boolean optional) {
+        Plugin plugin = Bukkit.getPluginManager().getPlugin(name);
+        boolean enabled = plugin != null && plugin.isEnabled();
+
+        String icon = enabled ? "✔" : "✘";
+        String color = enabled ? "\u001B[32m" : "\u001B[31m";
+        String version = enabled ? " v" + plugin.getPluginMeta().getVersion() : "";
+        String label = optional ? " (facultatif)" : "";
+
+        OMCLogger.info("  {}{} {}{}{}\u001B[0m", color, icon, name, version, label);
+    }
 }

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

@@ -1,11 +1,11 @@
 package fr.openmc.riftengine.core;
 
 
-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.riftengine.core.registry.glyphs.GlyphsRegistry;
+import fr.openmc.riftengine.core.registry.resolver.ResolverRegistry;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -14,12 +14,16 @@
 public final class RiftRegistry {
     // * Registre globaux
     public static GlyphsRegistry GLYPHS;
+    public static ResolverRegistry RESOLVERS;
 
     private static final List<LifecycleRegistry> LOADED = new ArrayList<>();
 
     private static final List<RegistryContext> ALL = List.of(
             new RegistryContext(
                     () -> GLYPHS = new GlyphsRegistry(),
+                    RegistryLoadingType.RUNTIME),
+            new RegistryContext(
+                    () -> RESOLVERS = new ResolverRegistry(),
                     RegistryLoadingType.RUNTIME)
     );
 
@@ -32,14 +36,15 @@ public static void initAll() {
             LifecycleRegistry r = load(ctx);
 
             r.init();
-            OMCLogger.successFormatted("Registre {} chargé pendant le runtime", r.getClass().getSimpleName());
+
+            RiftLog.REGISTRY_LOADED.send(r.getClass().getSimpleName());
         }
     }
 
     public static void stopAll() {
         for (LifecycleRegistry r : LOADED) {
             r.stop();
-            OMCLogger.successFormatted("Registre {} stoppé", r.getClass().getSimpleName());
+            RiftLog.REGISTRY_DISABLE.send(r.getClass().getSimpleName());
         }
         LOADED.clear();
     }

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

@@ -7,7 +7,10 @@
 import fr.openmc.riftengine.api.scanner.items.ItemEntry;
 import fr.openmc.riftengine.core.RiftConfig;
 import fr.openmc.riftengine.core.RiftPlugin;
+import fr.openmc.riftengine.core.RiftRegistry;
 import fr.openmc.riftengine.core.converter.writers.PackWriter;
+import fr.openmc.riftengine.core.converter.writers.blocks.BlocksMappingWriter;
+import fr.openmc.riftengine.core.converter.writers.blocks.TerrainTextureJsonWriter;
 import fr.openmc.riftengine.core.converter.writers.glyph.font.FontWriter;
 import fr.openmc.riftengine.core.converter.writers.glyph.icons.IconsWriter;
 import fr.openmc.riftengine.core.converter.writers.glyph.icons.SymbolWriter;
@@ -19,6 +22,7 @@
 import fr.openmc.riftengine.core.converter.writers.manifest.PackIdentity;
 import fr.openmc.riftengine.core.converter.writers.translations.TranslationInjector;
 import fr.openmc.riftengine.core.converter.writers.ui.ScoreboardUiWriter;
+import fr.openmc.riftengine.core.resolvers.items.ItemResourceResolver;
 import org.bukkit.plugin.java.JavaPlugin;
 
 import java.io.File;
@@ -27,42 +31,50 @@
 import java.util.ArrayList;
 import java.util.List;
 
-// todo: faire un converter manager clean, avec des systemes de step, (surtout du coté logger aussi)
 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;
         RiftConfig config = plugin.getRiftConfig();
         Path itemsAdderContents = getItemsAdderContents(plugin);
 
         try {
-            identity = PackIdentity.loadOrCreate(plugin);
+            PackIdentity identity = PackIdentity.loadOrCreate(plugin);
             List<ItemEntry> items = OMCRegistry.SCANNERS.ITEMS.scan(itemsAdderContents);
-            writers.addAll(List.of(
-                    new IconWriter(),
-                    new ManifestWriter(identity),
+            ItemResourceResolver resolver = RiftRegistry.RESOLVERS.ITEM_RESOURCE_RESOLVER;
 
-                    new TranslationInjector(),
-                    new FontWriter(),
-                    new ScoreboardUiWriter(config.isHideScoreboardNumberBedrock()),
+            register("Icônes", new IconWriter());
+            register("Manifest", new ManifestWriter(identity));
+            register("Traductions", new TranslationInjector());
+            register("Polices", new FontWriter());
 
-                    new IconsWriter(itemsAdderContents),
-                    new SymbolWriter(),
+            register("Scoreboard",
+                    new ScoreboardUiWriter(config.isHideScoreboardNumberBedrock()));
+
+            register("Icônes ItemsAdder", new IconsWriter(itemsAdderContents));
+            register("Mappings des symboles", new SymbolWriter());
+
+            register("Textures des items", new ItemsTextureJsonWriter(items, resolver));
+            register("Fichiers de textures", new ItemsTextureWriter(items, resolver));
+            register("Mappings des items", new ItemsMappingWriter(items, resolver));
+
+            register("Textures des blocs",
+                    new TerrainTextureJsonWriter(identity, items, resolver));
+            register("Mappings des blocs", new BlocksMappingWriter(items, resolver));
 
-                    new ItemsTextureJsonWriter(items),
-                    new ItemsTextureWriter(items),
-                    new ItemsMappingWriter(items)
-            ));
         } catch (Exception e) {
             throw new RuntimeException("Erreur lors d'initialisation du ConverterManager", e);
         }
     }
 
+    private void register(String name, PackWriter writer) {
+        writers.add(new RegisteredPackWriter(name, writer));
+    }
+
     /**
      * Prends un pack java et le convertit en pack bedrock
      */

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

@@ -0,0 +1,34 @@
+package fr.openmc.riftengine.core.converter;
+
+import fr.openmc.core.bootstrap.integration.OMCLogger;
+import fr.openmc.core.utils.text.DateUtils;
+import fr.openmc.riftengine.core.converter.writers.PackWriter;
+
+import java.nio.file.Path;
+import java.time.LocalDateTime;
+
+public class RegisteredPackWriter implements PackWriter {
+    private final String name;
+    private final PackWriter wrapped;
+
+    public RegisteredPackWriter(String name, PackWriter wrapped) {
+        this.name = name;
+        this.wrapped = wrapped;
+    }
+
+    @Override
+    public void write(Path bedrockRootPath, Path javaRootPath) throws Exception {
+        LocalDateTime start = DateUtils.getLocalDateTime();
+        OMCLogger.infoFormatted("Conversion : " + name);
+
+        try {
+            wrapped.write(bedrockRootPath, javaRootPath);
+
+            long elapsed = -DateUtils.getDelayBetweenNowMillis(start);
+            OMCLogger.successFormatted(name + " terminé en " + elapsed + " ms");
+        } catch (Exception e) {
+            OMCLogger.warnFormatted("Échec de " + name + " : " + e.getMessage(), e);
+            throw e;
+        }
+    }
+}

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

@@ -1,8 +1,34 @@
 package fr.openmc.riftengine.core.converter.writers;
 
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonObject;
+
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 
 public interface PackWriter {
+    Gson GSON = new GsonBuilder()
+            .setPrettyPrinting()
+            .disableHtmlEscaping() // fix des = qui était en caractere unicode
+            .create();
+
     void write(Path bedrockRootPath, Path javaRootPath) throws Exception;
+
+    default void writeJsonFile(Path outputFile, JsonObject root) throws IOException {
+        this.writeFile(outputFile, GSON.toJson(root));
+    }
+
+    default void writeFile(Path outputFile, String content) throws IOException {
+        Files.createDirectories(outputFile.getParent());
+        Files.writeString(outputFile, content, StandardCharsets.UTF_8);
+    }
+
+    default void copyFile(Path toCopy, Path where) throws IOException {
+        Files.createDirectories(where.getParent());
+        Files.copy(toCopy, where, StandardCopyOption.REPLACE_EXISTING);
+    }
 }