Backport to 1.7.10

44109f1 Recover from corrupted entity positions cache (fixes #73)

.drone.yml

@@ -7,6 +7,7 @@ pipeline:
     commands:
       - curl --fail --create-dirs -o $HOME/.gradle/init.d/mirror.gradle https://maven.johni0702.de/config/gradle
       - curl --fail --create-dirs -o $HOME/.m2/settings.xml https://maven.johni0702.de/config/maven
+      - ./gradlew setupCIWorkspace
       - ./gradlew :build
   archive:
     image: plugins/s3

.drone.yml.sig

@@ -1 +1 @@
-eyJhbGciOiJIUzI1NiJ9.cGlwZWxpbmU6CiAgY2xvbmU6CiAgICBpbWFnZTogcGx1Z2lucy9naXQKICAgIHRhZ3M6IHRydWUKICBidWlsZDoKICAgIGltYWdlOiBtYXZlbjozLjMuOS1qZGstOAogICAgY29tbWFuZHM6CiAgICAgIC0gY3VybCAtLWZhaWwgLS1jcmVhdGUtZGlycyAtbyAkSE9NRS8uZ3JhZGxlL2luaXQuZC9taXJyb3IuZ3JhZGxlIGh0dHBzOi8vbWF2ZW4uam9obmkwNzAyLmRlL2NvbmZpZy9ncmFkbGUKICAgICAgLSBjdXJsIC0tZmFpbCAtLWNyZWF0ZS1kaXJzIC1vICRIT01FLy5tMi9zZXR0aW5ncy54bWwgaHR0cHM6Ly9tYXZlbi5qb2huaTA3MDIuZGUvY29uZmlnL21hdmVuCiAgICAgIC0gLi9ncmFkbGV3IDpidWlsZAogIGFyY2hpdmU6CiAgICBpbWFnZTogcGx1Z2lucy9zMwogICAgYWNsOiBwdWJsaWMtcmVhZAogICAgcmVnaW9uOiAidXMtZWFzdC0xIgogICAgYnVja2V0OiAicmVwbGF5bW9kIgogICAgcGF0aF9zdHlsZTogdHJ1ZQogICAgc291cmNlOiBidWlsZC9saWJzLyoKICAgIHN0cmlwX3ByZWZpeDogYnVpbGQvbGlicy8KICAgIHRhcmdldDogLwo.Z6rpaLplJKQ4pzB8AjCnplgci42qEu7L4LeS0fGm4SY
+eyJhbGciOiJIUzI1NiJ9.cGlwZWxpbmU6CiAgY2xvbmU6CiAgICBpbWFnZTogcGx1Z2lucy9naXQKICAgIHRhZ3M6IHRydWUKICBidWlsZDoKICAgIGltYWdlOiBtYXZlbjozLjMuOS1qZGstOAogICAgY29tbWFuZHM6CiAgICAgIC0gY3VybCAtLWZhaWwgLS1jcmVhdGUtZGlycyAtbyAkSE9NRS8uZ3JhZGxlL2luaXQuZC9taXJyb3IuZ3JhZGxlIGh0dHBzOi8vbWF2ZW4uam9obmkwNzAyLmRlL2NvbmZpZy9ncmFkbGUKICAgICAgLSBjdXJsIC0tZmFpbCAtLWNyZWF0ZS1kaXJzIC1vICRIT01FLy5tMi9zZXR0aW5ncy54bWwgaHR0cHM6Ly9tYXZlbi5qb2huaTA3MDIuZGUvY29uZmlnL21hdmVuCiAgICAgIC0gLi9ncmFkbGV3IHNldHVwQ0lXb3Jrc3BhY2UKICAgICAgLSAuL2dyYWRsZXcgOmJ1aWxkCiAgYXJjaGl2ZToKICAgIGltYWdlOiBwbHVnaW5zL3MzCiAgICBhY2w6IHB1YmxpYy1yZWFkCiAgICByZWdpb246ICJ1cy1lYXN0LTEiCiAgICBidWNrZXQ6ICJyZXBsYXltb2QiCiAgICBwYXRoX3N0eWxlOiB0cnVlCiAgICBzb3VyY2U6IGJ1aWxkL2xpYnMvKgogICAgc3RyaXBfcHJlZml4OiBidWlsZC9saWJzLwogICAgdGFyZ2V0OiAvCg.riE6lhwfdNUhI7LO2SxEKFOjzjaX40ne7Ae9gyP75KE

.gitmodules

@@ -2,10 +2,6 @@
 	path = jGui
 	url = https://github.com/ReplayMod/jGui
 
-[submodule "ReplayStudio"]
-	path = ReplayStudio
-	url = https://github.com/ReplayMod/ReplayStudio
-
 [submodule "src/main/resources/assets/replaymod/lang"]
 	path = src/main/resources/assets/replaymod/lang
 	url = https://github.com/ReplayMod/Translations

build.gradle

@@ -7,23 +7,17 @@ buildscript {
             name = "forge"
             url = "http://files.minecraftforge.net/maven"
         }
-        maven {
-            name = "sponge"
-            url = "https://repo.spongepowered.org/maven"
-        }
         maven {
             name = "sonatype"
             url = "https://oss.sonatype.org/content/repositories/snapshots/"
         }
     }
     dependencies {
-        classpath 'net.minecraftforge.gradle:ForgeGradle:2.2-SNAPSHOT'
-        classpath 'org.spongepowered:mixingradle:0.4-SNAPSHOT'
+        classpath 'net.minecraftforge.gradle:ForgeGradle:1.2-SNAPSHOT'
     }
 }
 
-apply plugin: 'net.minecraftforge.gradle.forge'
-apply plugin: 'org.spongepowered.mixin'
+apply plugin: 'forge'
 
 sourceCompatibility = 1.8
 targetCompatibility = 1.8
@@ -32,13 +26,22 @@ version = gitDescribe()
 group= "com.replaymod"
 archivesBaseName = "replaymod"
 
+ext {
+    mixinConfigs = [
+            'compat.shaders', 'extras.playeroverview', 'recording', 'render', 'replay'
+    ].collect {"mixins.${it}.replaymod.json"}
+    mixinSrg = new File(project.buildDir, 'tmp/mixins/mixins.srg')
+    mixinRefMap = new File(project.buildDir, 'tmp/mixins/mixins.replaymod.refmap.json')
+}
+
 minecraft {
-    coreMod = 'com.replaymod.core.LoadingPlugin'
-    version = '1.10.2-12.18.2.2099'
+    version = '1.7.10-10.13.4.1558-1.7.10'
     runDir = "eclipse"
-    mappings = "snapshot_20160518"
+    mappings = "stable_12"
     replace '@MOD_VERSION@', project.version
-    replace '@MC_VERSION@', project.minecraft.version
+    // Includes intentional whitespace to stop Forge from declaring the mod to be compatible with
+    // a newer srg-compatible MC version (that may be using a different protocol version)
+    replace '@MC_VERSION@', "[ ${project.minecraft.version} ]"
 }
 
 repositories {
@@ -47,7 +50,7 @@ repositories {
         url = "http://repo.spongepowered.org/maven/"
     }
     maven {
-        url 'https://repo.spacehq.org/content/repositories/snapshots/'
+        url 'https://jitpack.io'
     }
 }
 
@@ -69,24 +72,22 @@ dependencies {
 
     shade 'org.aspectj:aspectjrt:1.8.2'
 
-    compile project(':ReplayStudio')
+    shade 'com.github.replaymod:ReplayStudio:181140c'
 
     testCompile 'junit:junit:4.11'
 }
 
