Convertion des fonts java (emoji, icon exclu)

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

@@ -0,0 +1,25 @@
+package fr.openmc.riftengine.core;
+
+import lombok.Getter;
+import org.bukkit.configuration.file.FileConfiguration;
+
+import java.io.IOException;
+
+public class RiftConfig {
+    private final FileConfiguration config;
+
+    public RiftConfig(RiftPlugin plugin, FileConfiguration config) throws IOException {
+        this.config = config;
+
+        plugin.saveDefaultConfig();
+
+        load();
+    }
+
+    @Getter
+    private boolean hideScoreboardNumberBedrock;
+
+    public void load() {
+        this.hideScoreboardNumberBedrock = config.getBoolean("bedrock.hide-scoreboard-number", true);
+    }
+}

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

@@ -2,6 +2,7 @@
 
 import fr.openmc.core.bootstrap.integration.OMCLogger;
 import fr.openmc.riftengine.core.converter.ConverterManager;
+import fr.openmc.riftengine.core.registry.glyphs.GlyphsRegistry;
 import lombok.Getter;
 import lombok.Setter;
 import org.bukkit.plugin.java.JavaPlugin;
@@ -13,6 +14,7 @@
 import org.geysermc.geyser.api.pack.ResourcePack;
 import org.geysermc.geyser.api.pack.option.PriorityOption;
 
+import java.io.IOException;
 import java.nio.file.Path;
 import java.util.function.Consumer;
 
