Add LiteLoader support

Author: AlexIIL

.gitignore

@@ -5,7 +5,6 @@
 /.classpath
 /.settings/
 /eclipse/
-/libs/
 /serverTest/
 
 

build.properties

@@ -1,6 +1,6 @@
 mc_version=1.8
 forge_version=11.14.1.1354
 
-mod_version=1.2.6
+mod_version=1.2.7
 fallback_build_number=1
 alexiil_lib_version=1.0.+

libs/liteloader-1.8.jar

@@ -0,0 +1,49 @@
+package alexiil.mods.load;
+
+import com.mumfrey.liteloader.client.gui.startup.LoadingBar;
+
+public class LiteLoaderProgress extends LoadingBar {
+    private static final int NUM_STATES = ModLoadingListener.State.values().length;
+    private static final int LITE_LOADER_INIT_ORDINAL = ModLoadingListener.State.LITE_LOADER_INIT.ordinal();
+    private static final float LITE_LOADER_START_PERCENT = LITE_LOADER_INIT_ORDINAL / (float) NUM_STATES;
+
+    private String message = "";
+    private int totalLiteProgress = 0;
+    private int liteProgress = 0;
+
+    @Override
+    protected void _dispose() {}
+
+    @Override
+    protected void _incLiteLoaderProgress() {
+        _incLiteLoaderProgress(message);
+    }
+
+    @Override
+    protected void _incLiteLoaderProgress(String arg0) {
+        message = arg0;
+        liteProgress++;
+        render();
+    }
+
+    @Override
+    protected void _incTotalLiteLoaderProgress(int arg0) {
+        totalLiteProgress += arg0;
+        render();
+    }
+
+    private void render() {
+        float litePercent = liteProgress / (float) totalLiteProgress;
+        litePercent /= (float) NUM_STATES;
+        float percent = LITE_LOADER_START_PERCENT + litePercent;
+        ProgressDisplayer.displayProgress("LiteLoader: " + message, percent);
+    }
+
+    @Override
+    protected void _setEnabled(boolean arg0) {}
+
+    @Override
+    protected void _setMessage(String arg0) {
+        message = arg0;
+    }
+}

libs/liteloader-core-1.8.jar

@@ -15,24 +15,43 @@
 
 public class ModLoadingListener {
     public enum State {
-        CONSTRUCT("Construction"), PRE_INIT("Pre Initialization"), INIT("Initialization"), POST_INIT("Post Initialization"), LOAD_COMPLETE(
-                "Completed"), FINAL_LOADING("Reloading Resource Packs", true);
+        CONSTRUCT("construction"), PRE_INIT("pre_initialization"), LITE_LOADER_INIT("lite", true, true), INIT("initialization"), POST_INIT(
+                "post_initialization"), LOAD_COMPLETE("completed"), FINAL_LOADING("reloading_resource_packs", true, false);
 
-        final String displayName;
+        private String translatedName = null;
+        final String name;
         /** If this state is only called once. This is false for all except for FINAL_LOADING */
         final boolean isLoneState;
+        /** If this is true, then ModStage.getNext will skip this, but it will still be included in the percentage
+         * calculation */
+        final boolean shouldSkip;
 
-        State(String name, boolean mods) {
-            displayName = name;
+        State(String name, boolean mods, boolean skip) {
             isLoneState = mods;
+            this.name = name;
+            shouldSkip = skip;
         }
 
         State(String name) {
-            this(name, false);
+            this(name, false, false);
+        }
+
+        public String translate() {
+            if (translatedName != null)
+                return translatedName;
+            String failure = name.replaceAll("\\_", " ");
+            String[] split = failure.split(" ");
+            failure = "";
+            for (int i = 0; i < split.length; i++) {
+                failure += i == 0 ? "" : " ";
+                failure += split[i].substring(0, 1).toUpperCase().concat(split[i].substring(1));
+            }
+            translatedName = Translation.translate("betterloadingscreen.state." + name, failure);
+            return translatedName;
         }
     }
 
-    public static class ModStage {
+    private static class ModStage {
         public final State state;
 
         @Override
@@ -56,21 +75,24 @@ public ModStage getNext() {
                 if (ord == State.values().length)
                     return null;
                 s = State.values()[ord];
+                if (s.shouldSkip)
+                    return new ModStage(s, ind).getNext();
             }
             return new ModStage(s, ind);
         }
 
         public String getDisplayText() {
             if (state.isLoneState)
-                return state.displayName;
-            return state.displayName + ": loading " + listeners.get(index).mod.getName();
+                return state.translate();
+            return state.translate() + ": " + Translation.translate("betterloadingscreen.loading", "loading") + " "
+                    + listeners.get(index).mod.getName();
         }
 
-        public double getProgress() {
-            double values = 100 / (float) State.values().length;
-            double part = state.ordinal() * values;
-            double size = listeners.size();
-            double percent = values * index / size;
+        public float getProgress() {
+            float values = 100 / (float) State.values().length;
+            float part = state.ordinal() * values;
+            float size = listeners.size();
+            float percent = values * index / size;
             return part + percent;
         }
     }

src/main/java/alexiil/mods/load/LiteLoaderProgress.java

@@ -12,17 +12,39 @@
 import org.objectweb.asm.tree.InsnNode;
 import org.objectweb.asm.tree.MethodInsnNode;
 import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.TypeInsnNode;
 
 import alexiil.mods.load.ProgressDisplayer;
 
-public class BetterLoadingScreenTransformer implements IClassTransformer {
+public class BetterLoadingScreenTransformer implements IClassTransformer, Opcodes {
     @Override
     public byte[] transform(String name, String transformedName, byte[] basicClass) {
         if (transformedName.equals("net.minecraft.client.Minecraft"))
             return transformMinecraft(basicClass, transformedName == name);
+        if (name.equals("com.mumfrey.liteloader.client.api.ObjectFactoryClient"))
+            return transformObjectFactoryClient(basicClass);
         return basicClass;
     }
 
+    private byte[] transformObjectFactoryClient(byte[] before) {
+        ClassNode classNode = new ClassNode();
+        ClassReader reader = new ClassReader(before);
+        reader.accept(classNode, 0);
+
+        for (MethodNode m : classNode.methods) {
+            if (m.name.equals("preBeginGame")) {
+                m.instructions.clear();
+                m.instructions.add(new TypeInsnNode(NEW, "alexiil/mods/load/LiteLoaderProgress"));
+                m.instructions.add(new MethodInsnNode(INVOKESPECIAL, "alexiil/mods/load/LiteLoaderProgress", "<init>", "()V", false));
+                m.instructions.add(new InsnNode(RETURN));
+            }
+        }
+
+        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
+        classNode.accept(cw);
+        return cw.toByteArray();
+    }
+
     private byte[] transformMinecraft(byte[] before, boolean dev) {
         boolean hasFoundStartGame = false;
         ClassNode classNode = new ClassNode();