Add Hex Text Compatibility to Angelica

dependencies.gradle

@@ -99,6 +99,10 @@ dependencies {
     compileOnly(rfg.deobf("curse.maven:xaeros-minimap-263420:5060684"))
     compileOnly(rfg.deobf("curse.maven:security-craft-64760:2818228"))
 
+    compileOnly(rfg.deobf("curse.maven:hex-text-1379870:7197368")) { transitive = false }
+    // For Testing Only -- Hex Text
+    // runtimeOnlyNonPublishable(rfg.deobf("curse.maven:hex-text-1379870:7197368")) { transitive = false }
+
     runtimeOnlyNonPublishable(rfg.deobf("CoreTweaks:CoreTweaks:0.3.3.2"))
     // For testing alternative splash screens, can be sourced from https://github.com/MalTeeez/ModernSplash/releases
     //runtimeOnly(rfg.deobf(files("dependencies/modernsplash-1.7.10-1.2.2-dev.jar")))

src/main/java/com/gtnewhorizons/angelica/AngelicaMod.java

@@ -48,6 +48,7 @@ public void preInit(FMLPreInitializationEvent event) {
 
     @Mod.EventHandler
     public void init(FMLInitializationEvent event) {
+        ModStatus.init();
         proxy.init(event);
     }
 

src/main/java/com/gtnewhorizons/angelica/client/font/color/AngelicaColorResolver.java

@@ -0,0 +1,10 @@
+package com.gtnewhorizons.angelica.client.font.color;
+
+/**
+ * Parses formatting markers into a {@link ResolvedText} description that the
+ * batching font renderer can consume.
+ */
+public interface AngelicaColorResolver {
+
+    ResolvedText resolve(CharSequence text, int start, int end, int baseColor, int baseShadowColor);
+}

src/main/java/com/gtnewhorizons/angelica/client/font/color/AngelicaColorResolvers.java

@@ -0,0 +1,60 @@
+package com.gtnewhorizons.angelica.client.font.color;
+
+import com.gtnewhorizons.angelica.client.font.BatchingFontRenderer;
+import com.gtnewhorizons.angelica.compat.hextext.HexTextCompat;
+import com.gtnewhorizons.angelica.compat.hextext.HexTextCompat.Bridge;
+import com.gtnewhorizons.angelica.compat.hextext.HexTextServices;
+import com.gtnewhorizons.angelica.config.FontConfig;
+
+public final class AngelicaColorResolvers {
+
+    private AngelicaColorResolvers() {
+    }
+
+    public static AngelicaColorResolver create(BatchingFontRenderer renderer, int[] vanillaPalette) {
+        AngelicaColorResolver fallback = new DefaultColorResolver(vanillaPalette);
+        if (!FontConfig.enableHexTextCompat) {
+            return fallback;
+        }
+
+        return new SwitchingColorResolver(vanillaPalette, fallback);
+    }
+
+    private static final class SwitchingColorResolver implements AngelicaColorResolver {
+
+        private final int[] vanillaPalette;
+        private final AngelicaColorResolver fallback;
+
+        private volatile HexTextColorResolver hexResolver;
+
+        private SwitchingColorResolver(int[] vanillaPalette, AngelicaColorResolver fallback) {
+            this.vanillaPalette = vanillaPalette;
+            this.fallback = fallback;
+        }
+
+        @Override
+        public ResolvedText resolve(CharSequence text, int start, int end, int baseColor, int baseShadowColor) {
+            if (!FontConfig.enableHexTextCompat) {
+                hexResolver = null;
+                return fallback.resolve(text, start, end, baseColor, baseShadowColor);
+            }
+
+            if (HexTextServices.isSupported()) {
+                HexTextColorResolver resolver = hexResolver;
+                if (resolver == null) {
+                    Bridge bridge = HexTextCompat.tryCreateBridge();
+                    if (bridge != null) {
+                        resolver = new HexTextColorResolver(vanillaPalette, bridge);
+                        hexResolver = resolver;
+                    } else {
+                        return fallback.resolve(text, start, end, baseColor, baseShadowColor);
+                    }
+                }
+                return resolver.resolve(text, start, end, baseColor, baseShadowColor);
+            }
+
+            hexResolver = null;
+            return fallback.resolve(text, start, end, baseColor, baseShadowColor);
+        }
+    }
+}

src/main/java/com/gtnewhorizons/angelica/client/font/color/DefaultColorResolver.java

@@ -0,0 +1,97 @@
+package com.gtnewhorizons.angelica.client.font.color;
+
+import static com.gtnewhorizons.angelica.client.font.BatchingFontRenderer.FORMATTING_CHAR;
+
+final class DefaultColorResolver implements AngelicaColorResolver {
+
+    private final int[] vanillaPalette;
+
+    DefaultColorResolver(int[] vanillaPalette) {
+        this.vanillaPalette = vanillaPalette;
+    }
+
+    @Override
+    public ResolvedText resolve(CharSequence text, int start, int end, int baseColor, int baseShadowColor) {
+        ResolvedText.Builder builder = ResolvedText.builder(end - start);
+        FormattingState state = new FormattingState(baseColor, baseShadowColor);
+
+        for (int index = Math.max(0, start); index < Math.min(text.length(), end); index++) {
+            char chr = text.charAt(index);
+            if (chr == FORMATTING_CHAR && index + 1 < end) {
+                char fmtCode = Character.toLowerCase(text.charAt(index + 1));
+                index++;
+                applyVanillaFormatting(state, fmtCode);
+                continue;
+            }
+
+            if (state.random) {
+                // keep vanilla behaviour; actual replacement happens during rendering
+            }
+
+            builder.append(chr, state.color, state.shadowColor, state.bold, state.italic, state.underline,
+                state.strikethrough, state.random);
+        }
+
+        return builder.build();
+    }
+
+    private void applyVanillaFormatting(FormattingState state, char fmtCode) {
+        if (charInRange(fmtCode, '0', '9') || charInRange(fmtCode, 'a', 'f')) {
+            state.random = false;
+            state.bold = false;
+            state.strikethrough = false;
+            state.underline = false;
+            state.italic = false;
+            int colorIdx = charInRange(fmtCode, '0', '9') ? (fmtCode - '0') : (fmtCode - 'a' + 10);
+            int rgb = vanillaPalette[colorIdx];
+            state.color = (state.color & 0xFF000000) | (rgb & 0x00FFFFFF);
+            int shadowRgb = vanillaPalette[colorIdx + 16];
+            state.shadowColor = (state.shadowColor & 0xFF000000) | (shadowRgb & 0x00FFFFFF);
+        } else if (fmtCode == 'k') {
+            state.random = true;
+        } else if (fmtCode == 'l') {
+            state.bold = true;
+        } else if (fmtCode == 'm') {
+            state.strikethrough = true;
+        } else if (fmtCode == 'n') {
+            state.underline = true;
+        } else if (fmtCode == 'o') {
+            state.italic = true;
+        } else if (fmtCode == 'r') {
+            state.reset();
+        }
+    }
+
+    private static boolean charInRange(char what, char fromInclusive, char toInclusive) {
+        return what >= fromInclusive && what <= toInclusive;
+    }
+
+    private static final class FormattingState {
+        final int baseColor;
+        final int baseShadowColor;
+        int color;
+        int shadowColor;
+        boolean italic;
+        boolean random;
+        boolean bold;
+        boolean strikethrough;
+        boolean underline;
+
+        FormattingState(int baseColor, int baseShadowColor) {
+            this.baseColor = baseColor;
+            this.baseShadowColor = baseShadowColor;
+            this.color = baseColor;
+            this.shadowColor = baseShadowColor;
+        }
+
+        void reset() {
+            color = baseColor;
+            shadowColor = baseShadowColor;
+            italic = false;
+            random = false;
+            bold = false;
+            strikethrough = false;
+            underline = false;
+        }
+    }
+}