@@ -24,11 +26,21 @@ public class RiftPlugin extends JavaPlugin implements EventRegistrar {
     @Setter
     private static ResourcePack resourcePack;
 
+    @Getter
+    private RiftConfig riftConfig;
+
     private ConverterManager converterManager;
 
+    public static final int[] RP_VERSION = new int[] {1,0};
+
     @Override
     public void onEnable() {
         instance = this;
+        try {
+            riftConfig = new RiftConfig(this, this.getConfig());
+        } catch (IOException e) {
+            throw new RuntimeException("Erreur lors de la lecture du fichier config.yml", e);
+        }
 
         // * Registries internal
         RiftRegistry.initAll();
@@ -40,7 +52,10 @@ public void onEnable() {
         // * Listeners
         registerEvent(SessionLoadResourcePacksEvent.class, this::onLoadResourcePacks);
 
+        GlyphsRegistry glyphsRegistry = RiftRegistry.GLYPHS;
         OMCLogger.info("RiftEngine activé!");
+        OMCLogger.infoFormatted(glyphsRegistry.size() + "/" + glyphsRegistry.maxSize() + "glyphs enregistré");
+        OMCLogger.infoFormatted("Glyphs : " + glyphsRegistry.values());
     }
 
     @Override

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

@@ -1,36 +1,30 @@
 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.glyphs.GlyphsRegistry;
 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;
+    public static GlyphsRegistry GLYPHS;
 
     private static final List<LifecycleRegistry> LOADED = new ArrayList<>();
 
     private static final List<RegistryContext> ALL = List.of(
             new RegistryContext(
                     () -> MAPPINGS = new MappingRegistry(),
+                    RegistryLoadingType.RUNTIME),
+            new RegistryContext(
+                    () -> GLYPHS = new GlyphsRegistry(),
                     RegistryLoadingType.RUNTIME)
     );
 

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

@@ -1,11 +1,15 @@
 package fr.openmc.riftengine.core.converter;
 
 import fr.openmc.core.bootstrap.integration.OMCLogger;
+import fr.openmc.riftengine.core.RiftConfig;
 import fr.openmc.riftengine.core.RiftPlugin;
 import fr.openmc.riftengine.core.converter.writers.PackWriter;
+import fr.openmc.riftengine.core.converter.writers.font.FontWriter;
+import fr.openmc.riftengine.core.converter.writers.manifest.IconWriter;
 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.converter.writers.ui.ScoreboardUiWriter;
 import fr.openmc.riftengine.core.utils.ZipUtils;
 import org.bukkit.plugin.java.JavaPlugin;
 
@@ -25,11 +29,16 @@ public class ConverterManager {
 
     public ConverterManager(RiftPlugin plugin) {
         this.plugin = plugin;
+        RiftConfig config = plugin.getRiftConfig();
+
         try {
             identity = PackIdentity.loadOrCreate(plugin);
             writers.addAll(List.of(
+                    new IconWriter(),
                     new ManifestWriter(identity),
-                    new TranslationInjector()
+                    new TranslationInjector(),
+                    new FontWriter(),
+                    new ScoreboardUiWriter(config.isHideScoreboardNumberBedrock())
             ));
         } catch (Exception e) {
             throw new RuntimeException("Erreur lors d'initialisation du ConverterManager", e);

src/main/java/fr/openmc/riftengine/core/converter/writers/font/FontChar.java

@@ -0,0 +1,36 @@
+package fr.openmc.riftengine.core.converter.writers.font;
+
+import com.google.gson.JsonArray;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FontChar {
+    public record InternalFontChar(int row, int col, int codePoint, String character) {}
+
+    /**
+     * Extrait les char qu'on a dans un JsonArray
+     * @param charsRows JsonArray contenant les chars
+     * @return liste des characteres (row, col, codePoint)
+     */
+    public static List<InternalFontChar> extractCharPositions(JsonArray charsRows) {
+        List<InternalFontChar> result = new ArrayList<>();
+
+        for (int row = 0; row < charsRows.size(); row++) {
+            String rowStr = charsRows.get(row).getAsString();
+            int col = 0;
+            int i = 0;
+            while (i < rowStr.length()) {
+                int codePoint = rowStr.codePointAt(i); // ex U+0061 retournera 97, car 61 hex -> 97 en dec
+                i++;
+
+                if (codePoint != 0) {
+                    String character = String.valueOf(Character.toChars(codePoint));
+                    result.add(new InternalFontChar(row, col, codePoint, character));
+                }
+                col++;
+            }
+        }
+        return result;
+    }
+}

src/main/java/fr/openmc/riftengine/core/converter/writers/font/FontWriter.java

@@ -0,0 +1,92 @@
+package fr.openmc.riftengine.core.converter.writers.font;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import fr.openmc.riftengine.core.RiftRegistry;
+import fr.openmc.riftengine.core.converter.writers.PackWriter;
+import fr.openmc.riftengine.core.registry.glyphs.types.FontGlyph;
+import fr.openmc.riftengine.core.utils.IdentifierUtils;
+import fr.openmc.riftengine.core.utils.ScanUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Reader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.List;
+
+/**
+ * écrit pas réelement dans un dossier fonts dans le resourcepack bedorck,
+ * aucun support de font sur bedrock, donc on passe par les glyphs.
+ * et faut pas oublier de le modifier sur le coté du client
+ */
+public class FontWriter implements PackWriter {
+    @Override
+    public void write(Path bedrockRootPath, Path javaRootPath) throws IOException {
+        List<Path> fonts = ScanUtils.scanAllPath(javaRootPath, "font");
+
+        for (Path fontFile : fonts) {
+            if (isMinecraftFont(fontFile)) continue;
+            if (!fontFile.getFileName().toString().endsWith(".json")) continue;
+
+            JsonObject fontJson;
+            try (Reader reader = Files.newBufferedReader(fontFile)) {
+                fontJson = JsonParser.parseReader(reader).getAsJsonObject();
+            }
+
+            String fontNamespace = null;
+            String fontId = null;
+            File fontPng = null;
+            JsonArray fontsChar = null;
+            try {
+                for (JsonElement c : fontJson.getAsJsonArray("providers")) {
+                    JsonObject provider = c.getAsJsonObject();
+
+                    // todo : support les autres providers (space, TTF, ...)
+                    if (provider.get("type").getAsString().equals("bitmap")) {
+                        String file = IdentifierUtils.normalizeId(provider.get("file").getAsString());
+
+                        fontNamespace = file.split(":")[0];
+                        fontId = file.split(":")[1]
+                                .replace("font/", "")
+                                .replace(".png", "");
+                        fontPng = javaRootPath
+                                .resolve("assets")
+                                .resolve(file.split(":")[0])
+                                .resolve("textures")
+                                .resolve(file.split(":")[1])
+                                .toFile();
+                        fontsChar = provider.getAsJsonArray("chars");
+                    }
+                }
+            } catch (Exception e) {
+                throw new IOException("Erreur lors de la lecture du fichier font " + fontFile, e);
+            }
+
+            if (fontPng == null || fontsChar == null || fontNamespace == null || fontId == null) return;
+
+            List<FontChar.InternalFontChar> positions = FontChar.extractCharPositions(fontsChar);
+
+            String page = RiftRegistry.GLYPHS.nextGlyphPage();
+
+            for (FontChar.InternalFontChar pos : positions) {
+                String namespace = fontNamespace + ":" + fontId + ":" + pos.character();
+                RiftRegistry.GLYPHS.register(new FontGlyph(namespace, page, pos.row(), pos.col()));
+            }
+
+            String fileName = "glyph_" + page + ".png";
+            Path glyphPath = bedrockRootPath.resolve("font").resolve(fileName);
+            Files.createDirectories(glyphPath.getParent());
+            Files.copy(fontPng.toPath(), glyphPath, StandardCopyOption.REPLACE_EXISTING);
+        }
+    }
+
+    private boolean isMinecraftFont(Path fontFile) {
+        Path namespaceDir = fontFile.getParent().getParent();
+        if (namespaceDir == null) return false;
+        return namespaceDir.getFileName().toString().equals("minecraft");
+    }
+}

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

@@ -0,0 +1,21 @@
+package fr.openmc.riftengine.core.converter.writers.manifest;
+
+import fr.openmc.riftengine.core.converter.writers.PackWriter;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+
+public class IconWriter implements PackWriter {
+    @Override
+    public void write(Path bedrockRootPath, Path javaRootPath) throws IOException {
+        try (InputStream is = getClass().getResourceAsStream("/pack_icon.png")) {
+            if (is == null) throw new IOException("Resource introuvable : pack_icon.png");
+
+            Files.copy(is, bedrockRootPath.resolve("pack_icon.png"), StandardCopyOption.REPLACE_EXISTING);
+        }
+
+    }
+}

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

@@ -17,25 +17,27 @@ public ManifestWriter(PackIdentity identity) {
 
     @Override
     public void write(Path bedrockRootPath, Path javaRootPath) throws IOException {
+        int[] v = identity.version();
+        String versionJson = "[" + v[0] + ", " + v[1] + ", " + v[2] + "]";
         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]
+                "version": %s,
+                "min_engine_version": [1, 21, 0]
               },
               "modules": [
                 {
                   "type": "resources",
                   "uuid": "%s",
-                  "version": [1, 0, 0]
+                  "version": %s
                 }
               ]
             }
-            """.formatted(identity.headerUuid(), identity.moduleUuid());
+            """.formatted(identity.headerUuid(), versionJson, identity.moduleUuid(), versionJson);
 
         Files.writeString(bedrockRootPath.resolve("manifest.json"), manifest, StandardCharsets.UTF_8);