Merge branch '1.8' into 1.8.9

91573d9 Update jGui, ReplayStudio and Translations
d71358b Add confirmation dialog before overwriting path presets (fixes #65)
1a55983 Move addCallback method from integration test Utils to main Utils
18c5bcd Be more cooperative with other mods on the ingame menu (fixes #42)
c054fe8 Register keys for simplepathing only once (fixes #63)
f13297c Fix default interpolator handling in keyframe gui and after loading (fixes #64)
391f304 Show error popup if entity tracker fails to load
0e0eaaa Fix entity tracker being set even if it failed loading (fixes #50)
a34bbbc Fix NPE when spectating a player without a camera entity
60879fb Change local class to be an inner class because Srg2Source breaks with it
dfafbec Load translations from github repo, only reload language not all resource packs
8a6ec51 Add missing tooltips to player overview and various missing chat messages
5677fc5 Re-add warning to replay editor
748a91e Fix missing tooltips on fav/like/dislike buttons in replay center
ee24866 Fix upload replay button not being updated when name/tags change
dba085c Move translations into separate repo
3f0e3e7 Fix NPE when receiving Replay|Restrict messages (fixes #16 GH)
40e1d85 Fix crash when saving the last keyframe in the edit gui (fixes #61)
03aada1 Update Mixin to 0.6.8 (fixes #9 GH)
0c1dc65 Fix interpolator being lost when moving keyframe to the end (fixes #62)
fcbbbc9 Add integration test. Run with ./gradlew runIntegrationTest
fe6ded0 Fix movement of keyframe via GuiEditKeyframe not updating selected keyframe
f58fa8f Fix Login GUI not respecting other GUIs opened on startup
4fc3a31 Fix OpenEye being installed into working dir instead of mcDataDir

.gitmodules

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

build.gradle

@@ -7,17 +7,23 @@ buildscript {
             name = "forge"
             url = "http://files.minecraftforge.net/maven"
         }
+        maven {
+            name = "sponge"
+            url = "https://repo.spongepowered.org/maven"
+        }
         maven {
             name = "sonatype"
             url = "https://oss.sonatype.org/content/repositories/snapshots/"
         }
     }
     dependencies {
-        classpath 'net.minecraftforge.gradle:ForgeGradle:1.2-SNAPSHOT'
+        classpath 'net.minecraftforge.gradle:ForgeGradle:2.2-SNAPSHOT'
+        classpath 'org.spongepowered:mixingradle:0.3-SNAPSHOT'
     }
 }
 
-apply plugin: 'forge'
+apply plugin: 'net.minecraftforge.gradle.forge'
+apply plugin: 'org.spongepowered.mixin'
 
 sourceCompatibility = 1.8
 targetCompatibility = 1.8
@@ -26,22 +32,13 @@ version = gitDescribe()
 group= "com.replaymod"
 archivesBaseName = "replaymod"
 
-ext {
-    mixinConfigs = [
-            'compat.shaders', 'extras.playeroverview', 'recording', 'render', 'replay'
-    ].collect {"mixins.${it}.replaymod.json"}
-    mixinSrg = new File(project.buildDir, 'tmp/mixins/mixins.srg')
-    mixinRefMap = new File(project.buildDir, 'tmp/mixins/mixins.replaymod.refmap.json')
-}
-
 minecraft {
-    version = '1.7.10-10.13.4.1558-1.7.10'
+    coreMod = 'com.replaymod.core.LoadingPlugin'
+    version = '1.8.9-11.15.1.1722'
     runDir = "eclipse"
-    mappings = "stable_12"
+    mappings = "stable_22"
     replace '@MOD_VERSION@', project.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} ]"
+    replace '@MC_VERSION@', project.minecraft.version
 }
 
 repositories {
@@ -50,7 +47,7 @@ repositories {
         url = "http://repo.spongepowered.org/maven/"
     }
     maven {
-        url 'https://jitpack.io'
+        url 'https://repo.spacehq.org/content/repositories/snapshots/'
     }
 }
 
@@ -72,22 +69,24 @@ dependencies {
 
     shade 'org.aspectj:aspectjrt:1.8.2'
 
-    shade 'com.github.replaymod:ReplayStudio:181140c'
+    compile project(':ReplayStudio')
 
     testCompile 'junit:junit:4.11'
 }
 
+tasks['idea'].dependsOn ':ReplayStudio:preshadowJar'
+
 jar {
     duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 
     dependsOn configurations.compile
     dependsOn configurations.shade
-
-    from project.mixinRefMap
+    dependsOn ':ReplayStudio:shadowJar'
 
     def shade = {files(
             configurations.compile.findAll {it.name.startsWith 'mixin-'}
                     + configurations.shade
+                    + getTasks().getByPath(':ReplayStudio:shadowJar').outputs.files
     )}
 
     def noticeDir = file("$buildDir/NOTICE")
@@ -116,8 +115,6 @@ jar {
     manifest {
          attributes 'TweakClass': 'org.spongepowered.asm.launch.MixinTweaker',
                  'TweakOrder': '0',
-                 'MixinConfigs': project.mixinConfigs.join(','),
-                 'FMLCorePlugin': 'com.replaymod.core.LoadingPlugin',
                  'FMLAT': 'replaymod_at.cfg'
 	}
 }
@@ -157,8 +154,6 @@ processResources
 
 sourceSets {
     main {
-        // Required so resources are loaded correctly in dev env
-        output.resourcesDir = output.classesDir
         // Directly include jGui into main build
         // This could also be done by including it as a gradle subproject, however
         // doing so caused classpath issues on some IntelliJ versions.
@@ -168,6 +163,7 @@ sourceSets {
         resources {
             srcDir 'jGui/src/main/resources'
         }
+        refMap = "mixins.replaymod.refmap.json"
     }
     integrationTest {
         compileClasspath += main.runtimeClasspath + main.output
@@ -183,21 +179,6 @@ task copySrg(type: Copy, dependsOn: 'genSrgs') {
     into 'build'
 }
 
-reobf.doFirst {
-    if (project.mixinSrg.exists()) {
-        addExtraSrgFile project.mixinSrg
-    }
-}
-
-compileJava.dependsOn copySrg
-compileJava {
-    options.compilerArgs += [
-            "-AoutSrgFile=${project.mixinSrg.canonicalPath}",
-            "-AoutRefMapFile=${project.mixinRefMap.canonicalPath}",
-            "-AreobfSrgFile=${project.file('build/mcp-srg.srg').canonicalPath}"
-    ]
-}
-
 setupDecompWorkspace.dependsOn copySrg
 setupDevWorkspace.dependsOn copySrg
 project.tasks.idea.dependsOn copySrg

settings.gradle

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

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

@@ -3,9 +3,6 @@ package com.replaymod.core;
 import com.google.common.collect.Iterables;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
-import cpw.mods.fml.common.gameevent.TickEvent;
 import de.johni0702.minecraft.gui.container.AbstractGuiOverlay;
 import de.johni0702.minecraft.gui.container.AbstractGuiScreen;
 import de.johni0702.minecraft.gui.container.GuiContainer;
@@ -19,6 +16,9 @@ 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;
@@ -84,21 +84,10 @@ public abstract class AbstractTask implements Task {
 
     private void expectGuiClosed0(int timeout, Runnable onClosed) {
         StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
-        FMLCommonHandler.instance().bus().register(new GuiEventHandler(timeout, stackTrace, onClosed));
-    }
-        public class GuiEventHandler {
+        class EventHandler {
             final net.minecraft.client.gui.GuiScreen currentScreen = mc.currentScreen;
-            private final int timeout;
-            private final StackTraceElement[] stackTrace;
-            private final Runnable onClosed;
             int framesPassed;
 
-            public GuiEventHandler(int timeout, StackTraceElement[] stackTrace, Runnable onClosed) {
-                this.timeout = timeout;
-                this.stackTrace = stackTrace;
-                this.onClosed = onClosed;
-            }
-
             @SubscribeEvent
             public void onGuiOpen(TickEvent.RenderTickEvent event) {
                 if (event.phase != TickEvent.Phase.START) return;
@@ -117,6 +106,8 @@ public abstract class AbstractTask implements Task {
                 }
             }
         }
+        FMLCommonHandler.instance().bus().register(new EventHandler());
+    }
 
     public void expectPopupClosed(Runnable onClosed) {
         expectPopupClosed0(10, onClosed);
@@ -128,25 +119,13 @@ public abstract class AbstractTask implements Task {
 
     private void expectPopupClosed0(int timeout, Runnable onClosed) {
         StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
-        FMLCommonHandler.instance().bus().register(new PopupEventHandler(timeout, stackTrace, onClosed));
-    }
-        public class PopupEventHandler {
-            private final int timeout;
-            private final StackTraceElement[] stackTrace;
-            private final Runnable onClosed;
-            private final AbstractGuiPopup popup;
+        AbstractGuiPopup popup = getPopup(mc.currentScreen);
+        if (popup == null) {
+            throw new IllegalStateException("No popup found.");
+        }
+        class EventHandler {
             int framesPassed;
 
-            public PopupEventHandler(int timeout, StackTraceElement[] stackTrace, Runnable onClosed) {
-                this.timeout = timeout;
-                this.stackTrace = stackTrace;
-                this.onClosed = onClosed;
-                this.popup = getPopup(mc.currentScreen);
-                if (this.popup == null) {
-                    throw new IllegalStateException("No popup found.");
-                }
-            }
-
             @SubscribeEvent
             public void onGuiOpen(TickEvent.RenderTickEvent event) {
                 if (event.phase != TickEvent.Phase.START) return;
@@ -164,6 +143,8 @@ public abstract class AbstractTask implements Task {
                 }
             }
         }
+        FMLCommonHandler.instance().bus().register(new EventHandler());
+    }
 
     private AbstractGuiPopup getPopup(net.minecraft.client.gui.GuiScreen minecraft) {
         GuiContainer<?> container = GuiOverlay.from(minecraft);
@@ -184,21 +165,10 @@ public abstract class AbstractTask implements Task {
 
     public <T> void expectGui(Class<T> guiClass, Consumer<T> onOpen) {
         StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
-        FMLCommonHandler.instance().bus().register(new ExpectGuiEventHandler<T>(guiClass, stackTrace, onOpen));
-    }
-        public class ExpectGuiEventHandler<T> {
-            private final Class<T> guiClass;
-            private final StackTraceElement[] stackTrace;
-            private final Consumer<T> onOpen;
+        class EventHandler {
             net.minecraft.client.gui.GuiScreen currentScreen;
             int framesPassed;
 
-            public ExpectGuiEventHandler(Class<T> guiClass, StackTraceElement[] stackTrace, Consumer<T> onOpen) {
-                this.guiClass = guiClass;
-                this.stackTrace = stackTrace;
-                this.onOpen = onOpen;
-            }
-
             @SubscribeEvent
             public void onGuiOpen(TickEvent.RenderTickEvent event) {
                 if (event.phase != TickEvent.Phase.START) return;
@@ -240,15 +210,16 @@ public abstract class AbstractTask implements Task {
                         return;
                     }
                 }
-                future.setException(new UnexpectedGuiException(guiClass, stackTrace,
-                        foundGui == null ? currentScreen : foundGui));
+                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));
             }
         }
-    class UnexpectedGuiException extends Exception {
-        UnexpectedGuiException(Class<?> guiClass, StackTraceElement[] stackTrace, Object foundGui) {
-            super("Expected instance of " + guiClass + " but found " + foundGui);
-            setStackTrace(Arrays.copyOfRange(stackTrace, 2, stackTrace.length));
-        }
+        FMLCommonHandler.instance().bus().register(new EventHandler());
     }
 
     private void clickNow(int x, int y) {

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

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

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

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

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

@@ -1,12 +1,12 @@
 package com.replaymod.recording;
 
 import com.replaymod.core.AbstractTask;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.client.gui.GuiCreateWorld;
 import net.minecraft.client.gui.GuiMainMenu;
 import net.minecraft.client.gui.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
@@ -17,17 +17,16 @@ public class CreateSPWorld extends AbstractTask {
                 click("Create New World");
                 expectGui(GuiCreateWorld.class, createWorld -> {
                     click("Create New World");
+                    class EventHandler {
+                        @SubscribeEvent
+                        public void onRenderIngame(RenderGameOverlayEvent.Pre event) {
+                            MinecraftForge.EVENT_BUS.unregister(this);
+                            runLater(() -> future.set(null));
+                        }
+                    }
                     MinecraftForge.EVENT_BUS.register(new EventHandler());
                 });
             });
         });
     }
-
-    public class EventHandler {
-        @SubscribeEvent
-        public void onRenderIngame(RenderGameOverlayEvent.Pre event) {
-            MinecraftForge.EVENT_BUS.unregister(this);
-            runLater(() -> future.set(null));
-        }
-    }
 }

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

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

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

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

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

@@ -1,17 +1,15 @@
 package com.replaymod.compat;
 
-import com.replaymod.compat.bettersprinting.DisableBetterSprinting;
 import com.replaymod.compat.optifine.DisableFastRender;
-import com.replaymod.compat.oranges17animations.HideInvisibleEntities;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.Mod;
-import cpw.mods.fml.common.event.FMLInitializationEvent;
-import cpw.mods.fml.common.eventhandler.EventBus;
+import com.replaymod.compat.shaders.ShaderBeginRender;
+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;
 
 @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";
@@ -19,9 +17,8 @@ public class ReplayModCompat {
     @Mod.EventHandler
     public void init(FMLInitializationEvent event) {
         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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -2,14 +2,14 @@ package com.replaymod.core;
 
 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.Multimap;
-import cpw.mods.fml.client.registry.ClientRegistry;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
-import cpw.mods.fml.common.gameevent.InputEvent;
-import cpw.mods.fml.common.gameevent.TickEvent;
 import net.minecraft.client.settings.KeyBinding;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.crash.CrashReportCategory;
 import net.minecraft.util.ReportedException;
+import net.minecraftforge.fml.client.registry.ClientRegistry;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.InputEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
 import org.lwjgl.input.Keyboard;
 
 import java.util.Collection;
@@ -64,7 +64,7 @@ public class KeyBindingRegistry {
 
     public void handleRepeatedKeyBindings() {
         for (Map.Entry<KeyBinding, Collection<Runnable>> entry : repeatedKeyBindingHandlers.asMap().entrySet()) {
-            if (entry.getKey().getIsKeyPressed()) {
+            if (entry.getKey().isKeyDown()) {
                 invokeKeyBindingHandlers(entry.getKey(), entry.getValue());
             }
         }

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

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

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

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

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

@@ -1,9 +1,9 @@
 package com.replaymod.core;
 
 import com.replaymod.core.events.SettingsChangedEvent;
-import cpw.mods.fml.common.FMLCommonHandler;
 import net.minecraft.client.resources.I18n;
 import net.minecraftforge.common.config.Configuration;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;

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

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

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

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

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

@@ -1,10 +1,10 @@
 package com.replaymod.core.handler;
 
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.GuiMainMenu;
 import net.minecraftforge.client.event.GuiScreenEvent;
 import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
 import java.util.List;
 

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

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

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

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

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

@@ -1,11 +1,8 @@
 package com.replaymod.core.utils;
 
-import io.netty.buffer.Unpooled;
 import net.minecraft.network.PacketBuffer;
 import net.minecraft.network.play.server.S3FPacketCustomPayload;
 
-import java.io.IOException;
-
 /**
  * Restrictions set by the server,
  * @see <a href="https://gist.github.com/Johni0702/2547c463e51f65f312cb">Replay Restrictions Gist</a>
@@ -17,8 +14,8 @@ public class Restrictions {
     private boolean onlyFirstPerson;
     private boolean onlyRecordingPlayer;
 
-    public String handle(S3FPacketCustomPayload packet) throws IOException {
-        PacketBuffer buffer = new PacketBuffer(Unpooled.wrappedBuffer(packet.func_149168_d()));
+    public String handle(S3FPacketCustomPayload packet) {
+        PacketBuffer buffer = packet.getBufferData();
         while (buffer.isReadable()) {
             String name = buffer.readStringFromBuffer(64);
             boolean active = buffer.readBoolean();

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

@@ -1,6 +1,5 @@
 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;
@@ -17,15 +16,11 @@ import de.johni0702.minecraft.gui.layout.HorizontalLayout;
 import de.johni0702.minecraft.gui.layout.VerticalLayout;
 import de.johni0702.minecraft.gui.popup.GuiInfoPopup;
 import de.johni0702.minecraft.gui.utils.Colors;
-import lombok.SneakyThrows;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.entity.AbstractClientPlayer;
 import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.network.NetworkPlayerInfo;
+import net.minecraft.client.resources.DefaultPlayerSkin;
 import net.minecraft.crash.CrashReport;
-import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.util.ResourceLocation;
-import org.apache.commons.io.Charsets;
-import org.apache.commons.io.FilenameUtils;
 import org.apache.logging.log4j.Logger;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.util.Dimension;
@@ -41,8 +36,6 @@ 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;
@@ -144,28 +137,15 @@ 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) {
-        EntityPlayer player = Minecraft.getMinecraft().theWorld.getPlayerEntityByUUID(uuid);
-        if (player == null || !(player instanceof AbstractClientPlayer)) {
-            return AbstractClientPlayer.locationStevePng;
+        NetworkPlayerInfo info = getMinecraft().getNetHandler().getPlayerInfo(uuid);
+        ResourceLocation skinLocation;
+        if (info != null && info.hasLocationSkin()) {
+            skinLocation = info.getLocationSkin();
+        } else {
+            skinLocation = DefaultPlayerSkin.getDefaultSkin(uuid);
         }
-        return ((AbstractClientPlayer) player).getLocationSkin();
+        return skinLocation;
     }
 
     public static boolean isCtrlDown() {

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

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

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

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

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

@@ -36,6 +36,7 @@ import de.johni0702.minecraft.gui.popup.GuiYesNoPopup;
 import de.johni0702.minecraft.gui.utils.Colors;
 import net.minecraft.crash.CrashReport;
 import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.FilenameUtils;
 import org.lwjgl.util.ReadableDimension;
 
 import javax.annotation.Nullable;
@@ -124,7 +125,7 @@ public class GuiReplayEditor extends GuiScreen {
     }
 
     public void save(File inputFile, PacketStream.FilterInfo...filters) {
-        save(Utils.fileNameToReplayName(inputFile.getName()), (outputFile) -> {
+        save(FilenameUtils.getBaseName(inputFile.getName()), (outputFile) -> {
             Studio studio = new ReplayStudio();
             File tmpDir = null;
             try {
@@ -219,7 +220,7 @@ public class GuiReplayEditor extends GuiScreen {
                         Utils.error(LOGGER, GuiReplayEditor.this, CrashReport.makeCrashReport(e, "Getting replay folder"), null);
                         return;
                     }
-                    File targetFile = new File(replayFolder, Utils.replayNameToFileName(name));
+                    File targetFile = new File(replayFolder, name + ".mcpr");
                     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,6 +20,7 @@ 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;
@@ -51,7 +52,7 @@ public class GuiTrimPanel extends GuiPanel {
 
     public final GuiDropdownMenu<File> inputReplays = new GuiDropdownMenu<File>(this)
             .setMinSize(new Dimension(200, 20)).onSelection(i -> updateSelectedReplay())
-            .setToString(f -> f == NO_REPLAY ? "" : Utils.fileNameToReplayName(f.getName()));
+            .setToString(f -> f == NO_REPLAY ? "" : FilenameUtils.getBaseName(f.getName()));
 
     public final GuiNumberField startHour = newGuiNumberField();
     public final GuiNumberField startMin = newGuiNumberField();

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

@@ -2,14 +2,14 @@ package com.replaymod.editor.handler;
 
 import com.replaymod.editor.ReplayModEditor;
 import com.replaymod.editor.gui.GuiReplayEditor;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import de.johni0702.minecraft.gui.container.GuiScreen;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.GuiMainMenu;
 import net.minecraft.client.resources.I18n;
 import net.minecraftforge.client.event.GuiScreenEvent;
 import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
 import java.util.List;
 

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

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

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

@@ -4,8 +4,6 @@ import com.replaymod.core.KeyBindingRegistry;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.replay.events.ReplayOpenEvent;
 import com.replaymod.replay.gui.overlay.GuiReplayOverlay;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import de.johni0702.minecraft.gui.GuiRenderer;
 import de.johni0702.minecraft.gui.RenderInfo;
 import de.johni0702.minecraft.gui.container.GuiContainer;
@@ -19,6 +17,8 @@ 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.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.util.Dimension;
 import org.lwjgl.util.ReadableDimension;

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

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

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

@@ -4,21 +4,17 @@ import com.replaymod.core.ReplayMod;
 import com.replaymod.extras.playeroverview.PlayerOverview;
 import com.replaymod.extras.urischeme.UriSchemeExtra;
 import com.replaymod.extras.youtube.YoutubeUpload;
-import cpw.mods.fml.common.Mod;
-import cpw.mods.fml.common.event.FMLInitializationEvent;
-import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+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";
@@ -36,8 +32,6 @@ public class ReplayModExtras {
             OpenEyeExtra.class
     );
 
-    private final Map<Class<? extends Extra>, Extra> instances = new HashMap<>();
-
     public static Logger LOGGER;
 
     @Mod.EventHandler
@@ -51,14 +45,9 @@ public class ReplayModExtras {
             try {
                 Extra extra = cls.newInstance();
                 extra.register(ReplayMod.instance);
-                instances.put(cls, extra);
             } catch (Throwable t) {
                 LOGGER.warn("Failed to load extra " + cls.getName() + ": ", t);
             }
         }
     }
-
-    public <T extends Extra> Optional<T> get(Class<T> cls) {
-        return Optional.ofNullable(instances.get(cls)).map(cls::cast);
-    }
 }

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

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

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

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

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

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

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

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

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

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

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

@@ -3,11 +3,11 @@ package com.replaymod.extras.youtube;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.extras.Extra;
 import com.replaymod.render.gui.GuiRenderingDone;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import de.johni0702.minecraft.gui.container.GuiScreen;
 import de.johni0702.minecraft.gui.element.GuiButton;
 import net.minecraftforge.client.event.GuiScreenEvent;
 import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
 public class YoutubeUpload implements Extra {
     @Override

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

@@ -36,8 +36,6 @@ 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";
@@ -139,7 +137,7 @@ public class YoutubeUploader {
 
             CommandLine commandLine = new CommandLine(settings.getExportCommand());
             commandLine.addArguments(args);
-            LOGGER.info("Re-encoding for ODS with {} {}", settings.getExportCommand(), args);
+            System.out.println("Re-encoding for ODS with " + settings.getExportCommand() + args);
             Process process = new ProcessBuilder(commandLine.toStrings()).directory(videoFile.getParentFile()).start();
 
             final AtomicBoolean active = new AtomicBoolean(true);
@@ -151,7 +149,7 @@ public class YoutubeUploader {
                         char c = (char) in.read();
                         if (c == '\r') {
                             String str = sb.toString();
-                            LOGGER.debug("[FFmpeg] {}", str);
+                            System.out.println(str);
                             if (str.startsWith("frame=")) {
                                 str = str.substring(6).trim();
                                 str = str.substring(0, str.indexOf(' '));

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

@@ -11,14 +11,14 @@ import com.replaymod.replay.events.ReplayCloseEvent;
 import com.replaymod.replaystudio.replay.ReplayFile;
 import com.replaymod.replaystudio.replay.ZipReplayFile;
 import com.replaymod.replaystudio.studio.ReplayStudio;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.Mod;
-import cpw.mods.fml.common.event.FMLInitializationEvent;
-import cpw.mods.fml.common.event.FMLPostInitializationEvent;
-import cpw.mods.fml.common.event.FMLPreInitializationEvent;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import de.johni0702.minecraft.gui.container.GuiScreen;
 import net.minecraftforge.common.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;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import org.apache.logging.log4j.Logger;
 
 import java.io.File;
@@ -29,7 +29,6 @@ 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";
@@ -41,7 +40,7 @@ public class ReplayModOnline {
 
     private ReplayModReplay replayModule;
 
-    public static Logger LOGGER;
+    private Logger logger;
 
     private ApiClient apiClient;
 
@@ -54,7 +53,7 @@ public class ReplayModOnline {
 
     @Mod.EventHandler
     public void preInit(FMLPreInitializationEvent event) {
-        LOGGER = event.getModLog();
+        logger = event.getModLog();
         core = ReplayMod.instance;
         replayModule = ReplayModReplay.instance;
 
@@ -70,7 +69,7 @@ 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());
             }
         }
 
@@ -83,10 +82,7 @@ public class ReplayModOnline {
         // Initial login prompt
         if (!core.getSettingsRegistry().get(Setting.SKIP_LOGIN_PROMPT)) {
             if (!isLoggedIn()) {
-                core.runLater(() -> {
-                    GuiScreen parent = GuiScreen.wrap(getMinecraft().currentScreen);
-                    new GuiLoginPrompt(apiClient, parent, parent, false).display();
-                });
+                core.runLater(() -> new GuiLoginPrompt(apiClient, GuiScreen.wrap(getMinecraft().currentScreen), null, false).display());
             }
         }
     }
@@ -100,7 +96,7 @@ public class ReplayModOnline {
     }
 
     public Logger getLogger() {
-        return LOGGER;
+        return logger;
     }
 
     public ApiClient getApiClient() {

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

@@ -37,6 +37,8 @@ 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;
@@ -49,8 +51,6 @@ import java.util.Date;
 import java.util.HashSet;
 import java.util.Set;
 
-import static com.replaymod.online.ReplayModOnline.LOGGER;
-
 public class GuiReplayCenter extends GuiScreen {
     private final ReplayModOnline mod;
     private final ApiClient apiClient;
@@ -336,7 +336,7 @@ public class GuiReplayCenter extends GuiScreen {
                             }
                         });
                     } catch (Exception e) {
-                        LOGGER.error("Could not load Replay File {}", fileInfo.getId(), e);
+                        FMLLog.getLogger().error("Could not load Replay File " + fileInfo.getId(), e);
                     }
                 }
             }
@@ -417,7 +417,7 @@ public class GuiReplayCenter extends GuiScreen {
             this.downloaded = downloaded;
             ReplayMetaData metaData = fileInfo.getMetadata();
 
-            name.setText(ChatFormatting.UNDERLINE + Utils.fileNameToReplayName(fileInfo.getName()));
+            name.setText(ChatFormatting.UNDERLINE + FilenameUtils.getBaseName(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,7 +2,6 @@ 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;
@@ -28,7 +27,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(), Utils.replayNameToFileName(resultName));
+            final File resultFile = new File(file.getParentFile(), resultName + ".mcpr");
             if (resultFile.exists()) {
                 Futures.addCallback(GuiYesNoPopup.open(GuiSaveModifiedReplay.this,
                         new GuiLabel().setI18nText("replaymod.gui.replaymodified.warning1", resultName).setColor(Colors.BLACK),

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

@@ -38,6 +38,7 @@ 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;
@@ -134,7 +135,7 @@ public class GuiUploadReplay extends GuiScreen {
         }
 
         // Apply to gui
-        name.setText(Utils.fileNameToReplayName(file.getName()));
+        name.setText(FilenameUtils.getBaseName(file.getName()));
         int secs = metaData.getDuration() / 1000;
         durationLabel.setI18nText("replaymod.gui.upload.duration", secs / 60, secs % 60);
         hideServerIP.setEnabled(!metaData.isSingleplayer());

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

@@ -5,8 +5,6 @@ import com.replaymod.online.gui.GuiLoginPrompt;
 import com.replaymod.online.gui.GuiReplayCenter;
 import com.replaymod.online.gui.GuiUploadReplay;
 import com.replaymod.replay.gui.screen.GuiReplayViewer;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import de.johni0702.minecraft.gui.container.AbstractGuiScreen;
 import de.johni0702.minecraft.gui.container.GuiPanel;
 import de.johni0702.minecraft.gui.container.GuiScreen;
@@ -16,6 +14,8 @@ 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;

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

@@ -10,9 +10,9 @@ import com.replaymod.replay.ReplayHandler;
 import com.replaymod.replaystudio.pathing.path.Keyframe;
 import com.replaymod.replaystudio.pathing.path.Path;
 import com.replaymod.replaystudio.pathing.path.Timeline;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.client.Minecraft;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
 import javax.annotation.Nullable;
 import java.util.Iterator;

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

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

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

@@ -1,9 +1,9 @@
 package com.replaymod.pathing.player;
 
 import com.replaymod.core.utils.WrappedTimer;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.eventhandler.Event;
 import net.minecraft.util.Timer;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.eventhandler.Event;
 
 /**
  * Wrapper around the current timer that prevents the timer from advancing by itself.

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

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

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

@@ -4,22 +4,21 @@ import com.replaymod.core.ReplayMod;
 import com.replaymod.core.utils.Restrictions;
 import com.replaymod.recording.handler.ConnectionEventHandler;
 import com.replaymod.recording.packet.PacketListener;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.Mod;
-import cpw.mods.fml.common.event.FMLInitializationEvent;
-import cpw.mods.fml.common.event.FMLPreInitializationEvent;
-import cpw.mods.fml.common.eventhandler.EventBus;
-import cpw.mods.fml.common.network.NetworkRegistry;
 import io.netty.channel.ChannelDuplexHandler;
 import io.netty.channel.ChannelHandler;
 import net.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;
+import net.minecraftforge.fml.common.eventhandler.EventBus;
+import net.minecraftforge.fml.common.network.NetworkRegistry;
 import org.apache.logging.log4j.Logger;
 import org.lwjgl.input.Keyboard;
 
 @Mod(modid = ReplayModRecording.MOD_ID,
         version = "@MOD_VERSION@",
         acceptedMinecraftVersions = "@MC_VERSION@",
-        acceptableRemoteVersions = "*",
         useMetadata = true)
 public class ReplayModRecording {
     public static final String MOD_ID = "replaymod-recording";

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

@@ -2,14 +2,14 @@ package com.replaymod.recording.gui;
 
 import com.replaymod.core.SettingsRegistry;
 import com.replaymod.recording.Setting;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.gui.Gui;
+import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.client.resources.I18n;
 import net.minecraftforge.client.event.RenderGameOverlayEvent;
 import net.minecraftforge.common.MinecraftForge;
-import org.lwjgl.opengl.GL11;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
 import static com.replaymod.core.ReplayMod.TEXTURE;
 import static com.replaymod.core.ReplayMod.TEXTURE_SIZE;
@@ -45,7 +45,8 @@ public class GuiRecordingOverlay {
             FontRenderer fontRenderer = mc.fontRendererObj;
             fontRenderer.drawString(I18n.format("replaymod.gui.recording").toUpperCase(), 30, 18 - (fontRenderer.FONT_HEIGHT / 2), 0xffffffff);
             mc.renderEngine.bindTexture(TEXTURE);
-            GL11.glEnable(GL11.GL_ALPHA_TEST);
+            GlStateManager.resetColor();
+            GlStateManager.enableAlpha();
             Gui.drawModalRectWithCustomSizedTexture(10, 10, 58, 20, 16, 16, TEXTURE_SIZE, TEXTURE_SIZE);
         }
     }

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

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

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

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

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

@@ -1,34 +1,28 @@
 package com.replaymod.recording.handler;
 
 import com.replaymod.recording.packet.PacketListener;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
-import cpw.mods.fml.common.gameevent.PlayerEvent;
-import cpw.mods.fml.common.gameevent.TickEvent;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import net.minecraft.client.Minecraft;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.network.Packet;
 import net.minecraft.network.PacketBuffer;
-import net.minecraft.network.play.server.S04PacketEntityEquipment;
-import net.minecraft.network.play.server.S0APacketUseBed;
-import net.minecraft.network.play.server.S0BPacketAnimation;
-import net.minecraft.network.play.server.S0CPacketSpawnPlayer;
-import net.minecraft.network.play.server.S0DPacketCollectItem;
-import net.minecraft.network.play.server.S12PacketEntityVelocity;
+import net.minecraft.network.play.server.*;
 import net.minecraft.network.play.server.S14PacketEntity.S17PacketEntityLookMove;
-import net.minecraft.network.play.server.S18PacketEntityTeleport;
-import net.minecraft.network.play.server.S19PacketEntityHeadLook;
-import net.minecraft.network.play.server.S1BPacketEntityAttach;
-import net.minecraft.network.play.server.S25PacketBlockBreakAnim;
 import net.minecraft.server.integrated.IntegratedServer;
+import net.minecraft.util.BlockPos;
 import net.minecraft.util.MathHelper;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.event.entity.minecart.MinecartInteractEvent;
 import net.minecraftforge.event.entity.player.PlayerSleepInBedEvent;
 import net.minecraftforge.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;
+import net.minecraftforge.fml.common.gameevent.TickEvent.PlayerTickEvent;
 
 import java.util.Objects;
 
@@ -80,11 +74,37 @@ public class RecordingEventHandler {
     }
 
     private S0CPacketSpawnPlayer spawnPlayer(EntityPlayer player) {
-        return new S0CPacketSpawnPlayer(player);
+        try {
+            S0CPacketSpawnPlayer packet = new S0CPacketSpawnPlayer();
+
+            ByteBuf bb = Unpooled.buffer();
+            PacketBuffer pb = new PacketBuffer(bb);
+
+            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(TickEvent.PlayerTickEvent e) {
+    public void onPlayerTick(PlayerTickEvent e) {
         try {
             if(e.player != mc.thePlayer) return;
 
@@ -92,7 +112,7 @@ public class RecordingEventHandler {
             if(lastX == null || lastY == null || lastZ == null) {
                 force = true;
                 lastX = e.player.posX;
-                lastY = e.player.boundingBox.minY;
+                lastY = e.player.posY;
                 lastZ = e.player.posZ;
             }
 
@@ -103,28 +123,28 @@ public class RecordingEventHandler {
             }
 
             double dx = e.player.posX - lastX;
-            double dy = e.player.boundingBox.minY - lastY;
+            double dy = e.player.posY - lastY;
             double dz = e.player.posZ - lastZ;
 
             lastX = e.player.posX;
-            lastY = e.player.boundingBox.minY;
+            lastY = e.player.posY;
             lastZ = e.player.posZ;
 
             Packet packet;
             if(force || Math.abs(dx) > 4.0 || Math.abs(dy) > 4.0 || Math.abs(dz) > 4.0) {
                 int x = MathHelper.floor_double(e.player.posX * 32.0D);
-                int y = MathHelper.floor_double(e.player.boundingBox.minY * 32.0D);
+                int 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);
+                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 S17PacketEntityLookMove(e.player.getEntityId(),
                         (byte) Math.round(dx * 32), (byte) Math.round(dy * 32), (byte) Math.round(dz * 32),
-                        newYaw, newPitch);
+                        newYaw, newPitch, e.player.onGround);
             }
 
             packetListener.save(packet);
@@ -133,7 +153,16 @@ public class RecordingEventHandler {
             int rotationYawHead = ((int)(e.player.rotationYawHead * 256.0F / 360.0F));
 
             if(!Objects.equals(rotationYawHead, rotationYawHeadBefore)) {
-                packetListener.save(new S19PacketEntityHeadLook(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;
             }
@@ -144,7 +173,17 @@ public class RecordingEventHandler {
             //Animation Packets
             //Swing Animation
             if(e.player.swingProgressInt == 1) {
-                packetListener.save(new S0BPacketAnimation(e.player, 0));
+                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);
             }
 
 			/*
@@ -224,7 +263,17 @@ public class RecordingEventHandler {
 
             //Sleeping
             if(!mc.thePlayer.isPlayerSleeping() && wasSleeping) {
-                packetListener.save(new S0BPacketAnimation(e.player, 2));
+                S0BPacketAnimation pac = new S0BPacketAnimation();
+
+                ByteBuf bb = Unpooled.buffer();
+                PacketBuffer pb = new PacketBuffer(bb);
+
+                pb.writeVarIntToBuffer(e.player.getEntityId());
+                pb.writeByte(2);
+
+                pac.readPacketData(pb);
+
+                packetListener.save(pac);
 
                 wasSleeping = false;
             }
@@ -235,7 +284,7 @@ public class RecordingEventHandler {
     }
 
     @SubscribeEvent
-    public void onPickupItem(PlayerEvent.ItemPickupEvent event) {
+    public void onPickupItem(ItemPickupEvent event) {
         try {
             packetListener.save(new S0DPacketCollectItem(event.pickedUp.getEntityId(), event.player.getEntityId()));
         } catch(Exception e) {
@@ -245,33 +294,80 @@ public class RecordingEventHandler {
 
     @SubscribeEvent
     public void onStartEating(PlayerUseItemEvent.Start event) {
-        if(!event.entityPlayer.isEating()) return;
-        packetListener.save(new S0BPacketAnimation(event.entityPlayer, 3));
+        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();
+        }
     }
 
     @SubscribeEvent
     public void onSleep(PlayerSleepInBedEvent event) {
-        if(event.entityPlayer != mc.thePlayer) {
-            return;
-        }
+        try {
+            if(event.entityPlayer != mc.thePlayer) {
+                return;
+            }
 
-        packetListener.save(new S0APacketUseBed(event.entityPlayer, event.x, event.y, event.z));
-        wasSleeping = true;
+            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;
+
+        } catch(Exception e) {
+            e.printStackTrace();
+        }
     }
 
     @SubscribeEvent
     public void enterMinecart(MinecartInteractEvent event) {
-        if(event.player != mc.thePlayer) {
-            return;
+        try {
+            if(event.player != mc.thePlayer) {
+                return;
+            }
+
+            S1BPacketEntityAttach pea = new S1BPacketEntityAttach();
+
+            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();
         }
-        packetListener.save(new S1BPacketEntityAttach(0, event.player, event.minecart));
-        lastRiding = event.minecart.getEntityId();
     }
 
-    public void onBlockBreakAnim(int breakerId, int x, int y, int z, int progress) {
+    public void onBlockBreakAnim(int breakerId, BlockPos pos, int progress) {
         EntityPlayer thePlayer = mc.thePlayer;
         if (thePlayer != null && breakerId == thePlayer.getEntityId()) {
-            packetListener.save(new S25PacketBlockBreakAnim(breakerId, x, y, z, progress));
+            packetListener.save(new S25PacketBlockBreakAnim(breakerId, pos, progress));
         }
     }
 

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

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

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

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

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

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

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

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

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

@@ -4,7 +4,6 @@ import com.replaymod.core.utils.Restrictions;
 import com.replaymod.replaystudio.data.Marker;
 import com.replaymod.replaystudio.replay.ReplayFile;
 import com.replaymod.replaystudio.replay.ReplayMetaData;
-import cpw.mods.fml.common.network.internal.FMLProxyPacket;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelHandlerContext;
@@ -13,10 +12,12 @@ 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.play.server.*;
 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;
 
@@ -84,7 +85,7 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
     public void save(Packet packet) {
         try {
             if(packet instanceof S0CPacketSpawnPlayer) {
-                UUID uuid = ((S0CPacketSpawnPlayer) packet).field_148955_b.getId();
+                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()]));
@@ -152,23 +153,20 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
 
                 if(packet instanceof S0DPacketCollectItem) {
                     if(mc.thePlayer != null ||
-                            ((S0DPacketCollectItem) packet).func_149353_d() == mc.thePlayer.getEntityId()) {
+                            ((S0DPacketCollectItem) packet).getEntityID() == mc.thePlayer.getEntityId()) {
                         super.channelRead(ctx, msg);
                         return;
                     }
                 }
 
-                if (packet instanceof S3FPacketCustomPayload) {
-                    S3FPacketCustomPayload p = (S3FPacketCustomPayload) packet;
-                    if ("MC|RPack".equals(p.func_149169_c())) {
-                        save(resourcePackRecorder.handleResourcePack(p));
-                        return;
-                    }
+                if (packet instanceof S48PacketResourcePackSend) {
+                    save(resourcePackRecorder.handleResourcePack((S48PacketResourcePackSend) packet));
+                    return;
                 }
 
                 if (packet instanceof FMLProxyPacket) {
                     // This packet requires special handling
-                    save(((FMLProxyPacket) packet).toS3FPacket());
+                    ((FMLProxyPacket) packet).toS3FPackets().forEach(this::save);
                     super.channelRead(ctx, msg);
                     return;
                 }
@@ -177,7 +175,7 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
 
                 if (packet instanceof S3FPacketCustomPayload) {
                     S3FPacketCustomPayload p = (S3FPacketCustomPayload) packet;
-                    if (Restrictions.PLUGIN_CHANNEL.equals(p.func_149169_c())) {
+                    if (Restrictions.PLUGIN_CHANNEL.equals(p.getChannelName())) {
                         packet = new S40PacketDisconnect(new ChatComponentText("Please update to view this replay."));
                         save(packet);
                     }
@@ -207,17 +205,17 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
 
         if(packet instanceof S0CPacketSpawnPlayer) {
             S0CPacketSpawnPlayer p = (S0CPacketSpawnPlayer) packet;
-            if (p.field_148960_i == null) {
-                p.field_148960_i = new DataWatcher(null);
+            if (p.watcher == null) {
+                p.watcher = new DataWatcher(null);
                 if(p.func_148944_c() != null) {
-                    for(DataWatcher.WatchableObject wo : (List<DataWatcher.WatchableObject>) p.func_148944_c()) {
-                        p.field_148960_i.addObject(wo.getDataValueId(), wo.getObject());
+                    for(DataWatcher.WatchableObject wo : p.func_148944_c()) {
+                        p.watcher.addObject(wo.getDataValueId(), wo.getObject());
                     }
                 }
             }
         }
 
-        Integer packetId = (Integer) EnumConnectionState.PLAY.func_150755_b().inverse().get(packet.getClass());
+        Integer packetId = EnumConnectionState.PLAY.getPacketId(EnumPacketDirection.CLIENTBOUND, packet);
         if (packetId == null) {
             throw new IOException("Unknown packet type:" + packet.getClass());
         }
@@ -235,7 +233,7 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
     }
 
     public void addMarker() {
-        Entity view = Minecraft.getMinecraft().renderViewEntity;
+        Entity view = Minecraft.getMinecraft().getRenderViewEntity();
         int timestamp = (int) (System.currentTimeMillis() - startTime);
 
         Marker marker = new Marker();

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

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

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

@@ -3,13 +3,13 @@ package com.replaymod.render;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.render.utils.RenderJob;
 import com.replaymod.replay.events.ReplayCloseEvent;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.Mod;
-import cpw.mods.fml.common.event.FMLPreInitializationEvent;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.util.ReportedException;
 import net.minecraftforge.common.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;
 import org.apache.commons.io.FileUtils;
 import org.apache.logging.log4j.Logger;
 
@@ -21,7 +21,6 @@ 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";

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

@@ -2,14 +2,13 @@ package com.replaymod.render;
 
 import com.replaymod.render.frame.RGBFrame;
 import com.replaymod.render.rendering.FrameConsumer;
-import com.replaymod.render.rendering.VideoRenderer;
 import com.replaymod.render.utils.ByteBufferPool;
 import com.replaymod.render.utils.StreamPipe;
-import cpw.mods.fml.common.versioning.ComparableVersion;
 import net.minecraft.client.Minecraft;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.crash.CrashReportCategory;
 import net.minecraft.util.Util;
+import net.minecraftforge.fml.common.versioning.ComparableVersion;
 import org.apache.commons.exec.CommandLine;
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
@@ -33,7 +32,6 @@ 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;
@@ -43,9 +41,8 @@ public class VideoWriter implements FrameConsumer<RGBFrame> {
 
     private ByteArrayOutputStream ffmpegLog = new ByteArrayOutputStream(4096);
 
-    public VideoWriter(final VideoRenderer renderer) throws IOException {
-        this.renderer = renderer;
-        this.settings = renderer.getRenderSettings();
+    public VideoWriter(final RenderSettings settings) throws IOException {
+        this.settings = settings;
 
         File outputFolder = settings.getOutputFile().getParentFile();
         FileUtils.forceMkdir(outputFolder);
@@ -60,13 +57,9 @@ public class VideoWriter implements FrameConsumer<RGBFrame> {
                     .replace("%FILTERS%", settings.getVideoFilters());
 
         String executable = settings.getExportCommand().isEmpty() ? findFFmpeg() : settings.getExportCommand();
-        LOGGER.info("Starting {} with args: {}", executable, commandArgs);
+        System.out.println("Starting " + executable + " with args: " + commandArgs);
         String[] cmdline = new CommandLine(executable).addArguments(commandArgs).toStrings();
-        try {
-            process = new ProcessBuilder(cmdline).directory(outputFolder).start();
-        } catch (IOException e) {
-            throw new NoFFmpegException(e);
-        }
+        process = new ProcessBuilder(cmdline).directory(outputFolder).start();
         File exportLogFile = new File(Minecraft.getMinecraft().mcDataDir, "export.log");
         OutputStream exportLogOut = new TeeOutputStream(new FileOutputStream(exportLogFile), ffmpegLog);
         new StreamPipe(process.getInputStream(), exportLogOut).start();
@@ -159,16 +152,6 @@ 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());
@@ -190,7 +173,7 @@ public class VideoWriter implements FrameConsumer<RGBFrame> {
         aborted = true;
     }
 
-    public File getVideoFile() throws FFmpegStartupException {
+    public File getVideoFile() {
         String log = ffmpegLog.toString();
         for (String line : log.split("\n")) {
             if (line.startsWith("Output #0")) {
@@ -198,30 +181,6 @@ public class VideoWriter implements FrameConsumer<RGBFrame> {
                 return new File(settings.getOutputFile().getParentFile(), fileName);
             }
         }
-        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;
-        }
+        throw new IllegalStateException("No output file found.");
     }
 }

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

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

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

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

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

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

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

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

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

@@ -1,109 +0,0 @@
-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,11 +1,8 @@
 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;
@@ -14,7 +11,6 @@ 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;
@@ -29,10 +25,12 @@ 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;
@@ -64,8 +62,7 @@ public class GuiRenderQueue extends AbstractGuiPopup<GuiRenderQueue> {
                             renameButton, removeButton),
                     closeButton);
 
-    private final AbstractGuiScreen container;
-    private final ReplayHandler replayHandler;
+    private final GuiContainer container;
     private Entry selectedEntry;
 
     {
@@ -87,10 +84,9 @@ public class GuiRenderQueue extends AbstractGuiPopup<GuiRenderQueue> {
         }).addElements(null, title, list, buttonPanel);
     }
 
-    public GuiRenderQueue(AbstractGuiScreen container, GuiRenderSettings guiRenderSettings, ReplayHandler replayHandler, Timeline timeline) {
+    public GuiRenderQueue(GuiContainer 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);
@@ -192,46 +188,30 @@ public class GuiRenderQueue extends AbstractGuiPopup<GuiRenderQueue> {
 
         renderButton.onClick(() -> {
             LOGGER.trace("Render button clicked");
-            processQueue(queue);
+            // Close all GUIs (so settings in GuiRenderSettings are saved)
+            getMinecraft().displayGuiScreen(null);
+            // Start rendering
+            for (RenderJob renderJob : queue) {
+                LOGGER.info("Starting render job {}", renderJob);
+                try {
+                    VideoRenderer videoRenderer = new VideoRenderer(renderJob.getSettings(), replayHandler, renderJob.getTimeline());
+                    videoRenderer.renderVideo();
+                } catch (IOException e) {
+                    LOGGER.error("Rendering video:", e);
+                    GuiErrorScreen errorScreen = new GuiErrorScreen(I18n.format("replaymod.gui.rendering.error.title"),
+                            I18n.format("replaymod.gui.rendering.error.message"));
+                    getMinecraft().displayGuiScreen(errorScreen);
+                    return;
+                } catch (Throwable t) {
+                    CrashReport crashReport = CrashReport.makeCrashReport(t, "Rendering video");
+                    throw new ReportedException(crashReport);
+                }
+            }
         });
 
         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,7 +7,6 @@ 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;
@@ -30,6 +29,7 @@ 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,13 +39,11 @@ 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);
@@ -201,21 +199,15 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
             try {
                 VideoRenderer videoRenderer = new VideoRenderer(save(false), replayHandler, timeline);
                 videoRenderer.renderVideo();
-            } catch (VideoWriter.NoFFmpegException e) {
-                LOGGER.error("Rendering video:", e);
+            } catch (IOException e) {
+                e.printStackTrace();
+
                 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) {
-                error(LOGGER, GuiRenderSettings.this, CrashReport.makeCrashReport(t, "Rendering video"), () -> {});
-                display(); // Re-show the render settings gui and the new error popup
+                CrashReport crashReport = CrashReport.makeCrashReport(t, "Rendering video");
+                throw new ReportedException(crashReport);
             }
         }
     }).setSize(100, 20).setI18nLabel("replaymod.gui.render");

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

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

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

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

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

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

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

@@ -4,6 +4,7 @@ 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;
 
@@ -12,8 +13,6 @@ 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";
@@ -97,7 +96,7 @@ public class MetadataInjector {
             videoFileOutputStream = new FileOutputStream(videoFile);
             tempIsoFile.getBox(videoFileOutputStream.getChannel());
         } catch(Exception e) {
-            LOGGER.error("360 Degree Metadata couldn't be injected", e);
+            FMLLog.getLogger().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

@@ -4,7 +4,7 @@ import com.replaymod.render.hooks.EntityRendererHandler;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.particle.EffectRenderer;
 import net.minecraft.client.particle.EntityFX;
-import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.WorldRenderer;
 import net.minecraft.entity.Entity;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
@@ -12,23 +12,22 @@ import org.spongepowered.asm.mixin.injection.Redirect;
 
 @Mixin(EffectRenderer.class)
 public abstract class MixinEffectRenderer {
-    @Redirect(method = "renderParticles", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/EntityFX;renderParticle(Lnet/minecraft/client/renderer/Tesselator;FFFFFF)V"))
-    private void renderNormalParticle(EntityFX fx, Tessellator tesselator, float partialTicks,
+    @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, tesselator, partialTicks, rotX, rotXZ, rotZ, rotYZ, 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/Tesselator;FFFFFF)V"))
-    private void renderLitParticle(EntityFX fx, Tessellator tesselator, float partialTicks,
+    @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, tesselator, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
+        renderParticle(fx, worldRenderer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
     }
 
-    private void renderParticle(EntityFX fx, Tessellator tessellator, float partialTicks,
-                                float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
+    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) {
-            Entity view = Minecraft.getMinecraft().renderViewEntity;
             // Align all particles towards the camera
             double dx = fx.prevPosX + (fx.posX - fx.prevPosX) * partialTicks - view.posX;
             double dy = fx.prevPosY + (fx.posY - fx.prevPosY) * partialTicks - view.posY;
@@ -43,6 +42,6 @@ public abstract class MixinEffectRenderer {
             rotYZ = (float) (-rotZ * Math.sin(pitch));
             rotXY = (float) (rotX * Math.sin(pitch));
         }
-        fx.renderParticle(tessellator, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
+        fx.renderParticle(worldRenderer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
     }
 }

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

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

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

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

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

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

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

@@ -2,17 +2,17 @@ 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 net.minecraft.client.renderer.entity.Render;
+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.CallbackInfoReturnable;
 
-@Mixin(RendererLivingEntity.class)
+@Mixin(Render.class)
 public abstract class MixinRender {
     @Inject(method = "canRenderName", at = @At("HEAD"), cancellable = true)
-    private void replayModRender_areAllNamesHidden(EntityLivingBase entity, CallbackInfoReturnable<Boolean> 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);

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

@@ -0,0 +1,63 @@
+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 {
+    public ChunkLoadingRenderGlobal replayModRender_hook;
+    private boolean replayModRender_passThroughSetupTerrain;
+
+    @Shadow
+    public boolean displayListEntitiesDirty;
+
+    @Shadow
+    public ChunkRenderDispatcher renderDispatcher;
+
+    @Shadow
+    public abstract void setupTerrain(Entity viewEntity, double partialTicks, ICamera camera,
+                                      int frameCount, boolean playerSpectator);
+
+    @Inject(method = "setupTerrain", at = @At("HEAD"), cancellable = true)
+    public void replayModRender_setupTerrain(Entity viewEntity, double partialTicks, ICamera camera,
+                                               int frameCount, boolean playerSpectator, CallbackInfo ci) {
+        if (replayModRender_hook != null && !replayModRender_passThroughSetupTerrain) {
+            replayModRender_passThroughSetupTerrain = true;
+
+            do {
+                setupTerrain(viewEntity, partialTicks, camera, replayModRender_hook.nextFrameId(), playerSpectator);
+            } while (displayListEntitiesDirty);
+
+            displayListEntitiesDirty = true;
+
+            replayModRender_passThroughSetupTerrain = false;
+            ci.cancel();
+        }
+    }
+
+    @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) {
+            replayModRender_hook.updateChunks();
+            ci.cancel();
+        }
+    }
+}

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

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

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

@@ -12,21 +12,21 @@ import com.replaymod.render.events.ReplayRenderEvent;
 import com.replaymod.render.frame.RGBFrame;
 import com.replaymod.render.gui.GuiRenderingDone;
 import com.replaymod.render.gui.GuiVideoRenderer;
+import com.replaymod.render.hooks.ChunkLoadingRenderGlobal;
 import com.replaymod.render.metadata.MetadataInjector;
 import com.replaymod.replay.ReplayHandler;
 import com.replaymod.replaystudio.pathing.path.Keyframe;
 import com.replaymod.replaystudio.pathing.path.Path;
 import com.replaymod.replaystudio.pathing.path.Timeline;
-import cpw.mods.fml.common.FMLCommonHandler;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.audio.SoundCategory;
 import net.minecraft.client.gui.ScaledResolution;
 import net.minecraft.client.renderer.OpenGlHelper;
 import net.minecraft.client.shader.Framebuffer;
 import net.minecraft.util.Timer;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 import org.lwjgl.input.Mouse;
 import org.lwjgl.opengl.Display;
-import org.lwjgl.opengl.GL11;
 import org.lwjgl.util.Dimension;
 import org.lwjgl.util.ReadableDimension;
 
@@ -39,10 +39,9 @@ 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;
-import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
 
 public class VideoRenderer implements RenderInfo {
     private final Minecraft mc = Minecraft.getMinecraft();
@@ -59,6 +58,7 @@ public class VideoRenderer implements RenderInfo {
 
     private TimelinePlayer timelinePlayer;
     private Future<Void> timelinePlayerFuture;
+    private ChunkLoadingRenderGlobal chunkLoadingRenderGlobal;
 
     private int framesDone;
     private int totalFrames;
@@ -66,7 +66,6 @@ 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;
@@ -77,7 +76,7 @@ public class VideoRenderer implements RenderInfo {
         this.timeline = timeline;
         this.gui = new GuiVideoRenderer(this);
         this.renderingPipeline = Pipelines.newPipeline(settings.getRenderMethod(), this,
-                videoWriter = new VideoWriter(this) {
+                videoWriter = new VideoWriter(settings) {
             @Override
             public void consume(RGBFrame frame) {
                 gui.updatePreview(frame);
@@ -90,7 +89,7 @@ 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() throws Throwable {
+    public boolean renderVideo() {
         FMLCommonHandler.instance().bus().post(new ReplayRenderEvent.Pre(this));
 
         setup();
@@ -139,10 +138,6 @@ public class VideoRenderer implements RenderInfo {
 
         FMLCommonHandler.instance().bus().post(new ReplayRenderEvent.Post(this));
 
-        if (failureCause != null) {
-            throw failureCause;
-        }
-
         return !cancelled;
     }
 
@@ -224,9 +219,11 @@ public class VideoRenderer implements RenderInfo {
 
         updateDisplaySize();
 
-        ScaledResolution scaled = new ScaledResolution(mc, displayWidth, displayHeight);
+        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
         guiFramebuffer = new Framebuffer(displayWidth, displayHeight, true);
     }
@@ -247,16 +244,13 @@ public class VideoRenderer implements RenderInfo {
         }
         mc.gameSettings.mapSoundLevels = originalSoundLevels;
         mc.displayGuiScreen(null);
+        if (chunkLoadingRenderGlobal != null) {
+            chunkLoadingRenderGlobal.uninstall();
+        }
 
         ReplayMod.soundHandler.playRenderSuccessSound();
 
-        try {
-            if (!hasFailed()) {
-                new GuiRenderingDone(ReplayModRender.instance, videoWriter.getVideoFile(), totalFrames, settings).display();
-            }
-        } catch (VideoWriter.FFmpegStartupException e) {
-            setFailure(e);
-        }
+        new GuiRenderingDone(ReplayModRender.instance, videoWriter.getVideoFile(), totalFrames, settings).display();
 
         // Finally, resize the Minecraft framebuffer to the actual width/height of the window
         mc.resize(displayWidth, displayHeight);
@@ -270,7 +264,11 @@ public class VideoRenderer implements RenderInfo {
         }
 
         mc.currentScreen = gui.toMinecraft();
-        mc.runTick();
+        try {
+            mc.runTick();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 
     public void drawGui() {
@@ -281,17 +279,23 @@ public class VideoRenderer implements RenderInfo {
                 guiFramebuffer.createBindFramebuffer(mc.displayWidth, mc.displayHeight);
             }
 
-            GL11.glPushMatrix();
-            GL11.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-            GL11.glEnable(GL_TEXTURE_2D);
+            pushMatrix();
+            clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+            enableTexture2D();
             guiFramebuffer.bindFramebuffer(true);
 
             mc.entityRenderer.setupOverlayRendering();
 
-            ScaledResolution scaled = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
+            ScaledResolution scaled = new ScaledResolution(mc);
             gui.toMinecraft().setWorldAndResolution(mc, scaled.getScaledWidth(), scaled.getScaledHeight());
 
-            gui.toMinecraft().handleInput();
+            try {
+                gui.toMinecraft().handleInput();
+            } catch (IOException e) {
+                // That's a strange exception from this kind of method O_o
+                // It isn't actually thrown here, so we'll deal with it the easy way
+                throw new RuntimeException(e);
+            }
 
             int mouseX = Mouse.getX() * scaled.getScaledWidth() / mc.displayWidth;
             int mouseY = scaled.getScaledHeight() - Mouse.getY() * scaled.getScaledHeight() / mc.displayHeight - 1;
@@ -299,17 +303,17 @@ public class VideoRenderer implements RenderInfo {
             gui.toMinecraft().drawScreen(mouseX, mouseY, 0);
 
             guiFramebuffer.unbindFramebuffer();
-            GL11.glPopMatrix();
-            GL11.glPushMatrix();
+            popMatrix();
+            pushMatrix();
             guiFramebuffer.framebufferRender(displayWidth, displayHeight);
-            GL11.glPopMatrix();
+            popMatrix();
 
             // if not in high performance mode, update the gui size if screen size changed
             // otherwise just swap the progress gui to screen
             if (settings.isHighPerformance()) {
                 Display.update();
             } else {
-                mc.resetSize();
+                mc.updateDisplay();
             }
             if (Mouse.isGrabbed()) {
                 Mouse.setGrabbed(false);
@@ -322,7 +326,7 @@ public class VideoRenderer implements RenderInfo {
                     return;
                 }
             }
-        } while (paused && !hasFailed());
+        } while (paused);
     }
 
     private boolean displaySizeChanged() {
@@ -363,20 +367,6 @@ 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/SoundHandler.java

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

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

@@ -3,20 +3,20 @@ package com.replaymod.replay;
 import com.replaymod.core.utils.WrappedTimer;
 import com.replaymod.replay.camera.CameraController;
 import com.replaymod.replay.camera.CameraEntity;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.eventhandler.Event;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.settings.GameSettings;
 import net.minecraft.client.settings.KeyBinding;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.util.ReportedException;
 import net.minecraft.util.Timer;
 import net.minecraftforge.client.ForgeHooksClient;
+import net.minecraftforge.fml.common.FMLCommonHandler;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.input.Mouse;
 
+import java.io.IOException;
+
 public class InputReplayTimer extends WrappedTimer {
     private final ReplayModReplay mod;
     private final Minecraft mc;
@@ -31,9 +31,6 @@ public class InputReplayTimer extends WrappedTimer {
     public void updateTimer() {
         super.updateTimer();
 
-        // 1.7.10: We have to run the scheduled executables (ours only) because MC would only run them every tick
-        FMLCommonHandler.instance().bus().post(new RunScheduledTasks());
-
         // If we are in a replay, we have to manually process key and mouse events as the
         // tick speed may vary or there may not be any ticks at all (when the replay is paused)
         if (mod.getReplayHandler() != null) {
@@ -46,7 +43,11 @@ public class InputReplayTimer extends WrappedTimer {
                     handleKeyEvent();
                 }
             } else {
-                mc.currentScreen.handleInput();
+                try {
+                    mc.currentScreen.handleInput();
+                } catch (IOException e) { // *SIGH*
+                    e.printStackTrace();
+                }
             }
         }
     }
@@ -88,14 +89,17 @@ public class InputReplayTimer extends WrappedTimer {
                 mc.setIngameFocus();
             }
         } else {
-            mc.currentScreen.handleMouseInput();
+            try {
+                mc.currentScreen.handleMouseInput();
+            } catch (IOException e) { // WHO IS RESPONSIBLE FOR THIS MESS?!?
+                e.printStackTrace();
+            }
         }
 
         FMLCommonHandler.instance().fireMouseInput();
     }
 
     protected void handleKeyEvent() {
-        // TODO 1.7.10: This might be missing some 1.7.10-only key bindings or implement some of them incorrectly
         int key = Keyboard.getEventKey() == 0 ? Keyboard.getEventCharacter() + 256 : Keyboard.getEventKey();
         boolean pressed = Keyboard.getEventKeyState();
 
@@ -123,11 +127,15 @@ public class InputReplayTimer extends WrappedTimer {
         if (pressed) {
             // This might be subject to change as vanilla shaders are still kinda unused in 1.8
             if (key == Keyboard.KEY_F4 && mc.entityRenderer != null) {
-                mc.entityRenderer.activateNextShader();
+                mc.entityRenderer.switchUseShader();
             }
 
             if (mc.currentScreen != null) {
-                mc.currentScreen.handleKeyboardInput();
+                try {
+                    mc.currentScreen.handleKeyboardInput();
+                } catch (IOException e) { // AND WHO THOUGHT THIS WAS A GREAT IDEA?
+                    e.printStackTrace();
+                }
             } else {
                 if (key == Keyboard.KEY_ESCAPE) {
                     mc.displayInGameMenu();
@@ -159,7 +167,7 @@ public class InputReplayTimer extends WrappedTimer {
                 }
 
                 if (key == 48 && Keyboard.isKeyDown(61)) {
-                    RenderManager.debugBoundingBox = !RenderManager.debugBoundingBox;
+                    mc.getRenderManager().setDebugBoundingBox(!mc.getRenderManager().isDebugBoundingBox());
                 }
 
                 if (key == 25 && Keyboard.isKeyDown(61)) {
@@ -178,6 +186,14 @@ public class InputReplayTimer extends WrappedTimer {
 
                 if (mc.gameSettings.keyBindTogglePerspective.isPressed()) {
                     mc.gameSettings.thirdPersonView = (mc.gameSettings.thirdPersonView + 1) % 3;
+
+                    if (mc.entityRenderer != null) { // Extra check, not in vanilla code
+                        if (mc.gameSettings.thirdPersonView == 0) {
+                            mc.entityRenderer.loadEntityShader(mc.getRenderViewEntity());
+                        } else if (mc.gameSettings.thirdPersonView == 1) {
+                            mc.entityRenderer.loadEntityShader(null);
+                        }
+                    }
                 }
             }
 
@@ -197,6 +213,4 @@ public class InputReplayTimer extends WrappedTimer {
 
         FMLCommonHandler.instance().fireKeyInput();
     }
-
-    public static class RunScheduledTasks extends Event {}
 }

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

@@ -8,16 +8,14 @@ import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.util.ScreenShotHelper;
 import org.apache.commons.io.FileUtils;
-import org.lwjgl.opengl.GL11;
 
 import javax.imageio.ImageIO;
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.File;
-import java.util.Queue;
-import java.util.concurrent.FutureTask;
 
 @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
 @Getter
@@ -40,18 +38,18 @@ public class NoGuiScreenshot {
                     mc.gameSettings.hideGUI = true;
 
                     // Render frame without GUI
-                    GL11.glPushMatrix();
-                    GL11.glClear(16640);
+                    GlStateManager.pushMatrix();
+                    GlStateManager.clear(16640);
                     mc.getFramebuffer().bindFramebuffer(true);
-                    GL11.glEnable(GL11.GL_TEXTURE_2D);
+                    GlStateManager.enableTexture2D();
 
-                    mc.entityRenderer.updateCameraAndRender(mc.timer.renderPartialTicks);
+                    mc.entityRenderer.updateCameraAndRender(mc.timer.renderPartialTicks, System.nanoTime());
 
                     mc.getFramebuffer().unbindFramebuffer();
-                    GL11.glPopMatrix();
-                    GL11.glPushMatrix();
+                    GlStateManager.popMatrix();
+                    GlStateManager.pushMatrix();
                     mc.getFramebuffer().framebufferRender(mc.displayWidth, mc.displayHeight);
-                    GL11.glPopMatrix();
+                    GlStateManager.popMatrix();
                 } catch (Throwable t) {
                     future.setException(t);
                     return;
@@ -101,9 +99,7 @@ public class NoGuiScreenshot {
         // of the game loop. We cannot use the addScheduledTask method as it'll run the task if called
         // from the minecraft thread which is exactly what we want to avoid.
         synchronized (mc.scheduledTasks) {
-            @SuppressWarnings("unchecked")
-            Queue<FutureTask> queue = mc.scheduledTasks;
-            queue.add(ListenableFutureTask.create(runnable, null));
+            mc.scheduledTasks.add(ListenableFutureTask.create(runnable, null));
         }
         return future;
     }

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

@@ -1,41 +1,39 @@
 package com.replaymod.replay;
 
 import com.google.common.base.Preconditions;
+import com.mojang.authlib.GameProfile;
 import com.replaymod.core.utils.Restrictions;
 import com.replaymod.replay.camera.CameraEntity;
 import com.replaymod.replay.camera.SpectatorCameraController;
 import com.replaymod.replay.events.ReplayCloseEvent;
 import com.replaymod.replay.events.ReplayOpenEvent;
 import com.replaymod.replay.gui.overlay.GuiReplayOverlay;
-import com.replaymod.replay.gui.screen.GuiOpeningReplay;
 import com.replaymod.replaystudio.data.Marker;
 import com.replaymod.replaystudio.replay.ReplayFile;
 import com.replaymod.replaystudio.util.Location;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.network.internal.FMLNetworkHandler;
 import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelOutboundHandlerAdapter;
 import io.netty.channel.embedded.EmbeddedChannel;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.EntityOtherPlayerMP;
 import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.client.gui.ScaledResolution;
-import net.minecraft.client.network.NetHandlerLoginClient;
+import net.minecraft.client.network.NetHandlerPlayClient;
 import net.minecraft.client.resources.I18n;
 import net.minecraft.entity.Entity;
-import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.network.EnumConnectionState;
+import net.minecraft.network.EnumPacketDirection;
 import net.minecraft.network.NetworkManager;
+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;
-import org.lwjgl.opengl.GL11;
 
 import java.io.IOException;
 import java.util.*;
 
+import static net.minecraft.client.renderer.GlStateManager.*;
 import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
 import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
-import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
 
 public class ReplayHandler {
 
@@ -126,37 +124,30 @@ public class ReplayHandler {
 
         ReplayModReplay.instance.replayHandler = null;
 
-        mc.displayGuiScreen(null);
-
         FMLCommonHandler.instance().bus().post(new ReplayCloseEvent.Post(this));
     }
 
     private void setup() {
         mc.ingameGUI.getChatGUI().clearChatMessages();
 
-        NetworkManager networkManager = new NetworkManager(true) {
+        NetworkManager networkManager = new NetworkManager(EnumPacketDirection.CLIENTBOUND) {
             @Override
             public void exceptionCaught(ChannelHandlerContext ctx, Throwable t) {
                 t.printStackTrace();
             }
         };
-        networkManager.setNetHandler(new NetHandlerLoginClient(networkManager, mc, null));
+        NetHandlerPlayClient netHandlerPlayClient =
+                new NetHandlerPlayClient(mc, null, networkManager, new GameProfile(UUID.randomUUID(), "Player"));
+        networkManager.setNetHandler(netHandlerPlayClient);
+        FMLClientHandler.instance().setPlayClient(netHandlerPlayClient);
 
-        mc.displayGuiScreen(new GuiOpeningReplay(networkManager));
+        channel = new EmbeddedChannel(networkManager);
+        NetworkDispatcher networkDispatcher = new NetworkDispatcher(networkManager);
+        channel.attr(NetworkDispatcher.FML_DISPATCHER).set(networkDispatcher);
 
-        ChannelOutboundHandlerAdapter dummyHandler = new ChannelOutboundHandlerAdapter();
-        channel = new EmbeddedChannel(dummyHandler);
-        channel.pipeline().remove(dummyHandler);
         channel.pipeline().addFirst("ReplayModReplay_replaySender", replaySender);
-        channel.pipeline().addAfter("ReplayModReplay_replaySender", "packet_handler", networkManager);
+        channel.pipeline().addAfter("ReplayModReplay_replaySender", "fml:packet_handler", networkDispatcher);
         channel.pipeline().fireChannelActive();
-
-        // Call twice to force-overwrite the NetworkManager's internal state
-        networkManager.setConnectionState(EnumConnectionState.PLAY);
-        networkManager.getNetHandler().onConnectionStateTransition(EnumConnectionState.LOGIN, EnumConnectionState.PLAY);
-        networkManager.setConnectionState(EnumConnectionState.PLAY);
-
-        FMLNetworkHandler.fmlClientHandshake(networkManager);
     }
 
     public ReplayFile getReplayFile() {
@@ -216,7 +207,7 @@ public class ReplayHandler {
      * When the entity is {@code null} or the camera entity, the camera becomes the view entity.
      * @param e The entity to spectate
      */
-    public void spectateEntity(EntityLivingBase e) {
+    public void spectateEntity(Entity e) {
         CameraEntity cameraEntity = getCameraEntity();
         if (cameraEntity == null) {
             return; // Cannot spectate if we have no camera
@@ -234,15 +225,15 @@ public class ReplayHandler {
             cameraEntity.setCameraController(new SpectatorCameraController(cameraEntity));
         }
 
-        if (mc.renderViewEntity != e) {
-            mc.renderViewEntity = e;
+        if (mc.getRenderViewEntity() != e) {
+            mc.setRenderViewEntity(e);
             cameraEntity.setCameraPosRot(e);
         }
     }
 
     /**
      * Set the camera as the view entity.
-     * This is equivalent to {@link #spectateEntity(EntityLivingBase) spectateEntity(null)}.
+     * This is equivalent to {@link #spectateEntity(Entity) spectateEntity(null)}.
      */
     public void spectateCamera() {
         spectateEntity(null);
@@ -253,7 +244,7 @@ public class ReplayHandler {
      * @return {@code true} if the camera is the view entity, {@code false} otherwise
      */
     public boolean isCameraView() {
-        return mc.thePlayer instanceof CameraEntity && mc.thePlayer == mc.renderViewEntity;
+        return mc.thePlayer instanceof CameraEntity && mc.thePlayer == mc.getRenderViewEntity();
     }
 
     /**
@@ -317,21 +308,21 @@ public class ReplayHandler {
                 replaySender.setSyncModeAndWait();
 
                 // Perform the rendering using OpenGL
-                GL11.glPushMatrix();
-                GL11.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-                GL11.glEnable(GL_TEXTURE_2D);
+                pushMatrix();
+                clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+                enableTexture2D();
                 mc.getFramebuffer().bindFramebuffer(true);
                 mc.entityRenderer.setupOverlayRendering();
 
-                ScaledResolution resolution = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
+                ScaledResolution resolution = new ScaledResolution(mc);
                 guiScreen.setWorldAndResolution(mc, resolution.getScaledWidth(), resolution.getScaledHeight());
                 guiScreen.drawScreen(0, 0, 0);
 
                 mc.getFramebuffer().unbindFramebuffer();
-                GL11.glPopMatrix();
-                GL11.glPushMatrix();
+                popMatrix();
+                pushMatrix();
                 mc.getFramebuffer().framebufferRender(mc.displayWidth, mc.displayHeight);
-                GL11.glPopMatrix();
+                popMatrix();
 
                 Display.update();
 
@@ -341,9 +332,7 @@ public class ReplayHandler {
                 replaySender.setReplaySpeed(0);
 
                 mc.getNetHandler().getNetworkManager().processReceivedPackets();
-                @SuppressWarnings("unchecked")
-                List<Entity> entities = (List<Entity>) mc.theWorld.loadedEntityList;
-                for (Entity entity : entities) {
+                for (Entity entity : mc.theWorld.loadedEntityList) {
                     if (entity instanceof EntityOtherPlayerMP) {
                         EntityOtherPlayerMP e = (EntityOtherPlayerMP) entity;
                         e.setPosition(e.otherPlayerMPX, e.otherPlayerMPY, e.otherPlayerMPZ);
@@ -356,7 +345,11 @@ public class ReplayHandler {
                     entity.prevRotationYaw = entity.rotationYaw;
                     entity.prevRotationPitch = entity.rotationPitch;
                 }
-                mc.runTick();
+                try {
+                    mc.runTick();
+                } catch (IOException e) {
+                    e.printStackTrace(); // This should never be thrown but whatever
+                }
 
                 //finally, updating the camera's position (which is not done by the sync jumping)
                 moveCameraToTargetPosition();

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

@@ -18,11 +18,11 @@ import com.replaymod.replaystudio.data.Marker;
 import com.replaymod.replaystudio.replay.ReplayFile;
 import com.replaymod.replaystudio.replay.ZipReplayFile;
 import com.replaymod.replaystudio.studio.ReplayStudio;
-import cpw.mods.fml.common.Mod;
-import cpw.mods.fml.common.event.FMLInitializationEvent;
-import cpw.mods.fml.common.event.FMLPostInitializationEvent;
-import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import net.minecraft.client.Minecraft;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
 import org.apache.logging.log4j.Logger;
 import org.lwjgl.input.Keyboard;
 
@@ -35,7 +35,6 @@ 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";
@@ -47,7 +46,7 @@ public class ReplayModReplay {
 
     private final CameraControllerRegistry cameraControllerRegistry = new CameraControllerRegistry();
 
-    public static Logger LOGGER;
+    private Logger logger;
 
     protected ReplayHandler replayHandler;
 
@@ -57,7 +56,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);
@@ -181,9 +180,6 @@ 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()) {
@@ -199,7 +195,7 @@ public class ReplayModReplay {
     }
 
     public Logger getLogger() {
-        return LOGGER;
+        return logger;
     }
 
     public CameraControllerRegistry getCameraControllerRegistry() {

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

@@ -2,73 +2,35 @@ package com.replaymod.replay;
 
 import com.google.common.base.Preconditions;
 import com.google.common.io.Files;
-import com.replaymod.core.ReplayMod;
+import com.google.common.util.concurrent.ListenableFutureTask;
 import com.replaymod.core.utils.Restrictions;
 import com.replaymod.replay.camera.CameraEntity;
 import com.replaymod.replaystudio.replay.ReplayFile;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
-import io.netty.channel.ChannelDuplexHandler;
 import io.netty.channel.ChannelHandler.Sharable;
 import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelPromise;
+import io.netty.channel.ChannelInboundHandlerAdapter;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiDownloadTerrain;
 import net.minecraft.client.gui.GuiErrorScreen;
-import net.minecraft.client.resources.FileResourcePack;
 import net.minecraft.client.resources.I18n;
-import net.minecraft.client.resources.ResourcePackRepository;
 import net.minecraft.entity.Entity;
-import net.minecraft.network.EnumConnectionState;
-import net.minecraft.network.Packet;
-import net.minecraft.network.PacketBuffer;
-import net.minecraft.network.play.server.S01PacketJoinGame;
-import net.minecraft.network.play.server.S02PacketChat;
-import net.minecraft.network.play.server.S06PacketUpdateHealth;
-import net.minecraft.network.play.server.S07PacketRespawn;
-import net.minecraft.network.play.server.S08PacketPlayerPosLook;
-import net.minecraft.network.play.server.S0CPacketSpawnPlayer;
-import net.minecraft.network.play.server.S0EPacketSpawnObject;
-import net.minecraft.network.play.server.S0FPacketSpawnMob;
-import net.minecraft.network.play.server.S10PacketSpawnPainting;
-import net.minecraft.network.play.server.S11PacketSpawnExperienceOrb;
-import net.minecraft.network.play.server.S13PacketDestroyEntities;
-import net.minecraft.network.play.server.S1FPacketSetExperience;
-import net.minecraft.network.play.server.S21PacketChunkData;
-import net.minecraft.network.play.server.S2APacketParticles;
-import net.minecraft.network.play.server.S2BPacketChangeGameState;
-import net.minecraft.network.play.server.S2CPacketSpawnGlobalEntity;
-import net.minecraft.network.play.server.S2DPacketOpenWindow;
-import net.minecraft.network.play.server.S2EPacketCloseWindow;
-import net.minecraft.network.play.server.S2FPacketSetSlot;
-import net.minecraft.network.play.server.S30PacketWindowItems;
-import net.minecraft.network.play.server.S36PacketSignEditorOpen;
-import net.minecraft.network.play.server.S37PacketStatistics;
-import net.minecraft.network.play.server.S39PacketPlayerAbilities;
-import net.minecraft.network.play.server.S3FPacketCustomPayload;
-import net.minecraft.network.play.server.S40PacketDisconnect;
+import net.minecraft.network.*;
+import net.minecraft.network.play.server.*;
 import net.minecraft.util.IChatComponent;
-import net.minecraft.util.MathHelper;
 import net.minecraft.world.EnumDifficulty;
 import net.minecraft.world.World;
 import net.minecraft.world.WorldSettings.GameType;
 import net.minecraft.world.WorldType;
-import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.chunk.IChunkProvider;
-import org.apache.commons.io.Charsets;
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
 
-import java.io.DataInputStream;
-import java.io.EOFException;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.ArrayList;
+import java.io.*;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.Callable;
 
 /**
  * Sends replay packets to netty channels.
@@ -76,7 +38,15 @@ import java.util.Map;
  * the replay restart from the beginning.
  */
 @Sharable
-public class ReplaySender extends ChannelDuplexHandler {
+public class ReplaySender extends ChannelInboundHandlerAdapter {
+
+    /**
+     * Previously packets for the client player were inserted using one fixed entity id (this one).
+     * This is no longer the case however to provide backwards compatibility, we have to convert
+     * these old packets to use the normal entity id.
+     * Need to punch someone? -> CrushedPixel
+     */
+    public static final int LEGACY_ENTITY_ID = Integer.MIN_VALUE + 9001;
 
     /**
      * These packets are ignored completely during replay.
@@ -90,7 +60,9 @@ public class ReplaySender extends ChannelDuplexHandler {
             S36PacketSignEditorOpen.class,
             S37PacketStatistics.class,
             S1FPacketSetExperience.class,
-            S39PacketPlayerAbilities.class);
+            S43PacketCamera.class,
+            S39PacketPlayerAbilities.class,
+            S45PacketTitle.class);
 
     private static int TP_DISTANCE_LIMIT = 128;
 
@@ -145,7 +117,7 @@ public class ReplaySender extends ChannelDuplexHandler {
     /**
      * Whether we need to restart the current replay. E.g. when jumping backwards in time
      */
-    protected boolean startFromBeginning;
+    protected boolean startFromBeginning = true;
 
     /**
      * Whether to terminate the replay. This only has an effect on the async mode and is {@code true} during sync mode.
@@ -270,7 +242,6 @@ public class ReplaySender extends ChannelDuplexHandler {
         try {
             channelInactive(ctx);
             ctx.channel().pipeline().close();
-            FileUtils.deleteDirectory(tempResourcePackFolder);
         } catch(Exception e) {
             e.printStackTrace();
         }
@@ -343,7 +314,7 @@ public class ReplaySender extends ChannelDuplexHandler {
 
         int i = pb.readVarIntFromBuffer();
 
-        Packet p = Packet.generatePacket(EnumConnectionState.PLAY.func_150755_b(), i);
+        Packet p = EnumConnectionState.PLAY.getPacket(EnumPacketDirection.CLIENTBOUND, i);
         p.readPacketData(pb);
 
         return p;
@@ -357,7 +328,7 @@ public class ReplaySender extends ChannelDuplexHandler {
     protected Packet processPacket(Packet p) throws Exception {
         if (p instanceof S3FPacketCustomPayload) {
             S3FPacketCustomPayload packet = (S3FPacketCustomPayload) p;
-            if (Restrictions.PLUGIN_CHANNEL.equals(packet.func_149169_c())) {
+            if (Restrictions.PLUGIN_CHANNEL.equals(packet.getChannelName())) {
                 final String unknown = replayHandler.getRestrictions().handle(packet);
                 if (unknown == null) {
                     return null;
@@ -383,7 +354,7 @@ public class ReplaySender extends ChannelDuplexHandler {
             }
         }
         if (p instanceof S40PacketDisconnect) {
-            IChatComponent reason = ((S40PacketDisconnect) p).func_149165_c();
+            IChatComponent reason = ((S40PacketDisconnect) p).getReason();
             if ("Please update to view this replay.".equals(reason.getUnformattedText())) {
                 // This version of the mod supports replay restrictions so we are allowed
                 // to remove this packet.
@@ -393,53 +364,47 @@ public class ReplaySender extends ChannelDuplexHandler {
 
         if(BAD_PACKETS.contains(p.getClass())) return null;
 
-        if (p instanceof S3FPacketCustomPayload) {
-            S3FPacketCustomPayload packet = (S3FPacketCustomPayload) p;
-            if ("MC|BOpen".equals(packet.func_149169_c())) {
-                return null;
-            }
-            if ("MC|RPack".equals(packet.func_149169_c())) {
-                String url = new String(packet.func_149168_d(), Charsets.UTF_8);
-                if (url.startsWith("replay://")) {
-                    int id = Integer.parseInt(url.substring("replay://".length()));
-                    Map<Integer, String> index = replayFile.getResourcePackIndex();
-                    if (index != null) {
-                        String hash = index.get(id);
-                        if (hash != null) {
-                            File file = new File(tempResourcePackFolder, hash + ".zip");
-                            if (!file.exists()) {
-                                IOUtils.copy(replayFile.getResourcePack(hash).get(), new FileOutputStream(file));
-                            }
-                            ResourcePackRepository repo = mc.getResourcePackRepository();
-                            repo.field_148533_g = false;
-                            repo.field_148532_f = new FileResourcePack(file);
-                            Minecraft.getMinecraft().scheduleResourcesRefresh();
+        convertLegacyEntityIds(p);
+
+        if(p instanceof S48PacketResourcePackSend) {
+            S48PacketResourcePackSend packet = (S48PacketResourcePackSend) p;
+            String url = packet.getURL();
+            if (url.startsWith("replay://")) {
+                int id = Integer.parseInt(url.substring("replay://".length()));
+                Map<Integer, String> index = replayFile.getResourcePackIndex();
+                if (index != null) {
+                    String hash = index.get(id);
+                    if (hash != null) {
+                        File file = new File(tempResourcePackFolder, hash + ".zip");
+                        if (!file.exists()) {
+                            IOUtils.copy(replayFile.getResourcePack(hash).get(), new FileOutputStream(file));
                         }
+                        mc.getResourcePackRepository().setResourcePackInstance(file);
                     }
-                    return null;
                 }
+                return null;
             }
         }
 
         if(p instanceof S01PacketJoinGame) {
             S01PacketJoinGame packet = (S01PacketJoinGame) p;
             allowMovement = true;
-            int entId = packet.func_149197_c();
+            int entId = packet.getEntityId();
             actualID = entId;
             entId = -1789435; // Camera entity id should be negative which is an invalid id and can't be used by servers
-            int dimension = packet.func_149194_f();
-            EnumDifficulty difficulty = packet.func_149192_g();
-            int maxPlayers = packet.func_149193_h();
-            WorldType worldType = packet.func_149196_i();
+            int dimension = packet.getDimension();
+            EnumDifficulty difficulty = packet.getDifficulty();
+            int maxPlayers = packet.getMaxPlayers();
+            WorldType worldType = packet.getWorldType();
 
-            p = new S01PacketJoinGame(entId, GameType.ADVENTURE, false, dimension,
-                    difficulty, maxPlayers, worldType);
+            p = new S01PacketJoinGame(entId, GameType.SPECTATOR, false, dimension,
+                    difficulty, maxPlayers, worldType, false);
         }
 
         if(p instanceof S07PacketRespawn) {
             S07PacketRespawn respawn = (S07PacketRespawn) p;
-            p = new S07PacketRespawn(respawn.func_149082_c(),
-                    respawn.func_149081_d(), respawn.func_149080_f(), GameType.ADVENTURE);
+            p = new S07PacketRespawn(respawn.getDimensionID(),
+                    respawn.getDifficulty(), respawn.getWorldType(), GameType.SPECTATOR);
 
             allowMovement = true;
         }
@@ -457,33 +422,44 @@ public class ReplaySender extends ChannelDuplexHandler {
 
             CameraEntity cent = replayHandler.getCameraEntity();
 
+            for (Object relative : ppl.func_179834_f()) {
+                if (relative == S08PacketPlayerPosLook.EnumFlags.X
+                        || relative == S08PacketPlayerPosLook.EnumFlags.Y
+                        || relative == S08PacketPlayerPosLook.EnumFlags.Z) {
+                    return null; // At least one of the coordinates is relative, so we don't care
+                }
+            }
+
             if(cent != null) {
-                if(!allowMovement && !((Math.abs(cent.posX - ppl.func_148932_c()) > TP_DISTANCE_LIMIT) ||
-                        (Math.abs(cent.posZ - ppl.func_148933_e()) > TP_DISTANCE_LIMIT))) {
+                if(!allowMovement && !((Math.abs(cent.posX - ppl.getX()) > TP_DISTANCE_LIMIT) ||
+                        (Math.abs(cent.posZ - ppl.getZ()) > TP_DISTANCE_LIMIT))) {
                     return null;
                 } else {
                     allowMovement = false;
                 }
             }
 
-            new Runnable() {
+            new Callable<Void>() {
                 @Override
                 @SuppressWarnings("unchecked")
-                public void run() {
+                public Void call() {
                     if (mc.theWorld == null || !mc.isCallingFromMinecraftThread()) {
-                        ReplayMod.instance.runLater(this);
-                        return;
+                        synchronized(mc.scheduledTasks) {
+                            mc.scheduledTasks.add(ListenableFutureTask.create(this));
+                        }
+                        return null;
                     }
 
                     CameraEntity cent = replayHandler.getCameraEntity();
-                    cent.setCameraPosition(ppl.func_148932_c(), ppl.func_148928_d(), ppl.func_148933_e());
+                    cent.setCameraPosition(ppl.getX(), ppl.getY(), ppl.getZ());
+                    return null;
                 }
-            }.run();
+            }.call();
         }
 
         if(p instanceof S2BPacketChangeGameState) {
             S2BPacketChangeGameState pg = (S2BPacketChangeGameState)p;
-            int reason = pg.func_149138_c();
+            int reason = pg.getGameState();
 
             // only allow the following packets:
             // 1 - End raining
@@ -510,26 +486,14 @@ public class ReplaySender extends ChannelDuplexHandler {
     @SuppressWarnings("unchecked")
     public void channelActive(ChannelHandlerContext ctx) throws Exception {
         this.ctx = ctx;
+        ctx.attr(NetworkManager.attrKeyConnectionState).set(EnumConnectionState.PLAY);
         super.channelActive(ctx);
     }
 
     @Override
-    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
-        // The embedded channel's event loop will consider every thread to be in it and as such provides no
-        // guarantees that only one thread is using the pipeline at any one time.
-        // For reading the replay sender (either sync or async) is the only thread ever writing.
-        // For writing it may very well happen that multiple threads want to use the pipline at the same time.
-        // It's unclear whether the EmbeddedChannel is supposed to be thread-safe (the behavior of the event loop
-        // does suggest that). However it seems like it either isn't (likely) or there is a race condition.
-        // See: https://www.replaymod.com/forum/thread/1752#post8045 (https://paste.replaymod.com/lotacatuwo)
-        // To work around this issue, we just outright drop all write/flush requests (they aren't needed anyway).
-        // This still leaves channel handlers upstream with the threading issue but they all seem to cope well with it.
-        promise.setSuccess();
-    }
-
-    @Override
-    public void flush(ChannelHandlerContext ctx) throws Exception {
-        // See write method above
+    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
+        FileUtils.deleteDirectory(tempResourcePackFolder);
+        super.channelInactive(ctx);
     }
 
     /**
@@ -731,7 +695,7 @@ public class ReplaySender extends ChannelDuplexHandler {
 
             if(p instanceof S0EPacketSpawnObject) {
                 S0EPacketSpawnObject pso = (S0EPacketSpawnObject)p;
-                int type = pso.func_148993_l();
+                int type = pso.getType();
                 if(type == 76) { // Firework rocket
                     return null;
                 }
@@ -757,9 +721,6 @@ public class ReplaySender extends ChannelDuplexHandler {
             }
 
             synchronized (this) {
-                if (timestamp == lastTimeStamp) { // Do nothing if we're already there
-                    return;
-                }
                 if (timestamp < lastTimeStamp) { // Restart the replay if we need to go backwards in time
                     hasWorldLoaded = false;
                     lastTimeStamp = 0;
@@ -817,50 +778,69 @@ public class ReplaySender extends ChannelDuplexHandler {
     }
 
     protected Packet processPacketSync(Packet p) {
-        if (p instanceof S21PacketChunkData) {
-            S21PacketChunkData packet = (S21PacketChunkData) p;
-            if (packet.func_149276_g() == 0) {
-                // If the chunk is getting unloaded, we will have to forcefully update the position of all entities
-                // within. Otherwise, if there wasn't a game tick recently, there may be entities that have moved
-                // out of the chunk by now but are still registered in it. If we do not update those, they will get
-                // unloaded even though they shouldn't.
-                // To make things worse, it seems like players were never supposed to be unloaded this way because
-                // they will remain glitched in the World#playerEntities list.
-                World world = mc.theWorld;
-                IChunkProvider chunkProvider = world.getChunkProvider();
-                // Get the chunk that will be unloaded
-                Chunk chunk = chunkProvider.provideChunk(packet.func_149273_e(), packet.func_149271_f());
-                if (!chunk.isEmpty()) {
-                    List<Entity> entitiesInChunk = new ArrayList<>();
-                    // Gather all entities in that chunk
-                    for (List entityList : chunk.entityLists) {
-                        @SuppressWarnings("unchecked")
-                        Collection<Entity> typedEntityList = entityList;
-                        entitiesInChunk.addAll(typedEntityList);
-                    }
-                    for (Entity entity : entitiesInChunk) {
-                        // Skip interpolation of position updates coming from server
-                        // (See: newX in EntityLivingBase or otherPlayerMPX in EntityOtherPlayerMP)
-                        entity.onUpdate();
+        return p; // During synchronous playback everything is sent normally
+    }
 
-                        // Check whether the entity has left the chunk
-                        int chunkX = MathHelper.floor_double(entity.posX / 16);
-                        int chunkZ = MathHelper.floor_double(entity.posZ / 16);
-                        if (entity.chunkCoordX != chunkX || entity.chunkCoordZ != chunkZ) {
-                            // Entity has left the chunk
-                            chunk.removeEntityAtIndex(entity, entity.chunkCoordY);
-                            if (chunkProvider.chunkExists(chunkX, chunkZ)) {
-                                chunkProvider.provideChunk(chunkX, chunkZ).addEntity(entity);
-                            } else {
-                                // Entity has left all loaded chunks
-                                entity.addedToChunk = false;
-                            }
-                        }
-                    }
-                }
+    /**
+     * This is necessary to convert packets from old replays to new replays.
+     * @param packet The packet to be transformed.
+     * @see #LEGACY_ENTITY_ID
+     */
+    private void convertLegacyEntityIds(Packet packet) {
+        if (packet instanceof S0CPacketSpawnPlayer) {
+            S0CPacketSpawnPlayer p = (S0CPacketSpawnPlayer) packet;
+            if (p.entityId == LEGACY_ENTITY_ID) {
+                p.entityId = actualID;
+            }
+        } else if (packet instanceof S18PacketEntityTeleport) {
+            S18PacketEntityTeleport p = (S18PacketEntityTeleport) packet;
+            if (p.entityId == LEGACY_ENTITY_ID) {
+                p.entityId = actualID;
+            }
+        } else if (packet instanceof S14PacketEntity.S17PacketEntityLookMove) {
+            S14PacketEntity.S17PacketEntityLookMove p = (S14PacketEntity.S17PacketEntityLookMove) packet;
+            if (p.entityId == LEGACY_ENTITY_ID) {
+                p.entityId = actualID;
+            }
+        } else if (packet instanceof S19PacketEntityHeadLook) {
+            S19PacketEntityHeadLook p = (S19PacketEntityHeadLook) packet;
+            if (p.entityId == LEGACY_ENTITY_ID) {
+                p.entityId = actualID;
+            }
+        } else if (packet instanceof S12PacketEntityVelocity) {
+            S12PacketEntityVelocity p = (S12PacketEntityVelocity) packet;
+            if (p.entityID == LEGACY_ENTITY_ID) {
+                p.entityID = actualID;
+            }
+        } else if (packet instanceof S0BPacketAnimation) {
+            S0BPacketAnimation p = (S0BPacketAnimation) packet;
+            if (p.entityId == LEGACY_ENTITY_ID) {
+                p.entityId = actualID;
+            }
+        } else if (packet instanceof S04PacketEntityEquipment) {
+            S04PacketEntityEquipment p = (S04PacketEntityEquipment) packet;
+            if (p.entityID == LEGACY_ENTITY_ID) {
+                p.entityID = actualID;
+            }
+        } else if (packet instanceof S1BPacketEntityAttach) {
+            S1BPacketEntityAttach p = (S1BPacketEntityAttach) packet;
+            if (p.entityId == LEGACY_ENTITY_ID) {
+                p.entityId = actualID;
+            }
+            if (p.vehicleEntityId == LEGACY_ENTITY_ID) {
+                p.vehicleEntityId = actualID;
+            }
+        } else if (packet instanceof S0DPacketCollectItem) {
+            S0DPacketCollectItem p = (S0DPacketCollectItem) packet;
+            if (p.entityId == LEGACY_ENTITY_ID) {
+                p.entityId = actualID;
+            }
+        } else if (packet instanceof S13PacketDestroyEntities) {
+            S13PacketDestroyEntities p = (S13PacketDestroyEntities) packet;
+            if (p.entityIDs.length == 1 && p.entityIDs[0] == LEGACY_ENTITY_ID) {
+                p.entityIDs[0] = actualID;
             }
         }
-        return p; // During synchronous playback everything is sent normally
     }
 
     private static final class PacketData {

src/main/java/com/replaymod/replay/camera/CameraEntity.java

@@ -5,31 +5,32 @@ import com.replaymod.core.events.SettingsChangedEvent;
 import com.replaymod.core.utils.Utils;
 import com.replaymod.replay.ReplayModReplay;
 import com.replaymod.replay.Setting;
-import com.replaymod.replay.events.ReplayChatMessageEvent;
 import com.replaymod.replaystudio.util.Location;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.common.eventhandler.EventPriority;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
-import cpw.mods.fml.common.gameevent.TickEvent;
 import lombok.Getter;
 import lombok.Setter;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.Minecraft;
-import net.minecraft.client.entity.EntityClientPlayerMP;
+import net.minecraft.client.entity.AbstractClientPlayer;
+import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.client.network.NetHandlerPlayClient;
 import net.minecraft.client.settings.KeyBinding;
 import net.minecraft.entity.Entity;
-import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.item.EntityItemFrame;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.stats.StatFileWriter;
-import net.minecraft.util.IChatComponent;
+import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.util.MovingObjectPosition;
 import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.Session;
 import net.minecraft.world.World;
+import net.minecraftforge.client.event.EntityViewRenderEvent;
 import net.minecraftforge.client.event.RenderGameOverlayEvent;
 import net.minecraftforge.client.event.RenderHandEvent;
 import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
 
 import java.util.Map;
 import java.util.UUID;
@@ -40,7 +41,7 @@ import java.util.function.Function;
  * During a replay {@link Minecraft#thePlayer} should be an instance of this class.
  * Camera movement is controlled by a separate {@link CameraController}.
  */
-public class CameraEntity extends EntityClientPlayerMP {
+public class CameraEntity extends EntityPlayerSP {
     /**
      * Roll of this camera in degrees.
      */
@@ -64,9 +65,8 @@ public class CameraEntity extends EntityClientPlayerMP {
      */
     private final EventHandler eventHandler = new EventHandler();
 
-    public CameraEntity(Minecraft mcIn, World worldIn, Session session, NetHandlerPlayClient netHandlerPlayClient, StatFileWriter statFileWriter) {
-        super(mcIn, worldIn, session, netHandlerPlayClient, statFileWriter);
-        entityUniqueID = UUID.randomUUID(); // Need to not have the same UUID as the player who recorded the replay
+    public CameraEntity(Minecraft mcIn, World worldIn, NetHandlerPlayClient netHandlerPlayClient, StatFileWriter statFileWriter) {
+        super(mcIn, worldIn, netHandlerPlayClient, statFileWriter);
         FMLCommonHandler.instance().bus().register(eventHandler);
         MinecraftForge.EVENT_BUS.register(eventHandler);
         if (ReplayModReplay.instance.getReplayHandler().getSpectatedUUID() == null) {
@@ -125,33 +125,31 @@ public class CameraEntity extends EntityClientPlayerMP {
      * @param to The entity whose position to copy
      */
     public void setCameraPosRot(Entity to) {
-        if (to == this) return;
-        float yOffset = 1.62f; // Magic value (eye height) from EntityRenderer#orientCamera
         prevPosX = to.prevPosX;
-        prevPosY = to.prevPosY + yOffset;
+        prevPosY = to.prevPosY;
         prevPosZ = to.prevPosZ;
         prevRotationYaw = to.prevRotationYaw;
         prevRotationPitch = to.prevRotationPitch;
         posX = to.posX;
-        posY = to.posY + yOffset;
+        posY = to.posY;
         posZ = to.posZ;
         rotationYaw = to.rotationYaw;
         rotationPitch = to.rotationPitch;
         lastTickPosX = to.lastTickPosX;
-        lastTickPosY = to.lastTickPosY + yOffset;
+        lastTickPosY = to.lastTickPosY;
         lastTickPosZ = to.lastTickPosZ;
         updateBoundingBox();
     }
 
     private void updateBoundingBox() {
-        this.boundingBox.setBounds(
+        setEntityBoundingBox(new AxisAlignedBB(
                 posX - width / 2, posY, posZ - width / 2,
-                posX + width / 2, posY + height, posZ + width / 2);
+                posX + width / 2, posY + height, posZ + width / 2));
     }
 
     @Override
     public void onUpdate() {
-        EntityLivingBase view = mc.renderViewEntity;
+        Entity view = mc.getRenderViewEntity();
         if (view != null) {
             // Make sure we're always spectating the right entity
             // This is important if the spectated player respawns as their
@@ -160,16 +158,11 @@ public class CameraEntity extends EntityClientPlayerMP {
             if (spectating != null && (view.getUniqueID() != spectating
                     || view.worldObj != worldObj)
                     || worldObj.getEntityByID(view.getEntityId()) != view) {
-                if (spectating == null) {
-                    // Entity (non-player) died, stop spectating
-                    ReplayModReplay.instance.getReplayHandler().spectateEntity(this);
-                    return;
-                }
                 view = worldObj.getPlayerEntityByUUID(spectating);
                 if (view != null) {
-                    mc.renderViewEntity = view;
+                    mc.setRenderViewEntity(view);
                 } else {
-                    mc.renderViewEntity = this;
+                    mc.setRenderViewEntity(this);
                     return;
                 }
             }
@@ -192,7 +185,7 @@ public class CameraEntity extends EntityClientPlayerMP {
 
     @Override
     public void setAngles(float yaw, float pitch) {
-        if (mc.renderViewEntity == this) {
+        if (mc.getRenderViewEntity() == this) {
             // Only update camera rotation when the camera is the view
             super.setAngles(yaw, pitch);
         }
@@ -209,8 +202,8 @@ public class CameraEntity extends EntityClientPlayerMP {
     }
 
     @Override
-    public boolean handleLavaMovement() {
-        return falseUnlessSpectating(Entity::handleLavaMovement); // Make sure no lava overlay is rendered
+    public boolean isInLava() {
+        return falseUnlessSpectating(Entity::isInLava); // Make sure no lava overlay is rendered
     }
 
     @Override
@@ -224,7 +217,7 @@ public class CameraEntity extends EntityClientPlayerMP {
     }
 
     private boolean falseUnlessSpectating(Function<Entity, Boolean> property) {
-        Entity view = mc.renderViewEntity;
+        Entity view = mc.getRenderViewEntity();
         if (view != null && view != this) {
             return property.apply(view);
         }
@@ -236,17 +229,20 @@ public class CameraEntity extends EntityClientPlayerMP {
         return false; // We are in full control of ourselves
     }
 
+    @Override
+    protected void createRunningParticles() {
+        // We do not produce any particles, we are a camera
+    }
+
     @Override
     public boolean canBeCollidedWith() {
         return false; // We are a camera, we cannot collide
     }
 
-    /* TODO 1.7.10: isSpectator has been added in 1.8, this is probably going to require lots of manual changes
     @Override
     public boolean isSpectator() {
         return ReplayModReplay.instance.getReplayHandler().isCameraView(); // Make sure we're treated as spectator
     }
-    */
 
     @Override
     public boolean shouldRenderInPass(int pass) {
@@ -258,7 +254,7 @@ public class CameraEntity extends EntityClientPlayerMP {
 
     @Override
     public boolean isInvisible() {
-        Entity view = mc.renderViewEntity;
+        Entity view = mc.getRenderViewEntity();
         if (view != this) {
             return view.isInvisible();
         }
@@ -267,16 +263,25 @@ public class CameraEntity extends EntityClientPlayerMP {
 
     @Override
     public ResourceLocation getLocationSkin() {
-        Entity view = mc.renderViewEntity;
+        Entity view = mc.getRenderViewEntity();
         if (view != this && view instanceof EntityPlayer) {
             return Utils.getResourceLocationForPlayerUUID(view.getUniqueID());
         }
         return super.getLocationSkin();
     }
 
+    @Override
+    public String getSkinType() {
+        Entity view = mc.getRenderViewEntity();
+        if (view != this && view instanceof AbstractClientPlayer) {
+            return ((AbstractClientPlayer) view).getSkinType();
+        }
+        return super.getSkinType();
+    }
+
     @Override
     public float getSwingProgress(float renderPartialTicks) {
-        Entity view = mc.renderViewEntity;
+        Entity view = mc.getRenderViewEntity();
         if (view != this && view instanceof EntityPlayer) {
             return ((EntityPlayer) view).getSwingProgress(renderPartialTicks);
         }
@@ -316,17 +321,17 @@ public class CameraEntity extends EntityClientPlayerMP {
 
         if (mc.gameSettings.keyBindAttack.isPressed() || mc.gameSettings.keyBindUseItem.isPressed()) {
             if (canSpectate(mc.pointedEntity)) {
-                ReplayModReplay.instance.getReplayHandler().spectateEntity((EntityLivingBase) mc.pointedEntity);
+                ReplayModReplay.instance.getReplayHandler().spectateEntity(mc.pointedEntity);
                 // Make sure we don't exit right away
                 mc.gameSettings.keyBindSneak.pressTime = 0;
             }
         }
 
         Map<String, KeyBinding> keyBindings = ReplayMod.instance.getKeyBindingRegistry().getKeyBindings();
-        if (keyBindings.get("replaymod.input.rollclockwise").getIsKeyPressed()) {
+        if (keyBindings.get("replaymod.input.rollclockwise").isKeyDown()) {
             roll += Utils.isCtrlDown() ? 0.2 : 1;
         }
-        if (keyBindings.get("replaymod.input.rollcounterclockwise").getIsKeyPressed()) {
+        if (keyBindings.get("replaymod.input.rollcounterclockwise").isKeyDown()) {
             roll -= Utils.isCtrlDown() ? 0.2 : 1;
         }
     }
@@ -340,19 +345,10 @@ public class CameraEntity extends EntityClientPlayerMP {
 
     public boolean canSpectate(Entity e) {
         return e != null && !e.isInvisible()
-                && e instanceof EntityPlayer; // 1.7.10 has no general concept of eye height
+                && (e instanceof EntityPlayer || e instanceof EntityLiving || e instanceof EntityItemFrame);
     }
 
-    @Override
-    public void addChatMessage(IChatComponent message) {
-        if (MinecraftForge.EVENT_BUS.post(new ReplayChatMessageEvent(this))) return;
-        super.addChatMessage(message);
-    }
-
-    // All event handlers need to be public in 1.7.10
-    public class EventHandler {
-        private EventHandler() {}
-
+    private class EventHandler {
         @SubscribeEvent
         public void onPreClientTick(TickEvent.ClientTickEvent event) {
             if (event.phase == TickEvent.Phase.START) {
@@ -390,14 +386,14 @@ public class CameraEntity extends EntityClientPlayerMP {
         @SubscribeEvent
         public void onRenderHand(RenderHandEvent event) {
             // Unless we are spectating another player, don't render our hand
-            if (mc.renderViewEntity == CameraEntity.this || !(mc.renderViewEntity instanceof EntityPlayer)) {
+            if (mc.getRenderViewEntity() == CameraEntity.this || !(mc.getRenderViewEntity() instanceof EntityPlayer)) {
                 event.setCanceled(true);
             }
         }
 
         @SubscribeEvent(priority = EventPriority.LOWEST)
         public void onRenderHandMonitor(RenderHandEvent event) {
-            Entity view = mc.renderViewEntity;
+            Entity view = mc.getRenderViewEntity();
             if (view instanceof EntityPlayer) {
                 EntityPlayer player = (EntityPlayer) view;
                 // When the spectated player has changed, force equip their items to prevent the equip animation
@@ -415,50 +411,11 @@ public class CameraEntity extends EntityClientPlayerMP {
             }
         }
 
-        /* TODO 1.7.10: This event has been added in 1.8, has to be replaced with mixin
         @SubscribeEvent
         public void onEntityViewRenderEvent(EntityViewRenderEvent.CameraSetup event) {
             if (mc.getRenderViewEntity() == CameraEntity.this) {
                 event.roll = roll;
             }
         }
-        */
-
-        private boolean heldItemTooltipsWasTrue;
-
-        @SubscribeEvent
-        public void preRenderGameOverlay(RenderGameOverlayEvent.Pre event) {
-            switch (event.type) {
-                case ALL:
-                    heldItemTooltipsWasTrue = mc.gameSettings.heldItemTooltips;
-                    mc.gameSettings.heldItemTooltips = false;
-                    break;
-                case ARMOR:
-                case HEALTH:
-                case FOOD:
-                case AIR:
-                case HOTBAR:
-                case EXPERIENCE:
-                case HEALTHMOUNT:
-                case JUMPBAR:
-                    event.setCanceled(true);
-                    break;
-                case HELMET:
-                case PORTAL:
-                case CROSSHAIRS:
-                case BOSSHEALTH:
-                case TEXT:
-                case CHAT:
-                case PLAYER_LIST:
-                case DEBUG:
-                    break;
-            }
-        }
-
-        @SubscribeEvent
-        public void postRenderGameOverlay(RenderGameOverlayEvent.Post event) {
-            if (event.type != RenderGameOverlayEvent.ElementType.ALL) return;
-            mc.gameSettings.heldItemTooltips = heldItemTooltipsWasTrue;
-        }
     }
 }

src/main/java/com/replaymod/replay/camera/ClassicCameraController.java

@@ -34,7 +34,7 @@ public class ClassicCameraController implements CameraController {
         boolean forward = false, backward = false, left = false, right = false, up = false, down = false;
         speedup = false;
         for(KeyBinding kb : Minecraft.getMinecraft().gameSettings.keyBindings) {
-            if(!kb.getIsKeyPressed()) continue;
+            if(!kb.isKeyDown()) continue;
             if(kb.getKeyDescription().equals("key.forward")) {
                 forward = true;
                 speedup = true;
@@ -161,7 +161,7 @@ public class ClassicCameraController implements CameraController {
         Vec3 dbf = direction;
 
         if(dirBefore != null) {
-            direction = dirBefore.normalize().addVector(direction.xCoord, direction.yCoord, direction.zCoord);
+            direction = dirBefore.normalize().add(direction);
         }
 
         dirBefore = dbf;
@@ -174,7 +174,7 @@ public class ClassicCameraController implements CameraController {
         float f3 = MathHelper.sin(-yaw * 0.017453292F - (float)Math.PI);
         float f4 = -MathHelper.cos(-pitch * 0.017453292F);
         float f5 = MathHelper.sin(-pitch * 0.017453292F);
-        return Vec3.createVectorHelper((double)(f3 * f4), (double)f5, (double)(f2 * f4));
+        return new Vec3((double)(f3 * f4), (double)f5, (double)(f2 * f4));
     }
 
     public enum MoveDirection {

src/main/java/com/replaymod/replay/camera/SpectatorCameraController.java

@@ -34,9 +34,9 @@ public class SpectatorCameraController implements CameraController {
         // Always make sure the camera is in the exact same spot as the spectated entity
         // This is necessary as some rendering code for the hand doesn't respect the view entity
         // and always uses mc.thePlayer
-        Entity view = mc.renderViewEntity;
+        Entity view = mc.getRenderViewEntity();
         if (view != null && view != camera) {
-            camera.setCameraPosRot(mc.renderViewEntity);
+            camera.setCameraPosRot(mc.getRenderViewEntity());
             // If it's a player, also 'steal' its inventory so the rendering code knows what item to render
             if (view instanceof EntityPlayer) {
                 EntityPlayer viewPlayer = (EntityPlayer) view;