-tasks['idea'].dependsOn ':ReplayStudio:preshadowJar'
-
 jar {
     duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 
     dependsOn configurations.compile
     dependsOn configurations.shade
-    dependsOn ':ReplayStudio:shadowJar'
+
+    from project.mixinRefMap
 
     def shade = {files(
             configurations.compile.findAll {it.name.startsWith 'mixin-'}
                     + configurations.shade
-                    + getTasks().getByPath(':ReplayStudio:shadowJar').outputs.files
     )}
 
     def noticeDir = file("$buildDir/NOTICE")
@@ -115,7 +116,8 @@ jar {
     manifest {
          attributes 'TweakClass': 'org.spongepowered.asm.launch.MixinTweaker',
                  'TweakOrder': '0',
-                 'FMLCorePluginContainsFMLMod': 'true',
+                 'MixinConfigs': project.mixinConfigs.join(','),
+                 'FMLCorePlugin': 'com.replaymod.core.LoadingPlugin',
                  'FMLAT': 'replaymod_at.cfg'
 	}
 }
@@ -155,6 +157,8 @@ processResources
 
 sourceSets {
     main {
+        // Required so resources are loaded correctly in dev env
+        output.resourcesDir = output.classesDir
         // Directly include jGui into main build
         // This could also be done by including it as a gradle subproject, however
         // doing so caused classpath issues on some IntelliJ versions.
@@ -164,7 +168,6 @@ sourceSets {
         resources {
             srcDir 'jGui/src/main/resources'
         }
-        refMap = "mixins.replaymod.refmap.json"
     }
     integrationTest {
         compileClasspath += main.runtimeClasspath + main.output
@@ -180,61 +183,25 @@ task copySrg(type: Copy, dependsOn: 'genSrgs') {
     into 'build'
 }
 
+reobf.doFirst {
+    if (project.mixinSrg.exists()) {
+        addExtraSrgFile project.mixinSrg
+    }
+}
+
+compileJava.dependsOn copySrg
+compileJava {
+    options.compilerArgs += [
+            "-AoutSrgFile=${project.mixinSrg.canonicalPath}",
+            "-AoutRefMapFile=${project.mixinRefMap.canonicalPath}",
+            "-AreobfSrgFile=${project.file('build/mcp-srg.srg').canonicalPath}"
+    ]
+}
+
 setupDecompWorkspace.dependsOn copySrg
 setupDevWorkspace.dependsOn copySrg
 project.tasks.idea.dependsOn copySrg
 
-
-import org.objectweb.asm.*
-
-import java.util.zip.ZipEntry
-import java.util.zip.ZipFile
-import java.util.zip.ZipOutputStream
-
-import static org.objectweb.asm.Opcodes.ASM5
-
-// MC binaries were complied with a java version that produces invalid class files under certain circumstances
-// This causes setupCIWorkspace to be insufficient for compiling.
-// Related JDK bug: https://bugs.openjdk.java.net/browse/JDK-8066725
-// As a workaround, to use setupCIWorkspace on Drone, we modify the bin jar in-place and remove all parameter annotations.
-// WARNING: This piece of code ignores any and all gradle conventions and will probably fail horribly when run outside
-// of a single-use environment (e.g. Drone). Use setupDecompWorkspace for normal use.
-tasks.deobfMcMCP.doLast {
-    println "Applying RuntimeInvisibleParameterAnnotations workaround..."
-    File jar = getOutJar()
-    File tmp = new File((File) getTemporaryDir(), "workaround.jar")
-    tmp.withOutputStream {
-        new ZipOutputStream(it).withStream { dst ->
-            new ZipFile(jar).withCloseable { src ->
-                src.entries().each {
-                    if (it.name.startsWith("net/minecraft/") && it.name.endsWith(".class")) {
-                        def cw = new ClassWriter(0)
-                        def cv = new ClassVisitor(ASM5, cw) {
-                            @Override
-                            MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
-                                return new MethodVisitor(ASM5, cv.visitMethod(access, name, desc, signature, exceptions)) {
-                                    @Override
-                                    AnnotationVisitor visitParameterAnnotation(int parameter, String pdesc, boolean visible) {
-                                        return null // Strip all parameter annotations
-                                    }
-                                }
-                            }
-                        }
-                        new ClassReader(src.getInputStream(it)).accept(cv, 0)
-                        dst.putNextEntry(new ZipEntry(it.name))
-                        dst.write(cw.toByteArray())
-                    } else {
-                        dst.putNextEntry(it)
-                        dst.write(src.getInputStream(it).bytes)
-                    }
-                }
-            }
-        }
-    }
-    jar.delete()
-    tmp.renameTo(jar)
-}
-
 task runIntegrationTest(type: JavaExec, dependsOn: ["makeStart", "jar"]) {
     main = 'GradleStart'
     standardOutput = System.out

settings.gradle

@@ -1 +0,0 @@
-include 'ReplayStudio'

src/integration-test/java/com/replaymod/core/AbstractTask.java

@@ -3,6 +3,9 @@ package com.replaymod.core;
 import com.google.common.collect.Iterables;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
 import de.johni0702.minecraft.gui.container.AbstractGuiOverlay;
 import de.johni0702.minecraft.gui.container.AbstractGuiScreen;
 import de.johni0702.minecraft.gui.container.GuiContainer;
@@ -16,9 +19,6 @@ import de.johni0702.minecraft.gui.utils.Consumer;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.settings.KeyBinding;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.FMLCommonHandler;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import net.minecraftforge.fml.common.gameevent.TickEvent;
 import org.lwjgl.input.Keyboard;
 
 import java.lang.reflect.Field;
@@ -50,8 +50,10 @@ public abstract class AbstractTask implements Task {
     public ListenableFuture<Void> execute() {
         future = SettableFuture.create();
 
+        FMLCommonHandler.instance().bus().register(this);
         MinecraftForge.EVENT_BUS.register(this);
         addCallback(future, success -> {
+            FMLCommonHandler.instance().bus().unregister(this);
             MinecraftForge.EVENT_BUS.unregister(this);
         }, error -> {});
 
@@ -82,15 +84,26 @@ public abstract class AbstractTask implements Task {
 
     private void expectGuiClosed0(int timeout, Runnable onClosed) {
         StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
-        class EventHandler {
+        FMLCommonHandler.instance().bus().register(new GuiEventHandler(timeout, stackTrace, onClosed));
+    }
+        public class GuiEventHandler {
             final net.minecraft.client.gui.GuiScreen currentScreen = mc.currentScreen;
+            private final int timeout;
+            private final StackTraceElement[] stackTrace;
+            private final Runnable onClosed;
             int framesPassed;
 
+            public GuiEventHandler(int timeout, StackTraceElement[] stackTrace, Runnable onClosed) {
+                this.timeout = timeout;
+                this.stackTrace = stackTrace;
+                this.onClosed = onClosed;
+            }
+
             @SubscribeEvent
             public void onGuiOpen(TickEvent.RenderTickEvent event) {
                 if (event.phase != TickEvent.Phase.START) return;
                 if (currentScreen != mc.currentScreen) {
-                    MinecraftForge.EVENT_BUS.unregister(this);
+                    FMLCommonHandler.instance().bus().unregister(this);
                     onClosed.run();
                 } else {
                     if (framesPassed < timeout) {
@@ -104,8 +117,6 @@ public abstract class AbstractTask implements Task {
                 }
             }
         }
-        MinecraftForge.EVENT_BUS.register(new EventHandler());
-    }
 
     public void expectPopupClosed(Runnable onClosed) {
         expectPopupClosed0(10, onClosed);
@@ -117,18 +128,30 @@ public abstract class AbstractTask implements Task {
 
     private void expectPopupClosed0(int timeout, Runnable onClosed) {
         StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
-        AbstractGuiPopup popup = getPopup(mc.currentScreen);
-        if (popup == null) {
-            throw new IllegalStateException("No popup found.");
-        }
-        class EventHandler {
+        FMLCommonHandler.instance().bus().register(new PopupEventHandler(timeout, stackTrace, onClosed));
+    }
+        public class PopupEventHandler {
+            private final int timeout;
+            private final StackTraceElement[] stackTrace;
+            private final Runnable onClosed;
+            private final AbstractGuiPopup popup;
             int framesPassed;
 
+            public PopupEventHandler(int timeout, StackTraceElement[] stackTrace, Runnable onClosed) {
+                this.timeout = timeout;
+                this.stackTrace = stackTrace;
+                this.onClosed = onClosed;
+                this.popup = getPopup(mc.currentScreen);
+                if (this.popup == null) {
+                    throw new IllegalStateException("No popup found.");
+                }
+            }
+
             @SubscribeEvent
             public void onGuiOpen(TickEvent.RenderTickEvent event) {
                 if (event.phase != TickEvent.Phase.START) return;
                 if (getPopup(mc.currentScreen) != popup) {
-                    MinecraftForge.EVENT_BUS.unregister(this);
+                    FMLCommonHandler.instance().bus().unregister(this);
                     onClosed.run();
                 } else {
                     if (framesPassed < timeout) {
@@ -141,8 +164,6 @@ public abstract class AbstractTask implements Task {
                 }
             }
         }
-        MinecraftForge.EVENT_BUS.register(new EventHandler());
-    }
 
     private AbstractGuiPopup getPopup(net.minecraft.client.gui.GuiScreen minecraft) {
         GuiContainer<?> container = GuiOverlay.from(minecraft);
@@ -163,10 +184,21 @@ public abstract class AbstractTask implements Task {
 
     public <T> void expectGui(Class<T> guiClass, Consumer<T> onOpen) {
         StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
-        class EventHandler {
+        FMLCommonHandler.instance().bus().register(new ExpectGuiEventHandler<T>(guiClass, stackTrace, onOpen));
+    }
+        public class ExpectGuiEventHandler<T> {
+            private final Class<T> guiClass;
+            private final StackTraceElement[] stackTrace;
+            private final Consumer<T> onOpen;
             net.minecraft.client.gui.GuiScreen currentScreen;
             int framesPassed;
 
+            public ExpectGuiEventHandler(Class<T> guiClass, StackTraceElement[] stackTrace, Consumer<T> onOpen) {
+                this.guiClass = guiClass;
+                this.stackTrace = stackTrace;
+                this.onOpen = onOpen;
+            }
+
             @SubscribeEvent
             public void onGuiOpen(TickEvent.RenderTickEvent event) {
                 if (event.phase != TickEvent.Phase.START) return;
@@ -179,7 +211,7 @@ public abstract class AbstractTask implements Task {
                     return;
                 }
 
-                MinecraftForge.EVENT_BUS.unregister(this);
+                FMLCommonHandler.instance().bus().unregister(this);
 
                 Object foundGui = null;
                 if (AbstractGuiScreen.class.isAssignableFrom(guiClass)) {
@@ -208,16 +240,15 @@ public abstract class AbstractTask implements Task {
                         return;
                     }
                 }
-                class UnexpectedGuiException extends Exception {
-                    UnexpectedGuiException(Object foundGui) {
-                        super("Expected instance of " + guiClass + " but found " + foundGui);
-                        setStackTrace(Arrays.copyOfRange(stackTrace, 2, stackTrace.length));
-                    }
-                }
-                future.setException(new UnexpectedGuiException(foundGui == null ? currentScreen : foundGui));
+                future.setException(new UnexpectedGuiException(guiClass, stackTrace,
+                        foundGui == null ? currentScreen : foundGui));
             }
         }
-        MinecraftForge.EVENT_BUS.register(new EventHandler());
+    class UnexpectedGuiException extends Exception {
+        UnexpectedGuiException(Class<?> guiClass, StackTraceElement[] stackTrace, Object foundGui) {
+            super("Expected instance of " + guiClass + " but found " + foundGui);
+            setStackTrace(Arrays.copyOfRange(stackTrace, 2, stackTrace.length));
+        }
     }
 
     private void clickNow(int x, int y) {

src/integration-test/java/com/replaymod/core/ReplayModIntegrationTest.java

@@ -10,10 +10,10 @@ import com.replaymod.recording.ExitSPWorld;
 import com.replaymod.replay.ExitReplay;
 import com.replaymod.replay.LoadReplay;
 import com.replaymod.replay.OpenReplayViewer;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import net.minecraft.client.Minecraft;
-import net.minecraftforge.fml.common.FMLCommonHandler;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
 import org.apache.logging.log4j.Logger;
 
 import static com.replaymod.core.AbstractTask.mc;

src/integration-test/java/com/replaymod/extra/DownloadOpenEye.java

@@ -2,7 +2,7 @@ package com.replaymod.extra;
 
 import com.replaymod.core.AbstractTask;
 import com.replaymod.extras.OpenEyeExtra;
-import net.minecraftforge.fml.common.Loader;
+import cpw.mods.fml.common.Loader;
 
 import java.io.File;
 import java.nio.file.NoSuchFileException;

src/integration-test/java/com/replaymod/recording/CreateSPWorld.java

@@ -1,32 +1,33 @@
 package com.replaymod.recording;
 
 import com.replaymod.core.AbstractTask;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.client.gui.GuiCreateWorld;
 import net.minecraft.client.gui.GuiMainMenu;
-import net.minecraft.client.gui.GuiWorldSelection;
+import net.minecraft.client.gui.GuiSelectWorld;
 import net.minecraftforge.client.event.RenderGameOverlayEvent;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
 public class CreateSPWorld extends AbstractTask {
     @Override
     protected void init() {
         expectGui(GuiMainMenu.class, mainMenu -> {
             click("Singleplayer");
-            expectGui(GuiWorldSelection.class, selectWorld -> {
+            expectGui(GuiSelectWorld.class, selectWorld -> {
                 click("Create New World");
                 expectGui(GuiCreateWorld.class, createWorld -> {
                     click("Create New World");
-                    class EventHandler {
-                        @SubscribeEvent
-                        public void onRenderIngame(RenderGameOverlayEvent.Pre event) {
-                            MinecraftForge.EVENT_BUS.unregister(this);
-                            runLater(() -> future.set(null));
-                        }
-                    }
                     MinecraftForge.EVENT_BUS.register(new EventHandler());
                 });
             });
         });
     }
+
+    public class EventHandler {
+        @SubscribeEvent
+        public void onRenderIngame(RenderGameOverlayEvent.Pre event) {
+            MinecraftForge.EVENT_BUS.unregister(this);
+            runLater(() -> future.set(null));
+        }
+    }
 }

src/integration-test/java/com/replaymod/replay/LoadReplay.java

@@ -2,10 +2,10 @@ package com.replaymod.replay;
 
 import com.replaymod.core.AbstractTask;
 import com.replaymod.replay.gui.screen.GuiReplayViewer;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import de.johni0702.minecraft.gui.function.Clickable;
 import net.minecraftforge.client.event.RenderGameOverlayEvent;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import org.lwjgl.util.Point;
 import org.lwjgl.util.ReadableDimension;
 
@@ -19,14 +19,15 @@ public class LoadReplay extends AbstractTask {
             // Load first replay
             click(replayViewer.loadButton);
 
-            class EventHandler {
-                @SubscribeEvent
-                public void onRenderIngame(RenderGameOverlayEvent.Pre event) {
-                    MinecraftForge.EVENT_BUS.unregister(this);
-                    runLater(() -> future.set(null));
-                }
-            }
             MinecraftForge.EVENT_BUS.register(new EventHandler());
         }));
     }
+
+    public class EventHandler {
+        @SubscribeEvent
+        public void onRenderIngame(RenderGameOverlayEvent.Pre event) {
+            MinecraftForge.EVENT_BUS.unregister(this);
+            runLater(() -> future.set(null));
+        }
+    }
 }

src/integration-test/java/com/replaymod/replay/SpectatePlayer.java

@@ -2,8 +2,8 @@ package com.replaymod.replay;
 
 import com.replaymod.core.AbstractTask;
 import com.replaymod.extras.playeroverview.PlayerOverviewGui;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import net.minecraftforge.fml.common.gameevent.TickEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
 import org.lwjgl.input.Keyboard;
 
 import java.util.concurrent.TimeoutException;
@@ -34,7 +34,7 @@ public class SpectatePlayer extends AbstractTask {
                 future.setException(new TimeoutException("Camera hasn't stopped spectating."));
                 return;
             }
-            if (mc.getRenderViewEntity() == mc.thePlayer) {
+            if (mc.renderViewEntity == mc.thePlayer) {
                 future.set(null);
             }
         }

src/main/java/com/replaymod/compat/ReplayModCompat.java

@@ -1,24 +1,27 @@
 package com.replaymod.compat;
 
+import com.replaymod.compat.bettersprinting.DisableBetterSprinting;
 import com.replaymod.compat.optifine.DisableFastRender;
-import com.replaymod.compat.shaders.ShaderBeginRender;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.fml.common.eventhandler.EventBus;
+import com.replaymod.compat.oranges17animations.HideInvisibleEntities;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.eventhandler.EventBus;
 
 @Mod(modid = ReplayModCompat.MOD_ID,
         version = "@MOD_VERSION@",
         acceptedMinecraftVersions = "@MC_VERSION@",
+        acceptableRemoteVersions = "*",
         useMetadata = true)
 public class ReplayModCompat {
     public static final String MOD_ID = "replaymod-compat";
 
     @Mod.EventHandler
     public void init(FMLInitializationEvent event) {
-        EventBus bus = MinecraftForge.EVENT_BUS;
-        bus.register(new ShaderBeginRender());
+        EventBus bus = FMLCommonHandler.instance().bus();
         bus.register(new DisableFastRender());
+        bus.register(new HideInvisibleEntities());
+        DisableBetterSprinting.register();
     }
 
 }

src/main/java/com/replaymod/compat/bettersprinting/DisableBetterSprinting.java

@@ -0,0 +1,97 @@
+package com.replaymod.compat.bettersprinting;
+
+import com.replaymod.replay.ReplayModReplay;
+import com.replaymod.replay.events.ReplayChatMessageEvent;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.ModContainer;
+import cpw.mods.fml.common.eventhandler.EventPriority;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.versioning.DefaultArtifactVersion;
+import cpw.mods.fml.common.versioning.Restriction;
+import cpw.mods.fml.common.versioning.VersionRange;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.PlayerControllerMP;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.IWorldAccess;
+import net.minecraftforge.client.event.GuiOpenEvent;
+import net.minecraftforge.common.MinecraftForge;
+
+import java.util.Collections;
+
+/**
+ * Old Better Sprinting versions replace the vanilla player with their own, overridden instance (replacing the camera entity).
+ *
+ * See: https://github.com/chylex/Better-Sprinting/blob/1.8/src/main/java/chylex/bettersprinting/client/player/impl/LogicImplOverride.java
+ */
+public class DisableBetterSprinting {
+    private static final VersionRange OLD_VERSION = VersionRange.newRange(null,
+            Collections.singletonList(new Restriction(null, false, new DefaultArtifactVersion("2.0.0"), false)));
+    private static final String LOGIC_CLASS_NAME = "chylex.bettersprinting.client.player.impl.LogicImplOverride";
+    private static final String CONTROLLER_OVERRIDE_CLASS_NAME = LOGIC_CLASS_NAME + ".PlayerControllerMPOverride";
+
+    public static void register() {
+        Loader.instance().getModList().stream()
+                .filter(mod -> mod.getModId().equalsIgnoreCase("bettersprinting"))
+                .findFirst()
+                .map(ModContainer::getProcessedVersion).filter(OLD_VERSION::containsVersion)
+                .ifPresent($_ -> MinecraftForge.EVENT_BUS.register(new DisableBetterSprinting()));
+    }
+
+    private DisableBetterSprinting() {}
+
+    private final Minecraft mc = Minecraft.getMinecraft();
+    private PlayerControllerMP originalController;
+    private BetterSprintingWorldAccess worldAccessHook = new BetterSprintingWorldAccess();
+
+    @SubscribeEvent(priority = EventPriority.HIGH)
+    public void beforeGuiOpenEvent(GuiOpenEvent event) {
+        if (ReplayModReplay.instance.getReplayHandler() != null && mc.theWorld != null) {
+            // During replay, get ready to revert BetterSprinting's overwritten playerController
+            originalController = mc.playerController;
+            mc.theWorld.addWorldAccess(worldAccessHook);
+        }
+    }
+
+    @SubscribeEvent(priority = EventPriority.LOW)
+    public void afterGuiOpenEvent(GuiOpenEvent event) {
+        if (ReplayModReplay.instance.getReplayHandler() != null && mc.theWorld != null) {
+            mc.theWorld.removeWorldAccess(worldAccessHook);
+        }
+    }
+
+    @SubscribeEvent
+    public void onReplayChatMessage(ReplayChatMessageEvent event) {
+        // Suppress this message if it's the Better Sprinting warning message
+        for (StackTraceElement elem : Thread.currentThread().getStackTrace()) {
+            if (LOGIC_CLASS_NAME.equals(elem.getClassName())) {
+                event.setCanceled(true);
+                return;
+            }
+        }
+    }
+
+    private class BetterSprintingWorldAccess implements IWorldAccess {
+        @Override
+        public void onEntityDestroy(Entity entityIn) {
+            if (mc.playerController != null && mc.playerController.getClass().getName().equals(CONTROLLER_OVERRIDE_CLASS_NAME)) {
+                // Someone has secretly swapped out the player controller and is about to substitute their own player entity.
+                // This is the right time to destroy their plan.
+                mc.playerController = originalController;
+            }
+        }
+
+        @Override public void markBlockForUpdate(int x, int y, int z) {}
+        @Override public void markBlockForRenderUpdate(int p_147588_1_, int p_147588_2_, int p_147588_3_) {}
+        @Override public void markBlockRangeForRenderUpdate(int x1, int y1, int z1, int x2, int y2, int z2) {}
+        @Override public void playSound(String soundName, double x, double y, double z, float volume, float pitch) {}
+        @Override public void playSoundToNearExcept(EntityPlayer except, String soundName, double x, double y, double z, float volume, float pitch) {}
+        @Override public void spawnParticle(String p_180442_1_, double p_180442_2_, double p_180442_3_, double p_180442_5_, double p_180442_7_, double p_180442_9_, double p_180442_11_) {}
+        @Override public void onEntityCreate(Entity p_72703_1_) {}
+        @Override public void playRecord(String recordName, int x, int y, int z) {}
+        @Override public void broadcastSound(int p_180440_1_, int x, int y, int z, int p_180440_3_) {}
+        @Override public void playAuxSFX(EntityPlayer p_72706_1_, int p_72706_2_, int p_72706_3_, int p_72706_4_, int p_72706_5_, int p_72706_6_) {}
+        @Override public void destroyBlockPartially(int p_147587_1_, int p_147587_2_, int p_147587_3_, int p_147587_4_, int p_147587_5_) {}
+        @Override public void onStaticEntitiesChanged() {}
+    }
+}

src/main/java/com/replaymod/compat/optifine/DisableFastRender.java

@@ -1,10 +1,11 @@
 package com.replaymod.compat.optifine;
 
 import com.replaymod.render.events.ReplayRenderEvent;
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.client.Minecraft;
-import net.minecraftforge.fml.client.FMLClientHandler;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
+// TODO 1.7.10: Is this still necessary (probably, but needs checking)?
 public class DisableFastRender {
 
     private final Minecraft mc = Minecraft.getMinecraft();

src/main/java/com/replaymod/compat/oranges17animations/HideInvisibleEntities.java

@@ -0,0 +1,28 @@
+package com.replaymod.compat.oranges17animations;
+
+import com.replaymod.replay.camera.CameraEntity;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.eventhandler.EventPriority;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import net.minecraft.client.Minecraft;
+import net.minecraftforge.client.event.RenderLivingEvent;
+
+/**
+ * Orange seems to have copied vast parts of the RendererLivingEntity into their ArmorAnimation class which cancels the RenderLivingEvent.Pre and calls its own code instead.
+ * This breaks our mixin which assures that, even though the camera is in spectator mode, it cannot see invisible entities.
+ *
+ * To fix this issue, we simply cancel the RenderLivingEvent.Pre before it gets to ArmorAnimation if the entity is invisible.
+ */
+public class HideInvisibleEntities {
+    private final Minecraft mc = Minecraft.getMinecraft();
+    private final boolean modLoaded = Loader.isModLoaded("animations");
+
+    @SubscribeEvent(priority = EventPriority.HIGH)
+    public void preRenderLiving(RenderLivingEvent.Pre event) {
+        if (modLoaded) {
+            if (mc.thePlayer instanceof CameraEntity && event.entity.isInvisible()) {
+                event.setCanceled(true);
+            }
+        }
+    }
+}

src/main/java/com/replaymod/compat/shaders/ShaderBeginRender.java

@@ -1,39 +0,0 @@
-package com.replaymod.compat.shaders;
-
-import com.replaymod.render.hooks.EntityRendererHandler;
-import net.minecraft.client.Minecraft;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import net.minecraftforge.fml.common.gameevent.TickEvent;
-
-import java.lang.reflect.InvocationTargetException;
-
-public class ShaderBeginRender {
-
-    private final Minecraft mc = Minecraft.getMinecraft();
-
-    /**
-     *  Invokes Shaders#beginRender when rendering a video,
-     *  as this would usually get called by EntityRenderer#renderWorld,
-     *  which we're not calling during rendering.
-     */
-    @SubscribeEvent
-    public void onRenderTickStart(TickEvent.RenderTickEvent event) {
-        if (event.phase != TickEvent.Phase.START) return;
-        if (ShaderReflection.shaders_beginRender == null) return;
-        if (ShaderReflection.config_isShaders == null) return;
-
-        try {
-            // check if video is being rendered
-            if (((EntityRendererHandler.IEntityRenderer) mc.entityRenderer).replayModRender_getHandler() == null)
-                return;
-
-            // check if Shaders are enabled
-            if (!(boolean) (ShaderReflection.config_isShaders.invoke(null))) return;
-
-            ShaderReflection.shaders_beginRender.invoke(null, mc, mc.timer.elapsedPartialTicks, 0);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-    }
-
-}

src/main/java/com/replaymod/compat/shaders/ShaderReflection.java

@@ -1,53 +0,0 @@
-package com.replaymod.compat.shaders;
-
-import net.minecraft.client.Minecraft;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-
-public class ShaderReflection {
-
-    // Shaders.frameTimeCounter
-    public static Field shaders_frameTimeCounter;
-
-    // Shaders.isShadowPass
-    public static Field shaders_isShadowPass;
-
-    // Shaders.beginRender()
-    public static Method shaders_beginRender;
-
-    // RenderGlobal.chunksToUpdateForced (Optifine only)
-    public static Field renderGlobal_chunksToUpdateForced;
-
-    // Config.isShaders() (Optifine only)
-    public static Method config_isShaders;
-
-    static {
-        try {
-            shaders_frameTimeCounter = Class.forName("shadersmod.client.Shaders")
-                    .getDeclaredField("frameTimeCounter");
-            shaders_frameTimeCounter.setAccessible(true);
-
-            shaders_isShadowPass = Class.forName("shadersmod.client.Shaders")
-                    .getDeclaredField("isShadowPass");
-            shaders_isShadowPass.setAccessible(true);
-
-            shaders_beginRender = Class.forName("shadersmod.client.Shaders")
-                    .getDeclaredMethod("beginRender", Minecraft.class, float.class, long.class);
-            shaders_beginRender.setAccessible(true);
-
-            renderGlobal_chunksToUpdateForced = Class.forName("net.minecraft.client.renderer.RenderGlobal")
-                    .getDeclaredField("chunksToUpdateForced");
-            renderGlobal_chunksToUpdateForced.setAccessible(true);
-
-            config_isShaders = Class.forName("Config")
-                    .getDeclaredMethod("isShaders");
-            config_isShaders.setAccessible(true);
-        } catch (ClassNotFoundException ignore) {
-            // no shaders mod installed
-        } catch (NoSuchMethodException | NoSuchFieldException e) {
-            // the method wasn't found. Has it been renamed?
-            e.printStackTrace();
-        }
-    }
-}

src/main/java/com/replaymod/compat/shaders/mixin/MixinShaderEntityRenderer.java

@@ -1,28 +0,0 @@
-package com.replaymod.compat.shaders.mixin;
-
-import com.replaymod.compat.shaders.ShaderReflection;
-import com.replaymod.replay.ReplayHandler;
-import com.replaymod.replay.ReplayModReplay;
-import net.minecraft.client.renderer.EntityRenderer;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(EntityRenderer.class)
-public abstract class MixinShaderEntityRenderer {
-
-    @Inject(method = "renderWorldPass", at = @At("HEAD"))
-    private void replayModCompat_updateShaderFrameTimeCounter(CallbackInfo ignore) {
-        if (ReplayModReplay.instance.getReplayHandler() == null) return;
-        if (ShaderReflection.shaders_frameTimeCounter == null) return;
-
-        ReplayHandler replayHandler = ReplayModReplay.instance.getReplayHandler();
-        float timestamp = replayHandler.getReplaySender().currentTimeStamp() / 1000f % 3600f;
-        try {
-            ShaderReflection.shaders_frameTimeCounter.set(null, timestamp);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-}

src/main/java/com/replaymod/compat/shaders/mixin/MixinShaderRenderChunk.java

@@ -1,28 +0,0 @@
-package com.replaymod.compat.shaders.mixin;
-
-import com.replaymod.render.hooks.EntityRendererHandler;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.chunk.RenderChunk;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(RenderChunk.class)
-public abstract class MixinShaderRenderChunk {
-
-    private final Minecraft mc = Minecraft.getMinecraft();
-
-    /**
-     *  Changes the RenderChunk#isPlayerUpdate method that Optifine adds
-     *  to always return true while rendering so no chunks are being added
-     *  to a separate rendering queue
-     */
-    @Inject(method = "isPlayerUpdate", at = @At("HEAD"), cancellable = true)
-    private void replayModCompat_disableIsPlayerUpdate(CallbackInfoReturnable<Boolean> ci) {
-        if (((EntityRendererHandler.IEntityRenderer) mc.entityRenderer).replayModRender_getHandler() == null) return;
-        ci.setReturnValue(true);
-    }
-
-
-}

src/main/java/com/replaymod/compat/shaders/mixin/MixinShaderRenderGlobal.java

@@ -1,40 +0,0 @@
-package com.replaymod.compat.shaders.mixin;
-
-import com.replaymod.compat.shaders.ShaderReflection;
-import com.replaymod.render.hooks.EntityRendererHandler;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.RenderGlobal;
-import net.minecraft.client.renderer.culling.ICamera;
-import net.minecraft.entity.Entity;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(RenderGlobal.class)
-public abstract class MixinShaderRenderGlobal {
-
-    private final Minecraft mc = Minecraft.getMinecraft();
-
-    @Shadow
-    public boolean displayListEntitiesDirty;
-
-    @Inject(method = "setupTerrain", at = @At("HEAD"), cancellable = true)
-    public void replayModCompat_setupTerrain(Entity viewEntity, double partialTicks, ICamera camera,
-                                             int frameCount, boolean playerSpectator, CallbackInfo ci) {
-        if (((EntityRendererHandler.IEntityRenderer) mc.entityRenderer).replayModRender_getHandler() == null) return;
-        if (ShaderReflection.shaders_isShadowPass == null) return;
-
-        // when called by the shadow pass, displayListEntitiesDirty can't be set to false, as no chunk updates
-        // are being processed. As it's being set to true by ChunkLoadingRenderGlobal#updateChunks, we have to
-        // set it to false manually to exit the loop imposed by MixinRenderGlobal#replayModRender_setupTerrain.
-        try {
-            if ((boolean) ShaderReflection.shaders_isShadowPass.get(null) == true) {
-                displayListEntitiesDirty = false;
-            }
-        } catch (IllegalAccessException ignore) {}
-
-    }
-
-}

src/main/java/com/replaymod/compat/shaders/mixin/MixinShaders.java

@@ -0,0 +1,50 @@
+package com.replaymod.compat.shaders.mixin;
+
+import com.replaymod.render.hooks.EntityRendererHandler;
+import com.replaymod.replay.ReplayHandler;
+import com.replaymod.replay.ReplayModReplay;
+import net.minecraft.client.Minecraft;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Pseudo;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+@Pseudo
+@Mixin(targets = "shadersmod/client/Shaders", remap = false)
+public abstract class MixinShaders {
+
+    @Shadow static Minecraft mc;
+    @Shadow static long systemTime;
+    @Shadow static long lastSystemTime;
+    @Shadow static long diffSystemTime;
+    @Shadow static int frameCounter;
+    @Shadow static float frameTime;
+    @Shadow static float frameTimeCounter;
+
+    @Redirect(method = "beginRender", at = @At(value = "INVOKE", target = "Ljava/lang/System;currentTimeMillis()J"))
+    private static long replayModCompat_currentTimeMillis() {
+        ReplayHandler replayHandler = ReplayModReplay.instance.getReplayHandler();
+        if (replayHandler != null) {
+            systemTime = replayHandler.getReplaySender().currentTimeStamp();
+
+            // We need to manipulate all the other previous-frame-time-based variables too
+
+            lastSystemTime = 0; // Draw all frames as if they were the first ones
+            // diffSystemTime will be set to 0 by Shaders
+            // frameTime will be set to 0 by Shaders
+            frameTimeCounter = systemTime / 1000f; // will be %= 3600f by Shaders
+
+            // Set frameCounter only if rendering is in progress
+            EntityRendererHandler entityRendererHandler =
+                    ((EntityRendererHandler.IEntityRenderer) mc.entityRenderer).replayModRender_getHandler();
+            if (entityRendererHandler != null) {
+                frameCounter = entityRendererHandler.getRenderInfo().getFramesDone();
+            }
+
+            return systemTime;
+        }
+        return System.currentTimeMillis();
+    }
+
+}

src/main/java/com/replaymod/core/GLErrorTransformer.java

@@ -0,0 +1,94 @@
+package com.replaymod.core;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.util.glu.GLU;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * Insert glGetError checks after all calls to any method in any GL*, ARB* and EXT* classes
+ */
+public class GLErrorTransformer implements IClassTransformer {
+    private static final String GL_CLASS = "org.lwjgl.opengl.GL";
+    private static final String GL = GL_CLASS.replace('.', '/');
+    private static final String ARB_CLASS = "org.lwjgl.opengl.ARB";
+    private static final String ARB = ARB_CLASS.replace('.', '/');
+    private static final String EXT_CLASS = "org.lwjgl.opengl.EXT";
+    private static final String EXT = EXT_CLASS.replace('.', '/');
+    private static final String GLErrorTransformer_CLASS = GLErrorTransformer.class.getName();
+    private static final String GLErrorTransformer = GLErrorTransformer_CLASS.replace('.', '/');
+
+    @Override
+    public byte[] transform(String name, String transformedName, byte[] basicClass) {
+        // Ignore (anonymous) inner classes of this transformer
+        if (name.startsWith(GLErrorTransformer_CLASS)) return basicClass;
+
+        ClassReader reader = new ClassReader(basicClass);
+        ClassWriter writer = new ClassWriter(reader, 0);
+        reader.accept(new ClassVisitor(Opcodes.ASM5, writer) {
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+                MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
+                return new MethodVisitor(Opcodes.ASM5, mv) {
+                    @Override
+                    public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
+                        super.visitMethodInsn(opcode, owner, name, desc, itf);
+                        if (owner.startsWith(GL) || owner.startsWith(ARB) || owner.startsWith(EXT)) {
+                            visitLdcInsn(owner.replace('/', '.'));
+                            visitLdcInsn(name);
+                            super.visitMethodInsn(Opcodes.INVOKESTATIC, GLErrorTransformer, "glErrorCheck", "(Ljava/lang/String;Ljava/lang/String;)V", false);
+                        }
+                    }
+
+                    @Override
+                    public void visitMaxs(int maxStack, int maxLocals) {
+                        super.visitMaxs(maxStack + 2, maxLocals);
+                    }
+                };
+            }
+        }, 0);
+        return writer.toByteArray();
+    }
+
+    private static boolean inGlBegin;
+
+    @SuppressWarnings("unused") // Called via ASM
+    public static void glErrorCheck(String cls, String method) {
+        if (method.equals("glBegin") && cls.equals(GL_CLASS + "11")) {
+            if (inGlBegin) {
+                // glBegin within glBegin
+                throw new GLError(GL11.GL_INVALID_OPERATION, cls, method);
+            }
+            inGlBegin = true;
+            return;
+        }
+        if (inGlBegin && method.equals("glEnd") && cls.equals(GL_CLASS + "11")) {
+            inGlBegin = false;
+        }
+        if (inGlBegin) {
+            return; // Cannot call glGetError in between of glBegin and glEnd
+        }
+        int err = GL11.glGetError();
+        if (err != 0) {
+            GLError e = new GLError(err, cls, method);
+            if ("true".equals(System.getProperty("replaymod.glerrors.throw", "true"))) {
+                throw e;
+            } else {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public static class GLError extends RuntimeException {
+        private GLError(int err, String cls, String method) {
+            super(GLU.gluErrorString(err) + " (" + err + ")");
+            StackTraceElement[] stack = getStackTrace();
+            stack[0] = new StackTraceElement(cls, method, stack[0].getFileName(), stack[0].getLineNumber());
+            setStackTrace(stack);
+        }
+    }
+}

src/main/java/com/replaymod/core/GLStateTrackerTransformer.java

@@ -0,0 +1,105 @@
+package com.replaymod.core;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Redirect all calls to GL11.glEnable and GL11.glDisable to the GLStateTracker (excluding that class itself).
+ */
+public class GLStateTrackerTransformer implements IClassTransformer {
+    private static final String GL11_CLASS = "org.lwjgl.opengl.GL11";
+    private static final String GL11 = GL11_CLASS.replace('.', '/');
+    private static final String glEnable = "glEnable";
+    private static final String glDisable = "glDisable";
+    private static final String GLStateTracker_CLASS = "com.replaymod.render.hooks.GLStateTracker";
+    private static final String GLStateTracker = GLStateTracker_CLASS.replace('.', '/');
+    private static final String hook_glEnable = "hook_glEnable";
+    private static final String hook_glDisable = "hook_glDisable";
+
+    @Override
+    public byte[] transform(String name, String transformedName, byte[] basicClass) {
+        // Ignore (anonymous) inner classes of this transformer
+        if (name.startsWith(GLStateTrackerTransformer.class.getName())) return basicClass;
+        // Ignore the state tracker itself
+        if (name.equals(GLStateTracker_CLASS)) return basicClass;
+
+        ClassReader reader = new ClassReader(basicClass);
+        Set<Method> eligibleMethods = findEligibleMethods(reader);
+        if (eligibleMethods.isEmpty()) {
+            return basicClass;
+        }
+
+        ClassWriter writer = new ClassWriter(reader, 0);
+        reader.accept(new ClassVisitor(Opcodes.ASM5, writer) {
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+                MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
+                if (!eligibleMethods.contains(new Method(name, desc))) {
+                    return mv;
+                }
+                return new MethodVisitor(Opcodes.ASM5, mv) {
+                    @Override
+                    public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
+                        if (owner.equals(GL11)) {
+                            if (name.equals(glEnable)) {
+                                owner = GLStateTracker;
+                                name = hook_glEnable;
+                            } else if (name.equals(glDisable)) {
+                                owner = GLStateTracker;
+                                name = hook_glDisable;
+                            }
+                        }
+                        super.visitMethodInsn(opcode, owner, name, desc, itf);
+                    }
+                };
+            }
+        }, 0);
+        return writer.toByteArray();
+    }
+
+    private Set<Method> findEligibleMethods(ClassReader reader) {
+        Set<Method> eligibleMethods = new HashSet<>();
+        reader.accept(new ClassVisitor(Opcodes.ASM5) {
+            @Override
+            public MethodVisitor visitMethod(int access, String methodName, String methodDesc, String signature, String[] exceptions) {
+                return new MethodVisitor(Opcodes.ASM5) {
+                    @Override
+                    public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
+                        if (owner.equals(GL11) && (name.equals(glEnable) || name.equals(glDisable))) {
+                            eligibleMethods.add(new Method(methodName, methodDesc));
+                        }
+                    }
+                };
+            }
+        }, ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+        return eligibleMethods;
+    }
+
+    private static class Method {
+        private final String name, desc;
+
+        private Method(String name, String desc) {
+            this.name = name;
+            this.desc = desc;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == null || getClass() != o.getClass()) return false;
+            Method method = (Method) o;
+            return name.equals(method.name) && desc.equals(method.desc);
+        }
+
+        @Override
+        public int hashCode() {
+            return name.hashCode() ^ desc.hashCode();
+        }
+    }
+}

src/main/java/com/replaymod/core/KeyBindingRegistry.java

@@ -2,20 +2,21 @@ package com.replaymod.core;
 
 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.Multimap;
+import cpw.mods.fml.client.registry.ClientRegistry;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.InputEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
 import net.minecraft.client.settings.KeyBinding;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.crash.CrashReportCategory;
 import net.minecraft.util.ReportedException;
-import net.minecraftforge.fml.client.registry.ClientRegistry;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import net.minecraftforge.fml.common.gameevent.InputEvent;
-import net.minecraftforge.fml.common.gameevent.TickEvent;
 import org.lwjgl.input.Keyboard;
 
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.Callable;
 
 public class KeyBindingRegistry {
     private Map<String, KeyBinding> keyBindings = new HashMap<String, KeyBinding>();
@@ -63,7 +64,7 @@ public class KeyBindingRegistry {
 
     public void handleRepeatedKeyBindings() {
         for (Map.Entry<KeyBinding, Collection<Runnable>> entry : repeatedKeyBindingHandlers.asMap().entrySet()) {
-            if (entry.getKey().isKeyDown()) {
+            if (entry.getKey().getIsKeyPressed()) {
                 invokeKeyBindingHandlers(entry.getKey(), entry.getValue());
             }
         }
@@ -85,7 +86,7 @@ public class KeyBindingRegistry {
                 CrashReport crashReport = CrashReport.makeCrashReport(cause, "Handling Key Binding");
                 CrashReportCategory category = crashReport.makeCategory("Key Binding");
                 category.addCrashSection("Key Binding", keyBinding);
-                category.setDetail("Handler", runnable::toString);
+                category.addCrashSectionCallable("Handler", runnable::toString);
                 throw new ReportedException(crashReport);
             }
         }
@@ -100,7 +101,12 @@ public class KeyBindingRegistry {
                 CrashReport crashReport = CrashReport.makeCrashReport(cause, "Handling Raw Key Binding");
                 CrashReportCategory category = crashReport.makeCategory("Key Binding");
                 category.addCrashSection("Key Code", keyCode);
-                category.setDetail("Handler", runnable::toString);
+                category.addCrashSectionCallable("Handler", new Callable() {
+                    @Override
+                    public Object call() throws Exception {
+                        return runnable;
+                    }
+                });
                 throw new ReportedException(crashReport);
             }
         }

src/main/java/com/replaymod/core/LoadingPlugin.java

@@ -1,7 +1,7 @@
 package com.replaymod.core;
 
-import net.minecraftforge.fml.relauncher.CoreModManager;
-import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin;
+import cpw.mods.fml.relauncher.CoreModManager;
+import cpw.mods.fml.relauncher.IFMLLoadingPlugin;
 import org.apache.logging.log4j.LogManager;
 import org.spongepowered.asm.launch.MixinBootstrap;
 import org.spongepowered.asm.mixin.Mixins;
@@ -10,6 +10,8 @@ import java.io.File;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.security.CodeSource;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 
 public class LoadingPlugin implements IFMLLoadingPlugin {
@@ -20,6 +22,7 @@ public class LoadingPlugin implements IFMLLoadingPlugin {
         Mixins.addConfiguration("mixins.render.replaymod.json");
         Mixins.addConfiguration("mixins.replay.replaymod.json");
         Mixins.addConfiguration("mixins.compat.shaders.replaymod.json");
+        Mixins.addConfiguration("mixins.extras.playeroverview.replaymod.json");
 
         CodeSource codeSource = getClass().getProtectionDomain().getCodeSource();
         if (codeSource != null) {
@@ -29,7 +32,8 @@ public class LoadingPlugin implements IFMLLoadingPlugin {
                 if (file.isFile()) {
                     // This forces forge to reexamine the jar file for FML mods
                     // Should eventually be handled by Mixin itself, maybe?
-                    CoreModManager.getIgnoredMods().remove(file.getName());
+                    CoreModManager.getLoadedCoremods().remove(file.getName());
+                    CoreModManager.getReparseableCoremods().add(file.getName());
                 }
             } catch (URISyntaxException e) {
                 e.printStackTrace();
@@ -42,8 +46,12 @@ public class LoadingPlugin implements IFMLLoadingPlugin {
 
     @Override
     public String[] getASMTransformerClass() {
-        return new String[]{
-        };
+        List<String> transformers = new ArrayList<>();
+        if ("true".equals(System.getProperty("replaymod.glerrors", "false"))) {
+            transformers.add(GLErrorTransformer.class.getName());
+        }
+        transformers.add(GLStateTrackerTransformer.class.getName());
+        return transformers.stream().toArray(String[]::new);
     }
 
     @Override

src/main/java/com/replaymod/core/ReplayMod.java

@@ -6,37 +6,47 @@ import com.replaymod.core.gui.GuiReplaySettings;
 import com.replaymod.core.gui.RestoreReplayGui;
 import com.replaymod.core.handler.MainMenuHandler;
 import com.replaymod.core.utils.OpenGLUtils;
+import com.replaymod.render.utils.SoundHandler;
+import com.replaymod.replay.InputReplayTimer;
 import com.replaymod.replaystudio.util.I18n;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.Mod.EventHandler;
+import cpw.mods.fml.common.Mod.Instance;
+import cpw.mods.fml.common.ModContainer;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.eventhandler.EventBus;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
 import de.johni0702.minecraft.gui.container.GuiScreen;
 import lombok.Getter;
+import lombok.RequiredArgsConstructor;
 import net.minecraft.client.Minecraft;
-import net.minecraft.client.settings.GameSettings;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.crash.CrashReportCategory;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.ChatComponentTranslation;
+import net.minecraft.util.ChatStyle;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IChatComponent;
 import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.text.*;
-import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.common.config.Configuration;
-import net.minecraftforge.fml.client.FMLClientHandler;
-import net.minecraftforge.fml.common.Loader;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.Mod.EventHandler;
-import net.minecraftforge.fml.common.Mod.Instance;
-import net.minecraftforge.fml.common.ModContainer;
-import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
 import org.apache.commons.io.FileUtils;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.ArrayDeque;
 import java.util.List;
+import java.util.Queue;
 
 @Mod(modid = ReplayMod.MOD_ID,
         useMetadata = true,
         version = "@MOD_VERSION@",
         acceptedMinecraftVersions = "@MC_VERSION@",
-        updateJSON = "https://raw.githubusercontent.com/ReplayMod/ReplayMod/master/versions.json",
+        acceptableRemoteVersions = "*",
         guiFactory = "com.replaymod.core.gui.GuiFactory")
 public class ReplayMod {
 
@@ -49,10 +59,10 @@ public class ReplayMod {
     private static String parseMinecraftVersion() {
         CrashReport crashReport = new CrashReport("", new Throwable());
         @SuppressWarnings("unchecked")
-        List<CrashReportCategory.Entry> list = crashReport.getCategory().children;
+        List<CrashReportCategory.Entry> list = crashReport.getCategory().field_85077_c;
         for (CrashReportCategory.Entry entry : list) {
-            if ("Minecraft Version".equals(entry.getKey())) {
-                return entry.getValue();
+            if ("Minecraft Version".equals(entry.func_85089_a())) {
+                return entry.func_85090_b();
             }
         }
         return "Unknown";
@@ -67,6 +77,8 @@ public class ReplayMod {
 
     @Deprecated
     public static Configuration config;
+    @Deprecated
+    public static SoundHandler soundHandler = new SoundHandler();
 
     private final KeyBindingRegistry keyBindingRegistry = new KeyBindingRegistry();
     private final SettingsRegistry settingsRegistry = new SettingsRegistry();
@@ -109,7 +121,8 @@ public class ReplayMod {
 
         new MainMenuHandler().register();
 
-        MinecraftForge.EVENT_BUS.register(keyBindingRegistry);
+        FMLCommonHandler.instance().bus().register(this);
+        FMLCommonHandler.instance().bus().register(keyBindingRegistry);
 
         getKeyBindingRegistry().registerKeyBinding("replaymod.input.settings", 0, () -> {
             new GuiReplaySettings(null, settingsRegistry).display();
@@ -120,10 +133,155 @@ public class ReplayMod {
     public void postInit(FMLPostInitializationEvent event) throws IOException {
         settingsRegistry.save(); // Save default values to disk
 
+        /* TODO 1.7.10: MC crashes when setting render distance to > 16
         if(!FMLClientHandler.instance().hasOptifine())
             GameSettings.Options.RENDER_DISTANCE.setValueMax(64f);
+            */
 
-        testIfMoeshAndExitMinecraft();
+        if (System.getProperty("replaymod.render.file") != null) {
+            final File file = new File(System.getProperty("replaymod.render.file"));
+            if (!file.exists()) {
+                throw new IOException("File \"" + file.getPath() + "\" not found.");
+            }
+
+            final String path = System.getProperty("replaymod.render.path");
+            String type = System.getProperty("replaymod.render.type");
+            String bitrate = System.getProperty("replaymod.render.bitrate");
+            String fps = System.getProperty("replaymod.render.fps");
+            String waitForChunks = System.getProperty("replaymod.render.waitforchunks");
+            String linearMovement = System.getProperty("replaymod.render.linearmovement");
+            String skyColor = System.getProperty("replaymod.render.skycolor");
+            String width = System.getProperty("replaymod.render.width");
+            String height = System.getProperty("replaymod.render.height");
+            String exportCommand = System.getProperty("replaymod.render.exportcommand");
+            String exportCommandArgs = System.getProperty("replaymod.render.exportcommandargs");
+            /*
+            final RenderOptions options = new RenderOptions();
+            if (bitrate != null) {
+                options.setBitrate(bitrate);
+            }
+            if (fps != null) {
+                options.setFps(Integer.parseInt(fps));
+            }
+            if (waitForChunks != null) {
+                options.setWaitForChunks(Boolean.parseBoolean(waitForChunks));
+            }
+            if (linearMovement != null) {
+                options.setLinearMovement(Boolean.parseBoolean(linearMovement));
+            }
+            if (skyColor != null) {
+                if (skyColor.startsWith("0x")) {
+                    options.setSkyColor(Integer.parseInt(skyColor.substring(2), 16));
+                } else {
+                    options.setSkyColor(Integer.parseInt(skyColor));
+                }
+            }
+            if (width != null) {
+                options.setWidth(Integer.parseInt(width));
+            }
+            if (height != null) {
+                options.setHeight(Integer.parseInt(height));
+            }
+
+            if (exportCommand != null) {
+                options.setExportCommand(exportCommand);
+            }
+            if (exportCommandArgs != null) {
+                options.setExportCommandArgs(exportCommandArgs);
+            } else {
+                options.setExportCommandArgs(EncodingPreset.MP4DEFAULT.getCommandLineArgs());
+            }
+
+            options.setOutputFile(new File(String.valueOf(System.currentTimeMillis())));
+
+            Pipelines.Preset pipelinePreset = Pipelines.Preset.DEFAULT;
+            if (type != null) {
+                String[] parts = type.split(":");
+                type = parts[0].toUpperCase();
+                if ("NORMAL".equals(type) || "DEFAULT".equals(type)) {
+                    pipelinePreset = Pipelines.Preset.DEFAULT;
+                } else if ("STEREO".equals(type) || "STEREOSCOPIC".equals(type)) {
+                    pipelinePreset = Pipelines.Preset.STEREOSCOPIC;
+                } else if ("CUBIC".equals(type)) {
+                    if (parts.length < 2) {
+                        throw new IllegalArgumentException("Cubic renderer requires boolean for whether it's stable.");
+                    }
+                    pipelinePreset = Pipelines.Preset.CUBIC;
+                } else if ("EQUIRECTANGULAR".equals(type)) {
+                    if (parts.length < 2) {
+                        throw new IllegalArgumentException("Equirectangular renderer requires boolean for whether it's stable.");
+                    }
+                    pipelinePreset = Pipelines.Preset.EQUIRECTANGULAR;
+                } else if ("ODS".equals(type)) {
+                    if (parts.length < 2) {
+                        throw new IllegalArgumentException("ODS renderer requires boolean for whether it's stable.");
+                    }
+                    pipelinePreset = Pipelines.Preset.ODS;
+                } else {
+                    throw new IllegalArgumentException("Unknown type: " + parts[0]);
+                }
+            }
+            options.setMode(pipelinePreset);
+            */
+
+            @SuppressWarnings("unchecked")
+            Queue<ListenableFutureTask> tasks = mc.scheduledTasks;
+            synchronized (mc.scheduledTasks) {
+                tasks.add(ListenableFutureTask.create(new Runnable() {
+                    @Override
+                    public void run() {
+                        String renderDistance = System.getProperty("replaymod.render.mc.renderdistance");
+                        String clouds = System.getProperty("replaymod.render.mc.clouds");
+                        if (renderDistance != null) {
+                            mc.gameSettings.renderDistanceChunks = Integer.parseInt(renderDistance);
+                        }
+                        if (clouds != null) {
+                            mc.gameSettings.clouds = Boolean.parseBoolean(clouds);
+                        }
+
+                        System.out.println("Loading replay...");
+                        // TODO
+//                        try {
+//                            ReplayHandler.startReplay(file, false);
+//                        } catch (Throwable t) {
+//                            t.printStackTrace();
+//                            FMLCommonHandler.instance().exitJava(1, false);
+//                        }
+//
+//                        int index = 0;
+//                        if (path != null) {
+//                            for (KeyframeSet set : ReplayHandler.getKeyframeRepository()) {
+//                                if (set.getName().equals(path)) {
+//                                    break;
+//                                }
+//                                index++;
+//                            }
+//                            if (index >= ReplayHandler.getKeyframeRepository().length) {
+//                                throw new IllegalArgumentException("No path named \"" + path + "\".");
+//                            }
+//                        } else if (ReplayHandler.getKeyframeRepository().length == 0) {
+//                            throw new IllegalArgumentException("Replay file has no paths defined.");
+//                        }
+//                        ReplayHandler.useKeyframePresetFromRepository(index);
+//
+//                        System.out.println("Rendering started...");
+//                        try {
+//                            ReplayProcess.startReplayProcess(options, true);
+//                        } catch (Throwable t) {
+//                            t.printStackTrace();
+//                            FMLCommonHandler.instance().exitJava(1, false);
+//                        }
+//                        if (mc.hasCrashed) {
+//                            System.out.println(mc.crashReporter.getCompleteReport());
+//                        }
+//                        System.out.println("Rendering done. Shutting down...");
+//                        mc.shutdown();
+                    }
+                }, null));
+            }
+
+            testIfMoeshAndExitMinecraft();
+        }
 
         runLater(() -> {
             // Cleanup deleted corrupted replays
@@ -159,9 +317,53 @@ public class ReplayMod {
         });
     }
 
+    /**
+     * Set when the currently running code has been scheduled by runLater.
+     * If this is the case, subsequent calls to runLater have to be delayed until all scheduled tasks have been
+     * processed, otherwise a livelock may occur.
+     */
+    private boolean inRunLater = false;
+
+    // 1.7.10: Cannot use MC's because it is processed only during ticks (so not at all when replay is paused)
+    private final Queue<ListenableFutureTask<?>> scheduledTasks = new ArrayDeque<>();
+
     public void runLater(Runnable runnable) {
-        synchronized (mc.scheduledTasks) {
-            mc.scheduledTasks.add(ListenableFutureTask.create(runnable, null));
+        if (mc.isCallingFromMinecraftThread() && inRunLater) {
+            EventBus bus = FMLCommonHandler.instance().bus();
+            bus.register(new RunLaterHelper(runnable));
+            return;
+        }
+        synchronized (scheduledTasks) {
+            scheduledTasks.add(ListenableFutureTask.create(() -> {
+                inRunLater = true;
+                try {
+                    runnable.run();
+                } finally {
+                    inRunLater = false;
+                }
+            }, null));
+        }
+    }
+
+    // in 1.7.10 apparently events can't be delivered to anonymous classes
+    @RequiredArgsConstructor
+    public class RunLaterHelper {
+        private final Runnable runnable;
+        @SubscribeEvent
+        public void onRenderTick(TickEvent.RenderTickEvent event) {
+            if (event.phase == TickEvent.Phase.START) {
+                runLater(runnable);
+                FMLCommonHandler.instance().bus().unregister(this);
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void runScheduledTasks(InputReplayTimer.RunScheduledTasks event) {
+        synchronized (scheduledTasks) {
+            while (!scheduledTasks.isEmpty()) {
+                scheduledTasks.poll().run();
+            }
         }
     }
 
@@ -190,13 +392,13 @@ public class ReplayMod {
     private void printToChat(boolean warning, String message, Object... args) {
         if (getSettingsRegistry().get(Setting.NOTIFICATIONS)) {
             // Some nostalgia: "§8[§6Replay Mod§8]§r Your message goes here"
-            Style coloredDarkGray = new Style().setColor(TextFormatting.DARK_GRAY);
-            Style coloredGold = new Style().setColor(TextFormatting.GOLD);
-            ITextComponent text = new TextComponentString("[").setStyle(coloredDarkGray)
-                    .appendSibling(new TextComponentTranslation("replaymod.title").setStyle(coloredGold))
-                    .appendSibling(new TextComponentString("] "))
-                    .appendSibling(new TextComponentTranslation(message, args).setStyle(new Style()
-                            .setColor(warning ? TextFormatting.RED : TextFormatting.DARK_GREEN)));
+            ChatStyle coloredDarkGray = new ChatStyle().setColor(EnumChatFormatting.DARK_GRAY);
+            ChatStyle coloredGold = new ChatStyle().setColor(EnumChatFormatting.GOLD);
+            IChatComponent text = new ChatComponentText("[").setChatStyle(coloredDarkGray)
+                    .appendSibling(new ChatComponentTranslation("replaymod.title").setChatStyle(coloredGold))
+                    .appendSibling(new ChatComponentText("] "))
+                    .appendSibling(new ChatComponentTranslation(message, args).setChatStyle(new ChatStyle()
+                            .setColor(warning ? EnumChatFormatting.RED : EnumChatFormatting.DARK_GREEN)));
             // Send message to chat GUI
             // The ingame GUI is initialized at startup, therefore this is possible before the client is connected
             mc.ingameGUI.getChatGUI().printChatMessage(text);

src/main/java/com/replaymod/core/SettingsRegistry.java

@@ -1,8 +1,8 @@
 package com.replaymod.core;
 
 import com.replaymod.core.events.SettingsChangedEvent;
+import cpw.mods.fml.common.FMLCommonHandler;
 import net.minecraft.client.resources.I18n;
-import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.common.config.Configuration;
 
 import java.lang.reflect.Field;
@@ -83,7 +83,7 @@ public class SettingsRegistry {
             throw new IllegalArgumentException("Default type " + key.getDefault().getClass() + " not supported.");
         }
         settings.put(key, value);
-        MinecraftForge.EVENT_BUS.post(new SettingsChangedEvent(this, key));
+        FMLCommonHandler.instance().bus().post(new SettingsChangedEvent(this, key));
     }
 
     public void save() {

src/main/java/com/replaymod/core/events/SettingsChangedEvent.java

@@ -1,9 +1,9 @@
 package com.replaymod.core.events;
 
 import com.replaymod.core.SettingsRegistry;
+import cpw.mods.fml.common.eventhandler.Event;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
-import net.minecraftforge.fml.common.eventhandler.Event;
 
 @RequiredArgsConstructor
 public class SettingsChangedEvent extends Event {

src/main/java/com/replaymod/core/gui/GuiFactory.java

@@ -1,9 +1,9 @@
 package com.replaymod.core.gui;
 
 import com.replaymod.core.ReplayMod;
+import cpw.mods.fml.client.IModGuiFactory;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiScreen;
-import net.minecraftforge.fml.client.IModGuiFactory;
 
 import java.util.Set;
 

src/main/java/com/replaymod/core/handler/MainMenuHandler.java

@@ -1,10 +1,12 @@
 package com.replaymod.core.handler;
 
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.GuiMainMenu;
 import net.minecraftforge.client.event.GuiScreenEvent;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+import java.util.List;
 
 /**
  * Moves certain buttons on the main menu upwards so we can inject our own.
@@ -16,12 +18,14 @@ public class MainMenuHandler {
 
     @SubscribeEvent
     public void onInit(GuiScreenEvent.InitGuiEvent.Post event) {
-        if (event.getGui() instanceof GuiMainMenu) {
-            for (GuiButton button : event.getButtonList()) {
+        if (event.gui instanceof GuiMainMenu) {
+            @SuppressWarnings("unchecked")
+            List<GuiButton> buttonList = event.buttonList;
+            for (GuiButton button : buttonList) {
                 // Buttons that aren't in a rectangle directly above our space don't need moving
-                if (button.xPosition + button.width < event.getGui().width / 2 - 100
-                        || button.xPosition > event.getGui().width / 2 + 100
-                        || button.yPosition > event.getGui().height / 4 + 10 + 4 * 24) continue;
+                if (button.xPosition + button.width < event.gui.width / 2 - 100
+                        || button.xPosition > event.gui.width / 2 + 100
+                        || button.yPosition > event.gui.height / 4 + 10 + 4 * 24) continue;
                 // Move button up to make space for two rows of buttons
                 // and then move back down by 10 to compensate for the space to the exit button that was already there
                 button.yPosition -= 2 * 24 - 10;

src/main/java/com/replaymod/core/utils/ModCompat.java

@@ -1,10 +1,9 @@
 package com.replaymod.core.utils;
 
 import com.replaymod.replaystudio.data.ModInfo;
-import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.fml.common.Loader;
-import net.minecraftforge.fml.common.ModContainer;
-import net.minecraftforge.fml.common.registry.GameData;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.ModContainer;
+import cpw.mods.fml.common.registry.GameData;
 
 import java.util.*;
 import java.util.function.Function;
@@ -17,14 +16,19 @@ public class ModCompat {
         Map<String, ModContainer> ignoreCaseMap = Loader.instance().getModList().stream()
                 .collect(Collectors.toMap(m -> m.getModId().toLowerCase(), Function.identity()));
         return Stream.concat(
-                ((Set<ResourceLocation>) GameData.getBlockRegistry().getKeys()).stream(),
-                ((Set<ResourceLocation>) GameData.getItemRegistry().getKeys()).stream()
-        ).map(ResourceLocation::getResourceDomain).filter(s -> !s.equals("minecraft")).distinct()
+                ((Set<String>) GameData.getBlockRegistry().getKeys()).stream(),
+                ((Set<String>) GameData.getItemRegistry().getKeys()).stream()
+        ).map(ModCompat::getResourceDomain).filter(s -> !s.equals("minecraft")).distinct()
                 .map(String::toLowerCase).map(ignoreCaseMap::get).filter(mod -> mod != null)
                 .map(mod -> new ModInfo(mod.getModId(), mod.getName(), mod.getVersion()))
                 .collect(Collectors.toList());
     }
 
+    private static String getResourceDomain(String name) {
+        if (!name.contains(":")) return null; // Still using old names without namespace, can't do anything, ignore
+        return name.split(":", 2)[0];
+    }
+
     public static final class ModInfoDifference {
         private final Set<ModInfo> missing = new HashSet<>();
         private final Map<ModInfo, String> differing = new HashMap<>();

src/main/java/com/replaymod/core/utils/OpenGLUtils.java

@@ -1,9 +1,6 @@
 package com.replaymod.core.utils;
 
-import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.client.renderer.Tessellator;
-import net.minecraft.client.renderer.VertexBuffer;
-import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;
 
@@ -29,22 +26,21 @@ public class OpenGLUtils {
     }
 
     public static void drawRotatedRectWithCustomSizedTexture(int x, int y, float rotation, float u, float v, int width, int height, float textureWidth, float textureHeight) {
-        GlStateManager.pushMatrix();
+        GL11.glPushMatrix();
 
         float f4 = 1.0F / textureWidth;
         float f5 = 1.0F / textureHeight;
 
-        Tessellator tessellator = Tessellator.getInstance();
-        VertexBuffer vertexBuffer = tessellator.getBuffer();
-        GlStateManager.translate(x+(width/2), y+(width/2), 0);
-        GlStateManager.rotate(rotation, 0, 0, 1);
-        vertexBuffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
-        vertexBuffer.pos(-width / 2, height / 2, 0.0D).tex((double) (u * f4), (double) ((v + (float) height) * f5)).endVertex();
-        vertexBuffer.pos(width/2, height/2, 0.0D).tex((double)((u + (float)width) * f4), (double)((v + (float)height) * f5)).endVertex();
-        vertexBuffer.pos(width/2, -height/2, 0.0D).tex((double)((u + (float)width) * f4), (double)(v * f5)).endVertex();
-        vertexBuffer.pos(-width/2, -height/2, 0.0D).tex((double)(u * f4), (double)(v * f5)).endVertex();
+        Tessellator tessellator = Tessellator.instance;
+        GL11.glTranslatef(x+(width/2), y+(width/2), 0);
+        GL11.glRotatef(rotation, 0, 0, 1);
+        tessellator.startDrawingQuads();
+        tessellator.addVertexWithUV(-width / 2, height / 2, 0.0D, (double) (u * f4), (double) ((v + (float) height) * f5));
+        tessellator.addVertexWithUV(width/2, height/2, 0.0D, (double)((u + (float)width) * f4), (double)((v + (float)height) * f5));
+        tessellator.addVertexWithUV(width/2, -height/2, 0.0D, (double)((u + (float)width) * f4), (double)(v * f5));
+        tessellator.addVertexWithUV(-width/2, -height/2, 0.0D, (double)(u * f4), (double)(v * f5));
         tessellator.draw();
 
-        GlStateManager.popMatrix();
+        GL11.glPopMatrix();
     }
 }

src/main/java/com/replaymod/core/utils/Restrictions.java

@@ -1,7 +1,10 @@
 package com.replaymod.core.utils;
 
+import io.netty.buffer.Unpooled;
 import net.minecraft.network.PacketBuffer;
-import net.minecraft.network.play.server.SPacketCustomPayload;
+import net.minecraft.network.play.server.S3FPacketCustomPayload;
+
+import java.io.IOException;
 
 /**
  * Restrictions set by the server,
@@ -14,8 +17,8 @@ public class Restrictions {
     private boolean onlyFirstPerson;
     private boolean onlyRecordingPlayer;
 
-    public String handle(SPacketCustomPayload packet) {
-        PacketBuffer buffer = packet.getBufferData();
+    public String handle(S3FPacketCustomPayload packet) throws IOException {
+        PacketBuffer buffer = new PacketBuffer(Unpooled.wrappedBuffer(packet.func_149168_d()));
         while (buffer.isReadable()) {
             String name = buffer.readStringFromBuffer(64);
             boolean active = buffer.readBoolean();

src/main/java/com/replaymod/core/utils/Utils.java

@@ -1,5 +1,6 @@
 package com.replaymod.core.utils;
 
+import com.google.common.net.PercentEscaper;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
@@ -16,11 +17,15 @@ import de.johni0702.minecraft.gui.layout.HorizontalLayout;
 import de.johni0702.minecraft.gui.layout.VerticalLayout;
 import de.johni0702.minecraft.gui.popup.GuiInfoPopup;
 import de.johni0702.minecraft.gui.utils.Colors;
+import lombok.SneakyThrows;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.AbstractClientPlayer;
 import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.network.NetworkPlayerInfo;
-import net.minecraft.client.resources.DefaultPlayerSkin;
 import net.minecraft.crash.CrashReport;
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.util.ResourceLocation;
+import org.apache.commons.io.Charsets;
+import org.apache.commons.io.FilenameUtils;
 import org.apache.logging.log4j.Logger;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.util.Dimension;
@@ -36,6 +41,8 @@ import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
 import java.security.KeyManagementException;
 import java.security.KeyStore;
 import java.security.KeyStoreException;
@@ -137,15 +144,28 @@ public class Utils {
         return mail.matches("^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$");
     }
 
-    public static ResourceLocation getResourceLocationForPlayerUUID(UUID uuid) {
-        NetworkPlayerInfo info = getMinecraft().getConnection().getPlayerInfo(uuid);
-        ResourceLocation skinLocation;
-        if (info != null && info.hasLocationSkin()) {
-            skinLocation = info.getLocationSkin();
-        } else {
-            skinLocation = DefaultPlayerSkin.getDefaultSkin(uuid);
+    private static final PercentEscaper REPLAY_NAME_ENCODER = new PercentEscaper(".-_ ", false);
+
+    public static String replayNameToFileName(String replayName) {
+        return REPLAY_NAME_ENCODER.escape(replayName) + ".mcpr";
+    }
+
+    @SneakyThrows(UnsupportedEncodingException.class)
+    public static String fileNameToReplayName(String fileName) {
+        String baseName = FilenameUtils.getBaseName(fileName);
+        try {
+            return URLDecoder.decode(baseName, Charsets.UTF_8.name());
+        } catch (IllegalArgumentException e) {
+            return baseName;
         }
-        return skinLocation;
+    }
+
+    public static ResourceLocation getResourceLocationForPlayerUUID(UUID uuid) {
+        EntityPlayer player = Minecraft.getMinecraft().theWorld.getPlayerEntityByUUID(uuid);
+        if (player == null || !(player instanceof AbstractClientPlayer)) {
+            return AbstractClientPlayer.locationStevePng;
+        }
+        return ((AbstractClientPlayer) player).getLocationSkin();
     }
 
     public static boolean isCtrlDown() {

src/main/java/com/replaymod/core/utils/WrappedTimer.java

@@ -27,7 +27,7 @@ public class WrappedTimer extends Timer {
         to.elapsedPartialTicks = from.elapsedPartialTicks;
         to.lastSyncSysClock = from.lastSyncSysClock;
         to.lastSyncHRClock = from.lastSyncHRClock;
-        to.counter = from.counter;
+        to.field_74285_i = from.field_74285_i;
         to.timeSyncAdjustment = from.timeSyncAdjustment;
     }
 }

src/main/java/com/replaymod/editor/ReplayModEditor.java

@@ -3,14 +3,15 @@ package com.replaymod.editor;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.editor.handler.GuiHandler;
 import com.replaymod.online.Setting;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import org.apache.logging.log4j.Logger;
 
 @Mod(modid = ReplayModEditor.MOD_ID,
         version = "@MOD_VERSION@",
         acceptedMinecraftVersions = "@MC_VERSION@",
+        acceptableRemoteVersions = "*",
         useMetadata = true)
 public class ReplayModEditor {
     public static final String MOD_ID = "replaymod-editor";

src/main/java/com/replaymod/editor/gui/GuiReplayEditor.java

@@ -36,7 +36,6 @@ import de.johni0702.minecraft.gui.popup.GuiYesNoPopup;
 import de.johni0702.minecraft.gui.utils.Colors;
 import net.minecraft.crash.CrashReport;
 import org.apache.commons.io.FileUtils;
-import org.apache.commons.io.FilenameUtils;
 import org.lwjgl.util.ReadableDimension;
 
 import javax.annotation.Nullable;
@@ -125,7 +124,7 @@ public class GuiReplayEditor extends GuiScreen {
     }
 
     public void save(File inputFile, PacketStream.FilterInfo...filters) {
-        save(FilenameUtils.getBaseName(inputFile.getName()), (outputFile) -> {
+        save(Utils.fileNameToReplayName(inputFile.getName()), (outputFile) -> {
             Studio studio = new ReplayStudio();
             File tmpDir = null;
             try {
@@ -220,7 +219,7 @@ public class GuiReplayEditor extends GuiScreen {
                         Utils.error(LOGGER, GuiReplayEditor.this, CrashReport.makeCrashReport(e, "Getting replay folder"), null);
                         return;
                     }
-                    File targetFile = new File(replayFolder, name + ".mcpr");
+                    File targetFile = new File(replayFolder, Utils.replayNameToFileName(name));
                     if (targetFile.exists()) {
                         LOGGER.trace("Selected file already exists, asking for confirmation");
                         Futures.addCallback(GuiYesNoPopup.open(GuiReplayEditor.this,

src/main/java/com/replaymod/editor/gui/GuiTrimPanel.java

@@ -20,7 +20,6 @@ import de.johni0702.minecraft.gui.layout.HorizontalLayout;
 import de.johni0702.minecraft.gui.layout.VerticalLayout;
 import net.minecraft.client.resources.I18n;
 import net.minecraft.crash.CrashReport;
-import org.apache.commons.io.FilenameUtils;
 import org.apache.commons.io.IOCase;
 import org.apache.commons.io.filefilter.SuffixFileFilter;
 import org.lwjgl.util.Dimension;
@@ -52,7 +51,7 @@ public class GuiTrimPanel extends GuiPanel {
 
     public final GuiDropdownMenu<File> inputReplays = new GuiDropdownMenu<File>(this)
             .setMinSize(new Dimension(200, 20)).onSelection(i -> updateSelectedReplay())
-            .setToString(f -> f == NO_REPLAY ? "" : FilenameUtils.getBaseName(f.getName()));
+            .setToString(f -> f == NO_REPLAY ? "" : Utils.fileNameToReplayName(f.getName()));
 
     public final GuiNumberField startHour = newGuiNumberField();
     public final GuiNumberField startMin = newGuiNumberField();

src/main/java/com/replaymod/editor/handler/GuiHandler.java

@@ -2,13 +2,16 @@ package com.replaymod.editor.handler;
 
 import com.replaymod.editor.ReplayModEditor;
 import com.replaymod.editor.gui.GuiReplayEditor;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import de.johni0702.minecraft.gui.container.GuiScreen;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.GuiMainMenu;
 import net.minecraft.client.resources.I18n;
 import net.minecraftforge.client.event.GuiScreenEvent;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+import java.util.List;
 
 public class GuiHandler {
     private static final int BUTTON_REPLAY_EDITOR = 17890237;
@@ -20,28 +23,31 @@ public class GuiHandler {
     }
 
     public void register() {
+        FMLCommonHandler.instance().bus().register(this);
         MinecraftForge.EVENT_BUS.register(this);
     }
 
     @SubscribeEvent
     public void injectIntoMainMenu(GuiScreenEvent.InitGuiEvent event) {
-        if (!(event.getGui() instanceof GuiMainMenu)) {
+        if (!(event.gui instanceof GuiMainMenu)) {
             return;
         }
 
-        GuiButton button = new GuiButton(BUTTON_REPLAY_EDITOR, event.getGui().width / 2 + 2,
-                event.getGui().height / 4 + 10 + 3 * 24, I18n.format("replaymod.gui.replayeditor"));
+        @SuppressWarnings("unchecked")
+        List<GuiButton> buttonList = event.buttonList;
+        GuiButton button = new GuiButton(BUTTON_REPLAY_EDITOR, event.gui.width / 2 + 2,
+                event.gui.height / 4 + 10 + 3 * 24, I18n.format("replaymod.gui.replayeditor"));
         button.width = button.width / 2 - 2;
-        event.getButtonList().add(button);
+        buttonList.add(button);
     }
 
     @SubscribeEvent
     public void onButton(GuiScreenEvent.ActionPerformedEvent.Pre event) {
-        if(!event.getButton().enabled) return;
+        if(!event.button.enabled) return;
 
-        if (event.getGui() instanceof GuiMainMenu) {
-            if (event.getButton().id == BUTTON_REPLAY_EDITOR) {
-                new GuiReplayEditor(GuiScreen.wrap(event.getGui()), mod.getCore()).display();
+        if (event.gui instanceof GuiMainMenu) {
+            if (event.button.id == BUTTON_REPLAY_EDITOR) {
+                new GuiReplayEditor(GuiScreen.wrap(event.gui), mod.getCore()).display();
             }
         }
     }

src/main/java/com/replaymod/extras/FullBrightness.java

@@ -5,13 +5,13 @@ import com.replaymod.replay.ReplayHandler;
 import com.replaymod.replay.ReplayModReplay;
 import com.replaymod.replay.events.ReplayOpenEvent;
 import com.replaymod.replay.gui.overlay.GuiReplayOverlay;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
 import de.johni0702.minecraft.gui.element.GuiImage;
 import de.johni0702.minecraft.gui.element.IGuiImage;
 import de.johni0702.minecraft.gui.layout.HorizontalLayout;
 import net.minecraft.client.settings.GameSettings;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import net.minecraftforge.fml.common.gameevent.TickEvent;
 import org.lwjgl.input.Keyboard;
 
 public class FullBrightness implements Extra {
@@ -40,7 +40,7 @@ public class FullBrightness implements Extra {
             }
         });
 
-        MinecraftForge.EVENT_BUS.register(this);
+        FMLCommonHandler.instance().bus().register(this);
     }
 
     @SubscribeEvent

src/main/java/com/replaymod/extras/HotkeyButtons.java

@@ -4,6 +4,8 @@ import com.replaymod.core.KeyBindingRegistry;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.replay.events.ReplayOpenEvent;
 import com.replaymod.replay.gui.overlay.GuiReplayOverlay;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import de.johni0702.minecraft.gui.GuiRenderer;
 import de.johni0702.minecraft.gui.RenderInfo;
 import de.johni0702.minecraft.gui.container.GuiContainer;
@@ -17,8 +19,6 @@ import de.johni0702.minecraft.gui.layout.GridLayout;
 import de.johni0702.minecraft.gui.layout.HorizontalLayout;
 import de.johni0702.minecraft.gui.layout.LayoutData;
 import net.minecraft.client.resources.I18n;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.util.Dimension;
 import org.lwjgl.util.ReadableDimension;
@@ -35,7 +35,7 @@ public class HotkeyButtons implements Extra {
     public void register(ReplayMod mod) throws Exception {
         this.mod = mod;
 
-        MinecraftForge.EVENT_BUS.register(this);
+        FMLCommonHandler.instance().bus().register(this);
     }
 
     @SubscribeEvent

src/main/java/com/replaymod/extras/LocalizationExtra.java

@@ -5,7 +5,7 @@ import com.replaymod.core.ReplayMod;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.resources.IResourcePack;
 import net.minecraft.client.resources.data.IMetadataSection;
-import net.minecraft.client.resources.data.MetadataSerializer;
+import net.minecraft.client.resources.data.IMetadataSerializer;
 import net.minecraft.util.ResourceLocation;
 import org.apache.commons.io.IOUtils;
 
@@ -99,12 +99,12 @@ public class LocalizationExtra implements Extra {
         }
 
         @Override
-        public Set<String> getResourceDomains() {
+        public Set getResourceDomains() {
             return ImmutableSet.of("replaymod");
         }
 
         @Override
-        public <T extends IMetadataSection> T getPackMetadata(MetadataSerializer metadataSerializer, String metadataSectionName) throws IOException {
+        public IMetadataSection getPackMetadata(IMetadataSerializer p_135058_1_, String p_135058_2_) throws IOException {
             return null;
         }
 

src/main/java/com/replaymod/extras/OpenEyeExtra.java

@@ -2,6 +2,7 @@ package com.replaymod.extras;
 
 import com.replaymod.core.ReplayMod;
 import com.replaymod.core.Setting;
+import cpw.mods.fml.common.Loader;
 import de.johni0702.minecraft.gui.container.AbstractGuiScreen;
 import de.johni0702.minecraft.gui.container.GuiContainer;
 import de.johni0702.minecraft.gui.container.GuiPanel;
@@ -14,7 +15,6 @@ import de.johni0702.minecraft.gui.layout.HorizontalLayout;
 import de.johni0702.minecraft.gui.layout.VerticalLayout;
 import de.johni0702.minecraft.gui.popup.AbstractGuiPopup;
 import de.johni0702.minecraft.gui.utils.Colors;
-import net.minecraftforge.fml.common.Loader;
 import org.apache.commons.io.FileUtils;
 
 import javax.net.ssl.HttpsURLConnection;

src/main/java/com/replaymod/extras/ReplayModExtras.java

@@ -4,17 +4,21 @@ import com.replaymod.core.ReplayMod;
 import com.replaymod.extras.playeroverview.PlayerOverview;
 import com.replaymod.extras.urischeme.UriSchemeExtra;
 import com.replaymod.extras.youtube.YoutubeUpload;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import org.apache.logging.log4j.Logger;
 
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 
 @Mod(modid = ReplayModExtras.MOD_ID,
         version = "@MOD_VERSION@",
         acceptedMinecraftVersions = "@MC_VERSION@",
+        acceptableRemoteVersions = "*",
         useMetadata = true)
 public class ReplayModExtras {
     public static final String MOD_ID = "replaymod-extras";
@@ -32,6 +36,8 @@ public class ReplayModExtras {
             OpenEyeExtra.class
     );
 
+    private final Map<Class<? extends Extra>, Extra> instances = new HashMap<>();
+
     public static Logger LOGGER;
 
     @Mod.EventHandler
@@ -45,9 +51,14 @@ public class ReplayModExtras {
             try {
                 Extra extra = cls.newInstance();
                 extra.register(ReplayMod.instance);
+                instances.put(cls, extra);
             } catch (Throwable t) {
                 LOGGER.warn("Failed to load extra " + cls.getName() + ": ", t);
             }
         }
     }
+
+    public <T extends Extra> Optional<T> get(Class<T> cls) {
+        return Optional.ofNullable(instances.get(cls)).map(cls::cast);
+    }
 }

src/main/java/com/replaymod/extras/playeroverview/PlayerOverview.java

@@ -1,7 +1,6 @@
 package com.replaymod.extras.playeroverview;
 
 import com.google.common.base.Optional;
-import com.google.common.base.Predicate;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.core.utils.Utils;
 import com.replaymod.extras.Extra;
@@ -9,17 +8,23 @@ import com.replaymod.replay.ReplayModReplay;
 import com.replaymod.replay.camera.CameraEntity;
 import com.replaymod.replay.events.ReplayCloseEvent;
 import com.replaymod.replay.events.ReplayOpenEvent;
-import net.minecraft.client.renderer.entity.RenderManager;
-import net.minecraft.client.renderer.entity.RenderPlayer;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.eventhandler.EventPriority;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraftforge.client.event.RenderHandEvent;
+import net.minecraftforge.client.event.RenderPlayerEvent;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import org.lwjgl.input.Keyboard;
 
 import java.io.IOException;
-import java.util.*;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.stream.Collectors;
 
 public class PlayerOverview implements Extra {
     private ReplayModReplay module;
@@ -36,12 +41,10 @@ public class PlayerOverview implements Extra {
             public void run() {
                 if (module.getReplayHandler() != null) {
                     @SuppressWarnings("unchecked")
-                    List<EntityPlayer> players = mod.getMinecraft().theWorld.getPlayers(EntityPlayer.class, new Predicate() {
-                        @Override
-                        public boolean apply(Object input) {
-                            return !(input instanceof CameraEntity); // Exclude the camera entity
-                        }
-                    });
+                    List<EntityPlayer> players = mod.getMinecraft().theWorld.playerEntities;
+                    players = players.stream()
+                            .filter(it -> !(it instanceof CameraEntity)) // Exclude the camera entity
+                            .collect(Collectors.toList());
                     if (!Utils.isCtrlDown()) {
                         // Hide all players that have an UUID v2 (commonly used for NPCs)
                         Iterator<EntityPlayer> iter = players.iterator();
@@ -57,13 +60,8 @@ public class PlayerOverview implements Extra {
             }
         });
 
+        FMLCommonHandler.instance().bus().register(this);
         MinecraftForge.EVENT_BUS.register(this);
-
-        RenderManager renderManager = mod.getMinecraft().getRenderManager();
-        @SuppressWarnings("unchecked")
-        Map<String, RenderPlayer> skinMap = renderManager.skinMap;
-        skinMap.put("default", new PlayerRenderHook(this, renderManager, false));
-        skinMap.put("slim", new PlayerRenderHook(this, renderManager, true));
     }
 
     public boolean isHidden(UUID uuid) {
@@ -96,12 +94,19 @@ public class PlayerOverview implements Extra {
 
     @SubscribeEvent
     public void oRenderHand(RenderHandEvent event) {
-        Entity view = module.getCore().getMinecraft().getRenderViewEntity();
+        Entity view = module.getCore().getMinecraft().renderViewEntity;
         if (view != null && isHidden(view.getUniqueID())) {
             event.setCanceled(true);
         }
     }
 
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void preRenderPlayer(RenderPlayerEvent.Pre event) {
+        if (isHidden(event.entityPlayer.getUniqueID())) {
+            event.setCanceled(true);
+        }
+    }
+
     public boolean isSavingEnabled() {
         return savingEnabled;
     }

src/main/java/com/replaymod/extras/playeroverview/PlayerOverviewGui.java

@@ -20,9 +20,7 @@ import de.johni0702.minecraft.gui.layout.HorizontalLayout;
 import de.johni0702.minecraft.gui.utils.Colors;
 import net.minecraft.client.audio.PositionedSoundRecord;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.EnumPlayerModelParts;
-import net.minecraft.init.MobEffects;
-import net.minecraft.init.SoundEvents;
+import net.minecraft.potion.Potion;
 import net.minecraft.util.ResourceLocation;
 import org.lwjgl.util.Dimension;
 import org.lwjgl.util.ReadableDimension;
@@ -47,14 +45,14 @@ public class PlayerOverviewGui extends GuiScreen implements Closeable {
     public final GuiCheckbox checkAll = new GuiCheckbox(contentPanel){
         @Override
         public void onClick() {
-            getMinecraft().getSoundHandler().playSound(PositionedSoundRecord.getMasterRecord(SoundEvents.UI_BUTTON_CLICK, 1.0F));
+            getMinecraft().getSoundHandler().playSound(PositionedSoundRecord.createPositionedSoundRecord(BUTTON_SOUND, 1.0F));
             playersScrollable.forEach(IGuiCheckbox.class).setChecked(true);
         }
     }.setLabel("").setChecked(true).setTooltip(new GuiTooltip().setI18nText("replaymod.gui.playeroverview.showall"));
     public final GuiCheckbox uncheckAll = new GuiCheckbox(contentPanel){
         @Override
         public void onClick() {
-            getMinecraft().getSoundHandler().playSound(PositionedSoundRecord.getMasterRecord(SoundEvents.UI_BUTTON_CLICK, 1.0F));
+            getMinecraft().getSoundHandler().playSound(PositionedSoundRecord.createPositionedSoundRecord(BUTTON_SOUND, 1.0F));
             playersScrollable.forEach(IGuiCheckbox.class).setChecked(false);
         }
     }.setLabel("").setChecked(false).setTooltip(new GuiTooltip().setI18nText("replaymod.gui.playeroverview.hideall"));
@@ -97,12 +95,10 @@ public class PlayerOverviewGui extends GuiScreen implements Closeable {
                         public void draw(GuiRenderer renderer, ReadableDimension size, RenderInfo renderInfo) {
                             renderer.bindTexture(texture);
                             renderer.drawTexturedRect(0, 0, 8, 8, 16, 16, 8, 8, 64, 64);
-                            if (p.isWearing(EnumPlayerModelParts.HAT)) {
-                                renderer.drawTexturedRect(0, 0, 40, 8, size.getWidth(), size.getHeight(), 8, 8, 64, 64);
-                            }
+                            renderer.drawTexturedRect(0, 0, 40, 8, size.getWidth(), size.getHeight(), 8, 8, 64, 64);
                         }
                     }.setSize(16, 16),
-                    new GuiLabel().setText(p.getName()).setColor(isSpectator(p) ? Colors.DKGREY : Colors.WHITE)
+                    new GuiLabel().setText(p.getDisplayName()).setColor(isSpectator(p) ? Colors.DKGREY : Colors.WHITE)
             ).onClick(new Runnable() {
                 @Override
                 public void run() {
@@ -146,7 +142,7 @@ public class PlayerOverviewGui extends GuiScreen implements Closeable {
     }
 
     private static boolean isSpectator(EntityPlayer e) {
-        return e.isInvisible() && e.getActivePotionEffect(MobEffects.INVISIBILITY) == null;
+        return e.isInvisible() && e.getActivePotionEffect(Potion.invisibility) == null;
     }
 
     private static final class PlayerComparator implements Comparator<EntityPlayer> {
@@ -154,7 +150,7 @@ public class PlayerOverviewGui extends GuiScreen implements Closeable {
         public int compare(EntityPlayer o1, EntityPlayer o2) {
             if (isSpectator(o1) && !isSpectator(o2)) return 1;
             if (isSpectator(o2) && !isSpectator(o1)) return -1;
-            return o1.getName().compareToIgnoreCase(o2.getName());
+            return o1.getDisplayName().compareToIgnoreCase(o2.getDisplayName());
         }
     }
 }

src/main/java/com/replaymod/extras/playeroverview/PlayerRenderHook.java

@@ -1,20 +0,0 @@
-package com.replaymod.extras.playeroverview;
-
-import net.minecraft.client.entity.AbstractClientPlayer;
-import net.minecraft.client.renderer.culling.ICamera;
-import net.minecraft.client.renderer.entity.RenderManager;
-import net.minecraft.client.renderer.entity.RenderPlayer;
-
-public class PlayerRenderHook extends RenderPlayer {
-    private final PlayerOverview extra;
-
-    public PlayerRenderHook(PlayerOverview extra, RenderManager renderManager, boolean useSmallArms) {
-        super(renderManager, useSmallArms);
-        this.extra = extra;
-    }
-
-    @Override
-    public boolean shouldRender(AbstractClientPlayer entity, ICamera camera, double camX, double camY, double camZ) {
-        return !extra.isHidden(entity.getUniqueID()) && super.shouldRender(entity, camera, camX, camY, camZ);
-    }
-}

src/main/java/com/replaymod/extras/playeroverview/mixin/MixinRenderPlayer.java

@@ -0,0 +1,39 @@
+package com.replaymod.extras.playeroverview.mixin;
+
+import com.replaymod.extras.ReplayModExtras;
+import com.replaymod.extras.playeroverview.PlayerOverview;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RenderPlayer;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.entity.Entity;
+import org.spongepowered.asm.mixin.Mixin;
+
+import java.util.UUID;
+
+/**
+ * This mixin prevents players that are hidden in the PlayerOverview from being rendered.
+ *
+ * Cancelling the RenderPlayerEvent.Pre is insufficient because it affects neither the shadows nor the fire texture.
+ * See: https://github.com/MinecraftForge/MinecraftForge/issues/2987
+ *
+ * The previous solution was to overwrite the RenderPlayer instances which has been dropped in favor of this one
+ * because it is less compatible with other mods whereas this one should be fine as long as no other mod completely
+ * overwrites the methods we modify in this mixin.
+ * One example of the previous solution breaking is when used with VanillaEnhancements because it replaces the
+ * RenderManager with a new custom one which in turn will reset our registered RenderPlayer instances because
+ * it does so after we have already registered with the old RenderManager.
+ */
+@Mixin(value = RenderPlayer.class, priority = 1200)
+public abstract class MixinRenderPlayer extends RendererLivingEntity {
+    public MixinRenderPlayer(ModelBase p_i1261_1_, float p_i1261_2_) {
+        super(p_i1261_1_, p_i1261_2_);
+    }
+
+    @Override
+    public void doRenderShadowAndFire(Entity entity, double d1, double d2, double d3, float f1, float f2) {
+        UUID uuid = entity.getUniqueID();
+        if (!ReplayModExtras.instance.get(PlayerOverview.class).map(po -> po.isHidden(uuid)).orElse(false)) {
+            super.doRenderShadowAndFire(entity, d1, d2, d3, f1, f2);
+        }
+    }
+}

src/main/java/com/replaymod/extras/urischeme/LinuxUriScheme.java

@@ -25,6 +25,7 @@ public class LinuxUriScheme extends UriScheme {
                 "Icon=" + iconFile.getAbsolutePath().replace("\\", "\\\\").replace("\"", "\\\"") + "\n" +
                 "Type=Application\n" +
                 "Terminal=false\n" +
+                "NoDisplay=true\n" +
                 "MimeType=x-scheme-handler/replaymod;";
 
         FileOutputStream out = new FileOutputStream(file);

src/main/java/com/replaymod/extras/youtube/YoutubeUpload.java

@@ -3,11 +3,11 @@ package com.replaymod.extras.youtube;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.extras.Extra;
 import com.replaymod.render.gui.GuiRenderingDone;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import de.johni0702.minecraft.gui.container.GuiScreen;
 import de.johni0702.minecraft.gui.element.GuiButton;
 import net.minecraftforge.client.event.GuiScreenEvent;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
 public class YoutubeUpload implements Extra {
     @Override
@@ -17,8 +17,8 @@ public class YoutubeUpload implements Extra {
 
     @SubscribeEvent
     public void onGuiOpen(GuiScreenEvent.InitGuiEvent.Post event) {
-        if (GuiScreen.from(event.getGui()) instanceof GuiRenderingDone) {
-            GuiRenderingDone gui = (GuiRenderingDone) GuiScreen.from(event.getGui());
+        if (GuiScreen.from(event.gui) instanceof GuiRenderingDone) {
+            GuiRenderingDone gui = (GuiRenderingDone) GuiScreen.from(event.gui);
             // Check if there already is a youtube button
             if (gui.actionsPanel.getChildren().stream().anyMatch(it -> it instanceof YoutubeButton)) {
                 return; // Button already added

src/main/java/com/replaymod/extras/youtube/YoutubeUploader.java

@@ -36,6 +36,8 @@ import java.security.GeneralSecurityException;
 import java.util.Collections;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import static com.replaymod.extras.ReplayModExtras.LOGGER;
+
 public class YoutubeUploader {
     private static final String CLIENT_ID = "743126594724-mfe7pj1k7e47uu5pk4503c8st9vj9ibu.apps.googleusercontent.com";
     private static final String CLIENT_SECRET = "gMwcy3mRYCRamCIjJIYP7rqc";
@@ -137,7 +139,7 @@ public class YoutubeUploader {
 
             CommandLine commandLine = new CommandLine(settings.getExportCommand());
             commandLine.addArguments(args);
-            System.out.println("Re-encoding for ODS with " + settings.getExportCommand() + args);
+            LOGGER.info("Re-encoding for ODS with {} {}", settings.getExportCommand(), args);
             Process process = new ProcessBuilder(commandLine.toStrings()).directory(videoFile.getParentFile()).start();
 
             final AtomicBoolean active = new AtomicBoolean(true);
@@ -149,7 +151,7 @@ public class YoutubeUploader {
                         char c = (char) in.read();
                         if (c == '\r') {
                             String str = sb.toString();
-                            System.out.println(str);
+                            LOGGER.debug("[FFmpeg] {}", str);
                             if (str.startsWith("frame=")) {
                                 str = str.substring(6).trim();
                                 str = str.substring(0, str.indexOf(' '));

src/main/java/com/replaymod/online/ReplayModOnline.java

@@ -11,14 +11,14 @@ import com.replaymod.replay.events.ReplayCloseEvent;
 import com.replaymod.replaystudio.replay.ReplayFile;
 import com.replaymod.replaystudio.replay.ZipReplayFile;
 import com.replaymod.replaystudio.studio.ReplayStudio;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import de.johni0702.minecraft.gui.container.GuiScreen;
-import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.common.config.Configuration;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import org.apache.logging.log4j.Logger;
 
 import java.io.File;
@@ -29,6 +29,7 @@ import static net.minecraft.client.Minecraft.getMinecraft;
 @Mod(modid = ReplayModOnline.MOD_ID,
         version = "@MOD_VERSION@",
         acceptedMinecraftVersions = "@MC_VERSION@",
+        acceptableRemoteVersions = "*",
         useMetadata = true)
 public class ReplayModOnline {
     public static final String MOD_ID = "replaymod-online";
@@ -40,7 +41,7 @@ public class ReplayModOnline {
 
     private ReplayModReplay replayModule;
 
-    private Logger logger;
+    public static Logger LOGGER;
 
     private ApiClient apiClient;
 
@@ -53,7 +54,7 @@ public class ReplayModOnline {
 
     @Mod.EventHandler
     public void preInit(FMLPreInitializationEvent event) {
-        logger = event.getModLog();
+        LOGGER = event.getModLog();
         core = ReplayMod.instance;
         replayModule = ReplayModReplay.instance;
 
@@ -69,12 +70,12 @@ public class ReplayModOnline {
     public void init(FMLInitializationEvent event) {
         if (!getDownloadsFolder().exists()){
             if (!getDownloadsFolder().mkdirs()) {
-                logger.warn("Failed to create downloads folder: " + getDownloadsFolder());
+                LOGGER.warn("Failed to create downloads folder: " + getDownloadsFolder());
             }
         }
 
         new GuiHandler(this).register();
-        MinecraftForge.EVENT_BUS.register(this);
+        FMLCommonHandler.instance().bus().register(this);
     }
 
     @Mod.EventHandler
@@ -82,7 +83,10 @@ public class ReplayModOnline {
         // Initial login prompt
         if (!core.getSettingsRegistry().get(Setting.SKIP_LOGIN_PROMPT)) {
             if (!isLoggedIn()) {
-                core.runLater(() -> new GuiLoginPrompt(apiClient, GuiScreen.wrap(getMinecraft().currentScreen), null, false).display());
+                core.runLater(() -> {
+                    GuiScreen parent = GuiScreen.wrap(getMinecraft().currentScreen);
+                    new GuiLoginPrompt(apiClient, parent, parent, false).display();
+                });
             }
         }
     }
@@ -96,7 +100,7 @@ public class ReplayModOnline {
     }
 
     public Logger getLogger() {
-        return logger;
+        return LOGGER;
     }
 
     public ApiClient getApiClient() {

src/main/java/com/replaymod/online/api/replay/holders/MinecraftVersion.java

@@ -2,9 +2,7 @@ package com.replaymod.online.api.replay.holders;
 
 public enum MinecraftVersion {
 
-    MC_1_8("Minecraft 1.8", "1.8"),
-    MC_1_9_4("Minecraft 1.9.4", "1.9.4"),
-    MC_1_10_2("Minecraft 1.10.2", "1.10.2");
+    MC_1_8("Minecraft 1.8", "1.8");
 
     private String niceName, apiName;
 

src/main/java/com/replaymod/online/gui/GuiReplayCenter.java

@@ -37,8 +37,6 @@ import de.johni0702.minecraft.gui.layout.VerticalLayout;
 import de.johni0702.minecraft.gui.popup.GuiYesNoPopup;
 import de.johni0702.minecraft.gui.utils.Colors;
 import de.johni0702.minecraft.gui.utils.Consumer;
-import net.minecraftforge.fml.common.FMLLog;
-import org.apache.commons.io.FilenameUtils;
 import org.apache.logging.log4j.core.helpers.Strings;
 import org.lwjgl.util.Dimension;
 import org.lwjgl.util.ReadableDimension;
@@ -51,6 +49,8 @@ import java.util.Date;
 import java.util.HashSet;
 import java.util.Set;
 
+import static com.replaymod.online.ReplayModOnline.LOGGER;
+
 public class GuiReplayCenter extends GuiScreen {
     private final ReplayModOnline mod;
     private final ApiClient apiClient;
@@ -336,7 +336,7 @@ public class GuiReplayCenter extends GuiScreen {
                             }
                         });
                     } catch (Exception e) {
-                        FMLLog.getLogger().error("Could not load Replay File " + fileInfo.getId(), e);
+                        LOGGER.error("Could not load Replay File {}", fileInfo.getId(), e);
                     }
                 }
             }
@@ -417,7 +417,7 @@ public class GuiReplayCenter extends GuiScreen {
             this.downloaded = downloaded;
             ReplayMetaData metaData = fileInfo.getMetadata();
 
-            name.setText(ChatFormatting.UNDERLINE + FilenameUtils.getBaseName(fileInfo.getName()));
+            name.setText(ChatFormatting.UNDERLINE + Utils.fileNameToReplayName(fileInfo.getName()));
             author.setI18nText("replaymod.gui.center.author",
                     "" + ChatFormatting.GRAY + ChatFormatting.ITALIC, fileInfo.getOwner());
             if (Strings.isEmpty(metaData.getServerName())) {

src/main/java/com/replaymod/online/gui/GuiSaveModifiedReplay.java

@@ -2,6 +2,7 @@ package com.replaymod.online.gui;
 
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
+import com.replaymod.core.utils.Utils;
 import de.johni0702.minecraft.gui.container.GuiPanel;
 import de.johni0702.minecraft.gui.container.GuiScreen;
 import de.johni0702.minecraft.gui.element.GuiButton;
@@ -27,7 +28,7 @@ public class GuiSaveModifiedReplay extends GuiScreen {
         @Override
         public void run() {
             String resultName = name.getText().trim().replace("[^a-zA-Z0-9\\.\\- ]", "_");
-            final File resultFile = new File(file.getParentFile(), resultName + ".mcpr");
+            final File resultFile = new File(file.getParentFile(), Utils.replayNameToFileName(resultName));
             if (resultFile.exists()) {
                 Futures.addCallback(GuiYesNoPopup.open(GuiSaveModifiedReplay.this,
                         new GuiLabel().setI18nText("replaymod.gui.replaymodified.warning1", resultName).setColor(Colors.BLACK),

src/main/java/com/replaymod/online/gui/GuiUploadReplay.java

@@ -38,7 +38,6 @@ import net.minecraft.client.settings.KeyBinding;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.util.ReportedException;
 import org.apache.commons.io.FileUtils;
-import org.apache.commons.io.FilenameUtils;
 import org.apache.commons.lang3.StringUtils;
 
 import javax.annotation.Nullable;
@@ -135,7 +134,7 @@ public class GuiUploadReplay extends GuiScreen {
         }
 
         // Apply to gui
-        name.setText(FilenameUtils.getBaseName(file.getName()));
+        name.setText(Utils.fileNameToReplayName(file.getName()));
         int secs = metaData.getDuration() / 1000;
         durationLabel.setI18nText("replaymod.gui.upload.duration", secs / 60, secs % 60);
         hideServerIP.setEnabled(!metaData.isSingleplayer());

src/main/java/com/replaymod/online/handler/GuiHandler.java

@@ -5,6 +5,8 @@ import com.replaymod.online.gui.GuiLoginPrompt;
 import com.replaymod.online.gui.GuiReplayCenter;
 import com.replaymod.online.gui.GuiUploadReplay;
 import com.replaymod.replay.gui.screen.GuiReplayViewer;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import de.johni0702.minecraft.gui.container.AbstractGuiScreen;
 import de.johni0702.minecraft.gui.container.GuiPanel;
 import de.johni0702.minecraft.gui.container.GuiScreen;
@@ -14,9 +16,9 @@ import net.minecraft.client.gui.GuiMainMenu;
 import net.minecraft.client.resources.I18n;
 import net.minecraftforge.client.event.GuiScreenEvent;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
 import java.io.File;
+import java.util.List;
 
 public class GuiHandler {
     private static final int BUTTON_REPLAY_CENTER = 17890236;
@@ -28,23 +30,26 @@ public class GuiHandler {
     }
 
     public void register() {
+        FMLCommonHandler.instance().bus().register(this);
         MinecraftForge.EVENT_BUS.register(this);
     }
 
     @SubscribeEvent
     public void injectIntoMainMenu(GuiScreenEvent.InitGuiEvent event) {
-        if (!(event.getGui() instanceof GuiMainMenu)) {
+        if (!(event.gui instanceof GuiMainMenu)) {
             return;
         }
 
-        GuiButton button = new GuiButton(BUTTON_REPLAY_CENTER, event.getGui().width / 2 - 100,
-                event.getGui().height / 4 + 10 + 4 * 24, I18n.format("replaymod.gui.replaycenter"));
-        event.getButtonList().add(button);
+        @SuppressWarnings("unchecked")
+        List<GuiButton> buttonList = event.buttonList;
+        GuiButton button = new GuiButton(BUTTON_REPLAY_CENTER, event.gui.width / 2 - 100,
+                event.gui.height / 4 + 10 + 4 * 24, I18n.format("replaymod.gui.replaycenter"));
+        buttonList.add(button);
     }
 
     @SubscribeEvent
     public void injectIntoReplayViewer(GuiScreenEvent.InitGuiEvent.Post event) {
-        AbstractGuiScreen guiScreen = GuiScreen.from(event.getGui());
+        AbstractGuiScreen guiScreen = GuiScreen.from(event.gui);
         if (!(guiScreen instanceof GuiReplayViewer)) {
             return;
         }
@@ -70,15 +75,15 @@ public class GuiHandler {
 
     @SubscribeEvent
     public void onButton(GuiScreenEvent.ActionPerformedEvent.Pre event) {
-        if(!event.getButton().enabled) return;
+        if(!event.button.enabled) return;
 
-        if (event.getGui() instanceof GuiMainMenu) {
-            if (event.getButton().id == BUTTON_REPLAY_CENTER) {
+        if (event.gui instanceof GuiMainMenu) {
+            if (event.button.id == BUTTON_REPLAY_CENTER) {
                 GuiReplayCenter replayCenter = new GuiReplayCenter(mod);
                 if (mod.isLoggedIn()) {
                     replayCenter.display();
                 } else {
-                    new GuiLoginPrompt(mod.getApiClient(), GuiScreen.wrap(event.getGui()), replayCenter, true).display();
+                    new GuiLoginPrompt(mod.getApiClient(), GuiScreen.wrap(event.gui), replayCenter, true).display();
                 }
             }
         }

src/main/java/com/replaymod/pathing/player/AbstractTimelinePlayer.java

@@ -10,9 +10,9 @@ import com.replaymod.replay.ReplayHandler;
 import com.replaymod.replaystudio.pathing.path.Keyframe;
 import com.replaymod.replaystudio.pathing.path.Path;
 import com.replaymod.replaystudio.pathing.path.Timeline;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.client.Minecraft;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
 import javax.annotation.Nullable;
 import java.util.Iterator;
@@ -65,7 +65,7 @@ public abstract class AbstractTimelinePlayer {
         }
 
         replayHandler.getReplaySender().setSyncModeAndWait();
-        MinecraftForge.EVENT_BUS.register(this);
+        FMLCommonHandler.instance().bus().register(this);
         lastTime = 0;
         mc.timer = new ReplayTimer(mc.timer);
         mc.timer.timerSpeed = 1;
@@ -87,7 +87,7 @@ public abstract class AbstractTimelinePlayer {
             mc.timer = ((ReplayTimer) mc.timer).getWrapped();
             replayHandler.getReplaySender().setReplaySpeed(0);
             replayHandler.getReplaySender().setAsyncMode(true);
-            MinecraftForge.EVENT_BUS.unregister(this);
+            FMLCommonHandler.instance().bus().unregister(this);
             return;
         }
         long time = getTimePassed();

src/main/java/com/replaymod/pathing/player/RealtimeTimelinePlayer.java

@@ -3,6 +3,7 @@ package com.replaymod.pathing.player;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.replaymod.replay.ReplayHandler;
 import com.replaymod.replaystudio.pathing.path.Timeline;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 
 /**
  * Timeline player using the system time.
@@ -32,6 +33,7 @@ public class RealtimeTimelinePlayer extends AbstractTimelinePlayer {
     }
 
     @Override
+    @SubscribeEvent // 1.7.10 doesn't yet deal properly with inherited, overridden event handlers
     public void onTick(ReplayTimer.UpdatedEvent event) {
         if (secondFrame) {
             secondFrame = false;

src/main/java/com/replaymod/pathing/player/ReplayTimer.java

@@ -1,9 +1,9 @@
 package com.replaymod.pathing.player;
 
 import com.replaymod.core.utils.WrappedTimer;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.eventhandler.Event;
 import net.minecraft.util.Timer;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.Event;
 
 /**
  * Wrapper around the current timer that prevents the timer from advancing by itself.
@@ -20,7 +20,7 @@ public class ReplayTimer extends WrappedTimer {
         copy(this, state); // Save our current state
         super.updateTimer(); // Update current state
         copy(state, this); // Restore our old state
-        MinecraftForge.EVENT_BUS.post(new UpdatedEvent());
+        FMLCommonHandler.instance().bus().post(new UpdatedEvent());
     }
 
     public Timer getWrapped() {

src/main/java/com/replaymod/pathing/properties/SpectatorProperty.java

@@ -8,6 +8,7 @@ import com.replaymod.replaystudio.pathing.property.PropertyPart;
 import com.replaymod.replaystudio.pathing.property.PropertyParts;
 import lombok.NonNull;
 import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.world.World;
 
 import java.io.IOException;
@@ -36,7 +37,9 @@ public class SpectatorProperty extends AbstractProperty<Integer> {
         // Lookup entity by id, returns null if an entity with the id does not exists
         Entity target = world.getEntityByID(value);
         // Spectate entity, when called with null, returns to camera
-        handler.spectateEntity(target);
+        if (target instanceof EntityLivingBase) {
+            handler.spectateEntity((EntityLivingBase) target);
+        }
     }
 
     @Override

src/main/java/com/replaymod/recording/ReplayModRecording.java

@@ -4,21 +4,22 @@ import com.replaymod.core.ReplayMod;
 import com.replaymod.core.utils.Restrictions;
 import com.replaymod.recording.handler.ConnectionEventHandler;
 import com.replaymod.recording.packet.PacketListener;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.eventhandler.EventBus;
+import cpw.mods.fml.common.network.NetworkRegistry;
 import io.netty.channel.ChannelDuplexHandler;
 import io.netty.channel.ChannelHandler;
-import net.minecraftforge.common.MinecraftForge;
 import net.minecraft.network.NetworkManager;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
-import net.minecraftforge.fml.common.eventhandler.EventBus;
-import net.minecraftforge.fml.common.network.NetworkRegistry;
 import org.apache.logging.log4j.Logger;
 import org.lwjgl.input.Keyboard;
 
 @Mod(modid = ReplayModRecording.MOD_ID,
         version = "@MOD_VERSION@",
         acceptedMinecraftVersions = "@MC_VERSION@",
+        acceptableRemoteVersions = "*",
         useMetadata = true)
 public class ReplayModRecording {
     public static final String MOD_ID = "replaymod-recording";
@@ -53,7 +54,7 @@ public class ReplayModRecording {
 
     @Mod.EventHandler
     public void init(FMLInitializationEvent event) {
-        EventBus bus = MinecraftForge.EVENT_BUS;
+        EventBus bus = FMLCommonHandler.instance().bus();
         bus.register(connectionEventHandler = new ConnectionEventHandler(logger, core));
 
         NetworkRegistry.INSTANCE.newChannel(Restrictions.PLUGIN_CHANNEL, new RestrictionsChannelHandler());

src/main/java/com/replaymod/recording/gui/GuiRecordingOverlay.java

@@ -2,14 +2,14 @@ package com.replaymod.recording.gui;
 
 import com.replaymod.core.SettingsRegistry;
 import com.replaymod.recording.Setting;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.gui.Gui;
-import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.client.resources.I18n;
 import net.minecraftforge.client.event.RenderGameOverlayEvent;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import org.lwjgl.opengl.GL11;
 
 import static com.replaymod.core.ReplayMod.TEXTURE;
 import static com.replaymod.core.ReplayMod.TEXTURE_SIZE;
@@ -40,13 +40,12 @@ public class GuiRecordingOverlay {
      */
     @SubscribeEvent
     public void renderRecordingIndicator(RenderGameOverlayEvent.Post event) {
-        if (event.getType() != RenderGameOverlayEvent.ElementType.ALL) return;
+        if (event.type != RenderGameOverlayEvent.ElementType.ALL) return;
         if (settingsRegistry.get(Setting.INDICATOR)) {
             FontRenderer fontRenderer = mc.fontRendererObj;
             fontRenderer.drawString(I18n.format("replaymod.gui.recording").toUpperCase(), 30, 18 - (fontRenderer.FONT_HEIGHT / 2), 0xffffffff);
             mc.renderEngine.bindTexture(TEXTURE);
-            GlStateManager.resetColor();
-            GlStateManager.enableAlpha();
+            GL11.glEnable(GL11.GL_ALPHA_TEST);
             Gui.drawModalRectWithCustomSizedTexture(10, 10, 58, 20, 16, 16, TEXTURE_SIZE, TEXTURE_SIZE);
         }
     }

src/main/java/com/replaymod/recording/handler/ConnectionEventHandler.java

@@ -2,6 +2,7 @@ package com.replaymod.recording.handler;
 
 import com.replaymod.core.ReplayMod;
 import com.replaymod.core.utils.ModCompat;
+import com.replaymod.core.utils.Utils;
 import com.replaymod.recording.Setting;
 import com.replaymod.recording.gui.GuiRecordingOverlay;
 import com.replaymod.recording.packet.PacketListener;
@@ -9,11 +10,10 @@ import com.replaymod.replaystudio.replay.ReplayFile;
 import com.replaymod.replaystudio.replay.ReplayMetaData;
 import com.replaymod.replaystudio.replay.ZipReplayFile;
 import com.replaymod.replaystudio.studio.ReplayStudio;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.network.FMLNetworkEvent;
 import net.minecraft.client.Minecraft;
 import net.minecraft.network.NetworkManager;
-import net.minecraft.world.WorldType;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import net.minecraftforge.fml.common.network.FMLNetworkEvent.ClientDisconnectionFromServerEvent;
 import org.apache.logging.log4j.Logger;
 
 import java.io.File;
@@ -46,10 +46,6 @@ public class ConnectionEventHandler {
         try {
             boolean local = networkManager.isLocalChannel();
             if (local) {
-                if (mc.getIntegratedServer().getEntityWorld().getWorldType() == WorldType.DEBUG_WORLD) {
-                    logger.info("Debug World recording is not supported.");
-                    return;
-                }
                 if(!core.getSettingsRegistry().get(Setting.RECORD_SINGLEPLAYER)) {
                     logger.info("Singleplayer Recording is disabled");
                     return;
@@ -74,7 +70,7 @@ public class ConnectionEventHandler {
             File folder = core.getReplayFolder();
 
             String name = sdf.format(Calendar.getInstance().getTime());
-            File currentFile = new File(folder, name + ".mcpr");
+            File currentFile = new File(folder, Utils.replayNameToFileName(name));
             ReplayFile replayFile = new ZipReplayFile(new ReplayStudio(), currentFile);
 
             replayFile.writeModInfo(ModCompat.getInstalledNetworkMods());
@@ -95,14 +91,14 @@ public class ConnectionEventHandler {
             guiOverlay.register();
 
             core.printInfoToChat("replaymod.chat.recordingstarted");
-        } catch(Exception e) {
+        } catch(Throwable e) {
             e.printStackTrace();
             core.printWarningToChat("replaymod.chat.recordingfailed");
         }
     }
 
     @SubscribeEvent
-    public void onDisconnectedFromServerEvent(ClientDisconnectionFromServerEvent event) {
+    public void onDisconnectedFromServerEvent(FMLNetworkEvent.ClientDisconnectionFromServerEvent event) {
         if (packetListener != null) {
             guiOverlay.unregister();
             guiOverlay = null;

src/main/java/com/replaymod/recording/handler/FMLHandshakeFilter.java

@@ -1,8 +1,8 @@
 package com.replaymod.recording.handler;
 
+import cpw.mods.fml.common.network.handshake.FMLHandshakeMessage;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
-import net.minecraftforge.fml.common.network.handshake.FMLHandshakeMessage;
 
 /**
  * Filters out all handshake packets that were sent for recording but must
@@ -17,7 +17,7 @@ import net.minecraftforge.fml.common.network.handshake.FMLHandshakeMessage;
 public class FMLHandshakeFilter extends SimpleChannelInboundHandler<FMLHandshakeMessage> {
     @Override
     protected void channelRead0(ChannelHandlerContext ctx, FMLHandshakeMessage msg) throws Exception {
-        if (!(msg instanceof FMLHandshakeMessage.RegistryData)) {
+        if (!(msg instanceof FMLHandshakeMessage.ModIdData)) {
             // Pass on everything but RegistryData messages
             ctx.fireChannelRead(msg);
         }

src/main/java/com/replaymod/recording/handler/RecordingEventHandler.java

@@ -1,26 +1,34 @@
 package com.replaymod.recording.handler;
 
 import com.replaymod.recording.packet.PacketListener;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.PlayerEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
 import net.minecraft.client.Minecraft;
-import net.minecraft.entity.EntityLiving;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.EntityEquipmentSlot;
 import net.minecraft.item.ItemStack;
 import net.minecraft.network.Packet;
-import net.minecraft.network.datasync.EntityDataManager;
-import net.minecraft.network.play.server.*;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.play.server.S04PacketEntityEquipment;
+import net.minecraft.network.play.server.S0APacketUseBed;
+import net.minecraft.network.play.server.S0BPacketAnimation;
+import net.minecraft.network.play.server.S0CPacketSpawnPlayer;
+import net.minecraft.network.play.server.S0DPacketCollectItem;
+import net.minecraft.network.play.server.S12PacketEntityVelocity;
+import net.minecraft.network.play.server.S14PacketEntity.S17PacketEntityLookMove;
+import net.minecraft.network.play.server.S18PacketEntityTeleport;
+import net.minecraft.network.play.server.S19PacketEntityHeadLook;
+import net.minecraft.network.play.server.S1BPacketEntityAttach;
+import net.minecraft.network.play.server.S25PacketBlockBreakAnim;
 import net.minecraft.server.integrated.IntegratedServer;
-import net.minecraft.util.EnumHand;
-import net.minecraft.util.SoundCategory;
-import net.minecraft.util.SoundEvent;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.MathHelper;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.event.entity.minecart.MinecartInteractEvent;
 import net.minecraftforge.event.entity.player.PlayerSleepInBedEvent;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import net.minecraftforge.fml.common.gameevent.PlayerEvent.ItemPickupEvent;
-import net.minecraftforge.fml.common.gameevent.TickEvent;
-import net.minecraftforge.fml.common.gameevent.TickEvent.PlayerTickEvent;
+import net.minecraftforge.event.entity.player.PlayerUseItemEvent;
 
 import java.util.Objects;
 
@@ -30,24 +38,24 @@ public class RecordingEventHandler {
     private final PacketListener packetListener;
 
     private Double lastX, lastY, lastZ;
-    private ItemStack[] playerItems = new ItemStack[6];
+    private ItemStack[] playerItems = new ItemStack[5];
     private int ticksSinceLastCorrection;
     private boolean wasSleeping;
     private int lastRiding = -1;
     private Integer rotationYawHeadBefore;
-    private boolean wasHandActive;
-    private EnumHand lastActiveHand;
 
     public RecordingEventHandler(PacketListener packetListener) {
         this.packetListener = packetListener;
     }
 
     public void register() {
+        FMLCommonHandler.instance().bus().register(this);
         MinecraftForge.EVENT_BUS.register(this);
         ((RecordingEventSender) mc.renderGlobal).setRecordingEventHandler(this);
     }
 
     public void unregister() {
+        FMLCommonHandler.instance().bus().unregister(this);
         MinecraftForge.EVENT_BUS.unregister(this);
         RecordingEventSender recordingEventSender = ((RecordingEventSender) mc.renderGlobal);
         if (recordingEventSender.getRecordingEventHandler() == this) {
@@ -57,7 +65,7 @@ public class RecordingEventHandler {
 
     public void onPlayerJoin() {
         try {
-            packetListener.save(new SPacketSpawnPlayer(mc.thePlayer));
+            packetListener.save(spawnPlayer(mc.thePlayer));
         } catch(Exception e1) {
             e1.printStackTrace();
         }
@@ -65,33 +73,18 @@ public class RecordingEventHandler {
 
     public void onPlayerRespawn() {
         try {
-            packetListener.save(new SPacketSpawnPlayer(mc.thePlayer));
+            packetListener.save(spawnPlayer(mc.thePlayer));
         } catch(Exception e) {
             e.printStackTrace();
         }
     }
 
-    public void onClientSound(SoundEvent sound, SoundCategory category,
-                              double x, double y, double z, float volume, float pitch) {
-        try {
-            // Send to all other players in ServerWorldEventHandler#playSoundToAllNearExcept
-            packetListener.save(new SPacketSoundEffect(sound, category, x, y, z, volume, pitch));
-        } catch(Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    public void onClientEffect(int type, BlockPos pos, int data) {
-        try {
-            // Send to all other players in ServerWorldEventHandler#playEvent
-            packetListener.save(new SPacketEffect(type, pos, data, false));
-        } catch(Exception e) {
-            e.printStackTrace();
-        }
+    private S0CPacketSpawnPlayer spawnPlayer(EntityPlayer player) {
+        return new S0CPacketSpawnPlayer(player);
     }
 
     @SubscribeEvent
-    public void onPlayerTick(PlayerTickEvent e) {
+    public void onPlayerTick(TickEvent.PlayerTickEvent e) {
         try {
             if(e.player != mc.thePlayer) return;
 
@@ -99,7 +92,7 @@ public class RecordingEventHandler {
             if(lastX == null || lastY == null || lastZ == null) {
                 force = true;
                 lastX = e.player.posX;
-                lastY = e.player.posY;
+                lastY = e.player.boundingBox.minY;
                 lastZ = e.player.posZ;
             }
 
@@ -110,23 +103,28 @@ public class RecordingEventHandler {
             }
 
             double dx = e.player.posX - lastX;
-            double dy = e.player.posY - lastY;
+            double dy = e.player.boundingBox.minY - lastY;
             double dz = e.player.posZ - lastZ;
 
             lastX = e.player.posX;
-            lastY = e.player.posY;
+            lastY = e.player.boundingBox.minY;
             lastZ = e.player.posZ;
 
             Packet packet;
-            if (force || Math.abs(dx) > 8.0 || Math.abs(dy) > 8.0 || Math.abs(dz) > 8.0) {
-                packet = new SPacketEntityTeleport(e.player);
+            if(force || Math.abs(dx) > 4.0 || Math.abs(dy) > 4.0 || Math.abs(dz) > 4.0) {
+                int x = MathHelper.floor_double(e.player.posX * 32.0D);
+                int y = MathHelper.floor_double(e.player.boundingBox.minY * 32.0D);
+                int z = MathHelper.floor_double(e.player.posZ * 32.0D);
+                byte yaw = (byte) ((int) (e.player.rotationYaw * 256.0F / 360.0F));
+                byte pitch = (byte) ((int) (e.player.rotationPitch * 256.0F / 360.0F));
+                packet = new S18PacketEntityTeleport(e.player.getEntityId(), x, y, z, yaw, pitch);
             } else {
                 byte newYaw = (byte) ((int) (e.player.rotationYaw * 256.0F / 360.0F));
                 byte newPitch = (byte) ((int) (e.player.rotationPitch * 256.0F / 360.0F));
 
-                packet = new SPacketEntity.S17PacketEntityLookMove(e.player.getEntityId(),
-                        (short) Math.round(dx * 4096), (short) Math.round(dy * 4096), (short) Math.round(dz * 4096),
-                        newYaw, newPitch, e.player.onGround);
+                packet = new S17PacketEntityLookMove(e.player.getEntityId(),
+                        (byte) Math.round(dx * 32), (byte) Math.round(dy * 32), (byte) Math.round(dz * 32),
+                        newYaw, newPitch);
             }
 
             packetListener.save(packet);
@@ -135,16 +133,18 @@ public class RecordingEventHandler {
             int rotationYawHead = ((int)(e.player.rotationYawHead * 256.0F / 360.0F));
 
             if(!Objects.equals(rotationYawHead, rotationYawHeadBefore)) {
-                packetListener.save(new SPacketEntityHeadLook(e.player, (byte) rotationYawHead));
+                packetListener.save(new S19PacketEntityHeadLook(e.player, (byte) rotationYawHead));
+
                 rotationYawHeadBefore = rotationYawHead;
             }
 
-            packetListener.save(new SPacketEntityVelocity(e.player.getEntityId(), e.player.motionX, e.player.motionY, e.player.motionZ));
+            S12PacketEntityVelocity vel = new S12PacketEntityVelocity(e.player.getEntityId(), e.player.motionX, e.player.motionY, e.player.motionZ);
+            packetListener.save(vel);
 
             //Animation Packets
             //Swing Animation
-            if (e.player.isSwingInProgress && e.player.swingProgressInt == -1) {
-                packetListener.save(new SPacketAnimation(e.player, e.player.swingingHand == EnumHand.MAIN_HAND ? 0 : 3));
+            if(e.player.swingProgressInt == 1) {
+                packetListener.save(new S0BPacketAnimation(e.player, 0));
             }
 
 			/*
@@ -168,62 +168,65 @@ public class RecordingEventHandler {
 			 */
 
             //Inventory Handling
-            if (playerItems[0] != mc.thePlayer.getHeldItem(EnumHand.MAIN_HAND)) {
-                playerItems[0] = mc.thePlayer.getHeldItem(EnumHand.MAIN_HAND);
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.MAINHAND, playerItems[0]));
+            if(playerItems[0] != mc.thePlayer.getHeldItem()) {
+                playerItems[0] = mc.thePlayer.getHeldItem();
+                S04PacketEntityEquipment pee = new S04PacketEntityEquipment(e.player.getEntityId(), 0, playerItems[0]);
+                packetListener.save(pee);
             }
 
-            if (playerItems[1] != mc.thePlayer.getHeldItem(EnumHand.OFF_HAND)) {
-                playerItems[1] = mc.thePlayer.getHeldItem(EnumHand.OFF_HAND);
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.OFFHAND, playerItems[1]));
+            if(playerItems[1] != mc.thePlayer.inventory.armorInventory[0]) {
+                playerItems[1] = mc.thePlayer.inventory.armorInventory[0];
+                S04PacketEntityEquipment pee = new S04PacketEntityEquipment(e.player.getEntityId(), 1, playerItems[1]);
+                packetListener.save(pee);
             }
 
-            if (playerItems[2] != mc.thePlayer.inventory.armorInventory[0]) {
-                playerItems[2] = mc.thePlayer.inventory.armorInventory[0];
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.FEET, playerItems[2]));
+            if(playerItems[2] != mc.thePlayer.inventory.armorInventory[1]) {
+                playerItems[2] = mc.thePlayer.inventory.armorInventory[1];
+                S04PacketEntityEquipment pee = new S04PacketEntityEquipment(e.player.getEntityId(), 2, playerItems[2]);
+                packetListener.save(pee);
             }
 
-            if (playerItems[3] != mc.thePlayer.inventory.armorInventory[1]) {
-                playerItems[3] = mc.thePlayer.inventory.armorInventory[1];
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.LEGS, playerItems[3]));
+            if(playerItems[3] != mc.thePlayer.inventory.armorInventory[2]) {
+                playerItems[3] = mc.thePlayer.inventory.armorInventory[2];
+                S04PacketEntityEquipment pee = new S04PacketEntityEquipment(e.player.getEntityId(), 3, playerItems[3]);
+                packetListener.save(pee);
             }
 
-            if (playerItems[4] != mc.thePlayer.inventory.armorInventory[2]) {
-                playerItems[4] = mc.thePlayer.inventory.armorInventory[2];
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.CHEST, playerItems[4]));
-            }
-
-            if (playerItems[5] != mc.thePlayer.inventory.armorInventory[3]) {
-                playerItems[5] = mc.thePlayer.inventory.armorInventory[3];
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.HEAD, playerItems[5]));
+            if(playerItems[4] != mc.thePlayer.inventory.armorInventory[3]) {
+                playerItems[4] = mc.thePlayer.inventory.armorInventory[3];
+                S04PacketEntityEquipment pee = new S04PacketEntityEquipment(e.player.getEntityId(), 4, playerItems[4]);
+                packetListener.save(pee);
             }
 
             //Leaving Ride
 
             if((!mc.thePlayer.isRiding() && lastRiding != -1) ||
-                    (mc.thePlayer.isRiding() && lastRiding != mc.thePlayer.getRidingEntity().getEntityId())) {
+                    (mc.thePlayer.isRiding() && lastRiding != mc.thePlayer.ridingEntity.getEntityId())) {
                 if(!mc.thePlayer.isRiding()) {
                     lastRiding = -1;
                 } else {
-                    lastRiding = mc.thePlayer.getRidingEntity().getEntityId();
+                    lastRiding = mc.thePlayer.ridingEntity.getEntityId();
                 }
-                packetListener.save(new SPacketEntityAttach(e.player, e.player.getRidingEntity()));
+
+                S1BPacketEntityAttach pea = new S1BPacketEntityAttach();
+
+                ByteBuf buf = Unpooled.buffer();
+                PacketBuffer pbuf = new PacketBuffer(buf);
+
+                pbuf.writeInt(e.player.getEntityId());
+                pbuf.writeInt(lastRiding);
+                pbuf.writeBoolean(false);
+
+                pea.readPacketData(pbuf);
+
+                packetListener.save(pea);
             }
 
             //Sleeping
             if(!mc.thePlayer.isPlayerSleeping() && wasSleeping) {
-                packetListener.save(new SPacketAnimation(e.player, 2));
-                wasSleeping = false;
-            }
+                packetListener.save(new S0BPacketAnimation(e.player, 2));
 
-            // Active hand (e.g. eating, drinking, blocking)
-            if (mc.thePlayer.isHandActive() ^ wasHandActive || mc.thePlayer.getActiveHand() != lastActiveHand) {
-                wasHandActive = mc.thePlayer.isHandActive();
-                lastActiveHand = mc.thePlayer.getActiveHand();
-                EntityDataManager dataManager = new EntityDataManager(null);
-                int state = (wasHandActive ? 1 : 0) | (lastActiveHand == EnumHand.OFF_HAND ? 2 : 0);
-                dataManager.register(EntityLiving.HAND_STATES, (byte) state);
-                packetListener.save(new SPacketEntityMetadata(mc.thePlayer.getEntityId(), dataManager, true));
+                wasSleeping = false;
             }
 
         } catch(Exception e1) {
@@ -232,49 +235,43 @@ public class RecordingEventHandler {
     }
 
     @SubscribeEvent
-    public void onPickupItem(ItemPickupEvent event) {
+    public void onPickupItem(PlayerEvent.ItemPickupEvent event) {
         try {
-            packetListener.save(new SPacketCollectItem(event.pickedUp.getEntityId(), event.player.getEntityId()));
+            packetListener.save(new S0DPacketCollectItem(event.pickedUp.getEntityId(), event.player.getEntityId()));
         } catch(Exception e) {
             e.printStackTrace();
         }
     }
 
+    @SubscribeEvent
+    public void onStartEating(PlayerUseItemEvent.Start event) {
+        if(!event.entityPlayer.isEating()) return;
+        packetListener.save(new S0BPacketAnimation(event.entityPlayer, 3));
+    }
+
     @SubscribeEvent
     public void onSleep(PlayerSleepInBedEvent event) {
-        try {
-            if (event.getEntityPlayer() != mc.thePlayer) {
-                return;
-            }
-
-            packetListener.save(new SPacketUseBed(event.getEntityPlayer(), event.getPos()));
-
-            wasSleeping = true;
-
-        } catch(Exception e) {
-            e.printStackTrace();
+        if(event.entityPlayer != mc.thePlayer) {
+            return;
         }
+
+        packetListener.save(new S0APacketUseBed(event.entityPlayer, event.x, event.y, event.z));
+        wasSleeping = true;
     }
 
     @SubscribeEvent
     public void enterMinecart(MinecartInteractEvent event) {
-        try {
-            if(event.getEntity() != mc.thePlayer) {
-                return;
-            }
-
-            packetListener.save(new SPacketEntityAttach(event.getPlayer(), event.getMinecart()));
-
-            lastRiding = event.getMinecart().getEntityId();
-        } catch(Exception e) {
-            e.printStackTrace();
+        if(event.player != mc.thePlayer) {
+            return;
         }
+        packetListener.save(new S1BPacketEntityAttach(0, event.player, event.minecart));
+        lastRiding = event.minecart.getEntityId();
     }
 
-    public void onBlockBreakAnim(int breakerId, BlockPos pos, int progress) {
+    public void onBlockBreakAnim(int breakerId, int x, int y, int z, int progress) {
         EntityPlayer thePlayer = mc.thePlayer;
         if (thePlayer != null && breakerId == thePlayer.getEntityId()) {
-            packetListener.save(new SPacketBlockBreakAnim(breakerId, pos, progress));
+            packetListener.save(new S25PacketBlockBreakAnim(breakerId, x, y, z, progress));
         }
     }
 

src/main/java/com/replaymod/recording/mixin/MixinNetHandlerLoginClient.java

@@ -1,8 +1,10 @@
 package com.replaymod.recording.mixin;
 
 import com.replaymod.recording.ReplayModRecording;
+import cpw.mods.fml.common.network.FMLNetworkEvent;
 import net.minecraft.client.network.NetHandlerLoginClient;
 import net.minecraft.network.NetworkManager;
+import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
@@ -13,15 +15,15 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 public abstract class MixinNetHandlerLoginClient {
 
     @Shadow
-    private NetworkManager networkManager;
+    private @Final NetworkManager field_147393_d;
 
     /**
      * Starts the recording right before switching into PLAY state.
-     * We cannot use the {@link net.minecraftforge.fml.common.network.FMLNetworkEvent.ClientConnectedToServerEvent}
+     * We cannot use the {@link FMLNetworkEvent.ClientConnectedToServerEvent}
      * as it only fires after the forge handshake.
      */
     @Inject(method = "handleLoginSuccess", at=@At("HEAD"))
     public void replayModRecording_initiateRecording(CallbackInfo cb) {
-        ReplayModRecording.instance.initiateRecording(networkManager);
+        ReplayModRecording.instance.initiateRecording(field_147393_d);
     }
 }

src/main/java/com/replaymod/recording/mixin/MixinNetHandlerPlayClient.java

@@ -3,27 +3,20 @@ package com.replaymod.recording.mixin;
 import com.replaymod.recording.handler.RecordingEventHandler;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.network.NetHandlerPlayClient;
-import net.minecraft.client.network.NetworkPlayerInfo;
-import net.minecraft.network.play.server.SPacketPlayerListItem;
-import net.minecraft.network.play.server.SPacketRespawn;
+import net.minecraft.network.play.server.S01PacketJoinGame;
+import net.minecraft.network.play.server.S07PacketRespawn;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-import java.util.Map;
-import java.util.UUID;
-
 @Mixin(NetHandlerPlayClient.class)
 public abstract class MixinNetHandlerPlayClient {
 
     @Shadow
     private Minecraft gameController;
 
-    @Shadow
-    private Map<UUID, NetworkPlayerInfo> playerInfoMap;
-
     public RecordingEventHandler getRecordingEventHandler() {
         return ((RecordingEventHandler.RecordingEventSender) gameController.renderGlobal).getRecordingEventHandler();
     }
@@ -31,36 +24,27 @@ public abstract class MixinNetHandlerPlayClient {
     /**
      * Record the own player entity joining the world.
      * We cannot use the {@link net.minecraftforge.event.entity.EntityJoinWorldEvent} because the entity id
-     * of the player is set afterwards and the tablist entry might not yet be sent.
+     * of the player is set afterwards
      * @param packet The packet
      * @param ci Callback info
      */
-    @Inject(method = "handlePlayerListItem", at=@At("HEAD"))
-    public void recordOwnJoin(SPacketPlayerListItem packet, CallbackInfo ci) {
-        if (gameController.thePlayer == null) return;
-
+    @Inject(method = "handleJoinGame", at=@At("RETURN"))
+    public void recordOwnJoin(S01PacketJoinGame packet, CallbackInfo ci) {
         RecordingEventHandler handler = getRecordingEventHandler();
-        if (handler != null && packet.getAction() == SPacketPlayerListItem.Action.ADD_PLAYER) {
-            for (SPacketPlayerListItem.AddPlayerData data : packet.getEntries()) {
-                if (data.getProfile() == null || data.getProfile().getId() == null) continue;
-                // Only add spawn packet for our own player and only if he isn't known yet
-                if (data.getProfile().getId().equals(Minecraft.getMinecraft().thePlayer.getGameProfile().getId())
-                        && !playerInfoMap.containsKey(data.getProfile().getId())) {
-                    handler.onPlayerJoin();
-                }
-            }
+        if (handler != null) {
+            handler.onPlayerJoin();
         }
     }
 
     /**
      * Record the own player entity respawning.
      * We cannot use the {@link net.minecraftforge.event.entity.EntityJoinWorldEvent} because that would also include
-     * the first spawn which is already handled by {@link #recordOwnJoin(SPacketPlayerListItem, CallbackInfo)}.
+     * the first spawn which is already handled by {@link #recordOwnJoin(S01PacketJoinGame, CallbackInfo)}.
      * @param packet The packet
      * @param ci Callback info
      */
     @Inject(method = "handleRespawn", at=@At("RETURN"))
-    public void recordOwnRespawn(SPacketRespawn packet, CallbackInfo ci) {
+    public void recordOwnRespawn(S07PacketRespawn packet, CallbackInfo ci) {
         RecordingEventHandler handler = getRecordingEventHandler();
         if (handler != null) {
             handler.onPlayerRespawn();

src/main/java/com/replaymod/recording/mixin/MixinNetworkDispatcher.java

@@ -1,11 +1,11 @@
 package com.replaymod.recording.mixin;
 
 import com.replaymod.recording.handler.FMLHandshakeFilter;
+import cpw.mods.fml.common.network.handshake.FMLHandshakeCodec;
+import cpw.mods.fml.common.network.handshake.NetworkDispatcher;
+import cpw.mods.fml.relauncher.Side;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.embedded.EmbeddedChannel;
-import net.minecraftforge.fml.common.network.handshake.FMLHandshakeCodec;
-import net.minecraftforge.fml.common.network.handshake.NetworkDispatcher;
-import net.minecraftforge.fml.relauncher.Side;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;

src/main/java/com/replaymod/recording/mixin/MixinPlayerControllerMP.java

@@ -1,28 +0,0 @@
-package com.replaymod.recording.mixin;
-
-import com.replaymod.recording.handler.RecordingEventHandler;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.multiplayer.PlayerControllerMP;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-@Mixin(PlayerControllerMP.class)
-public abstract class MixinPlayerControllerMP implements RecordingEventHandler.RecordingEventSender {
-
-    @Shadow
-    private Minecraft mc;
-
-    // Redirects the call to playEvent without the initial player argument to the method with that argument
-    // The new method will then play it and (if applicable) record it. (See MixinWorldClient)
-    // This is necessary for the block break event (particles and sound) to be recorded. Otherwise it looks like the
-    // event was emitted because of a packet (player will be null) and not as it actually was (by the player).
-    @Redirect(method = "onPlayerDestroyBlock", at = @At(value = "INVOKE",
-            target = "Lnet/minecraft/world/World;playEvent(ILnet/minecraft/util/math/BlockPos;I)V"))
-    public void replayModRecording_playEvent_fixed(World world, int type, BlockPos pos, int data) {
-        world.playEvent(mc.thePlayer, type, pos, data);
-    }
-}

src/main/java/com/replaymod/recording/mixin/MixinRenderGlobal.java

@@ -2,7 +2,6 @@ package com.replaymod.recording.mixin;
 
 import com.replaymod.recording.handler.RecordingEventHandler;
 import net.minecraft.client.renderer.RenderGlobal;
-import net.minecraft.util.math.BlockPos;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -23,10 +22,10 @@ public abstract class MixinRenderGlobal implements RecordingEventHandler.Recordi
         return recordingEventHandler;
     }
 
-    @Inject(method = "sendBlockBreakProgress", at = @At("HEAD"))
-    public void saveBlockBreakProgressPacket(int breakerId, BlockPos pos, int progress, CallbackInfo info) {
+    @Inject(method = "destroyBlockPartially", at = @At("HEAD"))
+    public void saveBlockBreakProgressPacket(int breakerId, int x, int y, int z, int progress, CallbackInfo info) {
         if (recordingEventHandler != null) {
-            recordingEventHandler.onBlockBreakAnim(breakerId, pos, progress);
+            recordingEventHandler.onBlockBreakAnim(breakerId, x, y, z, progress);
         }
     }
 }

src/main/java/com/replaymod/recording/mixin/MixinWorldClient.java

@@ -1,62 +0,0 @@
-package com.replaymod.recording.mixin;
-
-import com.replaymod.recording.handler.RecordingEventHandler;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.multiplayer.WorldClient;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.profiler.Profiler;
-import net.minecraft.util.SoundCategory;
-import net.minecraft.util.SoundEvent;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-import net.minecraft.world.WorldProvider;
-import net.minecraft.world.storage.ISaveHandler;
-import net.minecraft.world.storage.WorldInfo;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(WorldClient.class)
-public abstract class MixinWorldClient extends World implements RecordingEventHandler.RecordingEventSender {
-    @Shadow
-    private Minecraft mc;
-
-    protected MixinWorldClient(ISaveHandler saveHandlerIn, WorldInfo info, WorldProvider providerIn, Profiler profilerIn, boolean client) {
-        super(saveHandlerIn, info, providerIn, profilerIn, client);
-    }
-
-    private RecordingEventHandler replayModRecording_getRecordingEventHandler() {
-        return ((RecordingEventHandler.RecordingEventSender) mc.renderGlobal).getRecordingEventHandler();
-    }
-
-    // Sounds that are emitted by thePlayer no longer take the long way over the server
-    // but are instead played directly by the client. The server only sends these sounds to
-    // other clients so we have to record them manually.
-    // E.g. Block place sounds
-    @Inject(method = "playSound", at = @At("HEAD"))
-    public void replayModRecording_recordClientSound(EntityPlayer player, double x, double y, double z, SoundEvent sound, SoundCategory category,
-                          float volume, float pitch, CallbackInfo ci) {
-        if (player == mc.thePlayer) {
-            RecordingEventHandler handler = replayModRecording_getRecordingEventHandler();
-            if (handler != null) {
-                handler.onClientSound(sound, category, x, y, z, volume, pitch);
-            }
-        }
-    }
-
-    // Same goes for level events (also called effects). E.g. door open, block break, etc.
-    // These are handled in the World class, so we override the method in WorldClient and add our special handling.
-    @Override
-    public void playEvent(EntityPlayer player, int type, BlockPos pos, int data) {
-        if (player == mc.thePlayer) {
-            // We caused this event, the server won't send it to us
-            RecordingEventHandler handler = replayModRecording_getRecordingEventHandler();
-            if (handler != null) {
-                handler.onClientEffect(type, pos, data);
-            }
-        }
-        super.playEvent(player, type, pos, data);
-    }
-}

src/main/java/com/replaymod/recording/packet/PacketListener.java

@@ -4,29 +4,25 @@ import com.replaymod.core.utils.Restrictions;
 import com.replaymod.replaystudio.data.Marker;
 import com.replaymod.replaystudio.replay.ReplayFile;
 import com.replaymod.replaystudio.replay.ReplayMetaData;
+import cpw.mods.fml.common.network.internal.FMLProxyPacket;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
 import net.minecraft.client.Minecraft;
+import net.minecraft.entity.DataWatcher;
 import net.minecraft.entity.Entity;
 import net.minecraft.network.EnumConnectionState;
-import net.minecraft.network.EnumPacketDirection;
 import net.minecraft.network.Packet;
 import net.minecraft.network.PacketBuffer;
-import net.minecraft.network.datasync.EntityDataManager;
 import net.minecraft.network.play.server.*;
-import net.minecraft.util.text.TextComponentString;
-import net.minecraftforge.fml.common.network.internal.FMLProxyPacket;
+import net.minecraft.util.ChatComponentText;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.io.DataOutputStream;
 import java.io.IOException;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.UUID;
+import java.util.*;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
@@ -87,8 +83,8 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
 
     public void save(Packet packet) {
         try {
-            if(packet instanceof SPacketSpawnPlayer) {
-                UUID uuid = ((SPacketSpawnPlayer) packet).getUniqueId();
+            if(packet instanceof S0CPacketSpawnPlayer) {
+                UUID uuid = ((S0CPacketSpawnPlayer) packet).field_148955_b.getId();
                 Set<String> uuids = new HashSet<>(Arrays.asList(metaData.getPlayers()));
                 uuids.add(uuid.toString());
                 metaData.setPlayers(uuids.toArray(new String[uuids.size()]));
@@ -154,32 +150,35 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
             try {
                 Packet packet = (Packet) msg;
 
-                if(packet instanceof SPacketCollectItem) {
+                if(packet instanceof S0DPacketCollectItem) {
                     if(mc.thePlayer != null ||
-                            ((SPacketCollectItem) packet).getEntityID() == mc.thePlayer.getEntityId()) {
+                            ((S0DPacketCollectItem) packet).func_149353_d() == mc.thePlayer.getEntityId()) {
                         super.channelRead(ctx, msg);
                         return;
                     }
                 }
 
-                if (packet instanceof SPacketResourcePackSend) {
-                    save(resourcePackRecorder.handleResourcePack((SPacketResourcePackSend) packet));
-                    return;
+                if (packet instanceof S3FPacketCustomPayload) {
+                    S3FPacketCustomPayload p = (S3FPacketCustomPayload) packet;
+                    if ("MC|RPack".equals(p.func_149169_c())) {
+                        save(resourcePackRecorder.handleResourcePack(p));
+                        return;
+                    }
                 }
 
                 if (packet instanceof FMLProxyPacket) {
                     // This packet requires special handling
-                    ((FMLProxyPacket) packet).toS3FPackets().forEach(this::save);
+                    save(((FMLProxyPacket) packet).toS3FPacket());
                     super.channelRead(ctx, msg);
                     return;
                 }
 
                 save(packet);
 
-                if (packet instanceof SPacketCustomPayload) {
-                    SPacketCustomPayload p = (SPacketCustomPayload) packet;
-                    if (Restrictions.PLUGIN_CHANNEL.equals(p.getChannelName())) {
-                        packet = new SPacketDisconnect(new TextComponentString("Please update to view this replay."));
+                if (packet instanceof S3FPacketCustomPayload) {
+                    S3FPacketCustomPayload p = (S3FPacketCustomPayload) packet;
+                    if (Restrictions.PLUGIN_CHANNEL.equals(p.func_149169_c())) {
+                        packet = new S40PacketDisconnect(new ChatComponentText("Please update to view this replay."));
                         save(packet);
                     }
                 }
@@ -192,37 +191,33 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
         super.channelRead(ctx, msg);
     }
 
-    private <T> void DataManager_set(EntityDataManager dataManager, EntityDataManager.DataEntry<T> entry) {
-        dataManager.register(entry.getKey(), entry.getValue());
-    }
-
     @SuppressWarnings("unchecked")
     private byte[] getPacketData(Packet packet) throws IOException {
-        if (packet instanceof SPacketSpawnMob) {
-            SPacketSpawnMob p = (SPacketSpawnMob) packet;
-            if (p.dataManager == null) {
-                p.dataManager = new EntityDataManager(null);
-                if (p.getDataManagerEntries() != null) {
-                    for (EntityDataManager.DataEntry<?> entry : p.getDataManagerEntries()) {
-                        DataManager_set(p.dataManager, entry);
+        if(packet instanceof S0FPacketSpawnMob) {
+            S0FPacketSpawnMob p = (S0FPacketSpawnMob) packet;
+            if (p.field_149043_l == null) {
+                p.field_149043_l = new DataWatcher(null);
+                if(p.func_149027_c() != null) {
+                    for(DataWatcher.WatchableObject wo : (List<DataWatcher.WatchableObject>) p.func_149027_c()) {
+                        p.field_149043_l.addObject(wo.getDataValueId(), wo.getObject());
                     }
                 }
             }
         }
 
-        if (packet instanceof SPacketSpawnPlayer) {
-            SPacketSpawnPlayer p = (SPacketSpawnPlayer) packet;
-            if (p.watcher == null) {
-                p.watcher = new EntityDataManager(null);
-                if (p.getDataManagerEntries() != null) {
-                    for (EntityDataManager.DataEntry<?> entry : p.getDataManagerEntries()) {
-                        DataManager_set(p.watcher, entry);
+        if(packet instanceof S0CPacketSpawnPlayer) {
+            S0CPacketSpawnPlayer p = (S0CPacketSpawnPlayer) packet;
+            if (p.field_148960_i == null) {
+                p.field_148960_i = new DataWatcher(null);
+                if(p.func_148944_c() != null) {
+                    for(DataWatcher.WatchableObject wo : (List<DataWatcher.WatchableObject>) p.func_148944_c()) {
+                        p.field_148960_i.addObject(wo.getDataValueId(), wo.getObject());
                     }
                 }
             }
         }
 
-        Integer packetId = EnumConnectionState.PLAY.getPacketId(EnumPacketDirection.CLIENTBOUND, packet);
+        Integer packetId = (Integer) EnumConnectionState.PLAY.func_150755_b().inverse().get(packet.getClass());
         if (packetId == null) {
             throw new IOException("Unknown packet type:" + packet.getClass());
         }
@@ -240,7 +235,7 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
     }
 
     public void addMarker() {
-        Entity view = Minecraft.getMinecraft().getRenderViewEntity();
+        Entity view = Minecraft.getMinecraft().renderViewEntity;
         int timestamp = (int) (System.currentTimeMillis() - startTime);
 
         Marker marker = new Marker();

src/main/java/com/replaymod/recording/packet/ResourcePackRecorder.java

@@ -2,27 +2,23 @@ package com.replaymod.recording.packet;
 
 import com.google.common.hash.Hashing;
 import com.google.common.io.Files;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
 import com.replaymod.replaystudio.replay.ReplayFile;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiScreenWorking;
 import net.minecraft.client.gui.GuiYesNo;
+import net.minecraft.client.gui.GuiYesNoCallback;
 import net.minecraft.client.multiplayer.ServerData;
+import net.minecraft.client.multiplayer.ServerData.ServerResourceMode;
 import net.minecraft.client.multiplayer.ServerList;
-import net.minecraft.client.network.NetHandlerPlayClient;
+import net.minecraft.client.resources.FileResourcePack;
 import net.minecraft.client.resources.I18n;
 import net.minecraft.client.resources.ResourcePackRepository;
-import net.minecraft.network.NetworkManager;
-import net.minecraft.network.play.client.CPacketResourcePackStatus;
-import net.minecraft.network.play.server.SPacketResourcePackSend;
+import net.minecraft.network.play.server.S3FPacketCustomPayload;
 import net.minecraft.util.HttpUtil;
-import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.Charsets;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-import javax.annotation.Nonnull;
 import java.io.File;
 import java.io.IOException;
 import java.io.OutputStream;
@@ -74,140 +70,75 @@ public class ResourcePackRecorder {
         }
     }
 
-    public synchronized SPacketResourcePackSend handleResourcePack(SPacketResourcePackSend packet) {
+    public synchronized S3FPacketCustomPayload handleResourcePack(S3FPacketCustomPayload packet) {
         final int requestId = nextRequestId++;
-        final NetHandlerPlayClient netHandler = mc.getConnection();
-        final NetworkManager netManager = netHandler.getNetworkManager();
-        final String url = packet.getURL();
-        final String hash = packet.getHash();
+        final String url = new String(packet.func_149168_d(), Charsets.UTF_8);
 
-        if (url.startsWith("level://")) {
-            String levelName = url.substring("level://".length());
-            File savesDir = new File(mc.mcDataDir, "saves");
-            final File levelDir = new File(savesDir, levelName);
-
-            if (levelDir.isFile()) {
-                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.ACCEPTED));
-                Futures.addCallback(mc.getResourcePackRepository().setResourcePackInstance(levelDir), new FutureCallback<Object>() {
-                    @Override
-                    public void onSuccess(Object result) {
-                        recordResourcePack(levelDir, requestId);
-                        netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.SUCCESSFULLY_LOADED));
-                    }
-
-                    @Override
-                    public void onFailure(@Nonnull Throwable throwable) {
-                        netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
-                    }
-                });
-            } else {
-                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
-            }
-        } else {
-            final ServerData serverData = mc.getCurrentServerData();
-            if (serverData != null && serverData.getResourceMode() == ServerData.ServerResourceMode.ENABLED) {
-                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.ACCEPTED));
-                downloadResourcePackFuture(requestId, url, hash);
-            } else if (serverData != null && serverData.getResourceMode() != ServerData.ServerResourceMode.PROMPT) {
-                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.DECLINED));
-            } else {
-                mc.addScheduledTask(() -> mc.displayGuiScreen(new GuiYesNo((result, id) -> {
+        ServerData serverData = mc.getCurrentServerData();
+        ServerResourceMode resourceMode = serverData == null ? ServerResourceMode.PROMPT : serverData.getResourceMode();
+        if (resourceMode == ServerResourceMode.ENABLED) {
+            downloadResourcePack(requestId, url);
+            mc.getResourcePackRepository().obtainResourcePack(url);
+        } else if (resourceMode == ServerResourceMode.PROMPT) {
+            // Lambdas MUST NOT be used with methods that need re-obfuscation in FG prior to 2.2 (will result in AbstractMethodError)
+            //noinspection Convert2Lambda
+            mc.displayGuiScreen(new GuiYesNo(new GuiYesNoCallback() {
+                @Override
+                public void confirmClicked(boolean result, int id) {
                     if (serverData != null) {
-                        serverData.setResourceMode(result ? ServerData.ServerResourceMode.ENABLED : ServerData.ServerResourceMode.DISABLED);
-                    }
-                    if (result) {
-                        netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.ACCEPTED));
-                        downloadResourcePackFuture(requestId, url, hash);
-                    } else {
-                        netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.DECLINED));
+                        serverData.setResourceMode(ServerResourceMode.ENABLED);
+                        ServerList.func_147414_b(serverData);
                     }
 
-                    ServerList.saveSingleServer(serverData);
                     mc.displayGuiScreen(null);
-                }, I18n.format("multiplayer.texturePrompt.line1"), I18n.format("multiplayer.texturePrompt.line2"), 0)));
-            }
-        }
 
-        return new SPacketResourcePackSend("replay://" + requestId, "");
-    }
-
-    private void downloadResourcePackFuture(int requestId, String url, final String hash) {
-        Futures.addCallback(downloadResourcePack(requestId, url, hash), new FutureCallback() {
-            @Override
-            public void onSuccess(Object result) {
-                mc.getConnection().sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.SUCCESSFULLY_LOADED));
-            }
-
-            @Override
-            public void onFailure(@Nonnull Throwable throwable) {
-                mc.getConnection().sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
-            }
-        });
-    }
-
-    private ListenableFuture downloadResourcePack(final int requestId, String url, String hash) {
-        final ResourcePackRepository repo = mc.mcResourcePackRepository;
-        String fileName;
-        if (hash.matches("^[a-f0-9]{40}$")) {
-            fileName = hash;
-        } else {
-            fileName = url.substring(url.lastIndexOf("/") + 1);
-
-            if (fileName.contains("?")) {
-                fileName = fileName.substring(0, fileName.indexOf("?"));
-            }
-
-            if (!fileName.endsWith(".zip")) {
-                return Futures.immediateFailedFuture(new IllegalArgumentException("Invalid filename; must end in .zip"));
-            }
-
-            fileName = "legacy_" + fileName.replaceAll("\\W", "");
-        }
-
-        final File file = new File(repo.dirServerResourcepacks, fileName);
-        repo.lock.lock();
-        try {
-            repo.clearResourcePack();
-
-            if (file.exists() && hash.length() == 40) {
-                try {
-                    String fileHash = Hashing.sha1().hashBytes(Files.toByteArray(file)).toString();
-                    if (fileHash.equals(hash)) {
-                        recordResourcePack(file, requestId);
-                        return repo.setResourcePackInstance(file);
+                    if (result) {
+                        downloadResourcePack(requestId, url);
                     }
-
-                    logger.warn("File " + file + " had wrong hash (expected " + hash + ", found " + fileHash + "). Deleting it.");
-                    FileUtils.deleteQuietly(file);
-                } catch (IOException ioexception) {
-                    logger.warn("File " + file + " couldn\'t be hashed. Deleting it.", ioexception);
-                    FileUtils.deleteQuietly(file);
                 }
-            }
-
-            final GuiScreenWorking guiScreen = new GuiScreenWorking();
-            final Minecraft mc = Minecraft.getMinecraft();
-
-            Futures.getUnchecked(mc.addScheduledTask(() -> mc.displayGuiScreen(guiScreen)));
-
-            Map<String, String> sessionInfo = ResourcePackRepository.func_190115_a();
-            repo.downloadingPacks = HttpUtil.downloadResourcePack(file, url, sessionInfo, 50 * 1024 * 1024, guiScreen, mc.getProxy());
-            Futures.addCallback(repo.downloadingPacks, new FutureCallback<Object>() {
-                @Override
-                public void onSuccess(Object value) {
-                    recordResourcePack(file, requestId);
-                    repo.setResourcePackInstance(file);
-                }
-
-                @Override
-                public void onFailure(@Nonnull Throwable throwable) {
-                    throwable.printStackTrace();
-                }
-            });
-            return repo.downloadingPacks;
-        } finally {
-            repo.lock.unlock();
+            }, I18n.format("multiplayer.texturePrompt.line1"), I18n.format("multiplayer.texturePrompt.line2"), 0));
         }
+
+        return new S3FPacketCustomPayload(packet.func_149169_c(), ("replay://" + requestId).getBytes(Charsets.UTF_8));
     }
 
+    private void downloadResourcePack(final int requestId, String url) {
+        final ResourcePackRepository repo = mc.mcResourcePackRepository;
+
+        String fileName = url.substring(url.lastIndexOf("/") + 1);
+
+        if (fileName.contains("?")) {
+            fileName = fileName.substring(0, fileName.indexOf("?"));
+        }
+
+        if (!fileName.endsWith(".zip")) {
+            return;
+        }
+
+        fileName = fileName.replaceAll("\\W", "");
+
+        File file = new File(repo.field_148534_e, fileName);
+
+        HashMap<String, String> hashmap = new HashMap<>();
+        hashmap.put("X-Minecraft-Username", mc.getSession().getUsername());
+        hashmap.put("X-Minecraft-UUID", mc.getSession().getPlayerID());
+        hashmap.put("X-Minecraft-Version", "1.7.10");
+
+        GuiScreenWorking guiScreen = new GuiScreenWorking();
+        Minecraft.getMinecraft().displayGuiScreen(guiScreen);
+        repo.func_148529_f();
+        repo.field_148533_g = true;
+        // Lambdas MUST NOT be used with methods that need re-obfuscation in FG prior to 2.2 (will result in AbstractMethodError)
+        //noinspection Convert2Lambda
+        HttpUtil.downloadResourcePack(file, url, new HttpUtil.DownloadListener() {
+            public void onDownloadComplete(File file) {
+                if (repo.field_148533_g) {
+                    repo.field_148533_g = false;
+                    repo.field_148532_f = new FileResourcePack(file);
+                    Minecraft.getMinecraft().scheduleResourcesRefresh();
+                    recordResourcePack(file, requestId);
+                }
+            }
+        }, hashmap, 50*1024*1024, guiScreen, Minecraft.getMinecraft().getProxy());
+    }
 }

src/main/java/com/replaymod/render/ReplayModRender.java

@@ -3,13 +3,13 @@ package com.replaymod.render;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.render.utils.RenderJob;
 import com.replaymod.replay.events.ReplayCloseEvent;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.util.ReportedException;
-import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.common.config.Configuration;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import org.apache.commons.io.FileUtils;
 import org.apache.logging.log4j.Logger;
 
@@ -21,6 +21,7 @@ import java.util.List;
 @Mod(modid = ReplayModRender.MOD_ID,
         version = "@MOD_VERSION@",
         acceptedMinecraftVersions = "@MC_VERSION@",
+        acceptableRemoteVersions = "*",
         useMetadata = true)
 public class ReplayModRender {
     public static final String MOD_ID = "replaymod-render";
@@ -45,7 +46,7 @@ public class ReplayModRender {
         core = ReplayMod.instance;
         configuration = new Configuration(event.getSuggestedConfigurationFile());
 
-        MinecraftForge.EVENT_BUS.register(this);
+        FMLCommonHandler.instance().bus().register(this);
 
         core.getSettingsRegistry().register(Setting.class);
     }

src/main/java/com/replaymod/render/VideoWriter.java

@@ -2,13 +2,14 @@ package com.replaymod.render;
 
 import com.replaymod.render.frame.RGBFrame;
 import com.replaymod.render.rendering.FrameConsumer;
+import com.replaymod.render.rendering.VideoRenderer;
 import com.replaymod.render.utils.ByteBufferPool;
 import com.replaymod.render.utils.StreamPipe;
+import cpw.mods.fml.common.versioning.ComparableVersion;
 import net.minecraft.client.Minecraft;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.crash.CrashReportCategory;
 import net.minecraft.util.Util;
-import net.minecraftforge.fml.common.versioning.ComparableVersion;
 import org.apache.commons.exec.CommandLine;
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
@@ -32,6 +33,7 @@ import static org.apache.commons.lang3.Validate.isTrue;
 
 public class VideoWriter implements FrameConsumer<RGBFrame> {
 
+    private final VideoRenderer renderer;
     private final RenderSettings settings;
     private final Process process;
     private final OutputStream outputStream;
@@ -41,8 +43,9 @@ public class VideoWriter implements FrameConsumer<RGBFrame> {
 
     private ByteArrayOutputStream ffmpegLog = new ByteArrayOutputStream(4096);
 
-    public VideoWriter(final RenderSettings settings) throws IOException {
-        this.settings = settings;
+    public VideoWriter(final VideoRenderer renderer) throws IOException {
+        this.renderer = renderer;
+        this.settings = renderer.getRenderSettings();
 
         File outputFolder = settings.getOutputFile().getParentFile();
         FileUtils.forceMkdir(outputFolder);
@@ -57,9 +60,13 @@ public class VideoWriter implements FrameConsumer<RGBFrame> {
                     .replace("%FILTERS%", settings.getVideoFilters());
 
         String executable = settings.getExportCommand().isEmpty() ? findFFmpeg() : settings.getExportCommand();
-        System.out.println("Starting " + executable + " with args: " + commandArgs);
+        LOGGER.info("Starting {} with args: {}", executable, commandArgs);
         String[] cmdline = new CommandLine(executable).addArguments(commandArgs).toStrings();
-        process = new ProcessBuilder(cmdline).directory(outputFolder).start();
+        try {
+            process = new ProcessBuilder(cmdline).directory(outputFolder).start();
+        } catch (IOException e) {
+            throw new NoFFmpegException(e);
+        }
         File exportLogFile = new File(Minecraft.getMinecraft().mcDataDir, "export.log");
         OutputStream exportLogOut = new TeeOutputStream(new FileOutputStream(exportLogFile), ffmpegLog);
         new StreamPipe(process.getInputStream(), exportLogOut).start();
@@ -152,6 +159,16 @@ public class VideoWriter implements FrameConsumer<RGBFrame> {
             if (aborted) {
                 return;
             }
+            try {
+                // Check whether this is a failure right at the beginning of the rendering process
+                // or at some later point (ffmpeg won't print the output file until the first frame
+                // has been written to stdin, so we can't already check for invalid args in <init>).
+                getVideoFile();
+            } catch (FFmpegStartupException e) {
+                // Possibly invalid ffmpeg arguments
+                renderer.setFailure(e);
+                return;
+            }
             CrashReport report = CrashReport.makeCrashReport(t, "Exporting frame");
             CrashReportCategory exportDetails = report.makeCategory("Export details");
             exportDetails.addCrashSection("Export command", settings.getExportCommand());
@@ -173,7 +190,7 @@ public class VideoWriter implements FrameConsumer<RGBFrame> {
         aborted = true;
     }
 
-    public File getVideoFile() {
+    public File getVideoFile() throws FFmpegStartupException {
         String log = ffmpegLog.toString();
         for (String line : log.split("\n")) {
             if (line.startsWith("Output #0")) {
@@ -181,6 +198,30 @@ public class VideoWriter implements FrameConsumer<RGBFrame> {
                 return new File(settings.getOutputFile().getParentFile(), fileName);
             }
         }
-        throw new IllegalStateException("No output file found.");
+        throw new FFmpegStartupException(settings, log);
+    }
+
+    public static class NoFFmpegException extends IOException {
+        public NoFFmpegException(Throwable cause) {
+            super(cause);
+        }
+    }
+
+    public static class FFmpegStartupException extends IOException {
+        private final RenderSettings settings;
+        private final String log;
+
+        public FFmpegStartupException(RenderSettings settings, String log) {
+            this.settings = settings;
+            this.log = log;
+        }
+
+        public RenderSettings getSettings() {
+            return settings;
+        }
+
+        public String getLog() {
+            return log;
+        }
     }
 }

src/main/java/com/replaymod/render/capturer/ODSFrameCapturer.java

@@ -4,10 +4,10 @@ import com.replaymod.render.RenderSettings;
 import com.replaymod.render.frame.CubicOpenGlFrame;
 import com.replaymod.render.frame.ODSOpenGlFrame;
 import com.replaymod.render.frame.OpenGlFrame;
+import com.replaymod.render.hooks.GLStateTracker;
 import com.replaymod.render.rendering.FrameCapturer;
 import com.replaymod.render.shader.Program;
 import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.util.ReportedException;
 import net.minecraft.util.ResourceLocation;
@@ -15,9 +15,13 @@ import org.lwjgl.util.ReadableDimension;
 
 import java.io.IOException;
 
-import static net.minecraft.client.renderer.GlStateManager.*;
 import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
 import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
+import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
+import static org.lwjgl.opengl.GL11.glClear;
+import static org.lwjgl.opengl.GL11.glEnable;
+import static org.lwjgl.opengl.GL11.glPopMatrix;
+import static org.lwjgl.opengl.GL11.glPushMatrix;
 
 public class ODSFrameCapturer implements FrameCapturer<ODSOpenGlFrame> {
     private static final ResourceLocation vertexResource = new ResourceLocation("replaymod", "shader/ods.vert");
@@ -28,8 +32,8 @@ public class ODSFrameCapturer implements FrameCapturer<ODSOpenGlFrame> {
     private final Program.Uniform directionVariable;
     private final Program.Uniform leftEyeVariable;
 
-    private final BooleanState[] previousStates = new BooleanState[3];
-    private final BooleanState previousFogState;
+    private final GLStateTracker.EnabledState[] previousStates = new GLStateTracker.EnabledState[2];
+    private final GLStateTracker.EnabledState previousFogState;
 
     private final Minecraft mc = Minecraft.getMinecraft();
 
@@ -42,6 +46,11 @@ public class ODSFrameCapturer implements FrameCapturer<ODSOpenGlFrame> {
                 return renderInfo.getFrameSize();
             }
 
+            @Override
+            public int getFramesDone() {
+                return renderInfo.getFramesDone();
+            }
+
             @Override
             public int getTotalFrames() {
                 return renderInfo.getTotalFrames();
@@ -73,15 +82,14 @@ public class ODSFrameCapturer implements FrameCapturer<ODSOpenGlFrame> {
             setTexture("lightMap", 1);
             linkState(0, "textureEnabled");
             linkState(1, "lightMapEnabled");
-            linkState(2, "hurtTextureEnabled");
             final Program.Uniform uniform = shaderProgram.getUniformVariable("fogEnabled");
-            previousFogState = GlStateManager.fogState.fog;
-            uniform.set(previousFogState.currentState);
-            GlStateManager.fogState.fog = new BooleanState(previousFogState.capability) {
+            previousFogState = GLStateTracker.getInstance().fog;
+            uniform.set(previousFogState.isEnabled());
+            GLStateTracker.getInstance().fog = new GLStateTracker.EnabledState() {
                 @Override
-                public void setState(boolean state) {
-                    super.setState(state);
-                    uniform.set(state);
+                public void setEnabled(boolean enabled) {
+                    super.setEnabled(enabled);
+                    uniform.set(enabled);
                 }
             };
             shaderProgram.stopUsing();
@@ -96,13 +104,13 @@ public class ODSFrameCapturer implements FrameCapturer<ODSOpenGlFrame> {
 
     private void linkState(int id, String var) {
         final Program.Uniform uniform = shaderProgram.getUniformVariable(var);
-        previousStates[id] = GlStateManager.textureState[id].texture2DState;
-        uniform.set(previousStates[id].currentState);
-        GlStateManager.textureState[id].texture2DState = new BooleanState(previousStates[id].capability) {
+        previousStates[id] = GLStateTracker.getInstance().texture[id];
+        uniform.set(previousStates[id].isEnabled());
+        GLStateTracker.getInstance().texture[id] = new GLStateTracker.EnabledState() {
             @Override
-            public void setState(boolean state) {
-                super.setState(state);
-                uniform.set(state);
+            public void setEnabled(boolean enabled) {
+                super.setEnabled(enabled);
+                uniform.set(enabled);
             }
         };
     }
@@ -132,10 +140,10 @@ public class ODSFrameCapturer implements FrameCapturer<ODSOpenGlFrame> {
         left.close();
         right.close();
         shaderProgram.delete();
-        for (int i = 0; i < 3; i++) {
-            GlStateManager.textureState[i].texture2DState = previousStates[i];
+        for (int i = 0; i < previousStates.length; i++) {
+            GLStateTracker.getInstance().texture[i] = previousStates[i];
         }
-        GlStateManager.fogState.fog = previousFogState;
+        GLStateTracker.getInstance().fog = previousFogState;
     }
 
     private class CubicStereoFrameCapturer extends CubicPboOpenGlFrameCapturer {
@@ -147,17 +155,17 @@ public class ODSFrameCapturer implements FrameCapturer<ODSOpenGlFrame> {
         protected OpenGlFrame renderFrame(int frameId, float partialTicks, CubicOpenGlFrameCapturer.Data captureData) {
             resize(getFrameWidth(), getFrameHeight());
 
-            pushMatrix();
+            glPushMatrix();
             frameBuffer().bindFramebuffer(true);
 
-            clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-            enableTexture2D();
+            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+            glEnable(GL_TEXTURE_2D);
 
             directionVariable.set(captureData.ordinal());
             worldRenderer.renderWorld(partialTicks, null);
 
             frameBuffer().unbindFramebuffer();
-            popMatrix();
+            glPopMatrix();
 
             return captureFrame(frameId, captureData);
         }

src/main/java/com/replaymod/render/capturer/OpenGlFrameCapturer.java

@@ -15,9 +15,9 @@ import org.lwjgl.util.WritableDimension;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 
-import static net.minecraft.client.renderer.GlStateManager.*;
 import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
 import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
+import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
 
 public abstract class OpenGlFrameCapturer<F extends Frame, D extends CaptureData> implements FrameCapturer<F> {
     protected final WorldRenderer worldRenderer;
@@ -76,16 +76,16 @@ public abstract class OpenGlFrameCapturer<F extends Frame, D extends CaptureData
     protected OpenGlFrame renderFrame(int frameId, float partialTicks, D captureData) {
         resize(getFrameWidth(), getFrameHeight());
 
-        pushMatrix();
+        GL11.glPushMatrix();
         frameBuffer().bindFramebuffer(true);
 
-        clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-        enableTexture2D();
+        GL11.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        GL11.glEnable(GL_TEXTURE_2D);
 
         worldRenderer.renderWorld(partialTicks, captureData);
 
         frameBuffer().unbindFramebuffer();
-        popMatrix();
+        GL11.glPopMatrix();
 
         return captureFrame(frameId, captureData);
     }

src/main/java/com/replaymod/render/capturer/RenderInfo.java

@@ -6,6 +6,8 @@ import org.lwjgl.util.ReadableDimension;
 public interface RenderInfo {
     ReadableDimension getFrameSize();
 
+    int getFramesDone();
+
     int getTotalFrames();
 
     float updateForNextFrame();

src/main/java/com/replaymod/render/events/ReplayRenderEvent.java

@@ -1,9 +1,9 @@
 package com.replaymod.render.events;
 
 import com.replaymod.render.rendering.VideoRenderer;
+import cpw.mods.fml.common.eventhandler.Event;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
-import net.minecraftforge.fml.common.eventhandler.Event;
 
 @RequiredArgsConstructor
 public abstract class ReplayRenderEvent extends Event {

src/main/java/com/replaymod/render/gui/GuiExportFailed.java

@@ -0,0 +1,109 @@
+package com.replaymod.render.gui;
+
+import com.replaymod.render.RenderSettings;
+import com.replaymod.render.VideoWriter;
+import de.johni0702.minecraft.gui.container.GuiPanel;
+import de.johni0702.minecraft.gui.container.GuiScreen;
+import de.johni0702.minecraft.gui.container.GuiVerticalList;
+import de.johni0702.minecraft.gui.element.GuiButton;
+import de.johni0702.minecraft.gui.element.GuiElement;
+import de.johni0702.minecraft.gui.element.GuiLabel;
+import de.johni0702.minecraft.gui.layout.CustomLayout;
+import de.johni0702.minecraft.gui.layout.HorizontalLayout;
+import de.johni0702.minecraft.gui.layout.VerticalLayout;
+import net.minecraft.crash.CrashReport;
+import net.minecraft.crash.CrashReportCategory;
+import net.minecraft.util.ReportedException;
+
+import java.util.Arrays;
+import java.util.function.Consumer;
+
+import static com.replaymod.render.ReplayModRender.LOGGER;
+
+public class GuiExportFailed extends GuiScreen {
+    public static GuiExportFailed tryToRecover(VideoWriter.FFmpegStartupException e, Consumer<RenderSettings> doRestart) {
+        // Always log the error first
+        LOGGER.error("Rendering video:", e);
+
+        RenderSettings settings = e.getSettings();
+        // Check whether the user has configured some custom ffmpeg arguments
+        if (settings.getEncodingPreset().getValue().equals(settings.getExportArguments())) {
+            // If they haven't, then this is probably a faulty ffmpeg installation and there's nothing we can do
+            CrashReport crashReport = CrashReport.makeCrashReport(e, "Exporting video");
+            CrashReportCategory details = crashReport.makeCategory("Export details");
+            details.addCrashSection("Settings", settings);
+            details.addCrashSection("FFmpeg log", e.getLog());
+            throw new ReportedException(crashReport);
+        } else {
+            // If they have, ask them whether it was intentional
+            GuiExportFailed gui = new GuiExportFailed(e, doRestart);
+            gui.display();
+            return gui;
+        }
+    }
+
+    private final GuiLabel logLabel = new GuiLabel(this)
+            .setI18nText("replaymod.gui.rendering.error.ffmpeglog");
+    private final GuiVerticalList logList = new GuiVerticalList(this).setDrawShadow(true);
+    private final GuiButton resetButton = new GuiButton().setI18nLabel("gui.yes").setSize(100, 20);
+    private final GuiButton abortButton = new GuiButton().setI18nLabel("gui.no").setSize(100, 20);
+    private final GuiPanel info = new GuiPanel(this)
+            .setLayout(new VerticalLayout().setSpacing(4))
+            .addElements(new VerticalLayout.Data(0.5),
+                    new GuiLabel().setI18nText("replaymod.gui.rendering.error.ffmpegargs.1"),
+                    new GuiLabel().setI18nText("replaymod.gui.rendering.error.ffmpegargs.2"),
+                    new GuiLabel(),
+                    new GuiPanel().setLayout(new HorizontalLayout(HorizontalLayout.Alignment.CENTER).setSpacing(5))
+                            .addElements(null, resetButton, abortButton)
+            );
+
+    {
+        setLayout(new CustomLayout<GuiScreen>() {
+            @Override
+            protected void layout(GuiScreen container, int width, int height) {
+                pos(info, width/2 - width(info)/2, (height/2 - height(info) - 30) / 2 + 30);
+                pos(logLabel, width/2 - width(logLabel)/2, height/2 + 4);
+                pos(logList, 10, y(logLabel) + height(logLabel) + 4);
+                size(logList, width - 10 - x(logList), height - 10 - y(logList));
+            }
+        });
+
+        setTitle(new GuiLabel().setI18nText("replaymod.gui.rendering.error.title"));
+        setBackground(Background.DIRT);
+    }
+
+    public GuiExportFailed(VideoWriter.FFmpegStartupException e, Consumer<RenderSettings> doRestart) {
+        logList.getListPanel().addElements(null,
+                Arrays.stream(e.getLog().replace("\t", "    ").split("\n"))
+                        .map(l -> new GuiLabel().setText(l))
+                        .toArray(GuiElement[]::new));
+
+        resetButton.onClick(() -> {
+            RenderSettings oldSettings = e.getSettings();
+            doRestart.accept(new RenderSettings(
+                    oldSettings.getRenderMethod(),
+                    oldSettings.getEncodingPreset(),
+                    oldSettings.getVideoWidth(),
+                    oldSettings.getVideoHeight(),
+                    oldSettings.getFramesPerSecond(),
+                    oldSettings.getBitRate(),
+                    oldSettings.getOutputFile(),
+                    oldSettings.isRenderNameTags(),
+                    oldSettings.isStabilizeYaw(),
+                    oldSettings.isStabilizePitch(),
+                    oldSettings.isStabilizeRoll(),
+                    oldSettings.getChromaKeyingColor(),
+                    oldSettings.isInject360Metadata(),
+                    oldSettings.getAntiAliasing(),
+                    oldSettings.getExportCommand(),
+                    oldSettings.getEncodingPreset().getValue(),
+                    oldSettings.isHighPerformance()
+            ));
+        });
+
+        abortButton.onClick(() -> {
+            // Assume they know what they're doing
+            getMinecraft().displayGuiScreen(null);
+        });
+    }
+}

src/main/java/com/replaymod/render/gui/GuiRenderQueue.java

@@ -1,8 +1,11 @@
 package com.replaymod.render.gui;
 
+import com.google.common.collect.Iterables;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
+import com.replaymod.core.utils.Utils;
 import com.replaymod.render.ReplayModRender;
+import com.replaymod.render.VideoWriter;
 import com.replaymod.render.rendering.VideoRenderer;
 import com.replaymod.render.utils.RenderJob;
 import com.replaymod.replay.ReplayHandler;
@@ -11,6 +14,7 @@ import com.replaymod.replaystudio.util.I18n;
 import de.johni0702.minecraft.gui.GuiRenderer;
 import de.johni0702.minecraft.gui.RenderInfo;
 import de.johni0702.minecraft.gui.container.AbstractGuiClickableContainer;
+import de.johni0702.minecraft.gui.container.AbstractGuiScreen;
 import de.johni0702.minecraft.gui.container.GuiContainer;
 import de.johni0702.minecraft.gui.container.GuiPanel;
 import de.johni0702.minecraft.gui.container.GuiVerticalList;
@@ -25,12 +29,10 @@ import de.johni0702.minecraft.gui.popup.GuiYesNoPopup;
 import de.johni0702.minecraft.gui.utils.Colors;
 import net.minecraft.client.gui.GuiErrorScreen;
 import net.minecraft.crash.CrashReport;
-import net.minecraft.util.ReportedException;
 import org.lwjgl.util.Dimension;
 import org.lwjgl.util.ReadableDimension;
 
 import javax.annotation.Nullable;
-import java.io.IOException;
 import java.util.List;
 
 import static com.replaymod.render.ReplayModRender.LOGGER;
@@ -62,7 +64,8 @@ public class GuiRenderQueue extends AbstractGuiPopup<GuiRenderQueue> {
                             renameButton, removeButton),
                     closeButton);
 
-    private final GuiContainer container;
+    private final AbstractGuiScreen container;
+    private final ReplayHandler replayHandler;
     private Entry selectedEntry;
 
     {
@@ -84,9 +87,10 @@ public class GuiRenderQueue extends AbstractGuiPopup<GuiRenderQueue> {
         }).addElements(null, title, list, buttonPanel);
     }
 
-    public GuiRenderQueue(GuiContainer container, GuiRenderSettings guiRenderSettings, ReplayHandler replayHandler, Timeline timeline) {
+    public GuiRenderQueue(AbstractGuiScreen container, GuiRenderSettings guiRenderSettings, ReplayHandler replayHandler, Timeline timeline) {
         super(container);
         this.container = container;
+        this.replayHandler = replayHandler;
         LOGGER.trace("Opening render queue popup");
 
         setBackgroundColor(Colors.DARK_TRANSPARENT);
@@ -188,30 +192,46 @@ public class GuiRenderQueue extends AbstractGuiPopup<GuiRenderQueue> {
 
         renderButton.onClick(() -> {
             LOGGER.trace("Render button clicked");
-            // Close all GUIs (so settings in GuiRenderSettings are saved)
-            getMinecraft().displayGuiScreen(null);
-            // Start rendering
-            for (RenderJob renderJob : queue) {
-                LOGGER.info("Starting render job {}", renderJob);
-                try {
-                    VideoRenderer videoRenderer = new VideoRenderer(renderJob.getSettings(), replayHandler, renderJob.getTimeline());
-                    videoRenderer.renderVideo();
-                } catch (IOException e) {
-                    LOGGER.error("Rendering video:", e);
-                    GuiErrorScreen errorScreen = new GuiErrorScreen(I18n.format("replaymod.gui.rendering.error.title"),
-                            I18n.format("replaymod.gui.rendering.error.message"));
-                    getMinecraft().displayGuiScreen(errorScreen);
-                    return;
-                } catch (Throwable t) {
-                    CrashReport crashReport = CrashReport.makeCrashReport(t, "Rendering video");
-                    throw new ReportedException(crashReport);
-                }
-            }
+            processQueue(queue);
         });
 
         updateButtons();
     }
 
+    private void processQueue(Iterable<RenderJob> queue) {
+        // Close all GUIs (so settings in GuiRenderSettings are saved)
+        getMinecraft().displayGuiScreen(null);
+        // Start rendering
+        int jobsDone = 0;
+        for (RenderJob renderJob : queue) {
+            LOGGER.info("Starting render job {}", renderJob);
+            try {
+                VideoRenderer videoRenderer = new VideoRenderer(renderJob.getSettings(), replayHandler, renderJob.getTimeline());
+                videoRenderer.renderVideo();
+            } catch (VideoWriter.NoFFmpegException e) {
+                LOGGER.error("Rendering video:", e);
+                GuiErrorScreen errorScreen = new GuiErrorScreen(I18n.format("replaymod.gui.rendering.error.title"),
+                        I18n.format("replaymod.gui.rendering.error.message"));
+                getMinecraft().displayGuiScreen(errorScreen);
+                return;
+            } catch (VideoWriter.FFmpegStartupException e) {
+                int jobsToSkip = jobsDone;
+                GuiExportFailed.tryToRecover(e, newSettings -> {
+                    // Update current job with fixed ffmpeg arguments
+                    renderJob.setSettings(newSettings);
+                    // Restart queue, skipping the already completed jobs
+                    processQueue(Iterables.skip(queue, jobsToSkip));
+                });
+                return;
+            } catch (Throwable t) {
+                Utils.error(LOGGER, this, CrashReport.makeCrashReport(t, "Rendering video"), () -> {});
+                container.display(); // Re-show the queue popup and the new error popup
+                return;
+            }
+            jobsDone++;
+        }
+    }
+
     @Override
     public void open() {
         super.open();

src/main/java/com/replaymod/render/gui/GuiRenderSettings.java

@@ -7,6 +7,7 @@ import com.google.gson.GsonBuilder;
 import com.google.gson.InstanceCreator;
 import com.replaymod.render.RenderSettings;
 import com.replaymod.render.ReplayModRender;
+import com.replaymod.render.VideoWriter;
 import com.replaymod.render.rendering.VideoRenderer;
 import com.replaymod.replay.ReplayHandler;
 import com.replaymod.replaystudio.pathing.path.Timeline;
@@ -29,7 +30,6 @@ import de.johni0702.minecraft.gui.utils.Utils;
 import net.minecraft.client.gui.GuiErrorScreen;
 import net.minecraft.client.resources.I18n;
 import net.minecraft.crash.CrashReport;
-import net.minecraft.util.ReportedException;
 import net.minecraftforge.common.config.Configuration;
 import net.minecraftforge.common.config.Property;
 import org.lwjgl.util.Color;
@@ -39,11 +39,13 @@ import org.lwjgl.util.ReadableDimension;
 
 import javax.annotation.Nullable;
 import java.io.File;
-import java.io.IOException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Map;
 
+import static com.replaymod.core.utils.Utils.error;
+import static com.replaymod.render.ReplayModRender.LOGGER;
+
 public class GuiRenderSettings extends GuiScreen implements Closeable {
     public final GuiPanel contentPanel = new GuiPanel(this).setBackgroundColor(Colors.DARK_TRANSPARENT);
     public final GuiVerticalList settingsList = new GuiVerticalList(contentPanel).setDrawSlider(true);
@@ -199,15 +201,21 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
             try {
                 VideoRenderer videoRenderer = new VideoRenderer(save(false), replayHandler, timeline);
                 videoRenderer.renderVideo();
-            } catch (IOException e) {
-                e.printStackTrace();
-
+            } catch (VideoWriter.NoFFmpegException e) {
+                LOGGER.error("Rendering video:", e);
                 GuiErrorScreen errorScreen = new GuiErrorScreen(I18n.format("replaymod.gui.rendering.error.title"),
                         I18n.format("replaymod.gui.rendering.error.message"));
                 getMinecraft().displayGuiScreen(errorScreen);
+            } catch (VideoWriter.FFmpegStartupException e) {
+                GuiExportFailed.tryToRecover(e, newSettings -> {
+                    // Update settings with fixed ffmpeg arguments
+                    exportArguments.setText(newSettings.getExportArguments());
+                    // Restart rendering, this will also save the changed ffmpeg arguments
+                    renderButton.onClick();
+                });
             } catch (Throwable t) {
-                CrashReport crashReport = CrashReport.makeCrashReport(t, "Rendering video");
-                throw new ReportedException(crashReport);
+                error(LOGGER, GuiRenderSettings.this, CrashReport.makeCrashReport(t, "Rendering video"), () -> {});
+                display(); // Re-show the render settings gui and the new error popup
             }
         }
     }).setSize(100, 20).setI18nLabel("replaymod.gui.render");

src/main/java/com/replaymod/render/hooks/ChunkLoadingRenderGlobal.java

@@ -1,104 +0,0 @@
-package com.replaymod.render.hooks;
-
-import com.replaymod.render.utils.JailingQueue;
-import net.minecraft.client.renderer.RegionRenderCacheBuilder;
-import net.minecraft.client.renderer.RenderGlobal;
-import net.minecraft.client.renderer.chunk.ChunkCompileTaskGenerator;
-import net.minecraft.client.renderer.chunk.ChunkRenderDispatcher;
-import net.minecraft.client.renderer.chunk.ChunkRenderWorker;
-import net.minecraft.client.renderer.chunk.RenderChunk;
-
-import java.lang.reflect.Field;
-import java.util.Iterator;
-import java.util.concurrent.PriorityBlockingQueue;
-
-public class ChunkLoadingRenderGlobal {
-
-    private final RenderGlobal hooked;
-    private final ChunkRenderDispatcher renderDispatcher;
-    private final JailingQueue<ChunkCompileTaskGenerator> workerJailingQueue;
-    private final CustomChunkRenderWorker renderWorker;
-    private int frame;
-
-    @SuppressWarnings("unchecked")
-    public ChunkLoadingRenderGlobal(RenderGlobal renderGlobal) {
-        this.hooked = renderGlobal;
-        this.renderDispatcher = renderGlobal.renderDispatcher;
-        this.renderWorker = new CustomChunkRenderWorker(renderDispatcher, new RegionRenderCacheBuilder());
-
-        int workerThreads = renderDispatcher.listThreadedWorkers.size();
-        PriorityBlockingQueue<ChunkCompileTaskGenerator> queueChunkUpdates = renderDispatcher.queueChunkUpdates;
-        workerJailingQueue = new JailingQueue<>(queueChunkUpdates);
-        renderDispatcher.queueChunkUpdates = workerJailingQueue;
-        ChunkCompileTaskGenerator element = new ChunkCompileTaskGenerator(null, null, 0);
-        element.finish();
-        for (int i = 0; i < workerThreads; i++) {
-            queueChunkUpdates.add(element);
-        }
-
-        // Temporary workaround for dead lock, will be replaced by a new (ShaderMod compatible) mechanism later
-        //noinspection StatementWithEmptyBody
-        while (renderDispatcher.runChunkUploads(0)) {}
-
-        workerJailingQueue.jail(workerThreads);
-        renderDispatcher.queueChunkUpdates = queueChunkUpdates;
-
-        try {
-            Field hookField = RenderGlobal.class.getField("replayModRender_hook");
-            hookField.set(hooked, this);
-        } catch (NoSuchFieldException | IllegalAccessException e) {
-            throw new Error(e);
-        }
-    }
-
-    public void updateChunks() {
-        while (renderDispatcher.runChunkUploads(0)) {
-            hooked.displayListEntitiesDirty = true;
-        }
-
-        while (!renderDispatcher.queueChunkUpdates.isEmpty()) {
-            try {
-                renderWorker.processTask(renderDispatcher.queueChunkUpdates.poll());
-            } catch (InterruptedException ignored) { }
-        }
-
-        Iterator<RenderChunk> iterator = hooked.chunksToUpdate.iterator();
-        while (iterator.hasNext()) {
-            RenderChunk renderchunk = iterator.next();
-
-            renderDispatcher.updateChunkNow(renderchunk);
-
-            renderchunk.clearNeedsUpdate();
-            iterator.remove();
-        }
-    }
-
-    public void uninstall() {
-        workerJailingQueue.freeAll();
-
-        try {
-            Field hookField = RenderGlobal.class.getField("replayModRender_hook");
-            hookField.set(hooked, null);
-        } catch (NoSuchFieldException | IllegalAccessException e) {
-            throw new Error(e);
-        }
-    }
-
-    public int nextFrameId() {
-        return frame++;
-    }
-
-    /**
-     * Custom ChunkRenderWorker class providing access to the protected processTask method
-     */
-    private static class CustomChunkRenderWorker extends ChunkRenderWorker {
-        public CustomChunkRenderWorker(ChunkRenderDispatcher p_i46202_1_, RegionRenderCacheBuilder p_i46202_2_) {
-            super(p_i46202_1_, p_i46202_2_);
-        }
-
-        @Override
-        protected void processTask(ChunkCompileTaskGenerator p_178474_1_) throws InterruptedException {
-            super.processTask(p_178474_1_);
-        }
-    }
-}

src/main/java/com/replaymod/render/hooks/EntityRendererHandler.java

@@ -2,11 +2,12 @@ package com.replaymod.render.hooks;
 
 import com.replaymod.render.RenderSettings;
 import com.replaymod.render.capturer.CaptureData;
+import com.replaymod.render.capturer.RenderInfo;
 import com.replaymod.render.capturer.WorldRenderer;
+import cpw.mods.fml.common.FMLCommonHandler;
 import lombok.Getter;
 import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.GlStateManager;
-import net.minecraftforge.fml.common.FMLCommonHandler;
+import org.lwjgl.opengl.GL11;
 
 import java.io.IOException;
 
@@ -16,12 +17,16 @@ public class EntityRendererHandler implements WorldRenderer {
     @Getter
     protected final RenderSettings settings;
 
+    @Getter
+    private final RenderInfo renderInfo;
+
     public CaptureData data;
 
     public boolean omnidirectional;
 
-    public EntityRendererHandler(RenderSettings settings) {
+    public EntityRendererHandler(RenderSettings settings, RenderInfo renderInfo) {
         this.settings = settings;
+        this.renderInfo = renderInfo;
 
         ((IEntityRenderer) mc.entityRenderer).replayModRender_setHandler(this);
     }
@@ -37,11 +42,11 @@ public class EntityRendererHandler implements WorldRenderer {
 
         mc.entityRenderer.updateLightmap(partialTicks);
 
-        GlStateManager.enableDepth();
-        GlStateManager.enableAlpha();
-        GlStateManager.alphaFunc(516, 0.5F);
+        GL11.glEnable(GL11.GL_DEPTH_TEST);
+        GL11.glEnable(GL11.GL_ALPHA_TEST);
+        GL11.glAlphaFunc(516, 0.5F);
 
-        mc.entityRenderer.renderWorldPass(2, partialTicks, finishTimeNano);
+        mc.entityRenderer.renderWorld(partialTicks, finishTimeNano);
 
         FMLCommonHandler.instance().onRenderTickEnd(partialTicks);
     }

src/main/java/com/replaymod/render/hooks/GLStateTracker.java

@@ -0,0 +1,63 @@
+package com.replaymod.render.hooks;
+
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL13;
+
+/**
+ * Tracks OpenGL state for use in the ODS shader.
+ * All methods should be called from the GL mixins only.
+ */
+public class GLStateTracker {
+    private static ThreadLocal<GLStateTracker> stateTracker = ThreadLocal.withInitial(GLStateTracker::new);
+    public static GLStateTracker getInstance() {
+        return stateTracker.get();
+    }
+
+    public int activeTexture;
+    public EnabledState fog = new EnabledState();
+    public EnabledState[] texture = new EnabledState[32];
+    {
+        for (int i = 0; i < texture.length; i++) {
+            texture[i] = new EnabledState();
+        }
+    }
+
+    public void updateActiveTexture(int magic) {
+        this.activeTexture = magic - GL13.GL_TEXTURE0;
+    }
+
+    public void updateEnabledState(int magic, boolean enabled) {
+        switch (magic) {
+            case GL11.GL_FOG: fog.setEnabled(enabled); break;
+            case GL11.GL_TEXTURE_2D: texture[activeTexture].setEnabled(enabled); break;
+        }
+    }
+
+    public static class EnabledState {
+        private boolean enabled;
+
+        public void setEnabled(boolean enabled) {
+            this.enabled = enabled;
+        }
+
+        public boolean isEnabled() {
+            return enabled;
+        }
+    }
+
+    // Called via ASM (see GLStateTrackerTransformer)
+    @Deprecated
+    @SuppressWarnings("unused")
+    public static void hook_glEnable(int magic) {
+        GL11.glEnable(magic);
+        getInstance().updateEnabledState(magic, true);
+    }
+
+    // Called via ASM (see GLStateTrackerTransformer)
+    @Deprecated
+    @SuppressWarnings("unused")
+    public static void hook_glDisable(int magic) {
+        GL11.glDisable(magic);
+        getInstance().updateEnabledState(magic, false);
+    }
+}

src/main/java/com/replaymod/render/metadata/MetadataInjector.java

@@ -4,7 +4,6 @@ import com.coremedia.iso.IsoFile;
 import com.coremedia.iso.boxes.*;
 import com.google.common.primitives.Bytes;
 import com.googlecode.mp4parser.BasicContainer;
-import net.minecraftforge.fml.common.FMLLog;
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
 
@@ -13,6 +12,8 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 
+import static com.replaymod.render.ReplayModRender.LOGGER;
+
 public class MetadataInjector {
 
     private static final String STITCHING_SOFTWARE = "Minecraft ReplayMod";
@@ -96,7 +97,7 @@ public class MetadataInjector {
             videoFileOutputStream = new FileOutputStream(videoFile);
             tempIsoFile.getBox(videoFileOutputStream.getChannel());
         } catch(Exception e) {
-            FMLLog.getLogger().error("360 Degree Metadata couldn't be injected", e);
+            LOGGER.error("360 Degree Metadata couldn't be injected", e);
         } finally {
             IOUtils.closeQuietly(tempIsoFile);
             IOUtils.closeQuietly(videoFileOutputStream);

src/main/java/com/replaymod/render/mixin/MixinEffectRenderer.java

@@ -0,0 +1,48 @@
+package com.replaymod.render.mixin;
+
+import com.replaymod.render.hooks.EntityRendererHandler;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.particle.EffectRenderer;
+import net.minecraft.client.particle.EntityFX;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.entity.Entity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+@Mixin(EffectRenderer.class)
+public abstract class MixinEffectRenderer {
+    @Redirect(method = "renderParticles", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/EntityFX;renderParticle(Lnet/minecraft/client/renderer/Tesselator;FFFFFF)V"))
+    private void renderNormalParticle(EntityFX fx, Tessellator tesselator, float partialTicks,
+                                float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
+        renderParticle(fx, tesselator, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
+    }
+
+    @Redirect(method = "renderLitParticles", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/EntityFX;renderParticle(Lnet/minecraft/client/renderer/Tesselator;FFFFFF)V"))
+    private void renderLitParticle(EntityFX fx, Tessellator tesselator, float partialTicks,
+                                 float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
+        renderParticle(fx, tesselator, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
+    }
+
+    private void renderParticle(EntityFX fx, Tessellator tessellator, float partialTicks,
+                                float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
+        EntityRendererHandler handler = ((EntityRendererHandler.IEntityRenderer) Minecraft.getMinecraft().entityRenderer).replayModRender_getHandler();
+        if (handler != null && handler.omnidirectional) {
+            Entity view = Minecraft.getMinecraft().renderViewEntity;
+            // Align all particles towards the camera
+            double dx = fx.prevPosX + (fx.posX - fx.prevPosX) * partialTicks - view.posX;
+            double dy = fx.prevPosY + (fx.posY - fx.prevPosY) * partialTicks - view.posY;
+            double dz = fx.prevPosZ + (fx.posZ - fx.prevPosZ) * partialTicks - view.posZ;
+            double pitch = -Math.atan2(dy, Math.sqrt(dx * dx + dz * dz));
+            double yaw = -Math.atan2(dx, dz);
+
+            rotX = (float) Math.cos(yaw);
+            rotZ = (float) Math.sin(yaw);
+            rotXZ = (float) Math.cos(pitch);
+
+            rotYZ = (float) (-rotZ * Math.sin(pitch));
+            rotXY = (float) (rotX * Math.sin(pitch));
+        }
+        fx.renderParticle(tessellator, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
+    }
+}

src/main/java/com/replaymod/render/mixin/MixinEntityRenderer.java

@@ -7,12 +7,12 @@ import com.replaymod.render.hooks.EntityRendererHandler;
 import com.replaymod.replay.camera.CameraEntity;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.EntityRenderer;
-import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.client.renderer.RenderGlobal;
 import net.minecraft.client.settings.GameSettings;
 import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.MovingObjectPosition;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.util.ReadableColor;
 import org.lwjgl.util.glu.Project;
@@ -40,6 +40,15 @@ public abstract class MixinEntityRenderer implements EntityRendererHandler.IEnti
         return replayModRender_handler;
     }
 
+    @Redirect(method = "renderWorld", at = @At(value = "INVOKE",target =
+            "Lnet/minecraft/client/renderer/RenderGlobal;updateRenderers(Lnet/minecraft/entity/EntityLivingBase;Z)Z"))
+    private boolean replayModRender_updateAllChunks(RenderGlobal self, EntityLivingBase view, boolean renderAllChunks) {
+        if (replayModRender_handler != null) {
+            renderAllChunks = true;
+        }
+        return self.updateRenderers(view, renderAllChunks);
+    }
+
     @Inject(method = "setupFog", at = @At("HEAD"), cancellable = true)
     private void replayModRender_onSetupFog(int fogDistanceFlag, float partialTicks, CallbackInfo ci) {
         if (replayModRender_handler == null) return;
@@ -51,7 +60,7 @@ public abstract class MixinEntityRenderer implements EntityRendererHandler.IEnti
     @Inject(method = "orientCamera", at = @At("HEAD"))
     private void replayModRender_resetRotationIfNeeded(float partialTicks, CallbackInfo ci) {
         if (replayModRender_handler != null) {
-            Entity entity = Minecraft.getMinecraft().getRenderViewEntity();
+            Entity entity = Minecraft.getMinecraft().renderViewEntity;
             RenderSettings settings = replayModRender_handler.getSettings();
             if (settings.isStabilizeYaw()) {
                 entity.prevRotationYaw = entity.rotationYaw = 0;
@@ -74,7 +83,7 @@ public abstract class MixinEntityRenderer implements EntityRendererHandler.IEnti
     @Inject(method = "setupCameraTransform", at = @At("HEAD"))
     private void replayModRender_beforeSetupCameraTransform(float partialTicks, int renderPass, CallbackInfo ci) {
         if (replayModRender_handler != null) {
-            Entity entity = Minecraft.getMinecraft().getRenderViewEntity();
+            Entity entity = Minecraft.getMinecraft().renderViewEntity;
             orgYaw = entity.rotationYaw;
             orgPitch = entity.rotationPitch;
             orgPrevYaw = entity.prevRotationYaw;
@@ -86,7 +95,7 @@ public abstract class MixinEntityRenderer implements EntityRendererHandler.IEnti
     @Inject(method = "setupCameraTransform", at = @At("RETURN"))
     private void replayModRender_afterSetupCameraTransform(float partialTicks, int renderPass, CallbackInfo ci) {
         if (replayModRender_handler != null) {
-            Entity entity = Minecraft.getMinecraft().getRenderViewEntity();
+            Entity entity = Minecraft.getMinecraft().renderViewEntity;
             entity.rotationYaw = orgYaw;
             entity.rotationPitch = orgPitch;
             entity.prevRotationYaw = orgPrevYaw;
@@ -104,7 +113,7 @@ public abstract class MixinEntityRenderer implements EntityRendererHandler.IEnti
                 ci.cancel();
                 return; // No spectator hands during 360° view, we wouldn't even know where to put it
             }
-            Entity currentEntity = Minecraft.getMinecraft().getRenderViewEntity();
+            Entity currentEntity = Minecraft.getMinecraft().renderViewEntity;
             if (currentEntity instanceof EntityPlayer && !(currentEntity instanceof CameraEntity)) {
                 if (renderPass == 2) { // Need to update render pass
                     renderPass = replayModRender_handler.data == StereoscopicOpenGlFrameCapturer.Data.LEFT_EYE ? 1 : 0;
@@ -118,16 +127,17 @@ public abstract class MixinEntityRenderer implements EntityRendererHandler.IEnti
     @Shadow
     public abstract void renderHand(float partialTicks, int renderPass);
 
-    @Redirect(method = "renderWorldPass", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderGlobal;drawSelectionBox(Lnet/minecraft/entity/player/EntityPlayer;Lnet/minecraft/util/math/RayTraceResult;IF)V"))
-    private void replayModRender_drawSelectionBox(RenderGlobal instance, EntityPlayer player, RayTraceResult rtr, int alwaysZero, float partialTicks) {
+    @Redirect(method = "renderWorld", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderGlobal;drawSelectionBox(Lnet/minecraft/entity/player/EntityPlayer;Lnet/minecraft/util/MovingObjectPosition;IF)V"))
+    private void replayModRender_drawSelectionBox(RenderGlobal instance, EntityPlayer player, MovingObjectPosition mop, int alwaysZero, float partialTicks) {
         if (replayModRender_handler == null) {
-            instance.drawSelectionBox(player, rtr, alwaysZero, partialTicks);
+            instance.drawSelectionBox(player, mop, alwaysZero, partialTicks);
         }
     }
 
     private int orgRenderDistanceChunks;
 
-    @Inject(method = "renderWorldPass", at = @At(value = "JUMP", ordinal = 0))
+    @Inject(method = "renderWorld", at = @At(value = "INVOKE", ordinal = 0, shift = At.Shift.AFTER,
+            target = "Lnet/minecraft/client/renderer/culling/ClippingHelperImpl;getInstance()Lnet/minecraft/client/renderer/culling/ClippingHelper;"))
     private void replayModRender_beforeRenderSky(CallbackInfo ci) {
         if (replayModRender_handler != null && replayModRender_handler.getSettings().getChromaKeyingColor() != null) {
             GameSettings settings = Minecraft.getMinecraft().gameSettings;
@@ -136,15 +146,15 @@ public abstract class MixinEntityRenderer implements EntityRendererHandler.IEnti
         }
     }
 
-    @Redirect(method = "renderWorldPass", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderGlobal;renderSky(FI)V"))
-    private void replayModRender_renderSky(RenderGlobal instance, float partialTicks, int renderPass) {
+    @Redirect(method = "renderWorld", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderGlobal;renderSky(F)V"))
+    private void replayModRender_renderSky(RenderGlobal instance, float partialTicks) {
         if (replayModRender_handler != null && replayModRender_handler.getSettings().getChromaKeyingColor() != null) {
             Minecraft.getMinecraft().gameSettings.renderDistanceChunks = orgRenderDistanceChunks;
             ReadableColor color = replayModRender_handler.getSettings().getChromaKeyingColor();
-            GlStateManager.clearColor(color.getRed() / 255f, color.getGreen() / 255f, color.getBlue() / 255f, 1);
-            GlStateManager.clear(GL11.GL_COLOR_BUFFER_BIT);
+            GL11.glClearColor(color.getRed() / 255f, color.getGreen() / 255f, color.getBlue() / 255f, 1);
+            GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
         } else {
-            instance.renderSky(partialTicks, renderPass);
+            instance.renderSky(partialTicks);
         }
     }
 
@@ -152,24 +162,24 @@ public abstract class MixinEntityRenderer implements EntityRendererHandler.IEnti
      *   Stereoscopic Renderer
      */
 
-    @Inject(method = "setupCameraTransform", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/GlStateManager;loadIdentity()V", shift = At.Shift.AFTER, ordinal = 0))
+    @Inject(method = "setupCameraTransform", at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glLoadIdentity()V", shift = At.Shift.AFTER, ordinal = 0, remap = false))
     private void replayModRender_setupStereoscopicProjection(float partialTicks, int renderPass, CallbackInfo ci) {
         if (replayModRender_getHandler() != null) {
             if (replayModRender_getHandler().data == StereoscopicOpenGlFrameCapturer.Data.LEFT_EYE) {
-                GlStateManager.translate(0.07, 0, 0);
+                GL11.glTranslatef(0.07f, 0, 0);
             } else if (replayModRender_getHandler().data == StereoscopicOpenGlFrameCapturer.Data.RIGHT_EYE) {
-                GlStateManager.translate(-0.07, 0, 0);
+                GL11.glTranslatef(-0.07f, 0, 0);
             }
         }
     }
 
-    @Inject(method = "setupCameraTransform", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/GlStateManager;loadIdentity()V", shift = At.Shift.AFTER, ordinal = 1))
+    @Inject(method = "setupCameraTransform", at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glLoadIdentity()V", shift = At.Shift.AFTER, ordinal = 1, remap = false))
     private void replayModRender_setupStereoscopicModelView(float partialTicks, int renderPass, CallbackInfo ci) {
         if (replayModRender_getHandler() != null) {
             if (replayModRender_getHandler().data == StereoscopicOpenGlFrameCapturer.Data.LEFT_EYE) {
-                GlStateManager.translate(0.1, 0, 0);
+                GL11.glTranslatef(0.1f, 0, 0);
             } else if (replayModRender_getHandler().data == StereoscopicOpenGlFrameCapturer.Data.RIGHT_EYE) {
-                GlStateManager.translate(-0.1, 0, 0);
+                GL11.glTranslatef(-0.1f, 0, 0);
             }
         }
     }
@@ -183,16 +193,11 @@ public abstract class MixinEntityRenderer implements EntityRendererHandler.IEnti
         replayModRender_gluPerspective(fovY, aspect, zNear, zFar);
     }
 
-    @Redirect(method = "renderWorldPass", at = @At(value = "INVOKE", target = "Lorg/lwjgl/util/glu/Project;gluPerspective(FFFF)V", remap = false))
+    @Redirect(method = "renderHand", at = @At(value = "INVOKE", target = "Lorg/lwjgl/util/glu/Project;gluPerspective(FFFF)V", remap = false))
     private void replayModRender_gluPerspective$1(float fovY, float aspect, float zNear, float zFar) {
         replayModRender_gluPerspective(fovY, aspect, zNear, zFar);
     }
 
-    @Redirect(method = "renderCloudsCheck", at = @At(value = "INVOKE", target = "Lorg/lwjgl/util/glu/Project;gluPerspective(FFFF)V", remap = false))
-    private void replayModRender_gluPerspective$2(float fovY, float aspect, float zNear, float zFar) {
-        replayModRender_gluPerspective(fovY, aspect, zNear, zFar);
-    }
-
     @Override
     public void replayModRender_gluPerspective(float fovY, float aspect, float zNear, float zFar) {
         if (replayModRender_getHandler() != null && replayModRender_getHandler().omnidirectional) {
@@ -207,28 +212,28 @@ public abstract class MixinEntityRenderer implements EntityRendererHandler.IEnti
         if (replayModRender_getHandler() != null && replayModRender_getHandler().data instanceof CubicOpenGlFrameCapturer.Data) {
             switch ((CubicOpenGlFrameCapturer.Data) replayModRender_getHandler().data) {
                 case FRONT:
-                    GlStateManager.rotate(0, 0.0F, 1.0F, 0.0F);
+                    GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
                     break;
                 case RIGHT:
-                    GlStateManager.rotate(90, 0.0F, 1.0F, 0.0F);
+                    GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
                     break;
                 case BACK:
-                    GlStateManager.rotate(180, 0.0F, 1.0F, 0.0F);
+                    GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
                     break;
                 case LEFT:
-                    GlStateManager.rotate(-90, 0.0F, 1.0F, 0.0F);
+                    GL11.glRotatef(-90, 0.0F, 1.0F, 0.0F);
                     break;
                 case BOTTOM:
-                    GlStateManager.rotate(90, 1.0F, 0.0F, 0.0F);
+                    GL11.glRotatef(90, 1.0F, 0.0F, 0.0F);
                     break;
                 case TOP:
-                    GlStateManager.rotate(-90, 1.0F, 0.0F, 0.0F);
+                    GL11.glRotatef(-90, 1.0F, 0.0F, 0.0F);
                     break;
             }
         }
         if (replayModRender_getHandler() != null && replayModRender_getHandler().omnidirectional) {
             // Minecraft goes back a little so we have to revert that
-            GlStateManager.translate(0.0F, 0.0F, 0.1F);
+            GL11.glTranslatef(0.0F, 0.0F, 0.1F);
         }
     }
 }

src/main/java/com/replaymod/render/mixin/MixinFrustum.java

@@ -0,0 +1,23 @@
+package com.replaymod.render.mixin;
+
+import com.replaymod.render.hooks.EntityRendererHandler;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.culling.Frustrum;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(Frustrum.class)
+public abstract class MixinFrustum {
+    @Inject(method = "isBoxInFrustum", at = @At("HEAD"), cancellable = true)
+    public void isBoxInFrustum(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, CallbackInfoReturnable<Boolean> ci) {
+        EntityRendererHandler handler = ((EntityRendererHandler.IEntityRenderer) Minecraft.getMinecraft().entityRenderer).replayModRender_getHandler();
+        if (handler != null && handler.omnidirectional && handler.data == null) {
+            // Normally the camera is always facing the direction of the omnidirectional image face that is currently
+            // getting rendered. With ODS however, the camera is always facing forwards and the turning happens in the
+            // vertex shader (non-trivial due to stereo). As such, all chunks need to be rendered all the time for ODS.
+            ci.setReturnValue(true);
+        }
+    }
+}

src/main/java/com/replaymod/render/mixin/MixinOpenGlHelper.java

@@ -0,0 +1,16 @@
+package com.replaymod.render.mixin;
+
+import com.replaymod.render.hooks.GLStateTracker;
+import net.minecraft.client.renderer.OpenGlHelper;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(OpenGlHelper.class)
+public abstract class MixinOpenGlHelper {
+    @Inject(method = "setActiveTexture", at = @At("RETURN"))
+    private static void replayModRender_trackActiveTexture(int magic, CallbackInfo ci) {
+        GLStateTracker.getInstance().updateActiveTexture(magic);
+    }
+}

src/main/java/com/replaymod/render/mixin/MixinParticleManager.java

@@ -1,47 +0,0 @@
-package com.replaymod.render.mixin;
-
-import com.replaymod.render.hooks.EntityRendererHandler;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.particle.Particle;
-import net.minecraft.client.particle.ParticleManager;
-import net.minecraft.client.renderer.VertexBuffer;
-import net.minecraft.entity.Entity;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-@Mixin(ParticleManager.class)
-public abstract class MixinParticleManager {
-    @Redirect(method = "renderParticles", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/Particle;renderParticle(Lnet/minecraft/client/renderer/VertexBuffer;Lnet/minecraft/entity/Entity;FFFFFF)V"))
-    private void renderNormalParticle(Particle particle, VertexBuffer vertexBuffer, Entity view, float partialTicks,
-                                      float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
-        renderParticle(particle, vertexBuffer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
-    }
-
-    @Redirect(method = "renderLitParticles", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/Particle;renderParticle(Lnet/minecraft/client/renderer/VertexBuffer;Lnet/minecraft/entity/Entity;FFFFFF)V"))
-    private void renderLitParticle(Particle particle, VertexBuffer vertexBuffer, Entity view, float partialTicks,
-                                 float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
-        renderParticle(particle, vertexBuffer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
-    }
-
-    private void renderParticle(Particle particle, VertexBuffer vertexBuffer, Entity view, float partialTicks,
-                                 float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
-        EntityRendererHandler handler = ((EntityRendererHandler.IEntityRenderer) Minecraft.getMinecraft().entityRenderer).replayModRender_getHandler();
-        if (handler != null && handler.omnidirectional) {
-            // Align all particles towards the camera
-            double dx = particle.prevPosX + (particle.posX - particle.prevPosX) * partialTicks - view.posX;
-            double dy = particle.prevPosY + (particle.posY - particle.prevPosY) * partialTicks - view.posY;
-            double dz = particle.prevPosZ + (particle.posZ - particle.prevPosZ) * partialTicks - view.posZ;
-            double pitch = -Math.atan2(dy, Math.sqrt(dx * dx + dz * dz));
-            double yaw = -Math.atan2(dx, dz);
-
-            rotX = (float) Math.cos(yaw);
-            rotZ = (float) Math.sin(yaw);
-            rotXZ = (float) Math.cos(pitch);
-
-            rotYZ = (float) (-rotZ * Math.sin(pitch));
-            rotXY = (float) (rotX * Math.sin(pitch));
-        }
-        particle.renderParticle(vertexBuffer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
-    }
-}

src/main/java/com/replaymod/render/mixin/MixinRender.java

@@ -2,19 +2,20 @@ package com.replaymod.render.mixin;
 
 import com.replaymod.render.hooks.EntityRendererHandler;
 import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.entity.Render;
-import net.minecraft.entity.Entity;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.entity.EntityLivingBase;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-@Mixin(Render.class)
+@Mixin(RendererLivingEntity.class)
 public abstract class MixinRender {
-    @Inject(method = "renderLivingLabel", at = @At("HEAD"), cancellable = true)
-    private void replayModRender_areAllNamesHidden(Entity entityIn, String str, double x, double y, double z, int maxDistance, CallbackInfo ci) {
+    @Inject(method = "canRenderName", at = @At("HEAD"), cancellable = true)
+    private void replayModRender_areAllNamesHidden(EntityLivingBase entity, CallbackInfoReturnable<Boolean> ci) {
         EntityRendererHandler handler = ((EntityRendererHandler.IEntityRenderer) Minecraft.getMinecraft().entityRenderer).replayModRender_getHandler();
         if (handler != null && !handler.getSettings().isRenderNameTags()) {
+            ci.setReturnValue(false);
             ci.cancel();
         }
     }

src/main/java/com/replaymod/render/mixin/MixinRenderGlobal.java

@@ -1,55 +0,0 @@
-package com.replaymod.render.mixin;
-
-import com.replaymod.render.hooks.ChunkLoadingRenderGlobal;
-import net.minecraft.client.renderer.RenderGlobal;
-import net.minecraft.client.renderer.chunk.ChunkRenderDispatcher;
-import net.minecraft.client.renderer.culling.ICamera;
-import net.minecraft.entity.Entity;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(RenderGlobal.class)
-public abstract class MixinRenderGlobal {
-    public ChunkLoadingRenderGlobal replayModRender_hook;
-    private boolean replayModRender_passThroughSetupTerrain;
-
-    @Shadow
-    public boolean displayListEntitiesDirty;
-
-    @Shadow
-    public ChunkRenderDispatcher renderDispatcher;
-
-    @Shadow
-    public abstract void setupTerrain(Entity viewEntity, double partialTicks, ICamera camera,
-                                      int frameCount, boolean playerSpectator);
-
-    @Inject(method = "setupTerrain", at = @At("HEAD"), cancellable = true)
-    public void replayModRender_setupTerrain(Entity viewEntity, double partialTicks, ICamera camera,
-                                               int frameCount, boolean playerSpectator, CallbackInfo ci) {
-        if (replayModRender_hook != null && !replayModRender_passThroughSetupTerrain) {
-            replayModRender_passThroughSetupTerrain = true;
-
-            do {
-                setupTerrain(viewEntity, partialTicks, camera, replayModRender_hook.nextFrameId(), playerSpectator);
-
-                replayModRender_hook.updateChunks();
-            } while (displayListEntitiesDirty);
-
-            displayListEntitiesDirty = true;
-
-            replayModRender_passThroughSetupTerrain = false;
-            ci.cancel();
-        }
-    }
-
-    @Inject(method = "updateChunks", at = @At("HEAD"), cancellable = true)
-    public void replayModRender_updateChunks(long finishTimeNano, CallbackInfo ci) {
-        if (replayModRender_hook != null) {
-            replayModRender_hook.updateChunks();
-            ci.cancel();
-        }
-    }
-}

src/main/java/com/replaymod/render/mixin/MixinRenderManager.java

@@ -8,7 +8,7 @@ import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 @Mixin(RenderManager.class)
 public abstract class MixinRenderManager {
@@ -19,7 +19,7 @@ public abstract class MixinRenderManager {
     private float playerViewY;
 
     @Inject(method = "doRenderEntity", at = @At("HEAD"))
-    private void replayModRender_reorientForCubicRendering(Entity entity, double dx, double dy, double dz, float iDoNotKnow, float partialTicks, boolean iDoNotCare, CallbackInfo ci) {
+    private void replayModRender_reorientForCubicRendering(Entity entity, double dx, double dy, double dz, float iDoNotKnow, float partialTicks, boolean iDoNotCare, CallbackInfoReturnable ci) {
         EntityRendererHandler handler = ((EntityRendererHandler.IEntityRenderer) Minecraft.getMinecraft().entityRenderer).replayModRender_getHandler();
         if (handler != null && handler.omnidirectional) {
             double pitch = -Math.atan2(dy, Math.sqrt(dx * dx + dz * dz));

src/main/java/com/replaymod/render/mixin/MixinRendererLivingEntity.java

@@ -0,0 +1,21 @@
+package com.replaymod.render.mixin;
+
+import com.replaymod.render.hooks.EntityRendererHandler;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.entity.EntityLivingBase;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(RendererLivingEntity.class)
+public abstract class MixinRendererLivingEntity {
+    @Inject(method = "canRenderName", at = @At("HEAD"), cancellable = true)
+    private void replayModRender_areAllNamesHidden(EntityLivingBase entity, CallbackInfoReturnable<Boolean> ci) {
+        EntityRendererHandler handler = ((EntityRendererHandler.IEntityRenderer) Minecraft.getMinecraft().entityRenderer).replayModRender_getHandler();
+        if (handler != null && !handler.getSettings().isRenderNameTags()) {
+            ci.setReturnValue(false); //this calls the cancel method
+        }
+    }
+}

src/main/java/com/replaymod/render/rendering/Pipelines.java

@@ -30,9 +30,9 @@ public class Pipelines {
         RenderSettings settings = renderInfo.getRenderSettings();
         FrameCapturer<OpenGlFrame> capturer;
         if (PixelBufferObject.SUPPORTED) {
-            capturer = new SimplePboOpenGlFrameCapturer(new EntityRendererHandler(settings), renderInfo);
+            capturer = new SimplePboOpenGlFrameCapturer(new EntityRendererHandler(settings, renderInfo), renderInfo);
         } else {
-            capturer = new SimpleOpenGlFrameCapturer(new EntityRendererHandler(settings), renderInfo);
+            capturer = new SimpleOpenGlFrameCapturer(new EntityRendererHandler(settings, renderInfo), renderInfo);
         }
         return new Pipeline<>(capturer, new OpenGlToRGBProcessor(), consumer);
     }
@@ -41,9 +41,9 @@ public class Pipelines {
         RenderSettings settings = renderInfo.getRenderSettings();
         FrameCapturer<StereoscopicOpenGlFrame> capturer;
         if (PixelBufferObject.SUPPORTED) {
-            capturer = new StereoscopicPboOpenGlFrameCapturer(new EntityRendererHandler(settings), renderInfo);
+            capturer = new StereoscopicPboOpenGlFrameCapturer(new EntityRendererHandler(settings, renderInfo), renderInfo);
         } else {
-            capturer = new StereoscopicOpenGlFrameCapturer(new EntityRendererHandler(settings), renderInfo);
+            capturer = new StereoscopicOpenGlFrameCapturer(new EntityRendererHandler(settings, renderInfo), renderInfo);
         }
         return new Pipeline<>(capturer, new StereoscopicToRGBProcessor(), consumer);
     }
@@ -52,9 +52,9 @@ public class Pipelines {
         RenderSettings settings = renderInfo.getRenderSettings();
         FrameCapturer<CubicOpenGlFrame> capturer;
         if (PixelBufferObject.SUPPORTED) {
-            capturer = new CubicPboOpenGlFrameCapturer(new EntityRendererHandler(settings), renderInfo, settings.getVideoWidth() / 4);
+            capturer = new CubicPboOpenGlFrameCapturer(new EntityRendererHandler(settings, renderInfo), renderInfo, settings.getVideoWidth() / 4);
         } else {
-            capturer = new CubicOpenGlFrameCapturer(new EntityRendererHandler(settings), renderInfo, settings.getVideoWidth() / 4);
+            capturer = new CubicOpenGlFrameCapturer(new EntityRendererHandler(settings, renderInfo), renderInfo, settings.getVideoWidth() / 4);
         }
         return new Pipeline<>(capturer, new CubicToRGBProcessor(), consumer);
     }
@@ -63,9 +63,9 @@ public class Pipelines {
         RenderSettings settings = renderInfo.getRenderSettings();
         FrameCapturer<CubicOpenGlFrame> capturer;
         if (PixelBufferObject.SUPPORTED) {
-            capturer = new CubicPboOpenGlFrameCapturer(new EntityRendererHandler(settings), renderInfo, settings.getVideoWidth() / 4);
+            capturer = new CubicPboOpenGlFrameCapturer(new EntityRendererHandler(settings, renderInfo), renderInfo, settings.getVideoWidth() / 4);
         } else {
-            capturer = new CubicOpenGlFrameCapturer(new EntityRendererHandler(settings), renderInfo, settings.getVideoWidth() / 4);
+            capturer = new CubicOpenGlFrameCapturer(new EntityRendererHandler(settings, renderInfo), renderInfo, settings.getVideoWidth() / 4);
         }
         return new Pipeline<>(capturer, new EquirectangularToRGBProcessor(settings.getVideoWidth() / 4), consumer);
     }
@@ -73,7 +73,7 @@ public class Pipelines {
     public static Pipeline<ODSOpenGlFrame, RGBFrame> newODSPipeline(RenderInfo renderInfo, FrameConsumer<RGBFrame> consumer) {
         RenderSettings settings = renderInfo.getRenderSettings();
         FrameCapturer<ODSOpenGlFrame> capturer =
-                new ODSFrameCapturer(new EntityRendererHandler(settings), renderInfo, settings.getVideoWidth() / 4);
+                new ODSFrameCapturer(new EntityRendererHandler(settings, renderInfo), renderInfo, settings.getVideoWidth() / 4);
         return new Pipeline<>(capturer, new ODSToRGBProcessor(settings.getVideoWidth() / 4), consumer);
     }
 }

src/main/java/com/replaymod/render/rendering/VideoRenderer.java

@@ -1,5 +1,6 @@
 package com.replaymod.render.rendering;
 
+import com.replaymod.core.ReplayMod;
 import com.replaymod.pathing.player.AbstractTimelinePlayer;
 import com.replaymod.pathing.player.ReplayTimer;
 import com.replaymod.pathing.properties.TimestampProperty;
@@ -11,22 +12,21 @@ import com.replaymod.render.events.ReplayRenderEvent;
 import com.replaymod.render.frame.RGBFrame;
 import com.replaymod.render.gui.GuiRenderingDone;
 import com.replaymod.render.gui.GuiVideoRenderer;
-import com.replaymod.render.hooks.ChunkLoadingRenderGlobal;
 import com.replaymod.render.metadata.MetadataInjector;
-import com.replaymod.render.utils.SoundHandler;
 import com.replaymod.replay.ReplayHandler;
 import com.replaymod.replaystudio.pathing.path.Keyframe;
 import com.replaymod.replaystudio.pathing.path.Path;
 import com.replaymod.replaystudio.pathing.path.Timeline;
+import cpw.mods.fml.common.FMLCommonHandler;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.audio.SoundCategory;
 import net.minecraft.client.gui.ScaledResolution;
 import net.minecraft.client.renderer.OpenGlHelper;
 import net.minecraft.client.shader.Framebuffer;
-import net.minecraft.util.SoundCategory;
 import net.minecraft.util.Timer;
-import net.minecraftforge.common.MinecraftForge;
 import org.lwjgl.input.Mouse;
 import org.lwjgl.opengl.Display;
+import org.lwjgl.opengl.GL11;
 import org.lwjgl.util.Dimension;
 import org.lwjgl.util.ReadableDimension;
 
@@ -39,9 +39,10 @@ import java.util.concurrent.Future;
 import java.util.concurrent.FutureTask;
 
 import static com.google.common.collect.Iterables.getLast;
-import static net.minecraft.client.renderer.GlStateManager.*;
+import static com.replaymod.render.ReplayModRender.LOGGER;
 import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
 import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
+import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
 
 public class VideoRenderer implements RenderInfo {
     private final Minecraft mc = Minecraft.getMinecraft();
@@ -54,11 +55,10 @@ public class VideoRenderer implements RenderInfo {
     private int fps;
     private boolean mouseWasGrabbed;
     private boolean debugInfoWasShown;
-    private Map<SoundCategory, Float> originalSoundLevels;
+    private Map originalSoundLevels;
 
     private TimelinePlayer timelinePlayer;
     private Future<Void> timelinePlayerFuture;
-    private ChunkLoadingRenderGlobal chunkLoadingRenderGlobal;
 
     private int framesDone;
     private int totalFrames;
@@ -66,6 +66,7 @@ public class VideoRenderer implements RenderInfo {
     private final GuiVideoRenderer gui;
     private boolean paused;
     private boolean cancelled;
+    private volatile Throwable failureCause;
 
     private Framebuffer guiFramebuffer;
     private int displayWidth, displayHeight;
@@ -76,7 +77,7 @@ public class VideoRenderer implements RenderInfo {
         this.timeline = timeline;
         this.gui = new GuiVideoRenderer(this);
         this.renderingPipeline = Pipelines.newPipeline(settings.getRenderMethod(), this,
-                videoWriter = new VideoWriter(settings) {
+                videoWriter = new VideoWriter(this) {
             @Override
             public void consume(RGBFrame frame) {
                 gui.updatePreview(frame);
@@ -89,8 +90,8 @@ public class VideoRenderer implements RenderInfo {
      * Render this video.
      * @return {@code true} if rendering was successful, {@code false} if the user aborted rendering (or the window was closed)
      */
-    public boolean renderVideo() {
-        MinecraftForge.EVENT_BUS.post(new ReplayRenderEvent.Pre(this));
+    public boolean renderVideo() throws Throwable {
+        FMLCommonHandler.instance().bus().post(new ReplayRenderEvent.Pre(this));
 
         setup();
 
@@ -136,7 +137,11 @@ public class VideoRenderer implements RenderInfo {
 
         finish();
 
-        MinecraftForge.EVENT_BUS.post(new ReplayRenderEvent.Post(this));
+        FMLCommonHandler.instance().bus().post(new ReplayRenderEvent.Post(this));
+
+        if (failureCause != null) {
+            throw failureCause;
+        }
 
         return !cancelled;
     }
@@ -196,9 +201,9 @@ public class VideoRenderer implements RenderInfo {
         for (SoundCategory category : SoundCategory.values()) {
             mutedSounds.put(category, 0f);
         }
-        originalSoundLevels = mc.gameSettings.soundLevels;
-        mutedSounds.put(SoundCategory.MASTER, originalSoundLevels.get(SoundCategory.MASTER));
-        mc.gameSettings.soundLevels = mutedSounds;
+        originalSoundLevels = mc.gameSettings.mapSoundLevels;
+        mutedSounds.put(SoundCategory.MASTER, (Float) originalSoundLevels.get(SoundCategory.MASTER));
+        mc.gameSettings.mapSoundLevels = mutedSounds;
 
         fps = settings.getFramesPerSecond();
 
@@ -219,7 +224,8 @@ public class VideoRenderer implements RenderInfo {
 
         updateDisplaySize();
 
-        chunkLoadingRenderGlobal = new ChunkLoadingRenderGlobal(mc.renderGlobal);
+        ScaledResolution scaled = new ScaledResolution(mc, displayWidth, displayHeight);
+        gui.toMinecraft().setWorldAndResolution(mc, scaled.getScaledWidth(), scaled.getScaledHeight());
 
         // Set up our own framebuffer to render the GUI to
         guiFramebuffer = new Framebuffer(displayWidth, displayHeight, true);
@@ -239,16 +245,19 @@ public class VideoRenderer implements RenderInfo {
         if (mouseWasGrabbed) {
             mc.mouseHelper.grabMouseCursor();
         }
-        mc.gameSettings.soundLevels = originalSoundLevels;
+        mc.gameSettings.mapSoundLevels = originalSoundLevels;
         mc.displayGuiScreen(null);
-        if (chunkLoadingRenderGlobal != null) {
-            chunkLoadingRenderGlobal.uninstall();
+
+        ReplayMod.soundHandler.playRenderSuccessSound();
+
+        try {
+            if (!hasFailed()) {
+                new GuiRenderingDone(ReplayModRender.instance, videoWriter.getVideoFile(), totalFrames, settings).display();
+            }
+        } catch (VideoWriter.FFmpegStartupException e) {
+            setFailure(e);
         }
 
-        new SoundHandler().playRenderSuccessSound();
-
-        new GuiRenderingDone(ReplayModRender.instance, videoWriter.getVideoFile(), totalFrames, settings).display();
-
         // Finally, resize the Minecraft framebuffer to the actual width/height of the window
         mc.resize(displayWidth, displayHeight);
     }
@@ -261,11 +270,7 @@ public class VideoRenderer implements RenderInfo {
         }
 
         mc.currentScreen = gui.toMinecraft();
-        try {
-            mc.runTick();
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
+        mc.runTick();
     }
 
     public void drawGui() {
@@ -276,23 +281,17 @@ public class VideoRenderer implements RenderInfo {
                 guiFramebuffer.createBindFramebuffer(mc.displayWidth, mc.displayHeight);
             }
 
-            pushMatrix();
-            clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-            enableTexture2D();
+            GL11.glPushMatrix();
+            GL11.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+            GL11.glEnable(GL_TEXTURE_2D);
             guiFramebuffer.bindFramebuffer(true);
 
             mc.entityRenderer.setupOverlayRendering();
 
-            ScaledResolution scaled = new ScaledResolution(mc);
+            ScaledResolution scaled = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
             gui.toMinecraft().setWorldAndResolution(mc, scaled.getScaledWidth(), scaled.getScaledHeight());
 
-            try {
-                gui.toMinecraft().handleInput();
-            } catch (IOException e) {
-                // That's a strange exception from this kind of method O_o
-                // It isn't actually thrown here, so we'll deal with it the easy way
-                throw new RuntimeException(e);
-            }
+            gui.toMinecraft().handleInput();
 
             int mouseX = Mouse.getX() * scaled.getScaledWidth() / mc.displayWidth;
             int mouseY = scaled.getScaledHeight() - Mouse.getY() * scaled.getScaledHeight() / mc.displayHeight - 1;
@@ -300,17 +299,17 @@ public class VideoRenderer implements RenderInfo {
             gui.toMinecraft().drawScreen(mouseX, mouseY, 0);
 
             guiFramebuffer.unbindFramebuffer();
-            popMatrix();
-            pushMatrix();
+            GL11.glPopMatrix();
+            GL11.glPushMatrix();
             guiFramebuffer.framebufferRender(displayWidth, displayHeight);
-            popMatrix();
+            GL11.glPopMatrix();
 
             // if not in high performance mode, update the gui size if screen size changed
             // otherwise just swap the progress gui to screen
             if (settings.isHighPerformance()) {
                 Display.update();
             } else {
-                mc.updateDisplay();
+                mc.resetSize();
             }
             if (Mouse.isGrabbed()) {
                 Mouse.setGrabbed(false);
@@ -323,7 +322,7 @@ public class VideoRenderer implements RenderInfo {
                     return;
                 }
             }
-        } while (paused);
+        } while (paused && !hasFailed());
     }
 
     private boolean displaySizeChanged() {
@@ -364,6 +363,20 @@ public class VideoRenderer implements RenderInfo {
         renderingPipeline.cancel();
     }
 
+    public boolean hasFailed() {
+        return failureCause != null;
+    }
+
+    public synchronized void setFailure(Throwable cause) {
+        if (this.failureCause != null) {
+            LOGGER.error("Further failure during failed rendering: ", cause);
+        } else {
+            LOGGER.error("Failure during rendering: ", cause);
+            this.failureCause = cause;
+            cancel();
+        }
+    }
+
     private class TimelinePlayer extends AbstractTimelinePlayer {
         public TimelinePlayer(ReplayHandler replayHandler) {
             super(replayHandler);