Merge branch 1.8 into 1.8.9

41d2547 Update translations
00e999f Fix replay not being closed when opened via URI scheme handler (fixes #92)
767ea29 Fix book gui not being suppressed during replay (fixes #90)
5b04edb Hide ReplayMod app entry from menus on Linux
6aff99d Fix livelock during netty write to embedded channel (fixes #85)
703805f Fix infinite loop in mc.scheduledTasks (fixes #86)
7a4440c Update ReplayStudio
0b9c56c Fix resource packs not working after first time jumping back in time
933ee5f [Compat] Fix camera entity with BetterSprinting prior to 2.0.0 (fixes #78)
83b1090 Fix hotbar being visible while spectating player (fixes #83)
5c73117 [Compat] Fix invisible entities with Orange's 1.7 Animations (fixes #78)
4704b29 Replace the RenderPlayer hook (used subclassing) with a mixin (fixes #79)
0c226b0 Fix path at end of replay resulting in constant reloading (fixes #56)
1b9b13e Rename render success sound to all lowercase (required for 1.11) (fixes #66)
c2000b3 Fix only front-facing chunks visible for ODS rendering (fixes #67)
aafeecc Fix initial login gui not closing on success (fixes #68)
9292add Use percent-encoding for replay file names (fixes #71)
8499c0f Fix name of invis armor stand with CustomNameVisible not rendering (fixes #72)
b9ea572 Try to handle invalid ffmpeg arguments more gracefully (fixes #77)
a2f8c88 Fix compression packets being recorded (fixes #80)
19629c3 Replace usages of System.out with logger
fe1d9b8 Stop Forge from allowing the mod to load on other MC versions (fixes #82)
1a1e96c Fix server with RM installed refusing clients without RM (fixes #76)
35eb9ca Replace usage of FMLLog with the mod logger

.drone.yml

@@ -7,7 +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
-      - JAVA_OPTS=-Xmx1516M ./gradlew setupDecompWorkspace
+      - ./gradlew setupCIWorkspace
       - ./gradlew :build
   archive:
     image: plugins/s3

.drone.yml.sig

@@ -1 +1 @@
-eyJhbGciOiJIUzI1NiJ9.cGlwZWxpbmU6CiAgY2xvbmU6CiAgICBpbWFnZTogcGx1Z2lucy9naXQKICAgIHRhZ3M6IHRydWUKICBidWlsZDoKICAgIGltYWdlOiBtYXZlbjozLjMuOS1qZGstOAogICAgY29tbWFuZHM6CiAgICAgIC0gY3VybCAtLWZhaWwgLS1jcmVhdGUtZGlycyAtbyAkSE9NRS8uZ3JhZGxlL2luaXQuZC9taXJyb3IuZ3JhZGxlIGh0dHBzOi8vbWF2ZW4uam9obmkwNzAyLmRlL2NvbmZpZy9ncmFkbGUKICAgICAgLSBjdXJsIC0tZmFpbCAtLWNyZWF0ZS1kaXJzIC1vICRIT01FLy5tMi9zZXR0aW5ncy54bWwgaHR0cHM6Ly9tYXZlbi5qb2huaTA3MDIuZGUvY29uZmlnL21hdmVuCiAgICAgIC0gSkFWQV9PUFRTPS1YbXgxNTE2TSAuL2dyYWRsZXcgc2V0dXBEZWNvbXBXb3Jrc3BhY2UKICAgICAgLSAuL2dyYWRsZXcgOmJ1aWxkCiAgYXJjaGl2ZToKICAgIGltYWdlOiBwbHVnaW5zL3MzCiAgICBhY2w6IHB1YmxpYy1yZWFkCiAgICByZWdpb246ICJ1cy1lYXN0LTEiCiAgICBidWNrZXQ6ICJyZXBsYXltb2QiCiAgICBwYXRoX3N0eWxlOiB0cnVlCiAgICBzb3VyY2U6IGJ1aWxkL2xpYnMvKgogICAgc3RyaXBfcHJlZml4OiBidWlsZC9saWJzLwogICAgdGFyZ2V0OiAvCg.nzPW0_TpMIjnFZZ5Ci439QDKlaDo1a3DCH-VCYUgpx8
+eyJhbGciOiJIUzI1NiJ9.cGlwZWxpbmU6CiAgY2xvbmU6CiAgICBpbWFnZTogcGx1Z2lucy9naXQKICAgIHRhZ3M6IHRydWUKICBidWlsZDoKICAgIGltYWdlOiBtYXZlbjozLjMuOS1qZGstOAogICAgY29tbWFuZHM6CiAgICAgIC0gY3VybCAtLWZhaWwgLS1jcmVhdGUtZGlycyAtbyAkSE9NRS8uZ3JhZGxlL2luaXQuZC9taXJyb3IuZ3JhZGxlIGh0dHBzOi8vbWF2ZW4uam9obmkwNzAyLmRlL2NvbmZpZy9ncmFkbGUKICAgICAgLSBjdXJsIC0tZmFpbCAtLWNyZWF0ZS1kaXJzIC1vICRIT01FLy5tMi9zZXR0aW5ncy54bWwgaHR0cHM6Ly9tYXZlbi5qb2huaTA3MDIuZGUvY29uZmlnL21hdmVuCiAgICAgIC0gLi9ncmFkbGV3IHNldHVwQ0lXb3Jrc3BhY2UKICAgICAgLSAuL2dyYWRsZXcgOmJ1aWxkCiAgYXJjaGl2ZToKICAgIGltYWdlOiBwbHVnaW5zL3MzCiAgICBhY2w6IHB1YmxpYy1yZWFkCiAgICByZWdpb246ICJ1cy1lYXN0LTEiCiAgICBidWNrZXQ6ICJyZXBsYXltb2QiCiAgICBwYXRoX3N0eWxlOiB0cnVlCiAgICBzb3VyY2U6IGJ1aWxkL2xpYnMvKgogICAgc3RyaXBfcHJlZml4OiBidWlsZC9saWJzLwogICAgdGFyZ2V0OiAvCg.riE6lhwfdNUhI7LO2SxEKFOjzjaX40ne7Ae9gyP75KE

.gitmodules

@@ -5,3 +5,7 @@
 [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

@@ -1,7 +1,5 @@
 import groovy.json.JsonOutput
 
-import java.util.zip.ZipInputStream
-
 buildscript {
     repositories {
         mavenCentral()
@@ -19,8 +17,8 @@ buildscript {
         }
     }
     dependencies {
-        classpath 'net.minecraftforge.gradle:ForgeGradle:2.2-SNAPSHOT'
+        classpath 'net.minecraftforge.gradle:ForgeGradle:2.1-SNAPSHOT'
-        classpath 'org.spongepowered:mixingradle:0.4-SNAPSHOT'
+        classpath 'org.spongepowered:mixingradle:0.3-SNAPSHOT'
     }
 }
 
@@ -36,11 +34,13 @@ archivesBaseName = "replaymod"
 
 minecraft {
     coreMod = 'com.replaymod.core.LoadingPlugin'
-    version = '1.11.2-13.20.0.2216'
+    version = '1.8.9-11.15.1.1722'
     runDir = "eclipse"
-    mappings = "snapshot_20161220"
+    mappings = "stable_22"
     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 {
@@ -61,7 +61,7 @@ configurations {
 dependencies {
     compile 'org.projectlombok:lombok:1.16.4'
 
-    compile 'org.spongepowered:mixin:0.6.4-SNAPSHOT'
+    compile 'org.spongepowered:mixin:0.6.8-SNAPSHOT'
     shade 'com.googlecode.mp4parser:isoparser:1.1.7'
     shade 'org.apache.commons:commons-exec:1.3'
     shade 'com.google.apis:google-api-services-youtube:v3-rev178-1.22.0'
@@ -103,27 +103,6 @@ jar {
     }
     from noticeDir
 
-    def langDir = file("$buildDir/languages")
-    doFirst {
-	try {
-        langDir.deleteDir()
-        langDir.mkdirs()
-        def dir = new File(langDir, 'assets/replaymod/lang/')
-        dir.mkdirs()
-        def zip = new ZipInputStream(new URL('http://replaymod.com/api/grab_languages').openStream())
-        def e;
-        while ((e = zip.nextEntry) != null) {
-            new File(dir, e.getName()) << zip
-            zip.closeEntry()
-        }
-	} catch(Exception e) {
-	    e.printStackTrace();
-	}
-    }
-    from (langDir) {
-        exclude '**/en_US.lang'
-    }
-
     from ({shade().collect { it.isDirectory() ? it : zipTree(it) }}) {
         exclude '**/NOTICE*'
         // exclude everything taken in from jGui for running the mod in a dev environment
@@ -138,7 +117,6 @@ jar {
     manifest {
          attributes 'TweakClass': 'org.spongepowered.asm.launch.MixinTweaker',
                  'TweakOrder': '0',
-                 'FMLCorePluginContainsFMLMod': 'true',
                  'FMLAT': 'replaymod_at.cfg'
 	}
 }
@@ -189,6 +167,13 @@ sourceSets {
         }
         refMap = "mixins.replaymod.refmap.json"
     }
+    integrationTest {
+        compileClasspath += main.runtimeClasspath + main.output
+        java {
+            srcDir file('src/integration-test/java')
+        }
+        resources.srcDir file('src/integration-test/resources')
+    }
 }
 
 task copySrg(type: Copy, dependsOn: 'genSrgs') {
@@ -200,6 +185,30 @@ setupDecompWorkspace.dependsOn copySrg
 setupDevWorkspace.dependsOn copySrg
 project.tasks.idea.dependsOn copySrg
 
+task runIntegrationTest(type: JavaExec, dependsOn: ["makeStart", "jar"]) {
+    main = 'GradleStart'
+    standardOutput = System.out
+    errorOutput = System.err
+    workingDir file(minecraft.runDir)
+
+    def testDir = new File(minecraft.runDir, "integration-test")
+    doFirst {
+        testDir.deleteDir()
+        testDir.mkdirs()
+    }
+
+    doLast {
+        testDir.deleteDir()
+    }
+
+    afterEvaluate {
+        def runClient = tasks.getByName("runClient")
+        runIntegrationTest.jvmArgs = runClient.jvmArgs + "-Dfml.noGrab=true"
+        runIntegrationTest.args = runClient.args + "--gameDir" + testDir.canonicalPath
+        runIntegrationTest.classpath runClient.classpath + sourceSets.integrationTest.output
+    }
+}
+
 def generateVersionsJson() {
     // List all tags
     def stdout = new ByteArrayOutputStream()

docs/content.md

@@ -56,7 +56,7 @@ Please use [Optifine](https://optifine.net/) instead.
 
 ### Custom Main Menu [custom-main-menu]
 The [Custom Main Menu](https://mods.curse.com/mc-mods/minecraft/226406-custom-main-menu) mod is often used in mod packs to customize their Main Menu with a button layout fitting the background image, links to their website / bug tracker and similar.
-If you are familiar with it, the button ids for the Replay Mod are: **17890234** (text: `replaymod.gui.replayviewer`), **17890235** (text: `replaymod.gui.replayviewer`) and **17890236** (text: `replaymod.gui.replaycenter`)
+If you are familiar with it, the button ids for the Replay Mod are: **17890234** (text: `replaymod.gui.replayviewer`), **17890237** (text: `replaymod.gui.replayeditor`) and **17890236** (text: `replaymod.gui.replaycenter`)
 
 Due to the nature of this Custom Main Menu mod, buttons added to the Main Menu by 3rd party mods like the **Replay Mod** will not show up by default.  
 Thus, to access the Replay Viewer/Editor/Center, you need to manually configure the position for those buttons.  

src/integration-test/java/IntegrationTest.java

@@ -0,0 +1,30 @@
+import org.apache.commons.io.FileUtils;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Entry point for running integration tests from within the IDE.
+ * This is <b>not</b> called when running integration tests directly from gradle.
+ */
+public class IntegrationTest {
+    public static void main(String[] args) throws Throwable {
+        // Prevent MC from grabbing our mouse during the test (it's not needed)
+        System.setProperty("fml.noGrab", "true");
+
+        // Make sure the test folder exists and is fresh
+        File gameDir = new File(System.getProperty("user.dir"), "integration-test");
+        if (gameDir.exists()) {
+            FileUtils.forceDelete(gameDir);
+        }
+        FileUtils.forceMkdir(gameDir);
+
+        // Set game dir to test folder and call regular entry point
+        List<String> argsList = new ArrayList<>(Arrays.asList(args));
+        argsList.add("--gameDir");
+        argsList.add(gameDir.getCanonicalPath());
+        GradleStart.main(argsList.toArray(new String[argsList.size()]));
+    }
+}

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

@@ -0,0 +1,342 @@
+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 de.johni0702.minecraft.gui.container.AbstractGuiOverlay;
+import de.johni0702.minecraft.gui.container.AbstractGuiScreen;
+import de.johni0702.minecraft.gui.container.GuiContainer;
+import de.johni0702.minecraft.gui.container.GuiOverlay;
+import de.johni0702.minecraft.gui.container.GuiScreen;
+import de.johni0702.minecraft.gui.element.GuiButton;
+import de.johni0702.minecraft.gui.element.GuiElement;
+import de.johni0702.minecraft.gui.element.GuiTexturedButton;
+import de.johni0702.minecraft.gui.popup.AbstractGuiPopup;
+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;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.concurrent.TimeoutException;
+
+import static com.replaymod.core.ReplayModIntegrationTest.LOGGER;
+import static com.replaymod.core.utils.Utils.addCallback;
+
+public abstract class AbstractTask implements Task {
+    public static Task create(Consumer<AbstractTask> init) {
+        return new AbstractTask() {
+            @Override
+            protected void init() {
+                init.consume(this);
+            }
+        };
+    }
+
+    public static final Minecraft mc = Minecraft.getMinecraft();
+    public final ReplayMod core = ReplayMod.instance;
+    public SettableFuture<Void> future;
+
+    @Override
+    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 -> {});
+
+        init();
+
+        return future;
+    }
+
+    protected void init() {}
+
+    protected void runLater(Runnable runnable) {
+        core.runLater(() -> {
+            try {
+                runnable.run();
+            } catch (Throwable t) {
+                future.setException(t);
+            }
+        });
+    }
+
+    public void expectGuiClosed(Runnable onClosed) {
+        expectGuiClosed0(10, onClosed);
+    }
+
+    public void expectGuiClosed(int timeout, Runnable onClosed) {
+        expectGuiClosed0(timeout, onClosed);
+    }
+
+    private void expectGuiClosed0(int timeout, Runnable onClosed) {
+        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
+        class EventHandler {
+            final net.minecraft.client.gui.GuiScreen currentScreen = mc.currentScreen;
+            int framesPassed;
+
+            @SubscribeEvent
+            public void onGuiOpen(TickEvent.RenderTickEvent event) {
+                if (event.phase != TickEvent.Phase.START) return;
+                if (currentScreen != mc.currentScreen) {
+                    FMLCommonHandler.instance().bus().unregister(this);
+                    onClosed.run();
+                } else {
+                    if (framesPassed < timeout) {
+                        framesPassed++;
+                    } else {
+                        Object gui = (gui = GuiScreen.from(currentScreen)) == null ? currentScreen : gui;
+                        Exception e = new TimeoutException("Timeout while waiting for " + gui + " to be closed.");
+                        e.setStackTrace(Arrays.copyOfRange(stackTrace, 3, stackTrace.length));
+                        future.setException(e);
+                    }
+                }
+            }
+        }
+        FMLCommonHandler.instance().bus().register(new EventHandler());
+    }
+
+    public void expectPopupClosed(Runnable onClosed) {
+        expectPopupClosed0(10, onClosed);
+    }
+
+    public void expectPopupClosed(int timeout, Runnable onClosed) {
+        expectPopupClosed0(timeout, onClosed);
+    }
+
+    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 {
+            int framesPassed;
+
+            @SubscribeEvent
+            public void onGuiOpen(TickEvent.RenderTickEvent event) {
+                if (event.phase != TickEvent.Phase.START) return;
+                if (getPopup(mc.currentScreen) != popup) {
+                    FMLCommonHandler.instance().bus().unregister(this);
+                    onClosed.run();
+                } else {
+                    if (framesPassed < timeout) {
+                        framesPassed++;
+                    } else {
+                        Exception e = new TimeoutException("Timeout while waiting for " + popup + " to be closed.");
+                        e.setStackTrace(Arrays.copyOfRange(stackTrace, 3, stackTrace.length));
+                        future.setException(e);
+                    }
+                }
+            }
+        }
+        FMLCommonHandler.instance().bus().register(new EventHandler());
+    }
+
+    private AbstractGuiPopup getPopup(net.minecraft.client.gui.GuiScreen minecraft) {
+        GuiContainer<?> container = GuiOverlay.from(minecraft);
+        if (container == null) {
+            container = GuiScreen.from(minecraft);
+        }
+        if (container != null) {
+            while (container.getContainer() != null) {
+                container = container.getContainer();
+            }
+            GuiElement popup = Iterables.getLast(container.getChildren());
+            if (popup instanceof AbstractGuiPopup) {
+                return (AbstractGuiPopup) popup;
+            }
+        }
+        return null;
+    }
+
+    public <T> void expectGui(Class<T> guiClass, Consumer<T> onOpen) {
+        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
+        class EventHandler {
+            net.minecraft.client.gui.GuiScreen currentScreen;
+            int framesPassed;
+
+            @SubscribeEvent
+            public void onGuiOpen(TickEvent.RenderTickEvent event) {
+                if (event.phase != TickEvent.Phase.START) return;
+                if (currentScreen != mc.currentScreen) {
+                    currentScreen = mc.currentScreen;
+                    framesPassed = 0;
+                }
+                if (framesPassed < 10) {
+                    framesPassed++;
+                    return;
+                }
+
+                FMLCommonHandler.instance().bus().unregister(this);
+
+                Object foundGui = null;
+                if (AbstractGuiScreen.class.isAssignableFrom(guiClass)) {
+                    AbstractGuiScreen guiScreen = GuiScreen.from(currentScreen);
+                    if (guiClass.isInstance(guiScreen)) {
+                        onOpen.consume(guiClass.cast(guiScreen));
+                        return;
+                    }
+                    foundGui = guiScreen;
+                } else if (AbstractGuiOverlay.class.isAssignableFrom(guiClass)) {
+                    AbstractGuiOverlay guiScreen = GuiOverlay.from(currentScreen);
+                    if (guiClass.isInstance(guiScreen)) {
+                        onOpen.consume(guiClass.cast(guiScreen));
+                        return;
+                    }
+                    foundGui = guiScreen;
+                } else if (AbstractGuiPopup.class.isAssignableFrom(guiClass)) {
+                    AbstractGuiPopup popup = getPopup(currentScreen);
+                    if (guiClass.isInstance(popup)) {
+                        onOpen.consume(guiClass.cast(popup));
+                        return;
+                    }
+                } else {
+                    if (guiClass.isInstance(currentScreen)) {
+                        onOpen.consume(guiClass.cast(currentScreen));
+                        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));
+            }
+        }
+        FMLCommonHandler.instance().bus().register(new EventHandler());
+    }
+
+    private void clickNow(int x, int y) {
+        try {
+            Method method = net.minecraft.client.gui.GuiScreen.class
+                    .getDeclaredMethod("mouseClicked", int.class, int.class, int.class);
+            method.setAccessible(true);
+            method.invoke(mc.currentScreen, x, y, 0);
+        } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+            future.setException(e);
+        }
+    }
+
+    public void click(int x, int y) {
+        runLater(() -> {
+            LOGGER.info("Clicking at {}/{}", x, y);
+            clickNow(x, y);
+        });
+    }
+
+    private void dragNow(int x, int y) {
+        try {
+            Method method = net.minecraft.client.gui.GuiScreen.class
+                    .getDeclaredMethod("mouseClickMove", int.class, int.class, int.class, long.class);
+            method.setAccessible(true);
+            method.invoke(mc.currentScreen, x, y, 0, 0);
+        } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+            future.setException(e);
+        }
+    }
+
+    public void drag(int x, int y) {
+        runLater(() -> {
+            LOGGER.info("Dragging to {}/{}", x, y);
+            dragNow(x, y);
+        });
+    }
+
+    public void click(GuiButton button) {
+        runLater(() -> {
+            if (!button.isEnabled()) {
+                future.setException(new IllegalStateException("Button is disabled: " + button.getLabel()));
+                return;
+            }
+            LOGGER.info("Clicking button {}", button.getLabel());
+            button.onClick();
+        });
+    }
+
+    public void click(GuiTexturedButton button) {
+        runLater(() -> {
+            if (!button.isEnabled()) {
+                future.setException(new IllegalStateException("Button is disabled: " + button.getTexture()));
+                return;
+            }
+            LOGGER.info("Clicking textured button {}", button.getTexture());
+            button.onClick();
+        });
+    }
+
+    public void click(String buttonText) {
+        runLater(() -> {
+            LOGGER.info("Clicking button {}", buttonText);
+            try {
+                Field field = net.minecraft.client.gui.GuiScreen.class.getDeclaredField("buttonList");
+                field.setAccessible(true);
+                @SuppressWarnings("unchecked")
+                List<net.minecraft.client.gui.GuiButton> buttonList = (List)
+                        field.get(mc.currentScreen);
+
+                net.minecraft.client.gui.GuiButton button = null;
+                for (net.minecraft.client.gui.GuiButton guiButton : buttonList) {
+                    if (guiButton.displayString.equals(buttonText)) {
+                        button = guiButton;
+                    }
+                }
+                if (button == null) {
+                    future.setException(new NoSuchElementException("No button with label: " + buttonText));
+                    return;
+                }
+
+                clickNow(button.xPosition + 5, button.yPosition + 5);
+            } catch (IllegalAccessException | NoSuchFieldException e) {
+                future.setException(e);
+            }
+        });
+    }
+
+    public void type(String string) {
+        for (char c : string.toCharArray()) {
+            press(c, Keyboard.getKeyIndex(String.valueOf(c).toUpperCase()));
+        }
+    }
+
+    public void press(int keyCode) {
+        String keyName = Keyboard.getKeyName(keyCode);
+        char character = keyName.length() == 1 ? keyName.charAt(0) : '\0';
+        press(character, keyCode);
+    }
+
+    public void press(char character, int keyCode) {
+        runLater(() -> {
+            LOGGER.info("Pressing key {}", Keyboard.getKeyName(keyCode));
+            if (mc.currentScreen == null || mc.currentScreen.allowUserInput) {
+                KeyBinding.onTick(keyCode);
+                FMLCommonHandler.instance().fireKeyInput();
+            }
+            if (mc.currentScreen != null) {
+                try {
+                    Method method = net.minecraft.client.gui.GuiScreen.class
+                            .getDeclaredMethod("keyTyped", char.class, int.class);
+                    method.setAccessible(true);
+                    method.invoke(mc.currentScreen, character, keyCode);
+                } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+                    future.setException(e);
+                }
+            }
+        });
+    }
+}

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

@@ -0,0 +1,41 @@
+package com.replaymod.core;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+
+import static com.replaymod.core.ReplayModIntegrationTest.LOGGER;
+import static com.replaymod.core.utils.Utils.addCallback;
+
+public class CompositeTask implements Task {
+    private SettableFuture<Void> future;
+    protected final Task[] children;
+
+    public CompositeTask(Task[] children) {
+        this.children = children;
+    }
+
+    @Override
+    public ListenableFuture<Void> execute() {
+        future = SettableFuture.create();
+        executeChild(0);
+        return future;
+    }
+
+    private void executeChild(int childIndex) {
+        if (future.isDone()) return;
+        if (childIndex < children.length) {
+            ReplayMod.instance.runLater(() -> {
+                try {
+                    Task task = children[childIndex];
+                    LOGGER.info("Running task {}", task);
+                    ListenableFuture<Void> childFuture = task.execute();
+                    addCallback(childFuture, done -> executeChild(childIndex + 1), err -> future.setException(err));
+                } catch (Throwable t) {
+                    future.setException(t);
+                }
+            });
+        } else {
+            future.set(null);
+        }
+    }
+}

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

@@ -0,0 +1,73 @@
+package com.replaymod.core;
+
+import com.replaymod.core.regression.RegressionTest60;
+import com.replaymod.core.regression.RegressionTest61;
+import com.replaymod.core.regression.RegressionTest62;
+import com.replaymod.extra.DownloadOpenEye;
+import com.replaymod.online.SkipLogin;
+import com.replaymod.recording.CreateSPWorld;
+import com.replaymod.recording.ExitSPWorld;
+import com.replaymod.replay.ExitReplay;
+import com.replaymod.replay.LoadReplay;
+import com.replaymod.replay.OpenReplayViewer;
+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;
+import static com.replaymod.core.ReplayModIntegrationTest.MOD_ID;
+import static com.replaymod.core.utils.Utils.addCallback;
+
+/**
+ * Helper mod that initiates the integration tests.
+ */
+@Mod(modid = MOD_ID)
+public class ReplayModIntegrationTest {
+    public static final String MOD_ID = "replaymod-integration-test";
+
+    public static Logger LOGGER;
+
+    @Mod.EventHandler
+    public void init(FMLPreInitializationEvent event) {
+        LOGGER = event.getModLog();
+
+        // Make sure the game window doesn't have to remain in focus during the test
+        mc.gameSettings.pauseOnLostFocus = false;
+
+        runTasks(
+                new SkipLogin(),
+                new DownloadOpenEye(),
+                new CreateSPWorld(),
+                new Wait(5000),
+                new ExitSPWorld(),
+                new OpenReplayViewer(),
+                new LoadReplay(),
+
+                new RegressionTest60(),
+                new RegressionTest61(),
+                new RegressionTest62(),
+
+                // new AbstractTask() {}, // Uncomment to not exit on success (useful for writing more tests)
+                new ExitReplay()
+        );
+    }
+
+    private void runTasks(Task... tests) {
+        addCallback(new CompositeTask(tests).execute(), success -> {
+            if (!Minecraft.getMinecraft().hasCrashed) {
+                LOGGER.info("===================================================");
+                LOGGER.info("=                 ALL TESTS PASSED                =");
+                LOGGER.info("===================================================");
+                FMLCommonHandler.instance().exitJava(0, false);
+            }
+        }, error -> {
+            LOGGER.error("Failed task:", error);
+            LOGGER.error("===================================================");
+            LOGGER.error("=                  TEST FAILED                    =");
+            LOGGER.error("===================================================");
+            FMLCommonHandler.instance().exitJava(1, false);
+        });
+    }
+}

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

@@ -0,0 +1,35 @@
+package com.replaymod.core;
+
+import com.google.common.util.concurrent.ListenableFuture;
+
+public interface Task {
+    ListenableFuture<Void> execute();
+
+    static Task click(int x, int y) {
+        return AbstractTask.create(task -> {
+            task.click(x, y);
+            task.runLater(() -> task.future.set(null));
+        });
+    }
+
+    static Task drag(int x, int y) {
+        return AbstractTask.create(task -> {
+            task.drag(x, y);
+            task.runLater(() -> task.future.set(null));
+        });
+    }
+
+    static Task pressKey(int keyCode) {
+        return AbstractTask.create(task -> {
+            task.press(keyCode);
+            task.runLater(() -> task.future.set(null));
+        });
+    }
+
+    static Task pressKey(char character, int keyCode) {
+        return AbstractTask.create(task -> {
+            task.press(character, keyCode);
+            task.runLater(() -> task.future.set(null));
+        });
+    }
+}

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

@@ -0,0 +1,9 @@
+package com.replaymod.core;
+
+public class Utils {
+    public static void times(int x, Runnable runnable) {
+        for (int i = 0; i < x; i++) {
+            runnable.run();
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+package com.replaymod.core;
+
+public class Wait extends AbstractTask {
+    private final int duration;
+
+    public Wait(int duration) {
+        this.duration = duration;
+    }
+
+    @Override
+    protected void init() {
+        new Thread(() -> {
+            try {
+                Thread.sleep(duration);
+                runLater(() -> future.set(null));
+            } catch (InterruptedException e) {
+                runLater(() -> future.setException(e));
+            }
+        }).start();
+    }
+}

src/integration-test/java/com/replaymod/core/regression/RegressionTest60.java

@@ -0,0 +1,59 @@
+package com.replaymod.core.regression;
+
+import com.replaymod.core.AbstractTask;
+import com.replaymod.core.CompositeTask;
+import com.replaymod.core.Task;
+import com.replaymod.replay.SpectatePlayer;
+import com.replaymod.replay.overlay.OverlayGui;
+import com.replaymod.simplepathing.GuiPathingTasks;
+import com.replaymod.simplepathing.gui.GuiEditKeyframe;
+import org.lwjgl.input.Keyboard;
+
+import static com.replaymod.core.AbstractTask.mc;
+import static com.replaymod.core.Utils.times;
+
+/**
+ * Regression test: #60 Crash in path preview when two spectator keyframes are closer than 50ms
+ */
+public class RegressionTest60 extends CompositeTask {
+    public RegressionTest60() {
+        super(new Task[]{
+                new SpectatePlayer(),
+                OverlayGui.whileOpened(
+                        // Place first spectator keyframe
+                        new GuiPathingTasks.ClickPositionKeyframeButton(),
+                        // Place second spectator keyframe
+                        Task.click(130, 50),
+                        new GuiPathingTasks.ClickPositionKeyframeButton(),
+                        // Move second keyframe to 20ms on the keyframe timeline
+                        AbstractTask.create(task -> {
+                            // Double click keyframe
+                            task.click(130, 50);
+                            task.click(130, 50);
+                            task.expectGui(GuiEditKeyframe.Spectator.class, gui -> {
+                                // Set ms field to 20
+                                task.click(mc.currentScreen.width / 2 + 80, mc.currentScreen.height / 2);
+                                times(4, () -> task.press(Keyboard.KEY_BACK));
+                                task.type("20");
+                                // Set other fields to 0
+                                times(2, () -> {
+                                    task.press(Keyboard.KEY_TAB);
+                                    times(4, () -> task.press(Keyboard.KEY_BACK));
+                                    task.press(Keyboard.KEY_0);
+                                });
+                                task.click(gui.saveButton);
+                                task.expectPopupClosed(() -> task.future.set(null));
+                            });
+                        }),
+                        // Place second spectator keyframe
+                        new GuiPathingTasks.ClickPositionKeyframeButton()
+                ),
+                // Stop spectating player
+                new SpectatePlayer.End(),
+                // Enable path preview
+                Task.pressKey(Keyboard.KEY_H),
+                new GuiPathingTasks.ClearKeyframeTimeline(),
+                Task.pressKey(Keyboard.KEY_H),
+        });
+    }
+}

src/integration-test/java/com/replaymod/core/regression/RegressionTest61.java

@@ -0,0 +1,35 @@
+package com.replaymod.core.regression;
+
+import com.replaymod.core.AbstractTask;
+import com.replaymod.core.CompositeTask;
+import com.replaymod.core.Task;
+import com.replaymod.replay.overlay.OverlayGui;
+import com.replaymod.simplepathing.GuiPathingTasks;
+import com.replaymod.simplepathing.gui.GuiEditKeyframe;
+
+/**
+ * Regression test: #61 NPE when saving in edit keyframe gui of last keyframe
+ */
+public class RegressionTest61 extends CompositeTask {
+    public RegressionTest61() {
+        super(new Task[]{
+                OverlayGui.whileOpened(
+                        // Place keyframe
+                        Task.click(130, 50),
+                        new GuiPathingTasks.ClickPositionKeyframeButton(),
+                        AbstractTask.create(task -> {
+                            // Double click keyframe
+                            task.click(130, 50);
+                            task.click(130, 50);
+                            task.expectGui(GuiEditKeyframe.Position.class, gui -> {
+                                task.click(gui.saveButton);
+                                task.expectPopupClosed(() -> task.future.set(null));
+                            });
+                        }),
+                        // Place second spectator keyframe
+                        new GuiPathingTasks.ClickPositionKeyframeButton()
+                ),
+                new GuiPathingTasks.ClearKeyframeTimeline(),
+        });
+    }
+}

src/integration-test/java/com/replaymod/core/regression/RegressionTest62.java

@@ -0,0 +1,28 @@
+package com.replaymod.core.regression;
+
+import com.replaymod.core.CompositeTask;
+import com.replaymod.core.Task;
+import com.replaymod.replay.overlay.OverlayGui;
+import com.replaymod.simplepathing.GuiPathingTasks;
+
+/**
+ * Regression test: #62 Swapping the only two existing keyframes causes NPE
+ */
+public class RegressionTest62 extends CompositeTask {
+    public RegressionTest62() {
+        super(new Task[]{
+                OverlayGui.whileOpened(
+                        // Place first keyframe
+                        Task.click(130, 50),
+                        new GuiPathingTasks.ClickPositionKeyframeButton(),
+                        // Place second keyframe
+                        Task.click(150, 50),
+                        new GuiPathingTasks.ClickPositionKeyframeButton(),
+                        // Move first keyframe past second keyframe
+                        Task.click(130,50),
+                        Task.drag(170,50)
+                ),
+                new GuiPathingTasks.ClearKeyframeTimeline()
+        });
+    }
+}

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

@@ -0,0 +1,25 @@
+package com.replaymod.extra;
+
+import com.replaymod.core.AbstractTask;
+import com.replaymod.extras.OpenEyeExtra;
+import net.minecraftforge.fml.common.Loader;
+
+import java.io.File;
+import java.nio.file.NoSuchFileException;
+
+public class DownloadOpenEye extends AbstractTask {
+    @Override
+    protected void init() {
+        expectGui(OpenEyeExtra.OfferGui.class, offerGui -> {
+            click(offerGui.yesButton);
+            expectGuiClosed(20 * 1000, () -> {
+                File targetFile = new File(mc.mcDataDir, "mods/" + Loader.MC_VERSION + "/OpenEye.jar");
+                if (!targetFile.exists()) {
+                    future.setException(new NoSuchFileException(targetFile.getAbsolutePath()));
+                } else {
+                    future.set(null);
+                }
+            });
+        });
+    }
+}

src/integration-test/java/com/replaymod/online/SkipLogin.java

@@ -0,0 +1,14 @@
+package com.replaymod.online;
+
+import com.replaymod.core.AbstractTask;
+import com.replaymod.online.gui.GuiLoginPrompt;
+
+public class SkipLogin extends AbstractTask {
+    @Override
+    protected void init() {
+        expectGui(GuiLoginPrompt.class, gui -> {
+            click(gui.cancelButton);
+            expectGuiClosed(() -> future.set(null));
+        });
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.replaymod.recording;
+
+import com.replaymod.core.AbstractTask;
+import net.minecraft.client.gui.GuiCreateWorld;
+import net.minecraft.client.gui.GuiMainMenu;
+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(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());
+                });
+            });
+        });
+    }
+}

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

@@ -0,0 +1,36 @@
+package com.replaymod.recording;
+
+import com.replaymod.core.AbstractTask;
+import net.minecraft.client.gui.GuiIngameMenu;
+import net.minecraft.client.gui.GuiMainMenu;
+import org.apache.commons.io.filefilter.DirectoryFileFilter;
+
+import java.io.IOException;
+
+public class ExitSPWorld extends AbstractTask {
+    @Override
+    protected void init() {
+        mc.displayInGameMenu();
+        expectGui(GuiIngameMenu.class, ingameMenu -> {
+            click("Save and Quit to Title");
+            expectGui(GuiMainMenu.class, mainMenu -> new Thread(() -> {
+                try {
+                    while (true) {
+                        String[] dirs = core.getReplayFolder().list(DirectoryFileFilter.DIRECTORY);
+                        if (dirs == null) {
+                            future.setException(new NullPointerException("dirs is null"));
+                            return;
+                        }
+                        if (dirs.length == 0) {
+                            runLater(() -> future.set(null));
+                            return;
+                        }
+                        Thread.sleep(10);
+                    }
+                } catch (IOException | InterruptedException e) {
+                    future.setException(e);
+                }
+            }).start());
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.replaymod.replay;
+
+import com.replaymod.core.AbstractTask;
+import net.minecraft.client.gui.GuiIngameMenu;
+import net.minecraft.client.gui.GuiMainMenu;
+
+public class ExitReplay extends AbstractTask {
+    @Override
+    protected void init() {
+        mc.displayInGameMenu();
+        expectGui(GuiIngameMenu.class, ingameMenu -> {
+            click("Exit Replay");
+            expectGui(GuiMainMenu.class, mainMenu -> future.set(null));
+        });
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.replaymod.replay;
+
+import com.replaymod.core.AbstractTask;
+import com.replaymod.replay.gui.screen.GuiReplayViewer;
+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;
+
+public class LoadReplay extends AbstractTask {
+    @Override
+    protected void init() {
+        expectGui(GuiReplayViewer.class, replayViewer -> runLater(() -> {
+            ReadableDimension size = replayViewer.getMaxSize();
+            // Select first entry
+            replayViewer.forEach(Clickable.class).mouseClick(new Point(size.getWidth() / 2, 40), 0);
+            // 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());
+        }));
+    }
+}

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

@@ -0,0 +1,15 @@
+package com.replaymod.replay;
+
+import com.replaymod.core.AbstractTask;
+import com.replaymod.replay.gui.screen.GuiReplayViewer;
+import net.minecraft.client.gui.GuiMainMenu;
+
+public class OpenReplayViewer extends AbstractTask {
+    @Override
+    protected void init() {
+        expectGui(GuiMainMenu.class, mainMenu -> {
+            click("Replay Viewer");
+            expectGui(GuiReplayViewer.class, replayViewer -> future.set(null));
+        });
+    }
+}

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

@@ -0,0 +1,42 @@
+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 org.lwjgl.input.Keyboard;
+
+import java.util.concurrent.TimeoutException;
+
+public class SpectatePlayer extends AbstractTask {
+    @Override
+    protected void init() {
+        press(Keyboard.KEY_B);
+        expectGui(PlayerOverviewGui.class, overview -> {
+            click(overview.getMaxSize().getWidth() / 2 - 60, 60);
+            press(Keyboard.KEY_ESCAPE);
+            expectGuiClosed(() -> future.set(null));
+        });
+    }
+
+    public static class End extends AbstractTask {
+        private int timeout;
+
+        @Override
+        protected void init() {
+            runLater(() -> press(Keyboard.KEY_LSHIFT));
+        }
+
+        @SubscribeEvent
+        public void onTick(TickEvent.RenderTickEvent event) {
+            if (event.phase != TickEvent.Phase.START) return;
+            if (timeout++ > 20) {
+                future.setException(new TimeoutException("Camera hasn't stopped spectating."));
+                return;
+            }
+            if (mc.getRenderViewEntity() == mc.thePlayer) {
+                future.set(null);
+            }
+        }
+    }
+}

src/integration-test/java/com/replaymod/replay/overlay/OverlayGui.java

@@ -0,0 +1,33 @@
+package com.replaymod.replay.overlay;
+
+import com.replaymod.core.AbstractTask;
+import com.replaymod.core.CompositeTask;
+import com.replaymod.core.Task;
+import com.replaymod.replay.gui.overlay.GuiReplayOverlay;
+import org.lwjgl.input.Keyboard;
+
+public class OverlayGui {
+    public static Task whileOpened(Task...tasks) {
+        Task[] nTasks = new Task[tasks.length + 2];
+        System.arraycopy(tasks, 0, nTasks, 1, tasks.length);
+        nTasks[0] = new Open();
+        nTasks[tasks.length + 1] = new Close();
+        return new CompositeTask(nTasks);
+    }
+
+    public static class Open extends AbstractTask {
+        @Override
+        protected void init() {
+            press(Keyboard.KEY_T);
+            expectGui(GuiReplayOverlay.class, done -> future.set(null));
+        }
+    }
+
+    public static class Close extends AbstractTask {
+        @Override
+        protected void init() {
+            press(Keyboard.KEY_ESCAPE);
+            expectGuiClosed(() -> future.set(null));
+        }
+    }
+}

src/integration-test/java/com/replaymod/simplepathing/GuiPathingTasks.java

@@ -0,0 +1,35 @@
+package com.replaymod.simplepathing;
+
+import com.replaymod.core.AbstractTask;
+import com.replaymod.replay.gui.overlay.GuiReplayOverlay;
+import com.replaymod.simplepathing.gui.GuiPathing;
+import de.johni0702.minecraft.gui.popup.GuiYesNoPopup;
+import org.lwjgl.input.Keyboard;
+
+public abstract class GuiPathingTasks extends AbstractTask {
+    @Override
+    protected void init() {
+        expectGui(GuiReplayOverlay.class, ign -> init0(ReplayModSimplePathing.instance.getGuiPathing()));
+    }
+
+    protected abstract void init0(GuiPathing guiPathing);
+
+    public static class ClickPositionKeyframeButton extends GuiPathingTasks {
+        @Override
+        protected void init0(GuiPathing guiPathing) {
+            click(guiPathing.positionKeyframeButton);
+            runLater(() -> future.set(null));
+        }
+    }
+
+    public static class ClearKeyframeTimeline extends AbstractTask {
+        @Override
+        protected void init() {
+            press(Keyboard.KEY_C);
+            expectGui(GuiYesNoPopup.class, popup -> {
+                click(popup.getYesButton());
+                expectGuiClosed(() -> future.set(null));
+            });
+        }
+    }
+}

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

@@ -1,8 +1,10 @@
 package com.replaymod.compat;
 
+import com.replaymod.compat.bettersprinting.DisableBetterSprinting;
 import com.replaymod.compat.optifine.DisableFastRender;
+import com.replaymod.compat.oranges17animations.HideInvisibleEntities;
 import com.replaymod.compat.shaders.ShaderBeginRender;
-import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.event.FMLInitializationEvent;
 import net.minecraftforge.fml.common.eventhandler.EventBus;
@@ -10,15 +12,18 @@ import net.minecraftforge.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;
+        EventBus bus = FMLCommonHandler.instance().bus();
         bus.register(new ShaderBeginRender());
         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 net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.PlayerControllerMP;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.IWorldAccess;
+import net.minecraftforge.client.event.GuiOpenEvent;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.Loader;
+import net.minecraftforge.fml.common.ModContainer;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.versioning.DefaultArtifactVersion;
+import net.minecraftforge.fml.common.versioning.Restriction;
+import net.minecraftforge.fml.common.versioning.VersionRange;
+
+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 onEntityRemoved(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(BlockPos pos) {}
+        @Override public void notifyLightSet(BlockPos pos) {}
+        @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(int p_180442_1_, boolean p_180442_2_, double p_180442_3_, double p_180442_5_, double p_180442_7_, double p_180442_9_, double p_180442_11_, double p_180442_13_, int... p_180442_15_) {}
+        @Override public void onEntityAdded(Entity entityIn) {}
+        @Override public void playRecord(String recordName, BlockPos blockPosIn) {}
+        @Override public void broadcastSound(int p_180440_1_, BlockPos p_180440_2_, int p_180440_3_) {}
+        @Override public void playAuxSFX(EntityPlayer p_180439_1_, int p_180439_2_, BlockPos blockPosIn, int p_180439_4_) {}
+        @Override public void sendBlockBreakProgress(int breakerId, BlockPos pos, int progress) {}
+    }
+}

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 net.minecraft.client.Minecraft;
+import net.minecraftforge.client.event.RenderLivingEvent;
+import net.minecraftforge.fml.common.Loader;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+/**
+ * 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/core/KeyBindingRegistry.java

@@ -16,6 +16,7 @@ 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>();
@@ -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

@@ -20,6 +20,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) {

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

@@ -6,6 +6,7 @@ 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.replaystudio.util.I18n;
 import de.johni0702.minecraft.gui.container.GuiScreen;
 import lombok.Getter;
@@ -13,11 +14,15 @@ 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.FMLCommonHandler;
 import net.minecraftforge.fml.common.Loader;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.Mod.EventHandler;
@@ -26,6 +31,9 @@ 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 net.minecraftforge.fml.common.eventhandler.EventBus;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
 import org.apache.commons.io.FileUtils;
 
 import java.io.File;
@@ -36,6 +44,7 @@ import java.util.List;
         useMetadata = true,
         version = "@MOD_VERSION@",
         acceptedMinecraftVersions = "@MC_VERSION@",
+        acceptableRemoteVersions = "*",
         updateJSON = "https://raw.githubusercontent.com/ReplayMod/ReplayMod/master/versions.json",
         guiFactory = "com.replaymod.core.gui.GuiFactory")
 public class ReplayMod {
@@ -67,6 +76,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 +120,7 @@ public class ReplayMod {
 
         new MainMenuHandler().register();
 
-        MinecraftForge.EVENT_BUS.register(keyBindingRegistry);
+        FMLCommonHandler.instance().bus().register(keyBindingRegistry);
 
         getKeyBindingRegistry().registerKeyBinding("replaymod.input.settings", 0, () -> {
             new GuiReplaySettings(null, settingsRegistry).display();
@@ -159,9 +170,36 @@ 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;
+
     public void runLater(Runnable runnable) {
+        if (mc.isCallingFromMinecraftThread() && inRunLater) {
+            EventBus bus = FMLCommonHandler.instance().bus();
+            bus.register(new Object() {
+                @SubscribeEvent
+                public void onRenderTick(TickEvent.RenderTickEvent event) {
+                    if (event.phase == TickEvent.Phase.START) {
+                        runLater(runnable);
+                        bus.unregister(this);
+                    }
+                }
+            });
+            return;
+        }
         synchronized (mc.scheduledTasks) {
-            mc.scheduledTasks.add(ListenableFutureTask.create(runnable, null));
+            mc.scheduledTasks.add(ListenableFutureTask.create(() -> {
+                inRunLater = true;
+                try {
+                    runnable.run();
+                } finally {
+                    inRunLater = false;
+                }
+            }, null));
         }
     }
 
@@ -190,13 +228,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);
+            ChatStyle coloredDarkGray = new ChatStyle().setColor(EnumChatFormatting.DARK_GRAY);
-            Style coloredGold = new Style().setColor(TextFormatting.GOLD);
+            ChatStyle coloredGold = new ChatStyle().setColor(EnumChatFormatting.GOLD);
-            ITextComponent text = new TextComponentString("[").setStyle(coloredDarkGray)
+            IChatComponent text = new ChatComponentText("[").setChatStyle(coloredDarkGray)
-                    .appendSibling(new TextComponentTranslation("replaymod.title").setStyle(coloredGold))
+                    .appendSibling(new ChatComponentTranslation("replaymod.title").setChatStyle(coloredGold))
-                    .appendSibling(new TextComponentString("] "))
+                    .appendSibling(new ChatComponentText("] "))
-                    .appendSibling(new TextComponentTranslation(message, args).setStyle(new Style()
+                    .appendSibling(new ChatComponentTranslation(message, args).setChatStyle(new ChatStyle()
-                            .setColor(warning ? TextFormatting.RED : TextFormatting.DARK_GREEN)));
+                            .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

@@ -2,8 +2,8 @@ package com.replaymod.core;
 
 import com.replaymod.core.events.SettingsChangedEvent;
 import net.minecraft.client.resources.I18n;
-import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.common.config.Configuration;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
@@ -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/gui/RestoreReplayGui.java

@@ -3,6 +3,7 @@ package com.replaymod.core.gui;
 import com.google.common.io.Files;
 import com.replaymod.replaystudio.PacketData;
 import com.replaymod.replaystudio.io.ReplayInputStream;
+import com.replaymod.replaystudio.io.ReplayOutputStream;
 import com.replaymod.replaystudio.replay.ReplayFile;
 import com.replaymod.replaystudio.replay.ReplayMetaData;
 import com.replaymod.replaystudio.replay.ZipReplayFile;
@@ -45,15 +46,19 @@ public class RestoreReplayGui extends AbstractGuiScreen<RestoreReplayGui> {
                 ReplayMetaData metaData = replayFile.getMetaData();
                 if (metaData != null && metaData.getDuration() == 0) {
                     // Try to restore replay duration
-                    try (ReplayInputStream in = replayFile.getPacketData()) {
+                    // We need to re-write the packet data in case there are any incomplete packets dangling at the end
+                    try (ReplayInputStream in = replayFile.getPacketData();
+                         ReplayOutputStream out = replayFile.writePacketData()) {
                         PacketData last = null;
                         while ((last = in.readPacket()) != null) {
                             metaData.setDuration((int) last.getTime());
+                            out.write(last);
                         }
-                        replayFile.writeMetaData(metaData);
                     } catch (Throwable t) {
                         t.printStackTrace();
                     }
+                    // Write back the actual duration
+                    replayFile.writeMetaData(metaData);
                 }
                 replayFile.save();
                 replayFile.close();

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

@@ -6,6 +6,8 @@ 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) {
+        if (event.gui instanceof GuiMainMenu) {
-            for (GuiButton button : event.getButtonList()) {
+            @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
+                if (button.xPosition + button.width < event.gui.width / 2 - 100
-                        || button.xPosition > event.getGui().width / 2 + 100
+                        || button.xPosition > event.gui.width / 2 + 100
-                        || button.yPosition > event.getGui().height / 4 + 10 + 4 * 24) continue;
+                        || 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/OpenGLUtils.java

@@ -2,7 +2,7 @@ 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.WorldRenderer;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;
@@ -35,7 +35,7 @@ public class OpenGLUtils {
         float f5 = 1.0F / textureHeight;
 
         Tessellator tessellator = Tessellator.getInstance();
-        VertexBuffer vertexBuffer = tessellator.getBuffer();
+        WorldRenderer vertexBuffer = tessellator.getWorldRenderer();
         GlStateManager.translate(x+(width/2), y+(width/2), 0);
         GlStateManager.rotate(rotation, 0, 0, 1);
         vertexBuffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);

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

@@ -1,7 +1,7 @@
 package com.replaymod.core.utils;
 
 import net.minecraft.network.PacketBuffer;
-import net.minecraft.network.play.server.SPacketCustomPayload;
+import net.minecraft.network.play.server.S3FPacketCustomPayload;
 
 /**
  * Restrictions set by the server,
@@ -14,10 +14,10 @@ public class Restrictions {
     private boolean onlyFirstPerson;
     private boolean onlyRecordingPlayer;
 
-    public String handle(SPacketCustomPayload packet) {
+    public String handle(S3FPacketCustomPayload packet) {
         PacketBuffer buffer = packet.getBufferData();
         while (buffer.isReadable()) {
-            String name = buffer.readString(64);
+            String name = buffer.readStringFromBuffer(64);
             boolean active = buffer.readBoolean();
 //            if ("no_xray".equals(name)) {
 //                noXray = active;

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

@@ -1,7 +1,9 @@
 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;
 import de.johni0702.minecraft.gui.GuiRenderer;
 import de.johni0702.minecraft.gui.RenderInfo;
 import de.johni0702.minecraft.gui.container.AbstractGuiScrollable;
@@ -15,24 +17,43 @@ 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.gui.GuiScreen;
 import net.minecraft.client.network.NetworkPlayerInfo;
 import net.minecraft.client.resources.DefaultPlayerSkin;
 import net.minecraft.crash.CrashReport;
 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;
 import org.lwjgl.util.ReadableDimension;
 
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import javax.imageio.ImageIO;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManagerFactory;
 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;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
 import java.text.SimpleDateFormat;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.UUID;
+import java.util.function.Consumer;
 
 import static net.minecraft.client.Minecraft.getMinecraft;
 
@@ -51,6 +72,42 @@ public class Utils {
         DEFAULT_THUMBNAIL = thumbnail;
     }
 
+
+    /**
+     * Neither the root certificate of LetsEncrypt nor the root that cross-signed it is included in the default
+     * Java keystore prior to 8u101.
+     * Therefore whenever a connection to the replaymod.com site is made, this SSLContext has to be used instead.
+     * It has been constructed to include the necessary root certificates.
+     * @see #SSL_SOCKET_FACTORY
+     */
+    public static final SSLContext SSL_CONTEXT;
+
+    /**
+     * @see #SSL_CONTEXT
+     */
+    public static final SSLSocketFactory SSL_SOCKET_FACTORY;
+
+    static {
+        // Largely from https://community.letsencrypt.org/t/134/37
+        try (InputStream in = Utils.class.getResourceAsStream("/dst_root_ca_x3.pem")){
+            Certificate certificate = CertificateFactory.getInstance("X.509").generateCertificate(in);
+
+            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
+            keyStore.load(null, null);
+            keyStore.setCertificateEntry("1", certificate);
+
+            TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+            trustManagerFactory.init(keyStore);
+
+            SSLContext ctx = SSLContext.getInstance("TLS");
+            ctx.init(null, trustManagerFactory.getTrustManagers(), null);
+            SSL_CONTEXT = ctx;
+            SSL_SOCKET_FACTORY = ctx.getSocketFactory();
+        } catch (IOException | CertificateException | KeyStoreException | NoSuchAlgorithmException | KeyManagementException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     public static String convertSecondsToShortString(int seconds) {
         int hours = seconds/(60*60);
         int min = seconds/60 - hours*60;
@@ -86,8 +143,24 @@ 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,}))$");
     }
 
+    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;
+        }
+    }
+
     public static ResourceLocation getResourceLocationForPlayerUUID(UUID uuid) {
-        NetworkPlayerInfo info = getMinecraft().getConnection().getPlayerInfo(uuid);
+        NetworkPlayerInfo info = getMinecraft().getNetHandler().getPlayerInfo(uuid);
         ResourceLocation skinLocation;
         if (info != null && info.hasLocationSkin()) {
             skinLocation = info.getLocationSkin();
@@ -101,6 +174,20 @@ public class Utils {
         return Keyboard.isKeyDown(Keyboard.KEY_LCONTROL) || Keyboard.isKeyDown(Keyboard.KEY_RCONTROL);
     }
 
+    public static <T> void addCallback(ListenableFuture<T> future, Consumer<T> onSuccess, Consumer<Throwable> onFailure) {
+        Futures.addCallback(future, new FutureCallback<T>() {
+            @Override
+            public void onSuccess(@Nullable T result) {
+                onSuccess.accept(result);
+            }
+
+            @Override
+            public void onFailure(@Nonnull Throwable t) {
+                onFailure.accept(t);
+            }
+        });
+    }
+
     public static GuiInfoPopup error(Logger logger, GuiContainer container, CrashReport crashReport, Runnable onClose) {
         // Convert crash report to string
         String crashReportStr = crashReport.getCompleteReport();

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

@@ -11,6 +11,7 @@ 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

@@ -1,5 +1,6 @@
 package com.replaymod.editor.gui;
 
+import com.google.common.io.Files;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.gson.JsonObject;
@@ -34,7 +35,7 @@ import de.johni0702.minecraft.gui.popup.GuiInfoPopup;
 import de.johni0702.minecraft.gui.popup.GuiYesNoPopup;
 import de.johni0702.minecraft.gui.utils.Colors;
 import net.minecraft.crash.CrashReport;
-import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.io.FileUtils;
 import org.lwjgl.util.ReadableDimension;
 
 import javax.annotation.Nullable;
@@ -57,6 +58,9 @@ public class GuiReplayEditor extends GuiScreen {
     public GuiButton currentTabButton;
     public GuiPanel currentTabPanel;
 
+    public final GuiLabel warningLabel = new GuiLabel(this).setColor(Colors.RED)
+            .setI18nText("replaymod.gui.editor.disclaimer");
+
     public final GuiPanel tabButtons = new GuiPanel(this).setLayout(new GridLayout().setSpacingX(5));
     public final List<GuiPanel> tabPanels = new ArrayList<>();
 
@@ -82,15 +86,18 @@ public class GuiReplayEditor extends GuiScreen {
                 // Move all inactive panels aside
                 tabPanels.forEach(e -> pos(e, Integer.MIN_VALUE, Integer.MIN_VALUE));
 
+                pos(warningLabel, 10, 22);
+                size(warningLabel, width - 20, 10);
+
+                pos(tabButtons, 10, y(warningLabel) + height(warningLabel) + 2);
+                size(tabButtons, width - 20, 20);
+
                 pos(buttonPanel, width - 10 - width(buttonPanel), height - 10 - height(buttonPanel));
 
                 if (currentTabPanel != null) {
-                    pos(currentTabPanel, 10, 50);
+                    pos(currentTabPanel, 10, y(tabButtons) + height(tabButtons) + 10);
                     size(currentTabPanel, width - 20, y(buttonPanel) - 10 - y(currentTabPanel));
                 }
-
-                pos(tabButtons, 10, 20);
-                size(tabButtons, width - 20, 20);
             }
         });
     }
@@ -117,12 +124,23 @@ 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();
-            try (ReplayFile outputReplay = new ZipReplayFile(studio, inputFile, outputFile);
+            File tmpDir = null;
-                 ReplayOutputStream out = outputReplay.writePacketData()) {
+            try {
-                // The input replay file MUST be closed before saving the output file
+                File actualOutputFile  = outputFile;
-                try (ReplayFile inputReplay = new ZipReplayFile(studio, inputFile);
+                if (outputFile.getCanonicalPath().equals(inputFile.getCanonicalPath())) {
+                    // Input and output files are identical. Due to the way the ZipReplayFile stores its temporary
+                    // data, the same replay file must not be opened twice for writing (tmp files will be deleted once
+                    // either one is closed or, on Windows, will throw an exception when deleted).
+                    tmpDir = Files.createTempDir();
+                    outputFile = new File(tmpDir, "replay.mcpr");
+                    LOGGER.debug("Output file is identical to input file, using temporary output file {} instead",
+                            outputFile);
+                }
+                try (ReplayFile outputReplay = new ZipReplayFile(studio, inputFile, outputFile);
+                     ReplayOutputStream out = outputReplay.writePacketData();
+                     ReplayFile inputReplay = new ZipReplayFile(studio, inputFile);
                      ReplayInputStream in = inputReplay.getPacketData()) {
                     ReplayMetaData metaData = inputReplay.getMetaData();
                     PacketStream stream = studio.createReplayStream(in, true);
@@ -154,11 +172,21 @@ public class GuiReplayEditor extends GuiScreen {
                     // Update duration of new replay
                     metaData.setDuration((int) lastTimestamp);
                     outputReplay.writeMetaData(metaData);
+
+                    out.close();
+                    outputReplay.save();
+                }
+                if (outputFile != actualOutputFile) {
+                    LOGGER.debug("Moving temporary output file {} to {}");
+                    FileUtils.forceDelete(actualOutputFile);
+                    FileUtils.moveFile(outputFile, actualOutputFile);
                 }
-                out.close();
-                outputReplay.save();
             } catch (IOException e) {
                 throw new RuntimeException(e);
+            } finally {
+                if (tmpDir != null && !FileUtils.deleteQuietly(tmpDir)) {
+                    LOGGER.warn("Failed to delete temporary directory {}", tmpDir);
+                }
             }
         });
     }
@@ -191,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;
@@ -39,6 +38,10 @@ import static com.replaymod.editor.ReplayModEditor.LOGGER;
 import static java.util.Optional.ofNullable;
 
 public class GuiTrimPanel extends GuiPanel {
+    private static GuiNumberField newGuiNumberField() {
+        return new GuiNumberField().setMaxLength(2).setSize(20, 20).setValidateOnFocusChange(true);
+    }
+
     // Special value indicating no replay files were found
     private static final File NO_REPLAY = new File(".");
     // Special value for the initial "Select Marker Keyframe" entry
@@ -48,18 +51,18 @@ 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 = new GuiNumberField().setSize(20, 20).setMaxLength(2);
+    public final GuiNumberField startHour = newGuiNumberField();
-    public final GuiNumberField startMin = new GuiNumberField().setSize(20, 20).setMaxLength(2);
+    public final GuiNumberField startMin = newGuiNumberField();
-    public final GuiNumberField startSec = new GuiNumberField().setSize(20, 20).setMaxLength(2);
+    public final GuiNumberField startSec = newGuiNumberField();
-    public final GuiNumberField startMilli = new GuiNumberField().setSize(40, 20).setMaxLength(4);
+    public final GuiNumberField startMilli = newGuiNumberField().setSize(40, 20).setMaxLength(4);
     public final GuiDropdownMenu<Marker> startMarker = new GuiDropdownMenu<>();
 
-    public final GuiNumberField endHour = new GuiNumberField().setSize(20, 20).setMaxLength(2);
+    public final GuiNumberField endHour = newGuiNumberField();
-    public final GuiNumberField endMin = new GuiNumberField().setSize(20, 20).setMaxLength(2);
+    public final GuiNumberField endMin = newGuiNumberField();
-    public final GuiNumberField endSec = new GuiNumberField().setSize(20, 20).setMaxLength(2);
+    public final GuiNumberField endSec = newGuiNumberField();
-    public final GuiNumberField endMilli = new GuiNumberField().setSize(40, 20).setMaxLength(4);
+    public final GuiNumberField endMilli = newGuiNumberField().setSize(40, 20).setMaxLength(4);
     public final GuiDropdownMenu<Marker> endMarker = new GuiDropdownMenu<>();
 
     public final GuiPanel timePanel = new GuiPanel(this)

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

@@ -8,8 +8,11 @@ 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.FMLCommonHandler;
 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,
+        @SuppressWarnings("unchecked")
-                event.getGui().height / 4 + 10 + 3 * 24, I18n.format("replaymod.gui.replayeditor"));
+        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.gui instanceof GuiMainMenu) {
-            if (event.getButton().id == BUTTON_REPLAY_EDITOR) {
+            if (event.button.id == BUTTON_REPLAY_EDITOR) {
-                new GuiReplayEditor(GuiScreen.wrap(event.getGui()), mod.getCore()).display();
+                new GuiReplayEditor(GuiScreen.wrap(event.gui), mod.getCore()).display();
             }
         }
     }

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

@@ -9,7 +9,7 @@ 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.FMLCommonHandler;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.gameevent.TickEvent;
 import org.lwjgl.input.Keyboard;
@@ -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

@@ -17,7 +17,7 @@ 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.FMLCommonHandler;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.util.Dimension;
@@ -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

@@ -1,106 +1,110 @@
 package com.replaymod.extras;
 
-import com.google.common.base.Charsets;
 import com.google.common.collect.ImmutableSet;
 import com.replaymod.core.ReplayMod;
-import com.replaymod.online.ReplayModOnline;
-import com.replaymod.online.api.ApiClient;
-import com.replaymod.online.api.ApiException;
-import lombok.RequiredArgsConstructor;
 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.lang3.StringEscapeUtils;
+import org.apache.commons.io.IOUtils;
 
 import java.awt.image.BufferedImage;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.net.ConnectException;
+import java.net.URL;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import static com.replaymod.extras.ReplayModExtras.LOGGER;
 
 public class LocalizationExtra implements Extra {
-    private ReplayModOnline module;
+    private static final String ZIP_FILE_URL = "https://github.com/ReplayMod/Translations/archive/master.zip";
+    private static final String LANG_PREFIX = "Translations-master/";
 
     @Override
     public void register(ReplayMod mod) throws Exception {
-        this.module = ReplayModOnline.instance;
-
         final Minecraft mc = mod.getMinecraft();
-        Thread localizedResourcePackLoader = new Thread(new Runnable() {
+        if (Boolean.parseBoolean(System.getProperty("replaymod.offline", "false"))) {
-            @Override
+            return;
-            public void run() {
+        }
-                try {
+        Thread localizedResourcePackLoader = new Thread(() -> {
+            try {
+                // Download zip of lang files
+                LOGGER.debug("Downloading languages from {}", ZIP_FILE_URL);
+                Map<String, byte[]> languages = new HashMap<>();
+                try (InputStream urlIn = new URL(ZIP_FILE_URL).openStream();
+                     ZipInputStream in = new ZipInputStream(urlIn)) {
+                    ZipEntry entry;
+                    while ((entry = in.getNextEntry()) != null) {
+                        String name = entry.getName();
+                        if (!name.startsWith(LANG_PREFIX) || !name.endsWith(".lang")) {
+                           continue;
+                        }
+                        name = name.substring(LANG_PREFIX.length());
+                        languages.put(name, IOUtils.toByteArray(in));
+                        LOGGER.debug("Added language file {}", name);
+                    }
+                }
+                LOGGER.debug("Downloaded {} languages", languages.size());
+
+                // Add lang files as resource pack
+                mc.addScheduledTask(() -> {
                     @SuppressWarnings("unchecked")
                     List<IResourcePack> defaultResourcePacks = mc.defaultResourcePacks;
-                    defaultResourcePacks.add(new LocalizedResourcePack(module.getApiClient()));
+                    defaultResourcePacks.add(new LocalizedResourcePack(languages));
-                    mc.addScheduledTask(new Runnable() {
+                    mc.getLanguageManager().onResourceManagerReload(mc.getResourceManager());
-                        @Override
+                    LOGGER.debug("Added language files to resource packs and reloaded LanguageManager");
-                        public void run() {
+                });
-                            mc.refreshResources();
+            } catch (Throwable t) {
-                        }
+                LOGGER.error("Loading localized resource pack:", t);
-                    });
-                } catch(Exception e) {
-                    e.printStackTrace();
-                }
             }
         }, "localizedResourcePackLoader");
+        localizedResourcePackLoader.setDaemon(true);
         localizedResourcePackLoader.start();
     }
 
-    @RequiredArgsConstructor
     public static class LocalizedResourcePack implements IResourcePack {
-        private final ApiClient apiClient;
+        private final Pattern LANG_PATTERN = Pattern.compile("^lang/([.+].lang)$");
-        private Map<String, String> availableLanguages = new HashMap<>();
+        private final Map<String, byte[]> languages;
-        private boolean websiteAvailable = true;
+
+        public LocalizedResourcePack(Map<String, byte[]> languages) {
+            this.languages = languages;
+        }
 
         @Override
         public InputStream getInputStream(ResourceLocation loc) {
-            if(!loc.getResourcePath().endsWith(".lang")) return null;
+            if (!"replaymod".equals(loc.getResourceDomain())) return null;
-            String langcode = loc.getResourcePath().split("/")[1].split("\\.")[0];
+            Matcher matcher = LANG_PATTERN.matcher(loc.getResourcePath());
-            if(availableLanguages.containsKey(langcode)) return new ByteArrayInputStream(availableLanguages.get(langcode).getBytes(Charsets.UTF_8));
+            if (matcher.matches()) {
+                byte[] bytes = languages.get(matcher.group());
+                if (bytes != null) {
+                    return new ByteArrayInputStream(bytes);
+                }
+            }
             return null;
         }
 
         @Override
         public boolean resourceExists(ResourceLocation loc) {
-            if(!(loc.getResourcePath().endsWith(".lang"))) return false;
+            // Assumes that getInputStream returns a ByteArrayInputStream that doesn't need to be closed
-            String langcode = loc.getResourcePath().split("/")[1].split("\\.")[0];
+            return getInputStream(loc) != null;
-            if(availableLanguages.containsKey(langcode)) return true;
-            if(!websiteAvailable) return false;
-            try {
-                if (Boolean.parseBoolean(System.getProperty("replaymod.offline", "false"))) {
-                    return false;
-                }
-                String lang = apiClient.getTranslation(langcode);
-                String prop = StringEscapeUtils.unescapeHtml4(lang);
-                availableLanguages.put(langcode, prop);
-                return true;
-            } catch (ApiException e) {
-                if (e.getError().getId() != 16) { // This language has not been translated
-                    e.printStackTrace();
-                }
-            } catch(ConnectException ce) {
-                websiteAvailable = false;
-                ce.printStackTrace();
-            } catch(Exception e) {
-                e.printStackTrace();
-            }
-            return false;
         }
 
         @Override
-        public Set<String> getResourceDomains() {
+        public Set getResourceDomains() {
-            return ImmutableSet.of("minecraft", "replaymod");
+            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

@@ -17,6 +17,7 @@ import de.johni0702.minecraft.gui.utils.Colors;
 import net.minecraftforge.fml.common.Loader;
 import org.apache.commons.io.FileUtils;
 
+import javax.net.ssl.HttpsURLConnection;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.net.URL;
@@ -24,8 +25,10 @@ import java.nio.channels.Channels;
 import java.nio.channels.FileChannel;
 import java.nio.channels.ReadableByteChannel;
 
+import static com.replaymod.core.utils.Utils.SSL_SOCKET_FACTORY;
+
 public class OpenEyeExtra implements Extra {
-    private static final String DOWNLOAD_URL = "http://www.replaymod.com/dl/openeye/" + Loader.MC_VERSION;
+    private static final String DOWNLOAD_URL = "https://www.replaymod.com/dl/openeye/" + Loader.MC_VERSION;
     private static final Setting<Boolean> ASK_FOR_OPEN_EYE = new Setting<>("advanced", "askForOpenEye", null, true);
 
     private ReplayMod mod;
@@ -40,7 +43,7 @@ public class OpenEyeExtra implements Extra {
         }
     }
 
-    private class OfferGui extends AbstractGuiScreen<OfferGui> {
+    public class OfferGui extends AbstractGuiScreen<OfferGui> {
         public final GuiScreen parent;
         public final GuiPanel textPanel = new GuiPanel().setLayout(new VerticalLayout().setSpacing(3))
                 .addElements(new VerticalLayout.Data(0.5),
@@ -66,10 +69,12 @@ public class OpenEyeExtra implements Extra {
                 GuiPopup popup = new GuiPopup(OfferGui.this);
                 new Thread(() -> {
                     try {
-                        File targetFile = new File("mods/" + Loader.MC_VERSION, "OpenEye.jar");
+                        File targetFile = new File(mod.getMinecraft().mcDataDir, "mods/" + Loader.MC_VERSION + "/OpenEye.jar");
                         FileUtils.forceMkdir(targetFile.getParentFile());
 
-                        ReadableByteChannel in = Channels.newChannel(new URL(DOWNLOAD_URL).openStream());
+                        HttpsURLConnection connection = (HttpsURLConnection) new URL(DOWNLOAD_URL).openConnection();
+                        connection.setSSLSocketFactory(SSL_SOCKET_FACTORY);
+                        ReadableByteChannel in = Channels.newChannel(connection.getInputStream());
                         FileChannel out = new FileOutputStream(targetFile).getChannel();
                         out.transferFrom(in, 0, Long.MAX_VALUE);
                     } catch (Throwable e) {
@@ -102,7 +107,7 @@ public class OpenEyeExtra implements Extra {
         }
     }
 
-    private static final class GuiPopup extends AbstractGuiPopup<GuiPopup> {
+    public static final class GuiPopup extends AbstractGuiPopup<GuiPopup> {
         GuiPopup(GuiContainer container) {
             super(container);
             popup.addElements(null, new GuiIndicator().setColor(Colors.BLACK));

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

@@ -10,11 +10,15 @@ import net.minecraftforge.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,11 +36,13 @@ public class ReplayModExtras {
             OpenEyeExtra.class
     );
 
-    private Logger logger;
+    private final Map<Class<? extends Extra>, Extra> instances = new HashMap<>();
+
+    public static Logger LOGGER;
 
     @Mod.EventHandler
     public void preInit(FMLPreInitializationEvent event) {
-        logger = event.getModLog();
+        LOGGER = event.getModLog();
     }
 
     @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);
+                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

@@ -9,10 +9,11 @@ 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.entity.Entity;
-import net.minecraft.client.renderer.entity.RenderPlayer;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.client.event.RenderHandEvent;
 import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import org.lwjgl.input.Keyboard;
 
@@ -34,7 +35,7 @@ public class PlayerOverview implements Extra {
             public void run() {
                 if (module.getReplayHandler() != null) {
                     @SuppressWarnings("unchecked")
-                    List<EntityPlayer> players = mod.getMinecraft().world.getPlayers(EntityPlayer.class, new Predicate() {
+                    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
@@ -55,13 +56,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) {
@@ -92,6 +88,14 @@ public class PlayerOverview implements Extra {
         hiddenPlayers.clear();
     }
 
+    @SubscribeEvent
+    public void oRenderHand(RenderHandEvent event) {
+        Entity view = module.getCore().getMinecraft().getRenderViewEntity();
+        if (view != null && isHidden(view.getUniqueID())) {
+            event.setCanceled(true);
+        }
+    }
+
     public boolean isSavingEnabled() {
         return savingEnabled;
     }

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

@@ -4,10 +4,15 @@ import com.replaymod.core.utils.Utils;
 import com.replaymod.replay.ReplayModReplay;
 import de.johni0702.minecraft.gui.GuiRenderer;
 import de.johni0702.minecraft.gui.RenderInfo;
-import de.johni0702.minecraft.gui.container.*;
+import de.johni0702.minecraft.gui.container.GuiClickable;
+import de.johni0702.minecraft.gui.container.GuiContainer;
+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.GuiCheckbox;
 import de.johni0702.minecraft.gui.element.GuiImage;
 import de.johni0702.minecraft.gui.element.GuiLabel;
+import de.johni0702.minecraft.gui.element.GuiTooltip;
 import de.johni0702.minecraft.gui.element.IGuiCheckbox;
 import de.johni0702.minecraft.gui.function.Closeable;
 import de.johni0702.minecraft.gui.layout.CustomLayout;
@@ -16,8 +21,7 @@ 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.potion.Potion;
-import net.minecraft.init.SoundEvents;
 import net.minecraft.util.ResourceLocation;
 import org.lwjgl.util.Dimension;
 import org.lwjgl.util.ReadableDimension;
@@ -37,21 +41,22 @@ public class PlayerOverviewGui extends GuiScreen implements Closeable {
     public final GuiVerticalList playersScrollable = new GuiVerticalList(contentPanel)
             .setDrawSlider(true).setDrawShadow(true);
     public final GuiCheckbox saveCheckbox = new GuiCheckbox(contentPanel)
+            .setTooltip(new GuiTooltip().setI18nText("replaymod.gui.playeroverview.remembersettings.description"))
             .setI18nLabel("replaymod.gui.playeroverview.remembersettings");
     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.create(BUTTON_SOUND, 1.0F));
             playersScrollable.forEach(IGuiCheckbox.class).setChecked(true);
         }
-    }.setLabel("").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.create(BUTTON_SOUND, 1.0F));
             playersScrollable.forEach(IGuiCheckbox.class).setChecked(false);
         }
-    }.setLabel("").setChecked(false);
+    }.setLabel("").setChecked(false).setTooltip(new GuiTooltip().setI18nText("replaymod.gui.playeroverview.hideall"));
 
     {
         setBackground(Background.NONE);
@@ -140,7 +145,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> {

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/MixinRender.java

@@ -0,0 +1,40 @@
+package com.replaymod.extras.playeroverview.mixin;
+
+import com.replaymod.extras.ReplayModExtras;
+import com.replaymod.extras.playeroverview.PlayerOverview;
+import net.minecraft.client.renderer.culling.ICamera;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+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;
+
+/**
+ * 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 shouldRender method.
+ * 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 = Render.class, priority = 1200)
+public abstract class MixinRender {
+    @Inject(method = "shouldRender", at=@At("HEAD"), cancellable = true)
+    public void replayModExtras_isPlayerHidden(Entity entity, ICamera camera, double camX, double camY, double camZ, CallbackInfoReturnable<Boolean> ci) {
+        ReplayModExtras.instance.get(PlayerOverview.class).ifPresent(playerOverview -> {
+            if (entity instanceof EntityPlayer) {
+                EntityPlayer player = (EntityPlayer) entity;
+                if (playerOverview.isHidden(player.getUniqueID())) {
+                    ci.setReturnValue(false);
+                }
+            }
+        });
+    }
+}

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

@@ -17,8 +17,8 @@ public class YoutubeUpload implements Extra {
 
     @SubscribeEvent
     public void onGuiOpen(GuiScreenEvent.InitGuiEvent.Post event) {
-        if (GuiScreen.from(event.getGui()) instanceof GuiRenderingDone) {
+        if (GuiScreen.from(event.gui) instanceof GuiRenderingDone) {
-            GuiRenderingDone gui = (GuiRenderingDone) GuiScreen.from(event.getGui());
+            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

@@ -12,8 +12,8 @@ import com.replaymod.replaystudio.replay.ReplayFile;
 import com.replaymod.replaystudio.replay.ZipReplayFile;
 import com.replaymod.replaystudio.studio.ReplayStudio;
 import de.johni0702.minecraft.gui.container.GuiScreen;
-import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.common.config.Configuration;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.event.FMLInitializationEvent;
 import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
@@ -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()) {
-                new GuiLoginPrompt(apiClient, null, 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/ApiClient.java

@@ -15,13 +15,19 @@ import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
 
 import javax.imageio.ImageIO;
+import javax.net.ssl.HttpsURLConnection;
 import java.awt.image.BufferedImage;
-import java.io.*;
+import java.io.BufferedInputStream;
-import java.net.HttpURLConnection;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
 import java.net.URL;
 import java.util.List;
 import java.util.function.Consumer;
 
+import static com.replaymod.core.utils.Utils.SSL_SOCKET_FACTORY;
+
 public class ApiClient {
 
     private static final Minecraft mc = Minecraft.getMinecraft();
@@ -130,7 +136,11 @@ public class ApiClient {
         QueryBuilder builder = new QueryBuilder(ReplayModApiMethods.get_thumbnail);
         builder.put("id", file);
         URL url = new URL(builder.toString());
-        return ImageIO.read(url);
+        HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
+        connection.setSSLSocketFactory(SSL_SOCKET_FACTORY);
+        try (InputStream in = connection.getInputStream()) {
+            return ImageIO.read(in);
+        }
     }
 
     private boolean cancelDownload = false;
@@ -143,7 +153,8 @@ public class ApiClient {
         builder.put("id", file);
         String url = builder.toString();
         URL website = new URL(url);
-        HttpURLConnection con = (HttpURLConnection) website.openConnection();
+        HttpsURLConnection con = (HttpsURLConnection) website.openConnection();
+        con.setSSLSocketFactory(SSL_SOCKET_FACTORY);
 
         int fileSize = con.getContentLength();
 

src/main/java/com/replaymod/online/api/SimpleApiClient.java

@@ -7,12 +7,14 @@ import com.google.gson.JsonParser;
 import com.replaymod.online.api.replay.holders.ApiError;
 import org.apache.commons.io.IOUtils;
 
+import javax.net.ssl.HttpsURLConnection;
 import java.io.IOException;
 import java.io.InputStream;
-import java.net.HttpURLConnection;
 import java.net.URL;
 import java.util.Map;
 
+import static com.replaymod.core.utils.Utils.SSL_SOCKET_FACTORY;
+
 public class SimpleApiClient {
 
     private static final JsonParser jsonParser = new JsonParser();
@@ -72,10 +74,11 @@ public class SimpleApiClient {
         // read response
         String responseContent = null;
         InputStream is = null;
-        HttpURLConnection httpUrlConnection = null;
+        HttpsURLConnection httpUrlConnection = null;
         try {
             URL url = new URL(urlString);
-            httpUrlConnection = (HttpURLConnection) url.openConnection();
+            httpUrlConnection = (HttpsURLConnection) url.openConnection();
+            httpUrlConnection.setSSLSocketFactory(SSL_SOCKET_FACTORY);
 
             httpUrlConnection.setRequestMethod("GET");
 

src/main/java/com/replaymod/online/api/replay/FileUploader.java

@@ -9,16 +9,18 @@ import lombok.RequiredArgsConstructor;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.StringUtils;
 
+import javax.net.ssl.HttpsURLConnection;
 import java.io.DataOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.InputStream;
-import java.net.HttpURLConnection;
 import java.net.URL;
 import java.net.URLEncoder;
 import java.util.Set;
 import java.util.function.Consumer;
 
+import static com.replaymod.core.utils.Utils.SSL_SOCKET_FACTORY;
+
 @RequiredArgsConstructor
 public class FileUploader {
     private static final Gson gson = new Gson();
@@ -48,7 +50,8 @@ public class FileUploader {
             postData += "&name=" + URLEncoder.encode(filename, "UTF-8");
 
             String url = ReplayModApiMethods.upload_file + postData;
-            HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection();
+            HttpsURLConnection con = (HttpsURLConnection) new URL(url).openConnection();
+            con.setSSLSocketFactory(SSL_SOCKET_FACTORY);
             con.setUseCaches(false);
             con.setDoOutput(true);
             con.setRequestMethod("POST");

src/main/java/com/replaymod/online/api/replay/ReplayModApiMethods.java

@@ -2,7 +2,7 @@ package com.replaymod.online.api.replay;
 
 public class ReplayModApiMethods {
 
-    public static final String REPLAYMOD_BASE_URL = "http://ReplayMod.com/api/";
+    public static final String REPLAYMOD_BASE_URL = "https://ReplayMod.com/api/";
 
     public static final String register = REPLAYMOD_BASE_URL+"register";
     public static final String check_authkey = REPLAYMOD_BASE_URL+"check_authkey";

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

@@ -2,11 +2,7 @@ package com.replaymod.online.api.replay.holders;
 
 public enum MinecraftVersion {
 
-    MC_1_8("Minecraft 1.8", "1.8"),
+    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_11("Minecraft 1.11", "1.11"),
-    MC_1_11_2("Minecraft 1.11.2", "1.11.2");
 
     private String niceName, apiName;
 

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

@@ -21,7 +21,7 @@ public class GuiLoginPrompt extends AbstractGuiScreen<GuiLoginPrompt> {
     private GuiLabel noAccountLabel = new GuiLabel(this).setI18nText("replaymod.gui.login.noacc");
     private GuiLabel statusLabel = new GuiLabel(this);
     private GuiButton loginButton = new GuiButton(this).setI18nLabel("replaymod.gui.login").setSize(150, 20).setEnabled(false);
-    private GuiButton cancelButton = new GuiButton(this).setI18nLabel("replaymod.gui.cancel").setSize(150, 20);
+    public GuiButton cancelButton = new GuiButton(this).setI18nLabel("replaymod.gui.cancel").setSize(150, 20);
     private GuiButton registerButton = new GuiButton(this).setI18nLabel("replaymod.gui.register").setSize(150, 20);
     private GuiTextField username = new GuiTextField(this).setSize(145, 20).setMaxLength(16).setFocused(true);
     private GuiPasswordField password = new GuiPasswordField(this).setSize(145, 20)

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

@@ -28,6 +28,7 @@ import de.johni0702.minecraft.gui.container.GuiScreen;
 import de.johni0702.minecraft.gui.element.GuiButton;
 import de.johni0702.minecraft.gui.element.GuiImage;
 import de.johni0702.minecraft.gui.element.GuiLabel;
+import de.johni0702.minecraft.gui.element.GuiTooltip;
 import de.johni0702.minecraft.gui.element.IGuiButton;
 import de.johni0702.minecraft.gui.element.advanced.GuiResourceLoadingList;
 import de.johni0702.minecraft.gui.layout.CustomLayout;
@@ -36,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;
@@ -50,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;
@@ -109,6 +110,7 @@ public class GuiReplayCenter extends GuiScreen {
         public void run() {
             GuiReplayEntry selected = list.getSelected();
             replayButtonPanel.forEach(IGuiButton.class).setEnabled(selected != null);
+            replayButtonPanel.forEach(IGuiButton.class).setTooltip(null);
             if (selected != null) {
                 int replayId = selected.fileInfo.getId();
                 boolean favorited = favoritedReplays.contains(replayId);
@@ -123,10 +125,22 @@ public class GuiReplayCenter extends GuiScreen {
                 favoriteButton.setI18nLabel("replaymod.gui.center." + (favorited ? "unfavorite" : "favorite"));
                 // Only allow button usage for either unfavorite or favorite after they've actually downloaded it
                 favoriteButton.setEnabled(favorited || selected.downloaded);
+                if (favoriteButton.isEnabled()) {
+                    favoriteButton.setTooltip(null);
+                } else {
+                    favoriteButton.setTooltip(new GuiTooltip().setI18nText("replaymod.gui.center.downloadrequired"));
+                }
 
                 // Similar for like/dislike buttons
                 likeButton.setEnabled(selected.downloaded);
                 dislikeButton.setEnabled(selected.downloaded);
+                if (likeButton.isEnabled()) {
+                    likeButton.setTooltip(null);
+                    dislikeButton.setTooltip(null);
+                } else {
+                    likeButton.setTooltip(new GuiTooltip().setI18nText("replaymod.gui.center.downloadrequired"));
+                    dislikeButton.setTooltip(new GuiTooltip().setI18nText("replaymod.gui.center.downloadrequired"));
+                }
                 likeButton.setI18nLabel("replaymod.gui." + (liked ? "removelike" : "like"));
                 dislikeButton.setI18nLabel("replaymod.gui." + (disliked ? "removedislike" : "dislike"));
             }
@@ -322,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);
                     }
                 }
             }
@@ -403,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

@@ -17,7 +17,12 @@ import com.replaymod.replaystudio.studio.ReplayStudio;
 import de.johni0702.minecraft.gui.container.GuiContainer;
 import de.johni0702.minecraft.gui.container.GuiPanel;
 import de.johni0702.minecraft.gui.container.GuiScreen;
-import de.johni0702.minecraft.gui.element.*;
+import de.johni0702.minecraft.gui.element.GuiButton;
+import de.johni0702.minecraft.gui.element.GuiCheckbox;
+import de.johni0702.minecraft.gui.element.GuiImage;
+import de.johni0702.minecraft.gui.element.GuiLabel;
+import de.johni0702.minecraft.gui.element.GuiTextField;
+import de.johni0702.minecraft.gui.element.GuiTooltip;
 import de.johni0702.minecraft.gui.element.advanced.GuiDropdownMenu;
 import de.johni0702.minecraft.gui.element.advanced.GuiProgressBar;
 import de.johni0702.minecraft.gui.element.advanced.GuiTextArea;
@@ -33,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;
@@ -130,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());
@@ -234,6 +238,8 @@ public class GuiUploadReplay extends GuiScreen {
         });
 
         validateInputs();
+        name.onTextChanged(s -> validateInputs());
+        tags.onTextChanged(s -> validateInputs());
     }
 
     public void validateInputs() {

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

@@ -14,9 +14,11 @@ 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.FMLCommonHandler;
 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,
+        @SuppressWarnings("unchecked")
-                event.getGui().height / 4 + 10 + 4 * 24, I18n.format("replaymod.gui.replaycenter"));
+        List<GuiButton> buttonList = event.buttonList;
-        event.getButtonList().add(button);
+        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.gui instanceof GuiMainMenu) {
-            if (event.getButton().id == BUTTON_REPLAY_CENTER) {
+            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/gui/GuiKeyframeRepository.java

@@ -4,6 +4,7 @@ import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.SettableFuture;
 import com.replaymod.core.ReplayMod;
+import com.replaymod.core.utils.Utils;
 import com.replaymod.replay.ReplayModReplay;
 import com.replaymod.replaystudio.pathing.PathingRegistry;
 import com.replaymod.replaystudio.pathing.path.Path;
@@ -11,7 +12,11 @@ import com.replaymod.replaystudio.pathing.path.Timeline;
 import com.replaymod.replaystudio.replay.ReplayFile;
 import de.johni0702.minecraft.gui.GuiRenderer;
 import de.johni0702.minecraft.gui.RenderInfo;
-import de.johni0702.minecraft.gui.container.*;
+import de.johni0702.minecraft.gui.container.AbstractGuiClickableContainer;
+import de.johni0702.minecraft.gui.container.GuiContainer;
+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.GuiLabel;
 import de.johni0702.minecraft.gui.element.GuiTextField;
@@ -41,9 +46,16 @@ public class GuiKeyframeRepository extends GuiScreen implements Closeable {
     public final GuiButton overwriteButton = new GuiButton(buttonPanel).onClick(new Runnable() {
         @Override
         public void run() {
-            timelines.put(selectedEntry.name, currentTimeline);
+            GuiYesNoPopup popup = GuiYesNoPopup.open(GuiKeyframeRepository.this,
-            overwriteButton.setDisabled();
+                    new GuiLabel().setI18nText("replaymod.gui.keyframerepo.overwrite").setColor(Colors.BLACK)
-            save();
+            ).setYesI18nLabel("gui.yes").setNoI18nLabel("gui.no");
+            Utils.addCallback(popup.getFuture(), doIt -> {
+                if (doIt) {
+                    timelines.put(selectedEntry.name, currentTimeline);
+                    overwriteButton.setDisabled();
+                    save();
+                }
+            }, Throwable::printStackTrace);
         }
     }).setSize(75, 20).setI18nLabel("replaymod.gui.overwrite").setDisabled();
     public final GuiButton saveAsButton = new GuiButton(buttonPanel).onClick(new Runnable() {

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

@@ -11,7 +11,7 @@ import com.replaymod.replaystudio.pathing.path.Keyframe;
 import com.replaymod.replaystudio.pathing.path.Path;
 import com.replaymod.replaystudio.pathing.path.Timeline;
 import net.minecraft.client.Minecraft;
-import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
 import javax.annotation.Nullable;
@@ -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/ReplayTimer.java

@@ -2,7 +2,7 @@ package com.replaymod.pathing.player;
 
 import com.replaymod.core.utils.WrappedTimer;
 import net.minecraft.util.Timer;
-import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 import net.minecraftforge.fml.common.eventhandler.Event;
 
 /**
@@ -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/recording/ReplayModRecording.java

@@ -4,8 +4,10 @@ import com.replaymod.core.ReplayMod;
 import com.replaymod.core.utils.Restrictions;
 import com.replaymod.recording.handler.ConnectionEventHandler;
 import com.replaymod.recording.packet.PacketListener;
-import net.minecraftforge.common.MinecraftForge;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandler;
 import net.minecraft.network.NetworkManager;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.event.FMLInitializationEvent;
 import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
@@ -17,6 +19,7 @@ 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";
@@ -51,12 +54,15 @@ 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.newSimpleChannel(Restrictions.PLUGIN_CHANNEL);
+        NetworkRegistry.INSTANCE.newChannel(Restrictions.PLUGIN_CHANNEL, new RestrictionsChannelHandler());
     }
 
+    @ChannelHandler.Sharable
+    private static class RestrictionsChannelHandler extends ChannelDuplexHandler {}
+
     public void initiateRecording(NetworkManager networkManager) {
         connectionEventHandler.onConnectedToServerEvent(networkManager);
     }

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

@@ -40,7 +40,7 @@ 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);

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;
@@ -66,9 +67,6 @@ public class ConnectionEventHandler {
                 worldName = mc.getIntegratedServer().getWorldName();
             } else if (Minecraft.getMinecraft().getCurrentServerData() != null) {
                 worldName = Minecraft.getMinecraft().getCurrentServerData().serverIP;
-            } else if (Minecraft.getMinecraft().isConnectedToRealms()) {
-                // we can't access the server name without tapping too deep in the Realms Library
-                worldName = "A Realms Server";
             } else {
                 logger.info("Recording not started as the world is neither local nor remote (probably a replay).");
                 return;
@@ -77,7 +75,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());

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

@@ -1,22 +1,24 @@
 package com.replaymod.recording.handler;
 
 import com.replaymod.recording.packet.PacketListener;
+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.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.network.Packet;
-import net.minecraft.network.datasync.EntityDataManager;
+import net.minecraft.network.PacketBuffer;
 import net.minecraft.network.play.server.*;
+import net.minecraft.network.play.server.S14PacketEntity.S17PacketEntityLookMove;
 import net.minecraft.server.integrated.IntegratedServer;
-import net.minecraft.util.EnumHand;
+import net.minecraft.util.BlockPos;
-import net.minecraft.util.SoundCategory;
+import net.minecraft.util.MathHelper;
-import net.minecraft.util.SoundEvent;
-import net.minecraft.util.math.BlockPos;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.event.entity.minecart.MinecartInteractEvent;
 import net.minecraftforge.event.entity.player.PlayerSleepInBedEvent;
+import net.minecraftforge.event.entity.player.PlayerUseItemEvent;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.gameevent.PlayerEvent.ItemPickupEvent;
 import net.minecraftforge.fml.common.gameevent.TickEvent;
@@ -30,24 +32,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 +59,7 @@ public class RecordingEventHandler {
 
     public void onPlayerJoin() {
         try {
-            packetListener.save(new SPacketSpawnPlayer(mc.player));
+            packetListener.save(spawnPlayer(mc.thePlayer));
         } catch(Exception e1) {
             e1.printStackTrace();
         }
@@ -65,35 +67,46 @@ public class RecordingEventHandler {
 
     public void onPlayerRespawn() {
         try {
-            packetListener.save(new SPacketSpawnPlayer(mc.player));
+            packetListener.save(spawnPlayer(mc.thePlayer));
         } catch(Exception e) {
             e.printStackTrace();
         }
     }
 
-    public void onClientSound(SoundEvent sound, SoundCategory category,
+    private S0CPacketSpawnPlayer spawnPlayer(EntityPlayer player) {
-                              double x, double y, double z, float volume, float pitch) {
         try {
-            // Send to all other players in ServerWorldEventHandler#playSoundToAllNearExcept
+            S0CPacketSpawnPlayer packet = new S0CPacketSpawnPlayer();
-            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) {
+            ByteBuf bb = Unpooled.buffer();
-        try {
+            PacketBuffer pb = new PacketBuffer(bb);
-            // Send to all other players in ServerWorldEventHandler#playEvent
+
-            packetListener.save(new SPacketEffect(type, pos, data, false));
+            pb.writeVarIntToBuffer(player.getEntityId());
+            pb.writeUuid(EntityPlayer.getUUID(player.getGameProfile()));
+
+            pb.writeInt(MathHelper.floor_double(player.posX * 32.0D));
+            pb.writeInt(MathHelper.floor_double(player.posY * 32.0D));
+            pb.writeInt(MathHelper.floor_double(player.posZ * 32.0D));
+            pb.writeByte((byte) ((int) (player.rotationYaw * 256.0F / 360.0F)));
+            pb.writeByte((byte) ((int) (player.rotationPitch * 256.0F / 360.0F)));
+
+            ItemStack itemstack = player.inventory.getCurrentItem();
+            pb.writeShort(itemstack == null ? 0 : Item.getIdFromItem(itemstack.getItem()));
+
+            player.getDataWatcher().writeTo(pb);
+
+            packet.readPacketData(pb);
+
+            return packet;
         } catch(Exception e) {
             e.printStackTrace();
+            return null;
         }
     }
 
     @SubscribeEvent
     public void onPlayerTick(PlayerTickEvent e) {
         try {
-            if(e.player != mc.player) return;
+            if(e.player != mc.thePlayer) return;
 
             boolean force = false;
             if(lastX == null || lastY == null || lastZ == null) {
@@ -118,14 +131,19 @@ public class RecordingEventHandler {
             lastZ = e.player.posZ;
 
             Packet packet;
-            if (force || Math.abs(dx) > 8.0 || Math.abs(dy) > 8.0 || Math.abs(dz) > 8.0) {
+            if(force || Math.abs(dx) > 4.0 || Math.abs(dy) > 4.0 || Math.abs(dz) > 4.0) {
-                packet = new SPacketEntityTeleport(e.player);
+                int x = MathHelper.floor_double(e.player.posX * 32.0D);
+                int y = MathHelper.floor_double(e.player.posY * 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, e.player.onGround);
             } 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(),
+                packet = new S17PacketEntityLookMove(e.player.getEntityId(),
-                        (short) Math.round(dx * 4096), (short) Math.round(dy * 4096), (short) Math.round(dz * 4096),
+                        (byte) Math.round(dx * 32), (byte) Math.round(dy * 32), (byte) Math.round(dz * 32),
                         newYaw, newPitch, e.player.onGround);
             }
 
@@ -135,16 +153,37 @@ 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));
+                S19PacketEntityHeadLook head = new S19PacketEntityHeadLook();
+                ByteBuf bb1 = Unpooled.buffer();
+                PacketBuffer pb1 = new PacketBuffer(bb1);
+
+                pb1.writeVarIntToBuffer(e.player.getEntityId());
+                pb1.writeByte(rotationYawHead);
+
+                head.readPacketData(pb1);
+
+                packetListener.save(head);
+
                 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) {
+            if(e.player.swingProgressInt == 1) {
-                packetListener.save(new SPacketAnimation(e.player, e.player.swingingHand == EnumHand.MAIN_HAND ? 0 : 3));
+                S0BPacketAnimation pac = new S0BPacketAnimation();
+
+                ByteBuf bb = Unpooled.buffer();
+                PacketBuffer pb = new PacketBuffer(bb);
+
+                pb.writeVarIntToBuffer(e.player.getEntityId());
+                pb.writeByte(0);
+
+                pac.readPacketData(pb);
+
+                packetListener.save(pac);
             }
 
 			/*
@@ -168,62 +207,75 @@ public class RecordingEventHandler {
 			 */
 
             //Inventory Handling
-            if (playerItems[0] != mc.player.getHeldItem(EnumHand.MAIN_HAND)) {
+            if(playerItems[0] != mc.thePlayer.getHeldItem()) {
-                playerItems[0] = mc.player.getHeldItem(EnumHand.MAIN_HAND);
+                playerItems[0] = mc.thePlayer.getHeldItem();
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.MAINHAND, playerItems[0]));
+                S04PacketEntityEquipment pee = new S04PacketEntityEquipment(e.player.getEntityId(), 0, playerItems[0]);
+                packetListener.save(pee);
             }
 
-            if (playerItems[1] != mc.player.getHeldItem(EnumHand.OFF_HAND)) {
+            if(playerItems[1] != mc.thePlayer.inventory.armorInventory[0]) {
-                playerItems[1] = mc.player.getHeldItem(EnumHand.OFF_HAND);
+                playerItems[1] = mc.thePlayer.inventory.armorInventory[0];
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.OFFHAND, playerItems[1]));
+                S04PacketEntityEquipment pee = new S04PacketEntityEquipment(e.player.getEntityId(), 1, playerItems[1]);
+                packetListener.save(pee);
             }
 
-            if (playerItems[2] != mc.player.getItemStackFromSlot(EntityEquipmentSlot.FEET)) {
+            if(playerItems[2] != mc.thePlayer.inventory.armorInventory[1]) {
-                playerItems[2] = mc.player.getItemStackFromSlot(EntityEquipmentSlot.FEET);
+                playerItems[2] = mc.thePlayer.inventory.armorInventory[1];
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.FEET, playerItems[2]));
+                S04PacketEntityEquipment pee = new S04PacketEntityEquipment(e.player.getEntityId(), 2, playerItems[2]);
+                packetListener.save(pee);
             }
 
-            if (playerItems[3] != mc.player.getItemStackFromSlot(EntityEquipmentSlot.LEGS)) {
+            if(playerItems[3] != mc.thePlayer.inventory.armorInventory[2]) {
-                playerItems[3] = mc.player.getItemStackFromSlot(EntityEquipmentSlot.LEGS);
+                playerItems[3] = mc.thePlayer.inventory.armorInventory[2];
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.LEGS, playerItems[3]));
+                S04PacketEntityEquipment pee = new S04PacketEntityEquipment(e.player.getEntityId(), 3, playerItems[3]);
+                packetListener.save(pee);
             }
 
-            if (playerItems[4] != mc.player.getItemStackFromSlot(EntityEquipmentSlot.CHEST)) {
+            if(playerItems[4] != mc.thePlayer.inventory.armorInventory[3]) {
-                playerItems[4] = mc.player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
+                playerItems[4] = mc.thePlayer.inventory.armorInventory[3];
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.CHEST, playerItems[4]));
+                S04PacketEntityEquipment pee = new S04PacketEntityEquipment(e.player.getEntityId(), 4, playerItems[4]);
-            }
+                packetListener.save(pee);
-
-            if (playerItems[5] != mc.player.getItemStackFromSlot(EntityEquipmentSlot.HEAD)) {
-                playerItems[5] = mc.player.getItemStackFromSlot(EntityEquipmentSlot.HEAD);
-                packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.HEAD, playerItems[5]));
             }
 
             //Leaving Ride
 
-            if((!mc.player.isRiding() && lastRiding != -1) ||
+            if((!mc.thePlayer.isRiding() && lastRiding != -1) ||
-                    (mc.player.isRiding() && lastRiding != mc.player.getRidingEntity().getEntityId())) {
+                    (mc.thePlayer.isRiding() && lastRiding != mc.thePlayer.ridingEntity.getEntityId())) {
-                if(!mc.player.isRiding()) {
+                if(!mc.thePlayer.isRiding()) {
                     lastRiding = -1;
                 } else {
-                    lastRiding = mc.player.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.player.isPlayerSleeping() && wasSleeping) {
+            if(!mc.thePlayer.isPlayerSleeping() && wasSleeping) {
-                packetListener.save(new SPacketAnimation(e.player, 2));
+                S0BPacketAnimation pac = new S0BPacketAnimation();
-                wasSleeping = false;
-            }
 
-            // Active hand (e.g. eating, drinking, blocking)
+                ByteBuf bb = Unpooled.buffer();
-            if (mc.player.isHandActive() ^ wasHandActive || mc.player.getActiveHand() != lastActiveHand) {
+                PacketBuffer pb = new PacketBuffer(bb);
-                wasHandActive = mc.player.isHandActive();
+
-                lastActiveHand = mc.player.getActiveHand();
+                pb.writeVarIntToBuffer(e.player.getEntityId());
-                EntityDataManager dataManager = new EntityDataManager(null);
+                pb.writeByte(2);
-                int state = (wasHandActive ? 1 : 0) | (lastActiveHand == EnumHand.OFF_HAND ? 2 : 0);
+
-                dataManager.register(EntityLiving.HAND_STATES, (byte) state);
+                pac.readPacketData(pb);
-                packetListener.save(new SPacketEntityMetadata(mc.player.getEntityId(), dataManager, true));
+
+                packetListener.save(pac);
+
+                wasSleeping = false;
             }
 
         } catch(Exception e1) {
@@ -234,8 +286,27 @@ public class RecordingEventHandler {
     @SubscribeEvent
     public void onPickupItem(ItemPickupEvent event) {
         try {
-            packetListener.save(new SPacketCollectItem(event.pickedUp.getEntityId(), event.player.getEntityId(),
+            packetListener.save(new S0DPacketCollectItem(event.pickedUp.getEntityId(), event.player.getEntityId()));
-                    event.pickedUp.getEntityItem().getMaxStackSize()));
+        } catch(Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @SubscribeEvent
+    public void onStartEating(PlayerUseItemEvent.Start event) {
+        try {
+            if(!event.entityPlayer.isEating()) return;
+            S0BPacketAnimation packet = new S0BPacketAnimation();
+
+            ByteBuf bb = Unpooled.buffer();
+            PacketBuffer pb = new PacketBuffer(bb);
+
+            pb.writeVarIntToBuffer(event.entityPlayer.getEntityId());
+            pb.writeByte(3);
+
+            packet.readPacketData(pb);
+
+            packetListener.save(packet);
         } catch(Exception e) {
             e.printStackTrace();
         }
@@ -244,11 +315,21 @@ public class RecordingEventHandler {
     @SubscribeEvent
     public void onSleep(PlayerSleepInBedEvent event) {
         try {
-            if (event.getEntityPlayer() != mc.player) {
+            if(event.entityPlayer != mc.thePlayer) {
                 return;
             }
 
-            packetListener.save(new SPacketUseBed(event.getEntityPlayer(), event.getPos()));
+            S0APacketUseBed pub = new S0APacketUseBed();
+
+            ByteBuf buf = Unpooled.buffer();
+            PacketBuffer pbuf = new PacketBuffer(buf);
+
+            pbuf.writeVarIntToBuffer(event.entityPlayer.getEntityId());
+            pbuf.writeBlockPos(event.pos);
+
+            pub.readPacketData(pbuf);
+
+            packetListener.save(pub);
 
             wasSleeping = true;
 
@@ -260,22 +341,33 @@ public class RecordingEventHandler {
     @SubscribeEvent
     public void enterMinecart(MinecartInteractEvent event) {
         try {
-            if(event.getEntity() != mc.player) {
+            if(event.player != mc.thePlayer) {
                 return;
             }
 
-            packetListener.save(new SPacketEntityAttach(event.getPlayer(), event.getMinecart()));
+            S1BPacketEntityAttach pea = new S1BPacketEntityAttach();
 
-            lastRiding = event.getMinecart().getEntityId();
+            ByteBuf buf = Unpooled.buffer();
+            PacketBuffer pbuf = new PacketBuffer(buf);
+
+            pbuf.writeInt(event.player.getEntityId());
+            pbuf.writeInt(event.minecart.getEntityId());
+            pbuf.writeBoolean(false);
+
+            pea.readPacketData(pbuf);
+
+            packetListener.save(pea);
+
+            lastRiding = event.minecart.getEntityId();
         } catch(Exception e) {
             e.printStackTrace();
         }
     }
 
     public void onBlockBreakAnim(int breakerId, BlockPos pos, int progress) {
-        EntityPlayer thePlayer = mc.player;
+        EntityPlayer thePlayer = mc.thePlayer;
         if (thePlayer != null && breakerId == thePlayer.getEntityId()) {
-            packetListener.save(new SPacketBlockBreakAnim(breakerId, pos, progress));
+            packetListener.save(new S25PacketBlockBreakAnim(breakerId, pos, progress));
         }
     }
 

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

@@ -4,8 +4,8 @@ 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.S07PacketRespawn;
-import net.minecraft.network.play.server.SPacketRespawn;
+import net.minecraft.network.play.server.S38PacketPlayerListItem;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
@@ -36,15 +36,15 @@ public abstract class MixinNetHandlerPlayClient {
      * @param ci Callback info
      */
     @Inject(method = "handlePlayerListItem", at=@At("HEAD"))
-    public void recordOwnJoin(SPacketPlayerListItem packet, CallbackInfo ci) {
+    public void recordOwnJoin(S38PacketPlayerListItem packet, CallbackInfo ci) {
-        if (gameController.player == null) return;
+        if (gameController.thePlayer == null) return;
 
         RecordingEventHandler handler = getRecordingEventHandler();
-        if (handler != null && packet.getAction() == SPacketPlayerListItem.Action.ADD_PLAYER) {
+        if (handler != null && packet.getAction() == S38PacketPlayerListItem.Action.ADD_PLAYER) {
-            for (SPacketPlayerListItem.AddPlayerData data : packet.getEntries()) {
+            for (S38PacketPlayerListItem.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().player.getGameProfile().getId())
+                if (data.getProfile().getId().equals(Minecraft.getMinecraft().thePlayer.getGameProfile().getId())
                         && !playerInfoMap.containsKey(data.getProfile().getId())) {
                     handler.onPlayerJoin();
                 }
@@ -55,12 +55,12 @@ public abstract class MixinNetHandlerPlayClient {
     /**
      * 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(S38PacketPlayerListItem, 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/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.player, type, pos, data);
-    }
-}

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

@@ -2,7 +2,7 @@ package com.replaymod.recording.mixin;
 
 import com.replaymod.recording.handler.RecordingEventHandler;
 import net.minecraft.client.renderer.RenderGlobal;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.BlockPos;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;

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.player) {
-            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.player) {
-            // 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

@@ -9,24 +9,21 @@ 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.minecraft.util.ChatComponentText;
 import net.minecraftforge.fml.common.network.internal.FMLProxyPacket;
 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.*;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.UUID;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
@@ -87,13 +84,16 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
 
     public void save(Packet packet) {
         try {
-            if(packet instanceof SPacketSpawnPlayer) {
+            if(packet instanceof S0CPacketSpawnPlayer) {
-                UUID uuid = ((SPacketSpawnPlayer) packet).getUniqueId();
+                UUID uuid = ((S0CPacketSpawnPlayer) packet).getPlayer();
                 Set<String> uuids = new HashSet<>(Arrays.asList(metaData.getPlayers()));
                 uuids.add(uuid.toString());
                 metaData.setPlayers(uuids.toArray(new String[uuids.size()]));
                 saveMetaData();
             }
+            if (packet instanceof S46PacketSetCompressionLevel) {
+                return; // Replay data is never compressed on the packet level
+            }
 
             byte[] bytes = getPacketData(packet);
             long now = System.currentTimeMillis();
@@ -154,16 +154,16 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
             try {
                 Packet packet = (Packet) msg;
 
-                if(packet instanceof SPacketCollectItem) {
+                if(packet instanceof S0DPacketCollectItem) {
-                    if(mc.player != null ||
+                    if(mc.thePlayer != null ||
-                            ((SPacketCollectItem) packet).getEntityID() == mc.player.getEntityId()) {
+                            ((S0DPacketCollectItem) packet).getEntityID() == mc.thePlayer.getEntityId()) {
                         super.channelRead(ctx, msg);
                         return;
                     }
                 }
 
-                if (packet instanceof SPacketResourcePackSend) {
+                if (packet instanceof S48PacketResourcePackSend) {
-                    save(resourcePackRecorder.handleResourcePack((SPacketResourcePackSend) packet));
+                    save(resourcePackRecorder.handleResourcePack((S48PacketResourcePackSend) packet));
                     return;
                 }
 
@@ -176,10 +176,10 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
 
                 save(packet);
 
-                if (packet instanceof SPacketCustomPayload) {
+                if (packet instanceof S3FPacketCustomPayload) {
-                    SPacketCustomPayload p = (SPacketCustomPayload) packet;
+                    S3FPacketCustomPayload p = (S3FPacketCustomPayload) packet;
                     if (Restrictions.PLUGIN_CHANNEL.equals(p.getChannelName())) {
-                        packet = new SPacketDisconnect(new TextComponentString("Please update to view this replay."));
+                        packet = new S40PacketDisconnect(new ChatComponentText("Please update to view this replay."));
                         save(packet);
                     }
                 }
@@ -192,31 +192,27 @@ 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) {
+        if(packet instanceof S0FPacketSpawnMob) {
-            SPacketSpawnMob p = (SPacketSpawnMob) packet;
+            S0FPacketSpawnMob p = (S0FPacketSpawnMob) packet;
-            if (p.dataManager == null) {
+            if (p.field_149043_l == null) {
-                p.dataManager = new EntityDataManager(null);
+                p.field_149043_l = new DataWatcher(null);
-                if (p.getDataManagerEntries() != null) {
+                if(p.func_149027_c() != null) {
-                    for (EntityDataManager.DataEntry<?> entry : p.getDataManagerEntries()) {
+                    for(DataWatcher.WatchableObject wo : (List<DataWatcher.WatchableObject>) p.func_149027_c()) {
-                        DataManager_set(p.dataManager, entry);
+                        p.field_149043_l.addObject(wo.getDataValueId(), wo.getObject());
                     }
                 }
             }
         }
 
-        if (packet instanceof SPacketSpawnPlayer) {
+        if(packet instanceof S0CPacketSpawnPlayer) {
-            SPacketSpawnPlayer p = (SPacketSpawnPlayer) packet;
+            S0CPacketSpawnPlayer p = (S0CPacketSpawnPlayer) packet;
             if (p.watcher == null) {
-                p.watcher = new EntityDataManager(null);
+                p.watcher = new DataWatcher(null);
-                if (p.getDataManagerEntries() != null) {
+                if(p.func_148944_c() != null) {
-                    for (EntityDataManager.DataEntry<?> entry : p.getDataManagerEntries()) {
+                    for(DataWatcher.WatchableObject wo : p.func_148944_c()) {
-                        DataManager_set(p.watcher, entry);
+                        p.watcher.addObject(wo.getDataValueId(), wo.getObject());
                     }
                 }
             }
@@ -228,7 +224,7 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
         }
         ByteBuf byteBuf = Unpooled.buffer();
         PacketBuffer packetBuffer = new PacketBuffer(byteBuf);
-        packetBuffer.writeVarInt(packetId);
+        packetBuffer.writeVarIntToBuffer(packetId);
         packet.writePacketData(packetBuffer);
 
         byteBuf.readerIndex(0);

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

@@ -15,8 +15,8 @@ import net.minecraft.client.network.NetHandlerPlayClient;
 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.client.C19PacketResourcePackStatus;
-import net.minecraft.network.play.server.SPacketResourcePackSend;
+import net.minecraft.network.play.server.S48PacketResourcePackSend;
 import net.minecraft.util.HttpUtil;
 import org.apache.commons.io.FileUtils;
 import org.apache.logging.log4j.LogManager;
@@ -26,6 +26,7 @@ import javax.annotation.Nonnull;
 import java.io.File;
 import java.io.IOException;
 import java.io.OutputStream;
+import java.util.HashMap;
 import java.util.Map;
 
 /**
@@ -52,6 +53,9 @@ public class ResourcePackRecorder {
             boolean doWrite = false; // Whether we are the first and have to write it
             synchronized (replayFile) { // Need to read, modify and write the resource pack index atomically
                 Map<Integer, String> index = replayFile.getResourcePackIndex();
+                if (index == null) {
+                    index = new HashMap<>();
+                }
                 if (!index.containsValue(hash)) {
                     // Hash is unknown, we have to write the resource pack ourselves
                     doWrite = true;
@@ -70,9 +74,9 @@ public class ResourcePackRecorder {
         }
     }
 
-    public synchronized SPacketResourcePackSend handleResourcePack(SPacketResourcePackSend packet) {
+    public synchronized S48PacketResourcePackSend handleResourcePack(S48PacketResourcePackSend packet) {
         final int requestId = nextRequestId++;
-        final NetHandlerPlayClient netHandler = mc.getConnection();
+        final NetHandlerPlayClient netHandler = mc.getNetHandler();
         final NetworkManager netManager = netHandler.getNetworkManager();
         final String url = packet.getURL();
         final String hash = packet.getHash();
@@ -83,60 +87,60 @@ public class ResourcePackRecorder {
             final File levelDir = new File(savesDir, levelName);
 
             if (levelDir.isFile()) {
-                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.ACCEPTED));
+                netManager.sendPacket(new C19PacketResourcePackStatus(hash, C19PacketResourcePackStatus.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));
+                        netManager.sendPacket(new C19PacketResourcePackStatus(hash, C19PacketResourcePackStatus.Action.SUCCESSFULLY_LOADED));
                     }
 
                     @Override
                     public void onFailure(@Nonnull Throwable throwable) {
-                        netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
+                        netManager.sendPacket(new C19PacketResourcePackStatus(hash, C19PacketResourcePackStatus.Action.FAILED_DOWNLOAD));
                     }
                 });
             } else {
-                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
+                netManager.sendPacket(new C19PacketResourcePackStatus(hash, C19PacketResourcePackStatus.Action.FAILED_DOWNLOAD));
             }
         } else {
             final ServerData serverData = mc.getCurrentServerData();
             if (serverData != null && serverData.getResourceMode() == ServerData.ServerResourceMode.ENABLED) {
-                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.ACCEPTED));
+                netManager.sendPacket(new C19PacketResourcePackStatus(hash, C19PacketResourcePackStatus.Action.ACCEPTED));
                 downloadResourcePackFuture(requestId, url, hash);
             } else if (serverData != null && serverData.getResourceMode() != ServerData.ServerResourceMode.PROMPT) {
-                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.DECLINED));
+                netManager.sendPacket(new C19PacketResourcePackStatus(hash, C19PacketResourcePackStatus.Action.DECLINED));
             } else {
                 mc.addScheduledTask(() -> mc.displayGuiScreen(new GuiYesNo((result, id) -> {
                     if (serverData != null) {
                         serverData.setResourceMode(result ? ServerData.ServerResourceMode.ENABLED : ServerData.ServerResourceMode.DISABLED);
                     }
                     if (result) {
-                        netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.ACCEPTED));
+                        netManager.sendPacket(new C19PacketResourcePackStatus(hash, C19PacketResourcePackStatus.Action.ACCEPTED));
                         downloadResourcePackFuture(requestId, url, hash);
                     } else {
-                        netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.DECLINED));
+                        netManager.sendPacket(new C19PacketResourcePackStatus(hash, C19PacketResourcePackStatus.Action.DECLINED));
                     }
 
-                    ServerList.saveSingleServer(serverData);
+                    ServerList.func_147414_b(serverData);
                     mc.displayGuiScreen(null);
                 }, I18n.format("multiplayer.texturePrompt.line1"), I18n.format("multiplayer.texturePrompt.line2"), 0)));
             }
         }
 
-        return new SPacketResourcePackSend("replay://" + requestId, "");
+        return new S48PacketResourcePackSend("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));
+                mc.getNetHandler().addToSendQueue(new C19PacketResourcePackStatus(hash, C19PacketResourcePackStatus.Action.SUCCESSFULLY_LOADED));
             }
 
             @Override
             public void onFailure(@Nonnull Throwable throwable) {
-                mc.getConnection().sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
+                mc.getNetHandler().addToSendQueue(new C19PacketResourcePackStatus(hash, C19PacketResourcePackStatus.Action.FAILED_DOWNLOAD));
             }
         });
     }
@@ -186,7 +190,7 @@ public class ResourcePackRecorder {
 
             Futures.getUnchecked(mc.addScheduledTask(() -> mc.displayGuiScreen(guiScreen)));
 
-            Map<String, String> sessionInfo = ResourcePackRepository.getDownloadHeaders();
+            Map<String, String> sessionInfo = Minecraft.getSessionInfo();
             repo.downloadingPacks = HttpUtil.downloadResourcePack(file, url, sessionInfo, 50 * 1024 * 1024, guiScreen, mc.getProxy());
             Futures.addCallback(repo.downloadingPacks, new FutureCallback<Object>() {
                 @Override

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

@@ -5,8 +5,8 @@ import com.replaymod.render.utils.RenderJob;
 import com.replaymod.replay.events.ReplayCloseEvent;
 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.FMLCommonHandler;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
@@ -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,6 +2,7 @@ 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 net.minecraft.client.Minecraft;
@@ -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 {
+    public VideoWriter(final VideoRenderer renderer) throws IOException {
-        this.settings = settings;
+        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/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)
+            processQueue(queue);
-            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);
-                }
-            }
         });
 
         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);
@@ -80,8 +82,8 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
                 }
             }).setMinSize(new Dimension(0, 20)).setValues(RenderSettings.EncodingPreset.values());
 
-    public final GuiNumberField videoWidth = new GuiNumberField().setSize(50, 20).setMinValue(1);
+    public final GuiNumberField videoWidth = new GuiNumberField().setSize(50, 20).setMinValue(1).setValidateOnFocusChange(true);
-    public final GuiNumberField videoHeight = new GuiNumberField().setSize(50, 20).setMinValue(1);
+    public final GuiNumberField videoHeight = new GuiNumberField().setSize(50, 20).setMinValue(1).setValidateOnFocusChange(true);
     public final GuiSlider frameRateSlider = new GuiSlider().onValueChanged(new Runnable() {
         @Override
         public void run() {
@@ -93,7 +95,7 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
             .setLayout(new HorizontalLayout(HorizontalLayout.Alignment.RIGHT).setSpacing(2))
             .addElements(new HorizontalLayout.Data(0.5), videoWidth, new GuiLabel().setText("*"), videoHeight);
 
-    public final GuiNumberField bitRateField = new GuiNumberField().setValue(10).setSize(50, 20);
+    public final GuiNumberField bitRateField = new GuiNumberField().setValue(10).setSize(50, 20).setValidateOnFocusChange(true);
     public final GuiDropdownMenu<String> bitRateUnit = new GuiDropdownMenu<String>()
             .setSize(50, 20).setValues("bps", "kbps", "mbps").setSelected("mbps");
 
@@ -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) {
+            } catch (VideoWriter.NoFFmpegException e) {
-                e.printStackTrace();
+                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");
+                error(LOGGER, GuiRenderSettings.this, CrashReport.makeCrashReport(t, "Rendering video"), () -> {});
-                throw new ReportedException(crashReport);
+                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

@@ -10,7 +10,7 @@ import net.minecraft.client.renderer.chunk.RenderChunk;
 
 import java.lang.reflect.Field;
 import java.util.Iterator;
-import java.util.concurrent.PriorityBlockingQueue;
+import java.util.concurrent.BlockingQueue;
 
 public class ChunkLoadingRenderGlobal {
 
@@ -27,10 +27,10 @@ public class ChunkLoadingRenderGlobal {
         this.renderWorker = new CustomChunkRenderWorker(renderDispatcher, new RegionRenderCacheBuilder());
 
         int workerThreads = renderDispatcher.listThreadedWorkers.size();
-        PriorityBlockingQueue<ChunkCompileTaskGenerator> queueChunkUpdates = renderDispatcher.queueChunkUpdates;
+        BlockingQueue<ChunkCompileTaskGenerator> queueChunkUpdates = renderDispatcher.queueChunkUpdates;
         workerJailingQueue = new JailingQueue<>(queueChunkUpdates);
         renderDispatcher.queueChunkUpdates = workerJailingQueue;
-        ChunkCompileTaskGenerator element = new ChunkCompileTaskGenerator(null, null, 0);
+        ChunkCompileTaskGenerator element = new ChunkCompileTaskGenerator(null, null);
         element.finish();
         for (int i = 0; i < workerThreads; i++) {
             queueChunkUpdates.add(element);
@@ -68,7 +68,7 @@ public class ChunkLoadingRenderGlobal {
 
             renderDispatcher.updateChunkNow(renderchunk);
 
-            renderchunk.clearNeedsUpdate();
+            renderchunk.setNeedsUpdate(false);
             iterator.remove();
         }
     }

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,47 @@
+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.WorldRenderer;
+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/WorldRenderer;Lnet/minecraft/entity/Entity;FFFFFF)V"))
+    private void renderNormalParticle(EntityFX fx, WorldRenderer worldRenderer, Entity view, float partialTicks,
+                                float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
+        renderParticle(fx, worldRenderer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
+    }
+
+    @Redirect(method = "renderLitParticles", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/EntityFX;renderParticle(Lnet/minecraft/client/renderer/WorldRenderer;Lnet/minecraft/entity/Entity;FFFFFF)V"))
+    private void renderLitParticle(EntityFX fx, WorldRenderer worldRenderer, Entity view, float partialTicks,
+                                 float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
+        renderParticle(fx, worldRenderer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
+    }
+
+    private void renderParticle(EntityFX fx, WorldRenderer worldRenderer, 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 = 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(worldRenderer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
+    }
+}

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

@@ -12,7 +12,7 @@ import net.minecraft.client.renderer.RenderGlobal;
 import net.minecraft.client.settings.GameSettings;
 import net.minecraft.entity.Entity;
 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;
@@ -118,10 +118,10 @@ 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"))
+    @Redirect(method = "renderWorldPass", 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, RayTraceResult rtr, int alwaysZero, float partialTicks) {
+    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);
         }
     }
 

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.Frustum;
+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(Frustum.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/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

@@ -7,14 +7,15 @@ import net.minecraft.entity.Entity;
 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)
 public abstract class MixinRender {
-    @Inject(method = "renderLivingLabel", at = @At("HEAD"), cancellable = true)
+    @Inject(method = "canRenderName", at = @At("HEAD"), cancellable = true)
-    private void replayModRender_areAllNamesHidden(Entity entityIn, String str, double x, double y, double z, int maxDistance, CallbackInfo ci) {
+    private void replayModRender_areAllNamesHidden(Entity 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

@@ -3,13 +3,16 @@ 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.chunk.RenderChunk;
 import net.minecraft.client.renderer.culling.ICamera;
 import net.minecraft.entity.Entity;
+import net.minecraft.util.BlockPos;
 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(RenderGlobal.class)
 public abstract class MixinRenderGlobal {
@@ -34,8 +37,6 @@ public abstract class MixinRenderGlobal {
 
             do {
                 setupTerrain(viewEntity, partialTicks, camera, replayModRender_hook.nextFrameId(), playerSpectator);
-
-                replayModRender_hook.updateChunks();
             } while (displayListEntitiesDirty);
 
             displayListEntitiesDirty = true;
@@ -45,6 +46,13 @@ public abstract class MixinRenderGlobal {
         }
     }
 
+    @Inject(method = "isPositionInRenderChunk", at = @At("HEAD"), cancellable = true)
+    public void replayModRender_isPositionInRenderChunk(BlockPos pos, RenderChunk chunk, CallbackInfoReturnable<Boolean> ci) {
+        if (replayModRender_hook != null) {
+            ci.setReturnValue(true);
+        }
+    }
+
     @Inject(method = "updateChunks", at = @At("HEAD"), cancellable = true)
     public void replayModRender_updateChunks(long finishTimeNano, CallbackInfo ci) {
         if (replayModRender_hook != null) {

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/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;
@@ -13,18 +14,17 @@ 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 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 net.minecraftforge.fml.common.FMLCommonHandler;
 import org.lwjgl.input.Mouse;
 import org.lwjgl.opengl.Display;
 import org.lwjgl.util.Dimension;
@@ -39,6 +39,7 @@ import java.util.concurrent.Future;
 import java.util.concurrent.FutureTask;
 
 import static com.google.common.collect.Iterables.getLast;
+import static com.replaymod.render.ReplayModRender.LOGGER;
 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;
@@ -54,7 +55,7 @@ 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;
@@ -66,6 +67,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 +78,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 +91,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() {
+    public boolean renderVideo() throws Throwable {
-        MinecraftForge.EVENT_BUS.post(new ReplayRenderEvent.Pre(this));
+        FMLCommonHandler.instance().bus().post(new ReplayRenderEvent.Pre(this));
 
         setup();
 
@@ -136,7 +138,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 +202,9 @@ public class VideoRenderer implements RenderInfo {
         for (SoundCategory category : SoundCategory.values()) {
             mutedSounds.put(category, 0f);
         }
-        originalSoundLevels = mc.gameSettings.soundLevels;
+        originalSoundLevels = mc.gameSettings.mapSoundLevels;
-        mutedSounds.put(SoundCategory.MASTER, originalSoundLevels.get(SoundCategory.MASTER));
+        mutedSounds.put(SoundCategory.MASTER, (Float) originalSoundLevels.get(SoundCategory.MASTER));
-        mc.gameSettings.soundLevels = mutedSounds;
+        mc.gameSettings.mapSoundLevels = mutedSounds;
 
         fps = settings.getFramesPerSecond();
 
@@ -219,6 +225,9 @@ public class VideoRenderer implements RenderInfo {
 
         updateDisplaySize();
 
+        ScaledResolution scaled = new ScaledResolution(mc);
+        gui.toMinecraft().setWorldAndResolution(mc, scaled.getScaledWidth(), scaled.getScaledHeight());
+
         chunkLoadingRenderGlobal = new ChunkLoadingRenderGlobal(mc.renderGlobal);
 
         // Set up our own framebuffer to render the GUI to
@@ -239,15 +248,21 @@ 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();
         }
 
-        new SoundHandler().playRenderSuccessSound();
+        ReplayMod.soundHandler.playRenderSuccessSound();
 
-        new GuiRenderingDone(ReplayModRender.instance, videoWriter.getVideoFile(), totalFrames, settings).display();
+        try {
+            if (!hasFailed()) {
+                new GuiRenderingDone(ReplayModRender.instance, videoWriter.getVideoFile(), totalFrames, settings).display();
+            }
+        } catch (VideoWriter.FFmpegStartupException e) {
+            setFailure(e);
+        }
 
         // Finally, resize the Minecraft framebuffer to the actual width/height of the window
         mc.resize(displayWidth, displayHeight);
@@ -323,7 +338,7 @@ public class VideoRenderer implements RenderInfo {
                     return;
                 }
             }
-        } while (paused);
+        } while (paused && !hasFailed());
     }
 
     private boolean displaySizeChanged() {
@@ -364,6 +379,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);

src/main/java/com/replaymod/render/utils/JailingQueue.java

@@ -2,18 +2,15 @@ package com.replaymod.render.utils;
 
 import com.google.common.base.Preconditions;
 
-import java.util.Collection;
+import java.util.*;
-import java.util.HashSet;
+import java.util.concurrent.BlockingQueue;
-import java.util.Iterator;
-import java.util.Set;
-import java.util.concurrent.PriorityBlockingQueue;
 import java.util.concurrent.TimeUnit;
 
-public class JailingQueue<T> extends PriorityBlockingQueue<T> {
+public class JailingQueue<T> extends AbstractQueue<T> implements BlockingQueue<T> {
-    private final PriorityBlockingQueue<T> delegate;
+    private final BlockingQueue<T> delegate;
     private final Set<Thread> jailed = new HashSet<Thread>();
 
-    public JailingQueue(PriorityBlockingQueue<T> delegate) {
+    public JailingQueue(BlockingQueue<T> delegate) {
         this.delegate = delegate;
     }
 
@@ -62,13 +59,13 @@ public class JailingQueue<T> extends PriorityBlockingQueue<T> {
     }
 
     @Override
-    public void put(T t) {
+    public void put(T t) throws InterruptedException {
         tryAccess();
         delegate.put(t);
     }
 
     @Override
-    public boolean offer(T t, long timeout, TimeUnit unit) {
+    public boolean offer(T t, long timeout, TimeUnit unit) throws InterruptedException {
         tryAccess();
         return delegate.offer(t, timeout, unit);
     }

src/main/java/com/replaymod/render/utils/SoundHandler.java

@@ -12,7 +12,7 @@ import java.io.InputStream;
 
 public class SoundHandler {
 
-    private final ResourceLocation successSoundLocation = new ResourceLocation("replaymod", "renderSuccess.wav");
+    private final ResourceLocation successSoundLocation = new ResourceLocation("replaymod", "render_success.wav");
 
     public void playRenderSuccessSound() {
         playSound(successSoundLocation);

src/main/java/com/replaymod/replay/InputReplayTimer.java

@@ -143,11 +143,10 @@ public class InputReplayTimer extends WrappedTimer {
 
                 // Following are a ton of vanilla keyboard shortcuts, some are removed as they're useless in the
                 // replay viewer as of now
-                // TODO Update maybe add new key bindings
                 // TODO: Translate magic values to Keyboard.KEY_ constants
 
                 if (key == 32 && Keyboard.isKeyDown(61) && mc.ingameGUI != null) {
-                    mc.ingameGUI.getChatGUI().clearChatMessages(false);
+                    mc.ingameGUI.getChatGUI().clearChatMessages();
                 }
 
                 if (key == 31 && Keyboard.isKeyDown(61)) {

src/main/java/com/replaymod/replay/ReplayHandler.java

@@ -23,8 +23,8 @@ import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.network.EnumPacketDirection;
 import net.minecraft.network.NetworkManager;
-import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.fml.client.FMLClientHandler;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 import net.minecraftforge.fml.common.network.handshake.NetworkDispatcher;
 import org.lwjgl.opengl.Display;
 
@@ -76,7 +76,7 @@ public class ReplayHandler {
         Preconditions.checkState(mc.isCallingFromMinecraftThread(), "Must be called from Minecraft thread.");
         this.replayFile = replayFile;
 
-        MinecraftForge.EVENT_BUS.post(new ReplayOpenEvent.Pre(this));
+        FMLCommonHandler.instance().bus().post(new ReplayOpenEvent.Pre(this));
 
         markers = new ArrayList<>(replayFile.getMarkers().or(Collections.emptySet()));
 
@@ -87,7 +87,7 @@ public class ReplayHandler {
         overlay = new GuiReplayOverlay(this);
         overlay.setVisible(true);
 
-        MinecraftForge.EVENT_BUS.post(new ReplayOpenEvent.Post(this));
+        FMLCommonHandler.instance().bus().post(new ReplayOpenEvent.Post(this));
     }
 
     void restartedReplay() {
@@ -101,7 +101,7 @@ public class ReplayHandler {
     public void endReplay() throws IOException {
         Preconditions.checkState(mc.isCallingFromMinecraftThread(), "Must be called from Minecraft thread.");
 
-        MinecraftForge.EVENT_BUS.post(new ReplayCloseEvent.Pre(this));
+        FMLCommonHandler.instance().bus().post(new ReplayCloseEvent.Pre(this));
 
         replaySender.terminateReplay();
 
@@ -110,12 +110,12 @@ public class ReplayHandler {
 
         channel.close().awaitUninterruptibly();
 
-        if (mc.player instanceof CameraEntity) {
+        if (mc.thePlayer instanceof CameraEntity) {
-            mc.player.setDead();
+            mc.thePlayer.setDead();
         }
 
-        if (mc.world != null) {
+        if (mc.theWorld != null) {
-            mc.world.sendQuittingDisconnectingPacket();
+            mc.theWorld.sendQuittingDisconnectingPacket();
             mc.loadWorld(null);
         }
 
@@ -124,11 +124,13 @@ public class ReplayHandler {
 
         ReplayModReplay.instance.replayHandler = null;
 
-        MinecraftForge.EVENT_BUS.post(new ReplayCloseEvent.Post(this));
+        mc.displayGuiScreen(null);
+
+        FMLCommonHandler.instance().bus().post(new ReplayCloseEvent.Post(this));
     }
 
     private void setup() {
-        mc.ingameGUI.getChatGUI().clearChatMessages(true);
+        mc.ingameGUI.getChatGUI().clearChatMessages();
 
         NetworkManager networkManager = new NetworkManager(EnumPacketDirection.CLIENTBOUND) {
             @Override
@@ -209,6 +211,9 @@ public class ReplayHandler {
      */
     public void spectateEntity(Entity e) {
         CameraEntity cameraEntity = getCameraEntity();
+        if (cameraEntity == null) {
+            return; // Cannot spectate if we have no camera
+        }
         if (e == null || e == cameraEntity) {
             spectating = null;
             e = cameraEntity;
@@ -241,7 +246,7 @@ public class ReplayHandler {
      * @return {@code true} if the camera is the view entity, {@code false} otherwise
      */
     public boolean isCameraView() {
-        return mc.player instanceof CameraEntity && mc.player == mc.getRenderViewEntity();
+        return mc.thePlayer instanceof CameraEntity && mc.thePlayer == mc.getRenderViewEntity();
     }
 
     /**
@@ -249,7 +254,7 @@ public class ReplayHandler {
      * @return The camera entity or {@code null} if it does not yet exist
      */
     public CameraEntity getCameraEntity() {
-        return mc.player instanceof CameraEntity ? (CameraEntity) mc.player : null;
+        return mc.thePlayer instanceof CameraEntity ? (CameraEntity) mc.thePlayer : null;
     }
 
     public UUID getSpectatedUUID() {
@@ -328,8 +333,8 @@ public class ReplayHandler {
                 replaySender.setAsyncMode(true);
                 replaySender.setReplaySpeed(0);
 
-                mc.getConnection().getNetworkManager().processReceivedPackets();
+                mc.getNetHandler().getNetworkManager().processReceivedPackets();
-                for (Entity entity : mc.world.loadedEntityList) {
+                for (Entity entity : mc.theWorld.loadedEntityList) {
                     if (entity instanceof EntityOtherPlayerMP) {
                         EntityOtherPlayerMP e = (EntityOtherPlayerMP) entity;
                         e.setPosition(e.otherPlayerMPX, e.otherPlayerMPY, e.otherPlayerMPZ);

src/main/java/com/replaymod/replay/ReplayModReplay.java

@@ -6,7 +6,11 @@ import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.core.utils.ModCompat;
-import com.replaymod.replay.camera.*;
+import com.replaymod.replay.camera.CameraController;
+import com.replaymod.replay.camera.CameraControllerRegistry;
+import com.replaymod.replay.camera.CameraEntity;
+import com.replaymod.replay.camera.ClassicCameraController;
+import com.replaymod.replay.camera.VanillaCameraController;
 import com.replaymod.replay.gui.overlay.GuiMarkerTimeline;
 import com.replaymod.replay.gui.screen.GuiModCompatWarning;
 import com.replaymod.replay.handler.GuiHandler;
@@ -31,6 +35,7 @@ import java.util.Optional;
 @Mod(modid = ReplayModReplay.MOD_ID,
         version = "@MOD_VERSION@",
         acceptedMinecraftVersions = "@MC_VERSION@",
+        acceptableRemoteVersions = "*",
         useMetadata = true)
 public class ReplayModReplay {
     public static final String MOD_ID = "replaymod-replay";
@@ -42,7 +47,7 @@ public class ReplayModReplay {
 
     private final CameraControllerRegistry cameraControllerRegistry = new CameraControllerRegistry();
 
-    private Logger logger;
+    public static Logger LOGGER;
 
     protected ReplayHandler replayHandler;
 
@@ -52,7 +57,7 @@ public class ReplayModReplay {
 
     @Mod.EventHandler
     public void preInit(FMLPreInitializationEvent event) {
-        logger = event.getModLog();
+        LOGGER = event.getModLog();
         core = ReplayMod.instance;
 
         core.getSettingsRegistry().register(Setting.class);
@@ -99,6 +104,7 @@ public class ReplayModReplay {
                         @Override
                         public void onSuccess(NoGuiScreenshot result) {
                             try {
+                                core.printInfoToChat("replaymod.chat.savingthumb");
                                 replayHandler.getReplayFile().writeThumb(result.getImage());
                                 core.printInfoToChat("replaymod.chat.savedthumb");
                             } catch (IOException e) {
@@ -109,6 +115,7 @@ public class ReplayModReplay {
                         @Override
                         public void onFailure(Throwable t) {
                             t.printStackTrace();
+                            core.printWarningToChat("replaymod.chat.failedthumb");
                         }
                     });
                 }
@@ -174,6 +181,9 @@ public class ReplayModReplay {
     }
 
     public void startReplay(ReplayFile replayFile, boolean checkModCompat) throws IOException {
+        if (replayHandler != null) {
+            replayHandler.endReplay();
+        }
         if (checkModCompat) {
             ModCompat.ModInfoDifference modDifference = new ModCompat.ModInfoDifference(replayFile.getModInfo());
             if (!modDifference.getMissing().isEmpty() || !modDifference.getDiffering().isEmpty()) {
@@ -189,7 +199,7 @@ public class ReplayModReplay {
     }
 
     public Logger getLogger() {
-        return logger;
+        return LOGGER;
     }
 
     public CameraControllerRegistry getCameraControllerRegistry() {