Merge branch '1.11' into 1.11.2

2a47f57 Merge branch '1.10.2' into 1.11
96b2904 Merge branch '1.9.4' into 1.10.2
6c8c779 Merge branch '1.8.9' into 1.9.4
aa16e42 Add workaround for setupCIWorkspace not being sufficient
ed56673 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

.drone.yml

@@ -3,9 +3,10 @@ pipeline:
     image: plugins/git
     tags: true
   build:
-    image: openjdk:8
+    image: maven:3.3.9-jdk-8
     commands:
-      - JAVA_OPTS=-Xmx1516M ./gradlew setupDecompWorkspace
+      - curl --fail --create-dirs -o $HOME/.gradle/init.d/mirror.gradle https://maven.johni0702.de/config/gradle
+      - curl --fail --create-dirs -o $HOME/.m2/settings.xml https://maven.johni0702.de/config/maven
       - ./gradlew :build
   archive:
     image: plugins/s3

.drone.yml.sig

@@ -1 +1 @@
-eyJhbGciOiJIUzI1NiJ9.cGlwZWxpbmU6CiAgY2xvbmU6CiAgICBpbWFnZTogcGx1Z2lucy9naXQKICAgIHRhZ3M6IHRydWUKICBidWlsZDoKICAgIGltYWdlOiBvcGVuamRrOjgKICAgIGNvbW1hbmRzOgogICAgICAtIEpBVkFfT1BUUz0tWG14MTUxNk0gLi9ncmFkbGV3IHNldHVwRGVjb21wV29ya3NwYWNlCiAgICAgIC0gLi9ncmFkbGV3IDpidWlsZAogIGFyY2hpdmU6CiAgICBpbWFnZTogcGx1Z2lucy9zMwogICAgYWNsOiBwdWJsaWMtcmVhZAogICAgcmVnaW9uOiAidXMtZWFzdC0xIgogICAgYnVja2V0OiAicmVwbGF5bW9kIgogICAgcGF0aF9zdHlsZTogdHJ1ZQogICAgc291cmNlOiBidWlsZC9saWJzLyoKICAgIHN0cmlwX3ByZWZpeDogYnVpbGQvbGlicy8KICAgIHRhcmdldDogLwo.Q_jQxd73CuNh8ZTGTw31yMmBIzWprIagmaddFYovDrc
+eyJhbGciOiJIUzI1NiJ9.cGlwZWxpbmU6CiAgY2xvbmU6CiAgICBpbWFnZTogcGx1Z2lucy9naXQKICAgIHRhZ3M6IHRydWUKICBidWlsZDoKICAgIGltYWdlOiBtYXZlbjozLjMuOS1qZGstOAogICAgY29tbWFuZHM6CiAgICAgIC0gY3VybCAtLWZhaWwgLS1jcmVhdGUtZGlycyAtbyAkSE9NRS8uZ3JhZGxlL2luaXQuZC9taXJyb3IuZ3JhZGxlIGh0dHBzOi8vbWF2ZW4uam9obmkwNzAyLmRlL2NvbmZpZy9ncmFkbGUKICAgICAgLSBjdXJsIC0tZmFpbCAtLWNyZWF0ZS1kaXJzIC1vICRIT01FLy5tMi9zZXR0aW5ncy54bWwgaHR0cHM6Ly9tYXZlbi5qb2huaTA3MDIuZGUvY29uZmlnL21hdmVuCiAgICAgIC0gLi9ncmFkbGV3IDpidWlsZAogIGFyY2hpdmU6CiAgICBpbWFnZTogcGx1Z2lucy9zMwogICAgYWNsOiBwdWJsaWMtcmVhZAogICAgcmVnaW9uOiAidXMtZWFzdC0xIgogICAgYnVja2V0OiAicmVwbGF5bW9kIgogICAgcGF0aF9zdHlsZTogdHJ1ZQogICAgc291cmNlOiBidWlsZC9saWJzLyoKICAgIHN0cmlwX3ByZWZpeDogYnVpbGQvbGlicy8KICAgIHRhcmdldDogLwo.Z6rpaLplJKQ4pzB8AjCnplgci42qEu7L4LeS0fGm4SY

.gitmodules

@@ -5,3 +5,7 @@
 [submodule "ReplayStudio"]
 	path = ReplayStudio
 	url = https://github.com/ReplayMod/ReplayStudio
+
+[submodule "src/main/resources/assets/replaymod/lang"]
+	path = src/main/resources/assets/replaymod/lang
+	url = https://github.com/ReplayMod/Translations

build.gradle

@@ -1,7 +1,5 @@
 import groovy.json.JsonOutput
 
-import java.util.zip.ZipInputStream
-
 buildscript {
     repositories {
         mavenCentral()
@@ -36,9 +34,11 @@ archivesBaseName = "replaymod"
 
 minecraft {
     coreMod = 'com.replaymod.core.LoadingPlugin'
-    version = '1.9.4-12.17.0.1976'
+    version = '1.11.2-13.20.0.2216'
     runDir = "eclipse"
-    mappings = "snapshot_20160518"
+    mappings = "snapshot_20161220"
+    replace '@MOD_VERSION@', project.version
+    replace '@MC_VERSION@', project.minecraft.version
 }
 
 repositories {
@@ -59,7 +59,7 @@ configurations {
 dependencies {
     compile 'org.projectlombok:lombok:1.16.4'
 
-    compile 'org.spongepowered:mixin:0.5.9-SNAPSHOT'
+    compile 'org.spongepowered:mixin:0.6.8-SNAPSHOT'
     shade 'com.googlecode.mp4parser:isoparser:1.1.7'
     shade 'org.apache.commons:commons-exec:1.3'
     shade 'com.google.apis:google-api-services-youtube:v3-rev178-1.22.0'
@@ -101,27 +101,6 @@ jar {
     }
     from noticeDir
 
-    def langDir = file("$buildDir/languages")
-    doFirst {
-	try {
-        langDir.deleteDir()
-        langDir.mkdirs()
-        def dir = new File(langDir, 'assets/replaymod/lang/')
-        dir.mkdirs()
-        def zip = new ZipInputStream(new URL('http://replaymod.com/api/grab_languages').openStream())
-        def e;
-        while ((e = zip.nextEntry) != null) {
-            new File(dir, e.getName()) << zip
-            zip.closeEntry()
-        }
-	} catch(Exception e) {
-	    e.printStackTrace();
-	}
-    }
-    from (langDir) {
-        exclude '**/en_US.lang'
-    }
-
     from ({shade().collect { it.isDirectory() ? it : zipTree(it) }}) {
         exclude '**/NOTICE*'
         // exclude everything taken in from jGui for running the mod in a dev environment
@@ -187,6 +166,13 @@ sourceSets {
         }
         refMap = "mixins.replaymod.refmap.json"
     }
+    integrationTest {
+        compileClasspath += main.runtimeClasspath + main.output
+        java {
+            srcDir file('src/integration-test/java')
+        }
+        resources.srcDir file('src/integration-test/resources')
+    }
 }
 
 task copySrg(type: Copy, dependsOn: 'genSrgs') {
@@ -198,6 +184,81 @@ setupDecompWorkspace.dependsOn copySrg
 setupDevWorkspace.dependsOn copySrg
 project.tasks.idea.dependsOn copySrg
 
+
+import org.objectweb.asm.*
+
+import java.util.zip.ZipEntry
+import java.util.zip.ZipFile
+import java.util.zip.ZipOutputStream
+
+import static org.objectweb.asm.Opcodes.ASM5
+
+// MC binaries were complied with a java version that produces invalid class files under certain circumstances
+// This causes setupCIWorkspace to be insufficient for compiling.
+// Related JDK bug: https://bugs.openjdk.java.net/browse/JDK-8066725
+// As a workaround, to use setupCIWorkspace on Drone, we modify the bin jar in-place and remove all parameter annotations.
+// WARNING: This piece of code ignores any and all gradle conventions and will probably fail horribly when run outside
+// of a single-use environment (e.g. Drone). Use setupDecompWorkspace for normal use.
+tasks.deobfMcMCP.doLast {
+    println "Applying RuntimeInvisibleParameterAnnotations workaround..."
+    File jar = getOutJar()
+    File tmp = new File((File) getTemporaryDir(), "workaround.jar")
+    tmp.withOutputStream {
+        new ZipOutputStream(it).withStream { dst ->
+            new ZipFile(jar).withCloseable { src ->
+                src.entries().each {
+                    if (it.name.startsWith("net/minecraft/") && it.name.endsWith(".class")) {
+                        def cw = new ClassWriter(0)
+                        def cv = new ClassVisitor(ASM5, cw) {
+                            @Override
+                            MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+                                return new MethodVisitor(ASM5, cv.visitMethod(access, name, desc, signature, exceptions)) {
+                                    @Override
+                                    AnnotationVisitor visitParameterAnnotation(int parameter, String pdesc, boolean visible) {
+                                        return null // Strip all parameter annotations
+                                    }
+                                }
+                            }
+                        }
+                        new ClassReader(src.getInputStream(it)).accept(cv, 0)
+                        dst.putNextEntry(new ZipEntry(it.name))
+                        dst.write(cw.toByteArray())
+                    } else {
+                        dst.putNextEntry(it)
+                        dst.write(src.getInputStream(it).bytes)
+                    }
+                }
+            }
+        }
+    }
+    jar.delete()
+    tmp.renameTo(jar)
+}
+
+task runIntegrationTest(type: JavaExec, dependsOn: ["makeStart", "jar"]) {
+    main = 'GradleStart'
+    standardOutput = System.out
+    errorOutput = System.err
+    workingDir file(minecraft.runDir)
+
+    def testDir = new File(minecraft.runDir, "integration-test")
+    doFirst {
+        testDir.deleteDir()
+        testDir.mkdirs()
+    }
+
+    doLast {
+        testDir.deleteDir()
+    }
+
+    afterEvaluate {
+        def runClient = tasks.getByName("runClient")
+        runIntegrationTest.jvmArgs = runClient.jvmArgs + "-Dfml.noGrab=true"
+        runIntegrationTest.args = runClient.args + "--gameDir" + testDir.canonicalPath
+        runIntegrationTest.classpath runClient.classpath + sourceSets.integrationTest.output
+    }
+}
+
 def generateVersionsJson() {
     // List all tags
     def stdout = new ByteArrayOutputStream()

docs/content.md

@@ -2,7 +2,14 @@
 ## Installing the Replay Mod [replaymod]
 The **ReplayMod** requires **Minecraft Forge** to be installed.
 
-For the use with the **Replay Mod**, we recommend using Forge Version `1.8-11.14.3.1450`, which can be downloaded [here](http://files.minecraftforge.net/maven/net/minecraftforge/forge/index_1.8.html)
+Depending on your **Replay Mod** version we recommend the following **Forge** versions:
+
+- Replay Mod 2.0.0 or later for Minecraft 1.11: Forge [1.11-13.19.1.2189](https://files.minecraftforge.net/maven/net/minecraftforge/forge/index_1.11.html)
+- Replay Mod 2.0.0 or later for Minecraft 1.10.2: Forge [1.10.2-12.18.2.2099](https://files.minecraftforge.net/maven/net/minecraftforge/forge/index_1.10.2.html)
+- Replay Mod 2.0.0 or later for Minecraft 1.9.4: Forge [1.9.4-12.17.0.1976](https://files.minecraftforge.net/maven/net/minecraftforge/forge/index_1.9.4.html)
+- Replay Mod 2.0.0 or later for Minecraft 1.8: Forge [1.8-11.14.4.1563](https://files.minecraftforge.net/maven/net/minecraftforge/forge/index_1.8.html)
+- Replay Mod 1.0.8 or older for Minecraft 1.8: Forge [1.8-11.14.3.1450](http://files.minecraftforge.net/maven/net/minecraftforge/forge/index_1.8.html)
+
 Other Forge Versions might, but don't necessarily work.
 
 If you don't know how to install Forge, follow [this tutorial](https://www.youtube.com/watch?v=4i7-RystzC4).
@@ -25,6 +32,10 @@ Next, download this **Batch Script** to quickly install FFmpeg: <https://replaym
 Put the downloaded script into the folder where you extracted FFmpeg and run itt by double-clicking it.
 If you see a success message in the console, you've sucessfully installed **FFmpeg**!
 
+Alternatively, starting with ReplayMod 2.0.0-b5, you can also extract the downloaded `.7z` file into a `ffmpeg` folder
+(you have to create it, it doesn't exist by default) in your `.minecraft` folder. No need to run any **Batch Script**.
+The FFmpeg executable should end up at `.minecraft/ffmpeg/bin/ffmpeg.exe`.
+
 ### Mac OSX [mac]
 On OSX, you can install **FFmpeg** with **[Homebrew](http://brew.sh/)** using `brew install ffmpeg`.
 
@@ -37,26 +48,35 @@ If in doubt, consult the documentation of your distribution.
 ## Compatibility with other Mods [compatibility]
 ### General information [general]
 In General, the Replay Mod _should_ be compatible with most Forge Mods.
-However, due to the way that recording works, many Mods that add new Blocks, Mobs or Game Mechanics are not supported.  
-Mods that simply modify the client (like the [PixelCam Mod](http://www.minecraftforum.net/forums/mapping-and-modding/minecraft-mods/2327429-pixelcam-camera-studio-for-minecraft-1-8)
-or the [CommandGroups Mod](http://www.minecraftforum.net/forums/mapping-and-modding/minecraft-mods/2443430-command-groups-mod-order-label-and-color-command)) usually work.
-
-### Optifine [optifine]
-The **Replay Mod** is compatible with `Optifine 1.8.0 HD U D5`, which can be downloaded at <https://optifine.net/downloads>.  
-Other Optifine versions for Minecraft 1.8.0 might, but don't have to be compatible as well.
-
-> **Warning:** If you have Optifine installed, you **can not render videos** from within the Replay Mod.  
-This might change in future Replay Mod versions.
 
 ### Shaders Mod [shaders]
-You can use the Replay Mod together with [karyonix' Shaders Mod](http://www.minecraftforum.net/forums/mapping-and-modding/minecraft-mods/1286604-shaders-mod-updated-by-karyonix),
-but rendering videos results in **possible crashes** and **malformed videos**.
-Therefore, you have to **uninstall the Shaders Mod before rendering**.
+[Karyonix' Shaders Mod](http://www.minecraftforum.net/forums/mapping-and-modding/minecraft-mods/1286604-shaders-mod-updated-by-karyonix)
+is no longer compatible with Minecraft Forge starting with 1.9.4. As such it is not compatible with the Replay Mod either.
+Please use [Optifine](https://optifine.net/) instead.
+
+### Custom Main Menu [custom-main-menu]
+The [Custom Main Menu](https://mods.curse.com/mc-mods/minecraft/226406-custom-main-menu) mod is often used in mod packs to customize their Main Menu with a button layout fitting the background image, links to their website / bug tracker and similar.
+If you are familiar with it, the button ids for the Replay Mod are: **17890234** (text: `replaymod.gui.replayviewer`), **17890237** (text: `replaymod.gui.replayeditor`) and **17890236** (text: `replaymod.gui.replaycenter`)
+
+Due to the nature of this Custom Main Menu mod, buttons added to the Main Menu by 3rd party mods like the **Replay Mod** will not show up by default.  
+Thus, to access the Replay Viewer/Editor/Center, you need to manually configure the position for those buttons.  
+To do so, you need to modify the Custom Main Menu configuration file.
+Usually, you can find it at `.minecraft/config/CustomMainMenu/mainmenu.json` (if you're using a mod pack launcher, it normally has its own .minecraft folder).  
+For an explanation of this config file, have a look at Custom Main Menu's page.
+
+You can find a list of already modified config files [here](https://gist.github.com/Johni0702/3f3fab81dbf7ada83d045d9fe8f345aa).
 
 ## Troubleshooting [troubleshooting]
 If you need help installing the **Replay Mod** or **FFmpeg**, please read [this forum thread](https://www.replaymod.com/forum/thread/220) 
 by [bela333](https://www.replaymod.com/user/bela333) - it covers most of the problems that users encountered so far.
 
+## Settings [settings]
+To access the **Replay Mod Settings** from the Main Menu click the **"Mods"** button, select the **Replay Mod** from the list and
+the click the **"Config"** button.
+
+When in a Replay, you can either bind a hotkey to the **Replay Mod Settings** in Minecraft's Control settings
+or use the hotkey GUI by clicking on the arrow button in the lower left corner.
+
 # Recording [recording]
 ![](img/recording-indicator.jpg)
 The **Recording Indicator** which is displayed while recording
@@ -88,6 +108,8 @@ You can move through block similar to Spectator Mode.
 
 Using the **Mouse Wheel**, you can modify your flying speed. Scrolling **up** causes you to fly faster, while scrolling **down** slows you down.
 
+If you prefer the camera to be controlled similar to vanilla Creative Mode, you can change that in the **Replay Settings**.
+
 ### Camera Roll [roll]
 ![](img/camera-tilted.jpg)
 A Screenshot taken with a **tilted camera**
@@ -251,13 +273,15 @@ The **Keyframe Repository** with two **Path Presets**
 
 Using the `X` key, you can open the **Keyframe Repository**. Every Replay File has a separate Keyframe Repository which can contain several **Keyframe Presets**.
 
-To save the Keyframes currently on your Timeline, click the **"Save current Path"** button.
-You can change the Preset's name using the Text Input Field in the upper right corner.  
-To load a Keyframe Preset, select a Preset from the list on the left side and click the **"Load"** button.  
+To save the Keyframes currently on your Timeline, click the **"Save as..."** button.
+You can change a Preset's name, select it from the list and click the **"Rename"** button.
+To load a Keyframe Preset, select a Preset from the list and click the **"Load"** button.
 Using the **"Remove"** button, you can permanently delete a Keyframe Preset from the **Keyframe Repository**.
 
 ## Custom Objects [objects]
 
+> Custom Objects are not available in the 2.0.0 versions. They are expected to return eventually.
+
 [YouTube](_Xdpg828fbE)
 
 ### Introduction [introduction]
@@ -416,12 +440,10 @@ There are **7 Encoding Presets** you can choose from:
 
 ### Advanced Settings [advanced]
 ![](img/rendersettings-advanced.jpg)
-The **Advanced Render Settings** Screen
+The **Advanced Render Settings**
 
-By clicking the **"Advanced Settings" Button** in the lower right corner, you can access more settings.
-
-#### Hide Nametags [nametags]
-If you don't want to see Entity's Nametags in the rendered video, simply tick the checkbox. Hidden Nametags also include Nametags of **Armor Stands** and **Mobs**, **not only Players**!
+#### Render Nametags [nametags]
+If you don't want to see Entity's Nametags in the rendered video, simply un-tick the checkbox. Hidden Nametags also include Nametags of **Armor Stands** and **Mobs**, **not only Players**!
 
 #### Stabilize Camera [stabilize]
 This setting is only applicable for **Cubic Rendering** and **Equirectangular Rendering**.  
@@ -443,14 +465,14 @@ Using a **Video Editing Software** like **Adobe After Effects** or **Sony Vegas*
 
 ### Command Line Settings [commandline]
 ![](img/rendersettings-commandline.jpg)
-The **Command Line Render Settings** Screen
+The **Command Line Render Settings**
 
 
 > **Note**: This is for advanced users only. If you do not know what your're doing, leave these settings as they are.
 
 The **Replay Mod** runs [FFmpeg](http://ffmpeg.org/) via the **Command Line** to encode videos.
 
-You can customize both the **executed Command** and the **Command Line Arguments** in the **Command Line Settings** Tag of the **Render Settings Screen**.
+You can customize both the **executed Command** and the **Command Line Arguments** in the **Command Line Settings** part of the **Render Settings Screen**.
 
 #### Custom Command [command]
 If you leave the left input field blank, `ffmpeg` will be used as **command**. If you haven't set your **PATH variable** to link to your FFmpeg distribution, simply enter the full path to your FFmpeg executable (e.g. `C:/ffmpeg/ffmpeg.exe` or `/usr/local/bin/ffmpeg`).
@@ -532,7 +554,7 @@ By clicking on a player's **Name or Head**, you can **spectate** this player.
 
 Next to each player, there's a **checkbox** using which you can toggle the player's **visibility**.
 This way, you can hide certain players from the Replay.  
-Above the individual checkboxes, there are two checkbox buttons - one to **hide all players** and one to **show all players**.
+Below the individual checkboxes, there are two checkbox buttons - one to **hide all players** and one to **show all players**.
 
 If you want to **save the player visibility settings**, check **"Remember Hidden Players" checkbox**.
 If checked, invisible players will stay invisible after closing the Replay (this can of course be reverted),

src/integration-test/java/IntegrationTest.java

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+package com.replaymod.replay;
+
+import com.replaymod.core.AbstractTask;
+import com.replaymod.replay.gui.screen.GuiReplayViewer;
+import de.johni0702.minecraft.gui.function.Clickable;
+import net.minecraftforge.client.event.RenderGameOverlayEvent;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import org.lwjgl.util.Point;
+import org.lwjgl.util.ReadableDimension;
+
+public class LoadReplay extends AbstractTask {
+    @Override
+    protected void init() {
+        expectGui(GuiReplayViewer.class, replayViewer -> runLater(() -> {
+            ReadableDimension size = replayViewer.getMaxSize();
+            // Select first entry
+            replayViewer.forEach(Clickable.class).mouseClick(new Point(size.getWidth() / 2, 40), 0);
+            // Load first replay
+            click(replayViewer.loadButton);
+
+            class EventHandler {
+                @SubscribeEvent
+                public void onRenderIngame(RenderGameOverlayEvent.Pre event) {
+                    MinecraftForge.EVENT_BUS.unregister(this);
+                    runLater(() -> future.set(null));
+                }
+            }
+            MinecraftForge.EVENT_BUS.register(new EventHandler());
+        }));
+    }
+}

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

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

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

@@ -0,0 +1,42 @@
+package com.replaymod.replay;
+
+import com.replaymod.core.AbstractTask;
+import com.replaymod.extras.playeroverview.PlayerOverviewGui;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+import org.lwjgl.input.Keyboard;
+
+import java.util.concurrent.TimeoutException;
+
+public class SpectatePlayer extends AbstractTask {
+    @Override
+    protected void init() {
+        press(Keyboard.KEY_B);
+        expectGui(PlayerOverviewGui.class, overview -> {
+            click(overview.getMaxSize().getWidth() / 2 - 60, 60);
+            press(Keyboard.KEY_ESCAPE);
+            expectGuiClosed(() -> future.set(null));
+        });
+    }
+
+    public static class End extends AbstractTask {
+        private int timeout;
+
+        @Override
+        protected void init() {
+            runLater(() -> press(Keyboard.KEY_LSHIFT));
+        }
+
+        @SubscribeEvent
+        public void onTick(TickEvent.RenderTickEvent event) {
+            if (event.phase != TickEvent.Phase.START) return;
+            if (timeout++ > 20) {
+                future.setException(new TimeoutException("Camera hasn't stopped spectating."));
+                return;
+            }
+            if (mc.getRenderViewEntity() == mc.player) {
+                future.set(null);
+            }
+        }
+    }
+}

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

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

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

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

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

@@ -2,19 +2,18 @@ package com.replaymod.compat;
 
 import com.replaymod.compat.optifine.DisableFastRender;
 import com.replaymod.compat.shaders.ShaderBeginRender;
-import com.replaymod.core.ReplayMod;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.event.FMLInitializationEvent;
 import net.minecraftforge.fml.common.eventhandler.EventBus;
 
-@Mod(modid = ReplayModCompat.MOD_ID, useMetadata = true)
+@Mod(modid = ReplayModCompat.MOD_ID,
+        version = "@MOD_VERSION@",
+        acceptedMinecraftVersions = "@MC_VERSION@",
+        useMetadata = true)
 public class ReplayModCompat {
     public static final String MOD_ID = "replaymod-compat";
 
-    @Mod.Instance(ReplayMod.MOD_ID)
-    private static ReplayMod core;
-
     @Mod.EventHandler
     public void init(FMLInitializationEvent event) {
         EventBus bus = MinecraftForge.EVENT_BUS;

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

@@ -0,0 +1,22 @@
+package com.replaymod.compat.shaders.mixin;
+
+import net.minecraft.client.renderer.EntityRenderer;
+import net.minecraftforge.client.ForgeHooksClient;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Pseudo;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Pseudo
+@Mixin(targets = "shadersmod/client/ShadersRender", remap = false)
+public abstract class MixinShadersRender {
+
+    @Inject(method = "renderHand0", at = @At("HEAD"), cancellable = true)
+    private static void replayModCompat_disableRenderHand0(EntityRenderer er, float partialTicks, int renderPass, CallbackInfo ci) {
+        if (ForgeHooksClient.renderFirstPersonHand(er.mc.renderGlobal, partialTicks, renderPass)) {
+            ci.cancel();
+        }
+    }
+
+}

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

@@ -34,6 +34,8 @@ import java.util.List;
 
 @Mod(modid = ReplayMod.MOD_ID,
         useMetadata = true,
+        version = "@MOD_VERSION@",
+        acceptedMinecraftVersions = "@MC_VERSION@",
         updateJSON = "https://raw.githubusercontent.com/ReplayMod/ReplayMod/master/versions.json",
         guiFactory = "com.replaymod.core.gui.GuiFactory")
 public class ReplayMod {

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

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

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

@@ -17,7 +17,7 @@ public class Restrictions {
     public String handle(SPacketCustomPayload packet) {
         PacketBuffer buffer = packet.getBufferData();
         while (buffer.isReadable()) {
-            String name = buffer.readStringFromBuffer(64);
+            String name = buffer.readString(64);
             boolean active = buffer.readBoolean();
 //            if ("no_xray".equals(name)) {
 //                noXray = active;

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

@@ -1,16 +1,55 @@
 package com.replaymod.core.utils;
 
-import net.minecraft.client.Minecraft;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import de.johni0702.minecraft.gui.GuiRenderer;
+import de.johni0702.minecraft.gui.RenderInfo;
+import de.johni0702.minecraft.gui.container.AbstractGuiScrollable;
+import de.johni0702.minecraft.gui.container.GuiContainer;
+import de.johni0702.minecraft.gui.container.GuiPanel;
+import de.johni0702.minecraft.gui.container.GuiScrollable;
+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.HorizontalLayout;
+import de.johni0702.minecraft.gui.layout.VerticalLayout;
+import de.johni0702.minecraft.gui.popup.GuiInfoPopup;
+import de.johni0702.minecraft.gui.utils.Colors;
+import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.client.network.NetworkPlayerInfo;
 import net.minecraft.client.resources.DefaultPlayerSkin;
+import net.minecraft.crash.CrashReport;
 import net.minecraft.util.ResourceLocation;
+import org.apache.logging.log4j.Logger;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.util.Dimension;
 import org.lwjgl.util.ReadableDimension;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import javax.imageio.ImageIO;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManagerFactory;
 import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Date;
 import java.util.UUID;
+import java.util.function.Consumer;
+
+import static net.minecraft.client.Minecraft.getMinecraft;
 
 public class Utils {
 
@@ -27,6 +66,42 @@ public class Utils {
         DEFAULT_THUMBNAIL = thumbnail;
     }
 
+
+    /**
+     * Neither the root certificate of LetsEncrypt nor the root that cross-signed it is included in the default
+     * Java keystore prior to 8u101.
+     * Therefore whenever a connection to the replaymod.com site is made, this SSLContext has to be used instead.
+     * It has been constructed to include the necessary root certificates.
+     * @see #SSL_SOCKET_FACTORY
+     */
+    public static final SSLContext SSL_CONTEXT;
+
+    /**
+     * @see #SSL_CONTEXT
+     */
+    public static final SSLSocketFactory SSL_SOCKET_FACTORY;
+
+    static {
+        // Largely from https://community.letsencrypt.org/t/134/37
+        try (InputStream in = Utils.class.getResourceAsStream("/dst_root_ca_x3.pem")){
+            Certificate certificate = CertificateFactory.getInstance("X.509").generateCertificate(in);
+
+            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
+            keyStore.load(null, null);
+            keyStore.setCertificateEntry("1", certificate);
+
+            TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+            trustManagerFactory.init(keyStore);
+
+            SSLContext ctx = SSLContext.getInstance("TLS");
+            ctx.init(null, trustManagerFactory.getTrustManagers(), null);
+            SSL_CONTEXT = ctx;
+            SSL_SOCKET_FACTORY = ctx.getSocketFactory();
+        } catch (IOException | CertificateException | KeyStoreException | NoSuchAlgorithmException | KeyManagementException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     public static String convertSecondsToShortString(int seconds) {
         int hours = seconds/(60*60);
         int min = seconds/60 - hours*60;
@@ -63,7 +138,7 @@ public class Utils {
     }
 
     public static ResourceLocation getResourceLocationForPlayerUUID(UUID uuid) {
-        NetworkPlayerInfo info = Minecraft.getMinecraft().getConnection().getPlayerInfo(uuid);
+        NetworkPlayerInfo info = getMinecraft().getConnection().getPlayerInfo(uuid);
         ResourceLocation skinLocation;
         if (info != null && info.hasLocationSkin()) {
             skinLocation = info.getLocationSkin();
@@ -76,4 +151,94 @@ public class Utils {
     public static boolean isCtrlDown() {
         return Keyboard.isKeyDown(Keyboard.KEY_LCONTROL) || Keyboard.isKeyDown(Keyboard.KEY_RCONTROL);
     }
+
+    public static <T> void addCallback(ListenableFuture<T> future, Consumer<T> onSuccess, Consumer<Throwable> onFailure) {
+        Futures.addCallback(future, new FutureCallback<T>() {
+            @Override
+            public void onSuccess(@Nullable T result) {
+                onSuccess.accept(result);
+            }
+
+            @Override
+            public void onFailure(@Nonnull Throwable t) {
+                onFailure.accept(t);
+            }
+        });
+    }
+
+    public static GuiInfoPopup error(Logger logger, GuiContainer container, CrashReport crashReport, Runnable onClose) {
+        // Convert crash report to string
+        String crashReportStr = crashReport.getCompleteReport();
+
+        // Log via logger
+        logger.error(crashReportStr);
+
+        // Try to save the crash report
+        if (crashReport.getFile() == null) {
+            try {
+                File folder = new File(getMinecraft().mcDataDir, "crash-reports");
+                File file = new File(folder, "crash-" + (new SimpleDateFormat("yyyy-MM-dd_HH.mm.ss")).format(new Date()) + "-client.txt");
+                logger.debug("Saving crash report to file: {}", file);
+                crashReport.saveToFile(file);
+            } catch (Throwable t) {
+                logger.error("Saving crash report file:", t);
+            }
+        } else {
+            logger.debug("Not saving crash report as file already exists: {}", crashReport.getFile());
+        }
+
+        logger.trace("Opening crash report popup GUI");
+        GuiCrashReportPopup popup = new GuiCrashReportPopup(container, crashReportStr);
+        Futures.addCallback(popup.getFuture(), new FutureCallback<Void>() {
+            @Override
+            public void onSuccess(@Nullable Void result) {
+                logger.trace("Crash report popup closed");
+                if (onClose != null) {
+                    onClose.run();
+                }
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                logger.error("During error popup:", t);
+            }
+        });
+        return popup;
+    }
+
+    private static class GuiCrashReportPopup extends GuiInfoPopup {
+        private final GuiScrollable scrollable;
+
+        public GuiCrashReportPopup(GuiContainer container, String crashReport) {
+            super(container);
+            setBackgroundColor(Colors.DARK_TRANSPARENT);
+
+            // Add crash report to scrollable info
+            getInfo().addElements(new VerticalLayout.Data(0.5),
+                    new GuiLabel().setColor(Colors.BLACK).setI18nText("replaymod.gui.unknownerror"),
+                    scrollable = new GuiScrollable().setScrollDirection(AbstractGuiScrollable.Direction.VERTICAL)
+                            .setLayout(new VerticalLayout().setSpacing(2))
+                            .addElements(null,Arrays.stream(crashReport.replace("\t", "    ").split("\n")).map(
+                                    l -> new GuiLabel().setText(l).setColor(Colors.BLACK)).toArray(GuiElement[]::new)));
+
+            // Replace close button with panel containing close and copy buttons
+            GuiButton copyToClipboardButton = new GuiButton().setI18nLabel("chat.copy").onClick(() ->
+                    GuiScreen.setClipboardString(crashReport)).setSize(150, 20);
+            GuiButton closeButton = getCloseButton();
+            popup.removeElement(closeButton);
+            popup.addElements(new VerticalLayout.Data(1),
+                    new GuiPanel().setLayout(new HorizontalLayout().setSpacing(5)).setSize(305, 20)
+                            .addElements(null, copyToClipboardButton, closeButton));
+
+            // And open it
+            open();
+        }
+
+        @Override
+        public void draw(GuiRenderer renderer, ReadableDimension size, RenderInfo renderInfo) {
+            // Re-size the scrollable containing the crash report to 3/4 of the screen
+            scrollable.setSize(size.getWidth() * 3 / 4, size.getHeight() * 3 / 4);
+            super.draw(renderer, size, renderInfo);
+        }
+    }
 }

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

@@ -0,0 +1,41 @@
+package com.replaymod.editor;
+
+import com.replaymod.core.ReplayMod;
+import com.replaymod.editor.handler.GuiHandler;
+import com.replaymod.online.Setting;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import org.apache.logging.log4j.Logger;
+
+@Mod(modid = ReplayModEditor.MOD_ID,
+        version = "@MOD_VERSION@",
+        acceptedMinecraftVersions = "@MC_VERSION@",
+        useMetadata = true)
+public class ReplayModEditor {
+    public static final String MOD_ID = "replaymod-editor";
+
+    @Mod.Instance(MOD_ID)
+    public static ReplayModEditor instance;
+
+    private ReplayMod core;
+
+    public static Logger LOGGER;
+
+    @Mod.EventHandler
+    public void preInit(FMLPreInitializationEvent event) {
+        ReplayModEditor.LOGGER = event.getModLog();
+        core = ReplayMod.instance;
+
+        core.getSettingsRegistry().register(Setting.class);
+    }
+
+    @Mod.EventHandler
+    public void init(FMLInitializationEvent event) {
+        new GuiHandler(this).register();
+    }
+
+    public ReplayMod getCore() {
+        return core;
+    }
+}

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

@@ -0,0 +1,389 @@
+package com.replaymod.editor.gui;
+
+import com.google.common.io.Files;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.gson.JsonObject;
+import com.replaymod.core.ReplayMod;
+import com.replaymod.core.utils.Utils;
+import com.replaymod.replaystudio.PacketData;
+import com.replaymod.replaystudio.Studio;
+import com.replaymod.replaystudio.filter.StreamFilter;
+import com.replaymod.replaystudio.io.ReplayInputStream;
+import com.replaymod.replaystudio.io.ReplayOutputStream;
+import com.replaymod.replaystudio.replay.ReplayFile;
+import com.replaymod.replaystudio.replay.ReplayMetaData;
+import com.replaymod.replaystudio.replay.ZipReplayFile;
+import com.replaymod.replaystudio.stream.PacketStream;
+import com.replaymod.replaystudio.studio.ReplayStudio;
+import de.johni0702.minecraft.gui.GuiRenderer;
+import de.johni0702.minecraft.gui.RenderInfo;
+import de.johni0702.minecraft.gui.container.GuiContainer;
+import de.johni0702.minecraft.gui.container.GuiPanel;
+import de.johni0702.minecraft.gui.container.GuiScreen;
+import de.johni0702.minecraft.gui.element.GuiButton;
+import de.johni0702.minecraft.gui.element.GuiLabel;
+import de.johni0702.minecraft.gui.element.GuiTextField;
+import de.johni0702.minecraft.gui.element.GuiTooltip;
+import de.johni0702.minecraft.gui.element.advanced.GuiProgressBar;
+import de.johni0702.minecraft.gui.layout.CustomLayout;
+import de.johni0702.minecraft.gui.layout.GridLayout;
+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.popup.GuiInfoPopup;
+import de.johni0702.minecraft.gui.popup.GuiYesNoPopup;
+import de.johni0702.minecraft.gui.utils.Colors;
+import net.minecraft.crash.CrashReport;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.FilenameUtils;
+import org.lwjgl.util.ReadableDimension;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+import static com.replaymod.editor.ReplayModEditor.LOGGER;
+
+public class GuiReplayEditor extends GuiScreen {
+    private final ReplayMod mod;
+
+    private volatile ProcessingStage processingStage;
+    private volatile double progress;
+    private GuiProcessingProgressPopup popup;
+
+    public GuiButton currentTabButton;
+    public GuiPanel currentTabPanel;
+
+    public final GuiLabel warningLabel = new GuiLabel(this).setColor(Colors.RED)
+            .setI18nText("replaymod.gui.editor.disclaimer");
+
+    public final GuiPanel tabButtons = new GuiPanel(this).setLayout(new GridLayout().setSpacingX(5));
+    public final List<GuiPanel> tabPanels = new ArrayList<>();
+
+    public final GuiButton saveButton = new GuiButton().setI18nLabel("replaymod.gui.save").setSize(100, 20);
+    public final GuiButton backButton = new GuiButton().setI18nLabel("replaymod.gui.back").setSize(100, 20);
+
+    public final GuiPanel buttonPanel = new GuiPanel(this).setLayout(new HorizontalLayout().setSpacing(5))
+            .addElements(null, saveButton, backButton);
+
+    public GuiReplayEditor(GuiScreen parent, ReplayMod mod) {
+        this.mod = mod;
+        backButton.onClick(parent::display);
+
+        setTitle(new GuiLabel().setI18nText("replaymod.gui.replayeditor"));
+
+        makeTab("trim", () -> new GuiTrimPanel(this));
+        makeTab("connect", GuiPanel::new).setDisabled(); // Not yet implemented
+        makeTab("modify", GuiPanel::new).setDisabled(); // Not yet implemented
+
+        setLayout(new CustomLayout<GuiScreen>() {
+            @Override
+            protected void layout(GuiScreen container, int width, int height) {
+                // Move all inactive panels aside
+                tabPanels.forEach(e -> pos(e, Integer.MIN_VALUE, Integer.MIN_VALUE));
+
+                pos(warningLabel, 10, 22);
+                size(warningLabel, width - 20, 10);
+
+                pos(tabButtons, 10, y(warningLabel) + height(warningLabel) + 2);
+                size(tabButtons, width - 20, 20);
+
+                pos(buttonPanel, width - 10 - width(buttonPanel), height - 10 - height(buttonPanel));
+
+                if (currentTabPanel != null) {
+                    pos(currentTabPanel, 10, y(tabButtons) + height(tabButtons) + 10);
+                    size(currentTabPanel, width - 20, y(buttonPanel) - 10 - y(currentTabPanel));
+                }
+            }
+        });
+    }
+
+    public GuiButton makeTab(String name, Supplier<GuiPanel> panel) {
+        GuiButton button =  new GuiButton().setI18nLabel("replaymod.gui.editor." + name + ".title")
+                .setTooltip(new GuiTooltip().setI18nText("replaymod.gui.editor." + name + ".description"))
+                .setSize(Integer.MAX_VALUE, Integer.MAX_VALUE);
+        button.onClick(() -> {
+            // Remove previous tab
+            if (currentTabButton != null) {
+                currentTabButton.setEnabled();
+                removeElement(currentTabPanel);
+            }
+
+            // Activate new tab
+            currentTabButton = button.setDisabled();
+            addElements(null, currentTabPanel = panel.get());
+        });
+        // Add new tab button to tabs panel
+        tabButtons.addElements(null, button);
+        ((GridLayout) tabButtons.getLayout()).setColumns(tabButtons.getChildren().size());
+        return button;
+    }
+
+    public void save(File inputFile, PacketStream.FilterInfo...filters) {
+        save(FilenameUtils.getBaseName(inputFile.getName()), (outputFile) -> {
+            Studio studio = new ReplayStudio();
+            File tmpDir = null;
+            try {
+                File actualOutputFile  = outputFile;
+                if (outputFile.getCanonicalPath().equals(inputFile.getCanonicalPath())) {
+                    // Input and output files are identical. Due to the way the ZipReplayFile stores its temporary
+                    // data, the same replay file must not be opened twice for writing (tmp files will be deleted once
+                    // either one is closed or, on Windows, will throw an exception when deleted).
+                    tmpDir = Files.createTempDir();
+                    outputFile = new File(tmpDir, "replay.mcpr");
+                    LOGGER.debug("Output file is identical to input file, using temporary output file {} instead",
+                            outputFile);
+                }
+                try (ReplayFile outputReplay = new ZipReplayFile(studio, inputFile, outputFile);
+                     ReplayOutputStream out = outputReplay.writePacketData();
+                     ReplayFile inputReplay = new ZipReplayFile(studio, inputFile);
+                     ReplayInputStream in = inputReplay.getPacketData()) {
+                    ReplayMetaData metaData = inputReplay.getMetaData();
+                    PacketStream stream = studio.createReplayStream(in, true);
+
+                    stream.addFilter(new ProgressFilter(metaData.getDuration()));
+                    for (PacketStream.FilterInfo info : filters) {
+                        stream.addFilter(info.getFilter(), info.getFrom(), info.getTo());
+                        LOGGER.debug("Added filter {}", info);
+                    }
+
+                    LOGGER.info("Built pipeline: {}", stream);
+                    stream.start();
+
+                    long lastTimestamp = 0;
+
+                    PacketData data;
+                    while ((data = stream.next()) != null) {
+                        out.write(data);
+                        lastTimestamp = data.getTime();
+                    }
+
+                    for (PacketData d : stream.end()) {
+                        out.write(d);
+                        lastTimestamp = d.getTime();
+                    }
+
+                    updateProgress(ProcessingStage.FINALIZING, 0);
+
+                    // Update duration of new replay
+                    metaData.setDuration((int) lastTimestamp);
+                    outputReplay.writeMetaData(metaData);
+
+                    out.close();
+                    outputReplay.save();
+                }
+                if (outputFile != actualOutputFile) {
+                    LOGGER.debug("Moving temporary output file {} to {}");
+                    FileUtils.forceDelete(actualOutputFile);
+                    FileUtils.moveFile(outputFile, actualOutputFile);
+                }
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            } finally {
+                if (tmpDir != null && !FileUtils.deleteQuietly(tmpDir)) {
+                    LOGGER.warn("Failed to delete temporary directory {}", tmpDir);
+                }
+            }
+        });
+    }
+
+    public void save(String sourceName, Consumer<File> runnable) {
+        GuiTextField nameField = new GuiTextField().setSize(200, 20).setFocused(true).setText(sourceName);
+        GuiYesNoPopup popup = GuiYesNoPopup.open(this,
+                nameField
+        ).setYesI18nLabel("replaymod.gui.editor.savemode.override").setNoI18nLabel("replaymod.gui.cancel");
+        nameField.onEnter(() -> {
+            if (popup.getYesButton().isEnabled()) {
+                popup.getYesButton().onClick();
+            }
+        }).onTextChanged(obj -> {
+            popup.getYesButton().setEnabled(!nameField.getText().isEmpty());
+            popup.setYesI18nLabel("replaymod.gui.editor.savemode." +
+                    (nameField.getText().equals(sourceName) ? "override" : "newfile"));
+        });
+        Futures.addCallback(popup.getFuture(), new FutureCallback<Boolean>() {
+            @Override
+            public void onSuccess(@Nullable Boolean result) {
+                if (result == Boolean.TRUE) {
+                    // Sanitize their input
+                    String name = nameField.getText().trim().replace("[^a-zA-Z0-9\\.\\- ]", "_");
+                    // This file is what they want
+                    File replayFolder;
+                    try {
+                        replayFolder = mod.getReplayFolder();
+                    } catch (IOException e) {
+                        Utils.error(LOGGER, GuiReplayEditor.this, CrashReport.makeCrashReport(e, "Getting replay folder"), null);
+                        return;
+                    }
+                    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,
+                                new GuiLabel().setColor(Colors.BLACK)
+                                        .setI18nText("replaymod.gui.replaymodified.warning1", name),
+                                new GuiLabel().setColor(Colors.BLACK)
+                                        .setI18nText("replaymod.gui.replaymodified.warning2"))
+                                .setYesI18nLabel("gui.yes").setNoI18nLabel("gui.no")
+                                .getFuture(), new FutureCallback<Boolean>() {
+                            @Override
+                            public void onSuccess(@Nullable Boolean result) {
+                                if (result == Boolean.TRUE) {
+                                    LOGGER.trace("Saving output in {}", targetFile);
+                                    runEdit(() -> runnable.accept(targetFile));
+                                } else {
+                                    LOGGER.trace("Not overwriting file {}, reopening naming dialog", targetFile);
+                                    save(sourceName, runnable);
+                                }
+                            }
+
+                            @Override
+                            public void onFailure(Throwable t) {
+                                LOGGER.error("During save file confirmation dialog:", t);
+                            }
+                        });
+                    } else {
+                        LOGGER.trace("Saving output in {}", targetFile);
+                        runEdit(() -> runnable.accept(targetFile));
+                    }
+                } else {
+                    LOGGER.trace("Saving cancelled");
+                }
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                LOGGER.error("During save file dialog:", t);
+            }
+        });
+    }
+
+    public void runEdit(Runnable runnable) {
+        popup = new GuiProcessingProgressPopup(this);
+        processingStage = ProcessingStage.INITIALIZING;
+        progress = 0;
+        new Thread(() -> {
+            LOGGER.info("Starting editing of replay");
+            try {
+                runnable.run();
+            } catch (Throwable t) {
+                CrashReport crashReport = CrashReport.makeCrashReport(t, "Editing replay file");
+                mod.runLater(() -> Utils.error(LOGGER, this, crashReport, popup::close));
+                return;
+            }
+            LOGGER.info("Successfully finished editing");
+            mod.runLater(() -> {
+                popup.close();
+                GuiInfoPopup.open(this, "replaymod.gui.editor.progress.status.finished");
+            });
+        }).start();
+    }
+
+    public void updateProgress(ProcessingStage stage, double progress) {
+        if (this.processingStage != stage) {
+            LOGGER.trace("Changing state from {} to {}", this.processingStage, stage);
+        }
+        this.processingStage = stage;
+        this.progress = progress;
+    }
+
+    public ReplayMod getMod() {
+        return mod;
+    }
+
+    public enum ProcessingStage {
+        INITIALIZING("initializing", 0.01),
+        WORKING("writing.raw", 0.89),
+        FINALIZING("writing.final", 0.1),
+        DONE("finished", 0);
+
+        private final String i18nKey;
+        private final double progressFraction;
+
+        ProcessingStage(String i18nKey, double progressFraction) {
+            this.i18nKey = "replaymod.gui.editor.progress.status." + i18nKey;
+            this.progressFraction = progressFraction;
+        }
+
+        public double getOverallProgress(double progress) {
+            progress *= progressFraction;
+            for (ProcessingStage processingStage : values()) {
+                if (processingStage == this) break;
+                progress += processingStage.progressFraction;
+            }
+            return progress;
+        }
+    }
+
+    private class ProgressFilter implements StreamFilter {
+        private final long total;
+
+        public ProgressFilter(long total) {
+            this.total = total;
+        }
+
+        @Override
+        public String getName() {
+            return "progress";
+        }
+
+        @Override
+        public void init(Studio studio, JsonObject config) {
+
+        }
+
+        @Override
+        public void onStart(PacketStream stream) {
+            updateProgress(ProcessingStage.WORKING, 0);
+        }
+
+        @Override
+        public boolean onPacket(PacketStream stream, PacketData data) {
+            updateProgress(ProcessingStage.WORKING, (double) data.getTime() / total);
+            return true;
+        }
+
+        @Override
+        public void onEnd(PacketStream stream, long timestamp) {}
+    }
+
+    private class GuiProcessingProgressPopup extends AbstractGuiPopup<GuiProcessingProgressPopup> {
+        private final GuiProgressBar progressBar = new GuiProgressBar().setSize(300, 20);
+
+        {
+            popup.setLayout(new VerticalLayout().setSpacing(10));
+            popup.addElements(new VerticalLayout.Data(0.5),
+                    new GuiLabel().setI18nText("replaymod.gui.editor.progress.title").setColor(Colors.BLACK),
+                    new GuiLabel().setI18nText("replaymod.gui.editor.progress.pleasewait").setColor(Colors.BLACK),
+                    progressBar);
+        }
+
+        public GuiProcessingProgressPopup(GuiContainer container) {
+            super(container);
+            open();
+        }
+
+        @Override
+        public void draw(GuiRenderer renderer, ReadableDimension size, RenderInfo renderInfo) {
+            // Update progress bar
+            progressBar.setI18nLabel(processingStage.i18nKey);
+            progressBar.setProgress((float) processingStage.getOverallProgress(progress));
+
+            super.draw(renderer, size, renderInfo);
+        }
+
+        @Override
+        public void close() {
+            super.close();
+        }
+
+        @Override
+        protected GuiProcessingProgressPopup getThis() {
+            return this;
+        }
+    }
+}

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

@@ -0,0 +1,202 @@
+package com.replaymod.editor.gui;
+
+import com.google.gson.JsonObject;
+import com.replaymod.core.utils.Utils;
+import com.replaymod.replaystudio.data.Marker;
+import com.replaymod.replaystudio.filter.ChangeTimestampFilter;
+import com.replaymod.replaystudio.filter.RemoveFilter;
+import com.replaymod.replaystudio.filter.SquashFilter;
+import com.replaymod.replaystudio.replay.ReplayFile;
+import com.replaymod.replaystudio.replay.ReplayMetaData;
+import com.replaymod.replaystudio.replay.ZipReplayFile;
+import com.replaymod.replaystudio.stream.PacketStream;
+import com.replaymod.replaystudio.studio.ReplayStudio;
+import de.johni0702.minecraft.gui.container.GuiPanel;
+import de.johni0702.minecraft.gui.element.GuiLabel;
+import de.johni0702.minecraft.gui.element.GuiNumberField;
+import de.johni0702.minecraft.gui.element.advanced.GuiDropdownMenu;
+import de.johni0702.minecraft.gui.layout.GridLayout;
+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;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+
+import static com.replaymod.editor.ReplayModEditor.LOGGER;
+import static java.util.Optional.ofNullable;
+
+public class GuiTrimPanel extends GuiPanel {
+    private static GuiNumberField newGuiNumberField() {
+        return new GuiNumberField().setMaxLength(2).setSize(20, 20).setValidateOnFocusChange(true);
+    }
+
+    // Special value indicating no replay files were found
+    private static final File NO_REPLAY = new File(".");
+    // Special value for the initial "Select Marker Keyframe" entry
+    private static final Marker NO_MARKER = new Marker(); static {NO_MARKER.setTime(-1);}
+
+    private final GuiReplayEditor gui;
+
+    public final GuiDropdownMenu<File> inputReplays = new GuiDropdownMenu<File>(this)
+            .setMinSize(new Dimension(200, 20)).onSelection(i -> updateSelectedReplay())
+            .setToString(f -> f == NO_REPLAY ? "" : FilenameUtils.getBaseName(f.getName()));
+
+    public final GuiNumberField startHour = newGuiNumberField();
+    public final GuiNumberField startMin = newGuiNumberField();
+    public final GuiNumberField startSec = newGuiNumberField();
+    public final GuiNumberField startMilli = newGuiNumberField().setSize(40, 20).setMaxLength(4);
+    public final GuiDropdownMenu<Marker> startMarker = new GuiDropdownMenu<>();
+
+    public final GuiNumberField endHour = newGuiNumberField();
+    public final GuiNumberField endMin = newGuiNumberField();
+    public final GuiNumberField endSec = newGuiNumberField();
+    public final GuiNumberField endMilli = newGuiNumberField().setSize(40, 20).setMaxLength(4);
+    public final GuiDropdownMenu<Marker> endMarker = new GuiDropdownMenu<>();
+
+    public final GuiPanel timePanel = new GuiPanel(this)
+            .setLayout(new GridLayout().setCellsEqualSize(false).setSpacingX(20).setSpacingY(5).setColumns(3))
+            .addElements(new GridLayout.Data(0, 0.5),
+                    new GuiLabel().setI18nText("replaymod.gui.start"),
+                    new GuiPanel().setLayout(new HorizontalLayout().setSpacing(2)).addElements(
+                            new HorizontalLayout.Data(0.5),
+                            startHour, new GuiLabel().setI18nText("replaymod.gui.hours"),
+                            startMin, new GuiLabel().setI18nText("replaymod.gui.minutes"),
+                            startSec, new GuiLabel().setI18nText("replaymod.gui.seconds"),
+                            startMilli, new GuiLabel().setI18nText("replaymod.gui.milliseconds")
+                    ), startMarker,
+                    new GuiLabel().setI18nText("replaymod.gui.end"),
+                    new GuiPanel().setLayout(new HorizontalLayout().setSpacing(2)).addElements(
+                            new HorizontalLayout.Data(0.5),
+                            endHour, new GuiLabel().setI18nText("replaymod.gui.hours"),
+                            endMin, new GuiLabel().setI18nText("replaymod.gui.minutes"),
+                            endSec, new GuiLabel().setI18nText("replaymod.gui.seconds"),
+                            endMilli, new GuiLabel().setI18nText("replaymod.gui.milliseconds")
+                    ), endMarker);
+
+    public GuiTrimPanel(GuiReplayEditor gui) {
+        this.gui = gui;
+
+        setLayout(new VerticalLayout().setSpacing(10));
+
+        Function<Marker, String> toString = m -> {
+            if (m == NO_MARKER) {
+                return I18n.format("replaymod.gui.editor.trim.marker");
+            } else {
+                return ofNullable(m.getName()).orElse(I18n.format("replaymod.gui.ingame.unnamedmarker"))
+                        + " (" + Utils.convertSecondsToShortString(m.getTime() / 1000) + ")";
+            }
+        };
+        startMarker.setToString(toString).setMinSize(new Dimension(100, 20)).onSelection(i ->
+                onSelectedMarkerChanged(startMarker, startHour, startMin, startSec, startMilli));
+        endMarker.setToString(toString).setMinSize(new Dimension(100, 20)).onSelection(i ->
+                onSelectedMarkerChanged(endMarker, endHour, endMin, endSec, endMilli));
+
+        File[] files = null;
+        try {
+            File folder = gui.getMod().getReplayFolder();
+            files = folder.listFiles((FileFilter) new SuffixFileFilter(".mcpr", IOCase.INSENSITIVE));
+        } catch (IOException e) {
+            Utils.error(LOGGER, gui, CrashReport.makeCrashReport(e, "Listing available replays"), gui.backButton::onClick);
+        }
+        if (files == null) {
+            LOGGER.warn("Replay file list is null, has the replay folder been deleted?");
+            files = new File[0];
+        } else {
+            LOGGER.debug("Found {} replays in the replay folder", files.length);
+        }
+        if (files.length == 0) {
+            inputReplays.setValues(NO_REPLAY);
+        } else {
+            inputReplays.setValues(files);
+        }
+
+        updateSelectedReplay();
+        updateReadyState();
+
+        gui.saveButton.onClick(() -> {
+            // Read start and end times
+            int start = ((startHour.getInteger() * 60 + startMin.getInteger()) * 60 + startSec.getInteger()) * 1000 + startMilli.getInteger();
+            int end = ((endHour.getInteger() * 60 + endMin.getInteger()) * 60 + endSec.getInteger()) * 1000 + endMilli.getInteger();
+            // Configure offset of change timestamp filter
+            ChangeTimestampFilter ctf = new ChangeTimestampFilter();
+            JsonObject config = new JsonObject();
+            config.addProperty("offset", -start);
+            ctf.init(null, config);
+            // Pass filters to save dialog
+            gui.save(inputReplays.getSelectedValue(),
+                    new PacketStream.FilterInfo(new SquashFilter(), -1, start),
+                    new PacketStream.FilterInfo(ctf, start, end),
+                    new PacketStream.FilterInfo(new RemoveFilter(), end, -1)
+            );
+        });
+    }
+
+    private void onSelectedMarkerChanged(GuiDropdownMenu<Marker> dropdown, GuiNumberField hour, GuiNumberField min,
+                                         GuiNumberField sec, GuiNumberField milli) {
+        Marker marker = dropdown.getSelectedValue();
+        if (marker != NO_MARKER) {
+            int time = marker.getTime();
+            setTime(time, hour, min, sec, milli);
+        }
+    }
+
+    private void setTime(int time, GuiNumberField hour, GuiNumberField min,
+                                         GuiNumberField sec, GuiNumberField milli) {
+        milli.setValue(time % 1000); time /= 1000;
+        sec.setValue(time % 60); time /= 60;
+        min.setValue(time % 60); time /= 60;
+        hour.setValue(time);
+    }
+
+    private void updateSelectedReplay() {
+        File file = inputReplays.getSelectedValue();
+        // Load markers and meta data from replay file
+        ReplayMetaData metaData;
+        Set<Marker> markers;
+        if (file == NO_REPLAY) {
+            metaData = new ReplayMetaData();
+            markers = Collections.emptySet();
+        } else {
+            try (ReplayFile replayFile = new ZipReplayFile(new ReplayStudio(), file)) {
+                metaData = replayFile.getMetaData();
+                markers = replayFile.getMarkers().or(Collections.emptySet());
+                LOGGER.debug("Loaded {} markers from replay {}", markers.size(), file);
+            } catch (Exception e) {
+                Utils.error(LOGGER, gui, CrashReport.makeCrashReport(e, "Reading markers from replay"), null);
+                metaData = new ReplayMetaData();
+                markers = Collections.emptySet();
+            }
+        }
+
+        // Sort and add initial "Select Event Marker" element
+        List<Marker> markerList = new ArrayList<>(markers);
+        markerList.sort(Comparator.comparing(Marker::getTime));
+        markerList.add(0, NO_MARKER);
+
+        // Set marker dropdown values
+        Marker[] markerArray = markerList.stream().toArray(Marker[]::new);
+        startMarker.setValues(markerArray).setSelected(0);
+        endMarker.setValues(markerArray).setSelected(0);
+
+        // Set start and end time values
+        setTime(0, startHour, startMin, startSec, startMilli);
+        setTime(metaData.getDuration(), endHour, endMin, endSec, endMilli);
+    }
+
+    private void updateReadyState() {
+        gui.saveButton.setEnabled(inputReplays.getSelectedValue() != NO_REPLAY);
+    }
+}

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

@@ -0,0 +1,48 @@
+package com.replaymod.editor.handler;
+
+import com.replaymod.editor.ReplayModEditor;
+import com.replaymod.editor.gui.GuiReplayEditor;
+import de.johni0702.minecraft.gui.container.GuiScreen;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiMainMenu;
+import net.minecraft.client.resources.I18n;
+import net.minecraftforge.client.event.GuiScreenEvent;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class GuiHandler {
+    private static final int BUTTON_REPLAY_EDITOR = 17890237;
+
+    private final ReplayModEditor mod;
+
+    public GuiHandler(ReplayModEditor mod) {
+        this.mod = mod;
+    }
+
+    public void register() {
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @SubscribeEvent
+    public void injectIntoMainMenu(GuiScreenEvent.InitGuiEvent event) {
+        if (!(event.getGui() instanceof GuiMainMenu)) {
+            return;
+        }
+
+        GuiButton button = new GuiButton(BUTTON_REPLAY_EDITOR, event.getGui().width / 2 + 2,
+                event.getGui().height / 4 + 10 + 3 * 24, I18n.format("replaymod.gui.replayeditor"));
+        button.width = button.width / 2 - 2;
+        event.getButtonList().add(button);
+    }
+
+    @SubscribeEvent
+    public void onButton(GuiScreenEvent.ActionPerformedEvent.Pre event) {
+        if(!event.getButton().enabled) return;
+
+        if (event.getGui() instanceof GuiMainMenu) {
+            if (event.getButton().id == BUTTON_REPLAY_EDITOR) {
+                new GuiReplayEditor(GuiScreen.wrap(event.getGui()), mod.getCore()).display();
+            }
+        }
+    }
+}

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

@@ -10,14 +10,12 @@ import de.johni0702.minecraft.gui.element.IGuiImage;
 import de.johni0702.minecraft.gui.layout.HorizontalLayout;
 import net.minecraft.client.settings.GameSettings;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.gameevent.TickEvent;
 import org.lwjgl.input.Keyboard;
 
 public class FullBrightness implements Extra {
-    @Mod.Instance(ReplayModReplay.MOD_ID)
-    private static ReplayModReplay module;
+    private ReplayModReplay module;
 
     private final IGuiImage indicator = new GuiImage().setTexture(ReplayMod.TEXTURE, 90, 20, 19, 13).setSize(19, 13);
 
@@ -27,6 +25,7 @@ public class FullBrightness implements Extra {
 
     @Override
     public void register(final ReplayMod mod) throws Exception {
+        this.module = ReplayModReplay.instance;
         this.gameSettings = mod.getMinecraft().gameSettings;
 
         mod.getKeyBindingRegistry().registerKeyBinding("replaymod.input.lighting", Keyboard.KEY_Z, new Runnable() {

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

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

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

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

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

@@ -12,16 +12,16 @@ import org.apache.logging.log4j.Logger;
 import java.util.Arrays;
 import java.util.List;
 
-@Mod(modid = ReplayModExtras.MOD_ID, useMetadata = true)
+@Mod(modid = ReplayModExtras.MOD_ID,
+        version = "@MOD_VERSION@",
+        acceptedMinecraftVersions = "@MC_VERSION@",
+        useMetadata = true)
 public class ReplayModExtras {
     public static final String MOD_ID = "replaymod-extras";
 
     @Mod.Instance(MOD_ID)
     public static ReplayModExtras instance;
 
-    @Mod.Instance(ReplayMod.MOD_ID)
-    private static ReplayMod core;
-
     private static final List<Class<? extends Extra>> builtin = Arrays.asList(
             PlayerOverview.class,
             UriSchemeExtra.class,
@@ -32,11 +32,11 @@ public class ReplayModExtras {
             OpenEyeExtra.class
     );
 
-    private Logger logger;
+    public static Logger LOGGER;
 
     @Mod.EventHandler
     public void preInit(FMLPreInitializationEvent event) {
-        logger = event.getModLog();
+        LOGGER = event.getModLog();
     }
 
     @Mod.EventHandler
@@ -44,9 +44,9 @@ public class ReplayModExtras {
         for (Class<? extends Extra> cls : builtin) {
             try {
                 Extra extra = cls.newInstance();
-                extra.register(core);
+                extra.register(ReplayMod.instance);
             } catch (Throwable t) {
-                logger.warn("Failed to load extra " + cls.getName() + ": ", t);
+                LOGGER.warn("Failed to load extra " + cls.getName() + ": ", t);
             }
         }
     }

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

@@ -11,9 +11,10 @@ import com.replaymod.replay.events.ReplayCloseEvent;
 import com.replaymod.replay.events.ReplayOpenEvent;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.client.renderer.entity.RenderPlayer;
+import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.client.event.RenderHandEvent;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import org.lwjgl.input.Keyboard;
 
@@ -21,20 +22,21 @@ import java.io.IOException;
 import java.util.*;
 
 public class PlayerOverview implements Extra {
-    @Mod.Instance(ReplayModReplay.MOD_ID)
-    private static ReplayModReplay module;
+    private ReplayModReplay module;
 
     private final Set<UUID> hiddenPlayers = new HashSet<>();
     private boolean savingEnabled;
 
     @Override
     public void register(final ReplayMod mod) throws Exception {
+        this.module = ReplayModReplay.instance;
+
         mod.getKeyBindingRegistry().registerKeyBinding("replaymod.input.playeroverview", Keyboard.KEY_B, new Runnable() {
             @Override
             public void run() {
                 if (module.getReplayHandler() != null) {
                     @SuppressWarnings("unchecked")
-                    List<EntityPlayer> players = mod.getMinecraft().theWorld.getPlayers(EntityPlayer.class, new Predicate() {
+                    List<EntityPlayer> players = mod.getMinecraft().world.getPlayers(EntityPlayer.class, new Predicate() {
                         @Override
                         public boolean apply(Object input) {
                             return !(input instanceof CameraEntity); // Exclude the camera entity
@@ -92,6 +94,14 @@ public class PlayerOverview implements Extra {
         hiddenPlayers.clear();
     }
 
+    @SubscribeEvent
+    public void oRenderHand(RenderHandEvent event) {
+        Entity view = module.getCore().getMinecraft().getRenderViewEntity();
+        if (view != null && isHidden(view.getUniqueID())) {
+            event.setCanceled(true);
+        }
+    }
+
     public boolean isSavingEnabled() {
         return savingEnabled;
     }

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

@@ -4,10 +4,15 @@ import com.replaymod.core.utils.Utils;
 import com.replaymod.replay.ReplayModReplay;
 import de.johni0702.minecraft.gui.GuiRenderer;
 import de.johni0702.minecraft.gui.RenderInfo;
-import de.johni0702.minecraft.gui.container.*;
+import de.johni0702.minecraft.gui.container.GuiClickable;
+import de.johni0702.minecraft.gui.container.GuiContainer;
+import de.johni0702.minecraft.gui.container.GuiPanel;
+import de.johni0702.minecraft.gui.container.GuiScreen;
+import de.johni0702.minecraft.gui.container.GuiVerticalList;
 import de.johni0702.minecraft.gui.element.GuiCheckbox;
 import de.johni0702.minecraft.gui.element.GuiImage;
 import de.johni0702.minecraft.gui.element.GuiLabel;
+import de.johni0702.minecraft.gui.element.GuiTooltip;
 import de.johni0702.minecraft.gui.element.IGuiCheckbox;
 import de.johni0702.minecraft.gui.function.Closeable;
 import de.johni0702.minecraft.gui.layout.CustomLayout;
@@ -37,6 +42,7 @@ public class PlayerOverviewGui extends GuiScreen implements Closeable {
     public final GuiVerticalList playersScrollable = new GuiVerticalList(contentPanel)
             .setDrawSlider(true).setDrawShadow(true);
     public final GuiCheckbox saveCheckbox = new GuiCheckbox(contentPanel)
+            .setTooltip(new GuiTooltip().setI18nText("replaymod.gui.playeroverview.remembersettings.description"))
             .setI18nLabel("replaymod.gui.playeroverview.remembersettings");
     public final GuiCheckbox checkAll = new GuiCheckbox(contentPanel){
         @Override
@@ -44,14 +50,14 @@ public class PlayerOverviewGui extends GuiScreen implements Closeable {
             getMinecraft().getSoundHandler().playSound(PositionedSoundRecord.getMasterRecord(SoundEvents.UI_BUTTON_CLICK, 1.0F));
             playersScrollable.forEach(IGuiCheckbox.class).setChecked(true);
         }
-    }.setLabel("").setChecked(true);
+    }.setLabel("").setChecked(true).setTooltip(new GuiTooltip().setI18nText("replaymod.gui.playeroverview.showall"));
     public final GuiCheckbox uncheckAll = new GuiCheckbox(contentPanel){
         @Override
         public void onClick() {
             getMinecraft().getSoundHandler().playSound(PositionedSoundRecord.getMasterRecord(SoundEvents.UI_BUTTON_CLICK, 1.0F));
             playersScrollable.forEach(IGuiCheckbox.class).setChecked(false);
         }
-    }.setLabel("").setChecked(false);
+    }.setLabel("").setChecked(false).setTooltip(new GuiTooltip().setI18nText("replaymod.gui.playeroverview.hideall"));
 
     {
         setBackground(Background.NONE);

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

@@ -4,7 +4,6 @@ import com.replaymod.core.ReplayMod;
 import com.replaymod.extras.Extra;
 import com.replaymod.online.ReplayModOnline;
 import de.johni0702.minecraft.gui.container.GuiScreen;
-import net.minecraftforge.fml.common.Mod;
 import org.apache.commons.io.IOUtils;
 
 import java.io.IOException;
@@ -13,14 +12,14 @@ import java.net.ServerSocket;
 import java.net.Socket;
 
 public class UriSchemeExtra implements Extra {
-    @Mod.Instance(ReplayModOnline.MOD_ID)
-    private static ReplayModOnline module;
+    private ReplayModOnline module;
 
     private ReplayMod mod;
 
     @Override
     public void register(final ReplayMod mod) throws Exception {
         this.mod = mod;
+        this.module = ReplayModOnline.instance;
 
         UriScheme uriScheme = UriScheme.create();
         if (uriScheme == null) {

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

@@ -26,18 +26,19 @@ import java.io.IOException;
 
 import static net.minecraft.client.Minecraft.getMinecraft;
 
-@Mod(modid = ReplayModOnline.MOD_ID, useMetadata = true)
+@Mod(modid = ReplayModOnline.MOD_ID,
+        version = "@MOD_VERSION@",
+        acceptedMinecraftVersions = "@MC_VERSION@",
+        useMetadata = true)
 public class ReplayModOnline {
     public static final String MOD_ID = "replaymod-online";
 
     @Mod.Instance(MOD_ID)
     public static ReplayModOnline instance;
 
-    @Mod.Instance(ReplayMod.MOD_ID)
-    private static ReplayMod core;
+    private ReplayMod core;
 
-    @Mod.Instance(ReplayModReplay.MOD_ID)
-    private static ReplayModReplay replayModule;
+    private ReplayModReplay replayModule;
 
     private Logger logger;
 
@@ -53,6 +54,8 @@ public class ReplayModOnline {
     @Mod.EventHandler
     public void preInit(FMLPreInitializationEvent event) {
         logger = event.getModLog();
+        core = ReplayMod.instance;
+        replayModule = ReplayModReplay.instance;
 
         core.getSettingsRegistry().register(Setting.class);
 
@@ -64,9 +67,11 @@ public class ReplayModOnline {
 
     @Mod.EventHandler
     public void init(FMLInitializationEvent event) {
+        if (!getDownloadsFolder().exists()){
             if (!getDownloadsFolder().mkdirs()) {
                 logger.warn("Failed to create downloads folder: " + getDownloadsFolder());
             }
+        }
 
         new GuiHandler(this).register();
         MinecraftForge.EVENT_BUS.register(this);
@@ -77,7 +82,7 @@ public class ReplayModOnline {
         // Initial login prompt
         if (!core.getSettingsRegistry().get(Setting.SKIP_LOGIN_PROMPT)) {
             if (!isLoggedIn()) {
-                new GuiLoginPrompt(apiClient, null, null, false).display();
+                core.runLater(() -> new GuiLoginPrompt(apiClient, GuiScreen.wrap(getMinecraft().currentScreen), null, false).display());
             }
         }
     }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src/main/java/com/replaymod/pathing/gui/GuiKeyframeRepository.java

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

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

@@ -4,6 +4,8 @@ import com.replaymod.core.ReplayMod;
 import com.replaymod.core.utils.Restrictions;
 import com.replaymod.recording.handler.ConnectionEventHandler;
 import com.replaymod.recording.packet.PacketListener;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandler;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraft.network.NetworkManager;
 import net.minecraftforge.fml.common.Mod;
@@ -14,15 +16,17 @@ import net.minecraftforge.fml.common.network.NetworkRegistry;
 import org.apache.logging.log4j.Logger;
 import org.lwjgl.input.Keyboard;
 
-@Mod(modid = ReplayModRecording.MOD_ID, useMetadata = true)
+@Mod(modid = ReplayModRecording.MOD_ID,
+        version = "@MOD_VERSION@",
+        acceptedMinecraftVersions = "@MC_VERSION@",
+        useMetadata = true)
 public class ReplayModRecording {
     public static final String MOD_ID = "replaymod-recording";
 
     @Mod.Instance(MOD_ID)
     public static ReplayModRecording instance;
 
-    @Mod.Instance(ReplayMod.MOD_ID)
-    private static ReplayMod core;
+    private ReplayMod core;
 
     private Logger logger;
 
@@ -31,6 +35,7 @@ public class ReplayModRecording {
     @Mod.EventHandler
     public void preInit(FMLPreInitializationEvent event) {
         logger = event.getModLog();
+        core = ReplayMod.instance;
 
         core.getSettingsRegistry().register(Setting.class);
 
@@ -51,9 +56,12 @@ public class ReplayModRecording {
         EventBus bus = MinecraftForge.EVENT_BUS;
         bus.register(connectionEventHandler = new ConnectionEventHandler(logger, core));
 
-        NetworkRegistry.INSTANCE.newSimpleChannel(Restrictions.PLUGIN_CHANNEL);
+        NetworkRegistry.INSTANCE.newChannel(Restrictions.PLUGIN_CHANNEL, new RestrictionsChannelHandler());
     }
 
+    @ChannelHandler.Sharable
+    private static class RestrictionsChannelHandler extends ChannelDuplexHandler {}
+
     public void initiateRecording(NetworkManager networkManager) {
         connectionEventHandler.onConnectedToServerEvent(networkManager);
     }

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

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

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

@@ -0,0 +1,25 @@
+package com.replaymod.recording.handler;
+
+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
+ * not actually be handled.
+ * This handler is only present when connected to the integrated server as
+ * otherwise all packets must be handled.
+ *
+ * When in single player, the game state packets must never be handled
+ * otherwise wired bugs related to semi-singletons can occur.
+ * See https://bugs.replaymod.com/show_bug.cgi?id=44
+ */
+public class FMLHandshakeFilter extends SimpleChannelInboundHandler<FMLHandshakeMessage> {
+    @Override
+    protected void channelRead0(ChannelHandlerContext ctx, FMLHandshakeMessage msg) throws Exception {
+        if (!(msg instanceof FMLHandshakeMessage.RegistryData)) {
+            // Pass on everything but RegistryData messages
+            ctx.fireChannelRead(msg);
+        }
+    }
+}

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

@@ -57,7 +57,7 @@ public class RecordingEventHandler {
 
     public void onPlayerJoin() {
         try {
-            packetListener.save(new SPacketSpawnPlayer(mc.thePlayer));
+            packetListener.save(new SPacketSpawnPlayer(mc.player));
         } catch(Exception e1) {
             e1.printStackTrace();
         }
@@ -65,7 +65,7 @@ public class RecordingEventHandler {
 
     public void onPlayerRespawn() {
         try {
-            packetListener.save(new SPacketSpawnPlayer(mc.thePlayer));
+            packetListener.save(new SPacketSpawnPlayer(mc.player));
         } catch(Exception e) {
             e.printStackTrace();
         }
@@ -93,7 +93,7 @@ public class RecordingEventHandler {
     @SubscribeEvent
     public void onPlayerTick(PlayerTickEvent e) {
         try {
-            if(e.player != mc.thePlayer) return;
+            if(e.player != mc.player) return;
 
             boolean force = false;
             if(lastX == null || lastY == null || lastZ == null) {
@@ -168,62 +168,62 @@ public class RecordingEventHandler {
 			 */
 
             //Inventory Handling
-            if (playerItems[0] != mc.thePlayer.getHeldItem(EnumHand.MAIN_HAND)) {
-                playerItems[0] = mc.thePlayer.getHeldItem(EnumHand.MAIN_HAND);
+            if (playerItems[0] != mc.player.getHeldItem(EnumHand.MAIN_HAND)) {
+                playerItems[0] = mc.player.getHeldItem(EnumHand.MAIN_HAND);
                 packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.MAINHAND, playerItems[0]));
             }
 
-            if (playerItems[1] != mc.thePlayer.getHeldItem(EnumHand.OFF_HAND)) {
-                playerItems[1] = mc.thePlayer.getHeldItem(EnumHand.OFF_HAND);
+            if (playerItems[1] != mc.player.getHeldItem(EnumHand.OFF_HAND)) {
+                playerItems[1] = mc.player.getHeldItem(EnumHand.OFF_HAND);
                 packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.OFFHAND, playerItems[1]));
             }
 
-            if (playerItems[2] != mc.thePlayer.inventory.armorInventory[0]) {
-                playerItems[2] = mc.thePlayer.inventory.armorInventory[0];
+            if (playerItems[2] != mc.player.getItemStackFromSlot(EntityEquipmentSlot.FEET)) {
+                playerItems[2] = mc.player.getItemStackFromSlot(EntityEquipmentSlot.FEET);
                 packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.FEET, playerItems[2]));
             }
 
-            if (playerItems[3] != mc.thePlayer.inventory.armorInventory[1]) {
-                playerItems[3] = mc.thePlayer.inventory.armorInventory[1];
+            if (playerItems[3] != mc.player.getItemStackFromSlot(EntityEquipmentSlot.LEGS)) {
+                playerItems[3] = mc.player.getItemStackFromSlot(EntityEquipmentSlot.LEGS);
                 packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.LEGS, playerItems[3]));
             }
 
-            if (playerItems[4] != mc.thePlayer.inventory.armorInventory[2]) {
-                playerItems[4] = mc.thePlayer.inventory.armorInventory[2];
+            if (playerItems[4] != mc.player.getItemStackFromSlot(EntityEquipmentSlot.CHEST)) {
+                playerItems[4] = mc.player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
                 packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.CHEST, playerItems[4]));
             }
 
-            if (playerItems[5] != mc.thePlayer.inventory.armorInventory[3]) {
-                playerItems[5] = mc.thePlayer.inventory.armorInventory[3];
+            if (playerItems[5] != mc.player.getItemStackFromSlot(EntityEquipmentSlot.HEAD)) {
+                playerItems[5] = mc.player.getItemStackFromSlot(EntityEquipmentSlot.HEAD);
                 packetListener.save(new SPacketEntityEquipment(e.player.getEntityId(), EntityEquipmentSlot.HEAD, playerItems[5]));
             }
 
             //Leaving Ride
 
-            if((!mc.thePlayer.isRiding() && lastRiding != -1) ||
-                    (mc.thePlayer.isRiding() && lastRiding != mc.thePlayer.getRidingEntity().getEntityId())) {
-                if(!mc.thePlayer.isRiding()) {
+            if((!mc.player.isRiding() && lastRiding != -1) ||
+                    (mc.player.isRiding() && lastRiding != mc.player.getRidingEntity().getEntityId())) {
+                if(!mc.player.isRiding()) {
                     lastRiding = -1;
                 } else {
-                    lastRiding = mc.thePlayer.getRidingEntity().getEntityId();
+                    lastRiding = mc.player.getRidingEntity().getEntityId();
                 }
                 packetListener.save(new SPacketEntityAttach(e.player, e.player.getRidingEntity()));
             }
 
             //Sleeping
-            if(!mc.thePlayer.isPlayerSleeping() && wasSleeping) {
+            if(!mc.player.isPlayerSleeping() && wasSleeping) {
                 packetListener.save(new SPacketAnimation(e.player, 2));
                 wasSleeping = false;
             }
 
             // Active hand (e.g. eating, drinking, blocking)
-            if (mc.thePlayer.isHandActive() ^ wasHandActive || mc.thePlayer.getActiveHand() != lastActiveHand) {
-                wasHandActive = mc.thePlayer.isHandActive();
-                lastActiveHand = mc.thePlayer.getActiveHand();
+            if (mc.player.isHandActive() ^ wasHandActive || mc.player.getActiveHand() != lastActiveHand) {
+                wasHandActive = mc.player.isHandActive();
+                lastActiveHand = mc.player.getActiveHand();
                 EntityDataManager dataManager = new EntityDataManager(null);
                 int state = (wasHandActive ? 1 : 0) | (lastActiveHand == EnumHand.OFF_HAND ? 2 : 0);
                 dataManager.register(EntityLiving.HAND_STATES, (byte) state);
-                packetListener.save(new SPacketEntityMetadata(mc.thePlayer.getEntityId(), dataManager, true));
+                packetListener.save(new SPacketEntityMetadata(mc.player.getEntityId(), dataManager, true));
             }
 
         } catch(Exception e1) {
@@ -234,7 +234,8 @@ public class RecordingEventHandler {
     @SubscribeEvent
     public void onPickupItem(ItemPickupEvent event) {
         try {
-            packetListener.save(new SPacketCollectItem(event.pickedUp.getEntityId(), event.player.getEntityId()));
+            packetListener.save(new SPacketCollectItem(event.pickedUp.getEntityId(), event.player.getEntityId(),
+                    event.pickedUp.getEntityItem().getMaxStackSize()));
         } catch(Exception e) {
             e.printStackTrace();
         }
@@ -243,7 +244,7 @@ public class RecordingEventHandler {
     @SubscribeEvent
     public void onSleep(PlayerSleepInBedEvent event) {
         try {
-            if (event.getEntityPlayer() != mc.thePlayer) {
+            if (event.getEntityPlayer() != mc.player) {
                 return;
             }
 
@@ -259,7 +260,7 @@ public class RecordingEventHandler {
     @SubscribeEvent
     public void enterMinecart(MinecartInteractEvent event) {
         try {
-            if(event.getEntity() != mc.thePlayer) {
+            if(event.getEntity() != mc.player) {
                 return;
             }
 
@@ -272,7 +273,7 @@ public class RecordingEventHandler {
     }
 
     public void onBlockBreakAnim(int breakerId, BlockPos pos, int progress) {
-        EntityPlayer thePlayer = mc.thePlayer;
+        EntityPlayer thePlayer = mc.player;
         if (thePlayer != null && breakerId == thePlayer.getEntityId()) {
             packetListener.save(new SPacketBlockBreakAnim(breakerId, pos, progress));
         }

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

@@ -37,14 +37,14 @@ public abstract class MixinNetHandlerPlayClient {
      */
     @Inject(method = "handlePlayerListItem", at=@At("HEAD"))
     public void recordOwnJoin(SPacketPlayerListItem packet, CallbackInfo ci) {
-        if (gameController.thePlayer == null) return;
+        if (gameController.player == null) return;
 
         RecordingEventHandler handler = getRecordingEventHandler();
         if (handler != null && packet.getAction() == SPacketPlayerListItem.Action.ADD_PLAYER) {
             for (SPacketPlayerListItem.AddPlayerData data : packet.getEntries()) {
                 if (data.getProfile() == null || data.getProfile().getId() == null) continue;
                 // Only add spawn packet for our own player and only if he isn't known yet
-                if (data.getProfile().getId().equals(Minecraft.getMinecraft().thePlayer.getGameProfile().getId())
+                if (data.getProfile().getId().equals(Minecraft.getMinecraft().player.getGameProfile().getId())
                         && !playerInfoMap.containsKey(data.getProfile().getId())) {
                     handler.onPlayerJoin();
                 }

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

@@ -1,7 +1,11 @@
 package com.replaymod.recording.mixin;
 
+import com.replaymod.recording.handler.FMLHandshakeFilter;
+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;
@@ -11,17 +15,32 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 @Mixin(value = NetworkDispatcher.class, remap = false)
 public abstract class MixinNetworkDispatcher {
 
+    @Shadow
+    private Side side;
+
     @Shadow
     private EmbeddedChannel handshakeChannel;
 
     /**
-     * Always sets fml:isLocal to false.
+     * Always sets fml:isLocal to false on the server side.
      * This effectively removes the difference in the FML handshake between SP and MP
      * and forces the block/item ids, etc. to always be send.
-     * This might have undesired side effects but at least it works at all.
+     * Injects a {@link FMLHandshakeFilter} on the client side to filter out
+     * those extra, unexpected packets.
      */
     @Inject(method = "insertIntoChannel", at=@At("HEAD"))
-    public void replayModRecording_forceIsLocalToFalse(CallbackInfo cb) {
+    public void replayModRecording_setupForLocalRecording(CallbackInfo cb) {
+        // If we're in multiplayer, everything is fine as is
+        if (!handshakeChannel.attr(NetworkDispatcher.IS_LOCAL).get()) return;
+
+        if (side == Side.SERVER) {
+            // On the server side, force all packets to be sent
             handshakeChannel.attr(NetworkDispatcher.IS_LOCAL).set(false);
+        } else {
+            // On the client side, discard additional packets
+            ChannelPipeline pipeline = handshakeChannel.pipeline();
+            pipeline.addAfter(pipeline.context(FMLHandshakeCodec.class).name(),
+                    "replaymod_filter", new FMLHandshakeFilter());
+        }
     }
 }

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

@@ -23,6 +23,6 @@ public abstract class MixinPlayerControllerMP implements RecordingEventHandler.R
     @Redirect(method = "onPlayerDestroyBlock", at = @At(value = "INVOKE",
             target = "Lnet/minecraft/world/World;playEvent(ILnet/minecraft/util/math/BlockPos;I)V"))
     public void replayModRecording_playEvent_fixed(World world, int type, BlockPos pos, int data) {
-        world.playEvent(mc.thePlayer, type, pos, data);
+        world.playEvent(mc.player, type, pos, data);
     }
 }

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

@@ -38,7 +38,7 @@ public abstract class MixinWorldClient extends World implements RecordingEventHa
     @Inject(method = "playSound", at = @At("HEAD"))
     public void replayModRecording_recordClientSound(EntityPlayer player, double x, double y, double z, SoundEvent sound, SoundCategory category,
                           float volume, float pitch, CallbackInfo ci) {
-        if (player == mc.thePlayer) {
+        if (player == mc.player) {
             RecordingEventHandler handler = replayModRecording_getRecordingEventHandler();
             if (handler != null) {
                 handler.onClientSound(sound, category, x, y, z, volume, pitch);
@@ -50,7 +50,7 @@ public abstract class MixinWorldClient extends World implements RecordingEventHa
     // These are handled in the World class, so we override the method in WorldClient and add our special handling.
     @Override
     public void playEvent(EntityPlayer player, int type, BlockPos pos, int data) {
-        if (player == mc.thePlayer) {
+        if (player == mc.player) {
             // We caused this event, the server won't send it to us
             RecordingEventHandler handler = replayModRecording_getRecordingEventHandler();
             if (handler != null) {

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

@@ -155,8 +155,8 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
                 Packet packet = (Packet) msg;
 
                 if(packet instanceof SPacketCollectItem) {
-                    if(mc.thePlayer != null ||
-                            ((SPacketCollectItem) packet).getEntityID() == mc.thePlayer.getEntityId()) {
+                    if(mc.player != null ||
+                            ((SPacketCollectItem) packet).getEntityID() == mc.player.getEntityId()) {
                         super.channelRead(ctx, msg);
                         return;
                     }
@@ -228,7 +228,7 @@ public class PacketListener extends ChannelInboundHandlerAdapter {
         }
         ByteBuf byteBuf = Unpooled.buffer();
         PacketBuffer packetBuffer = new PacketBuffer(byteBuf);
-        packetBuffer.writeVarIntToBuffer(packetId);
+        packetBuffer.writeVarInt(packetId);
         packet.writePacketData(packetBuffer);
 
         byteBuf.readerIndex(0);

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

@@ -26,6 +26,7 @@ import javax.annotation.Nonnull;
 import java.io.File;
 import java.io.IOException;
 import java.io.OutputStream;
+import java.util.HashMap;
 import java.util.Map;
 
 /**
@@ -52,6 +53,9 @@ public class ResourcePackRecorder {
             boolean doWrite = false; // Whether we are the first and have to write it
             synchronized (replayFile) { // Need to read, modify and write the resource pack index atomically
                 Map<Integer, String> index = replayFile.getResourcePackIndex();
+                if (index == null) {
+                    index = new HashMap<>();
+                }
                 if (!index.containsValue(hash)) {
                     // Hash is unknown, we have to write the resource pack ourselves
                     doWrite = true;
@@ -83,39 +87,39 @@ public class ResourcePackRecorder {
             final File levelDir = new File(savesDir, levelName);
 
             if (levelDir.isFile()) {
-                netManager.sendPacket(new CPacketResourcePackStatus(hash, CPacketResourcePackStatus.Action.ACCEPTED));
+                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.ACCEPTED));
                 Futures.addCallback(mc.getResourcePackRepository().setResourcePackInstance(levelDir), new FutureCallback<Object>() {
                     @Override
                     public void onSuccess(Object result) {
                         recordResourcePack(levelDir, requestId);
-                        netManager.sendPacket(new CPacketResourcePackStatus(hash, CPacketResourcePackStatus.Action.SUCCESSFULLY_LOADED));
+                        netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.SUCCESSFULLY_LOADED));
                     }
 
                     @Override
                     public void onFailure(@Nonnull Throwable throwable) {
-                        netManager.sendPacket(new CPacketResourcePackStatus(hash, CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
+                        netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
                     }
                 });
             } else {
-                netManager.sendPacket(new CPacketResourcePackStatus(hash, CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
+                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
             }
         } else {
             final ServerData serverData = mc.getCurrentServerData();
             if (serverData != null && serverData.getResourceMode() == ServerData.ServerResourceMode.ENABLED) {
-                netManager.sendPacket(new CPacketResourcePackStatus(hash, CPacketResourcePackStatus.Action.ACCEPTED));
+                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.ACCEPTED));
                 downloadResourcePackFuture(requestId, url, hash);
             } else if (serverData != null && serverData.getResourceMode() != ServerData.ServerResourceMode.PROMPT) {
-                netManager.sendPacket(new CPacketResourcePackStatus(hash, CPacketResourcePackStatus.Action.DECLINED));
+                netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.DECLINED));
             } else {
                 mc.addScheduledTask(() -> mc.displayGuiScreen(new GuiYesNo((result, id) -> {
                     if (serverData != null) {
                         serverData.setResourceMode(result ? ServerData.ServerResourceMode.ENABLED : ServerData.ServerResourceMode.DISABLED);
                     }
                     if (result) {
-                        netManager.sendPacket(new CPacketResourcePackStatus(hash, CPacketResourcePackStatus.Action.ACCEPTED));
+                        netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.ACCEPTED));
                         downloadResourcePackFuture(requestId, url, hash);
                     } else {
-                        netManager.sendPacket(new CPacketResourcePackStatus(hash, CPacketResourcePackStatus.Action.DECLINED));
+                        netManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.DECLINED));
                     }
 
                     ServerList.saveSingleServer(serverData);
@@ -131,12 +135,12 @@ public class ResourcePackRecorder {
         Futures.addCallback(downloadResourcePack(requestId, url, hash), new FutureCallback() {
             @Override
             public void onSuccess(Object result) {
-                mc.getConnection().sendPacket(new CPacketResourcePackStatus(hash, CPacketResourcePackStatus.Action.SUCCESSFULLY_LOADED));
+                mc.getConnection().sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.SUCCESSFULLY_LOADED));
             }
 
             @Override
             public void onFailure(@Nonnull Throwable throwable) {
-                mc.getConnection().sendPacket(new CPacketResourcePackStatus(hash, CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
+                mc.getConnection().sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.FAILED_DOWNLOAD));
             }
         });
     }
@@ -186,7 +190,7 @@ public class ResourcePackRecorder {
 
             Futures.getUnchecked(mc.addScheduledTask(() -> mc.displayGuiScreen(guiScreen)));
 
-            Map<String, String> sessionInfo = Minecraft.getSessionInfo();
+            Map<String, String> sessionInfo = ResourcePackRepository.getDownloadHeaders();
             repo.downloadingPacks = HttpUtil.downloadResourcePack(file, url, sessionInfo, 50 * 1024 * 1024, guiScreen, mc.getProxy());
             Futures.addCallback(repo.downloadingPacks, new FutureCallback<Object>() {
                 @Override

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

@@ -1,6 +1,8 @@
 package com.replaymod.render;
 
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.Getter;
 import net.minecraft.client.resources.I18n;
 import org.lwjgl.util.ReadableColor;
 
@@ -45,7 +47,7 @@ public class RenderSettings {
         }
 
         public String getValue() {
-            return "-y -f rawvideo -pix_fmt rgb24 -s %WIDTH%x%HEIGHT% -r %FPS% -i - " + preset;
+            return "-y -f rawvideo -pix_fmt rgb24 -s %WIDTH%x%HEIGHT% -r %FPS% -i - %FILTERS%" + preset;
         }
 
         public String getFileExtension() {
@@ -64,6 +66,19 @@ public class RenderSettings {
         }
     }
 
+    @AllArgsConstructor
+    public enum AntiAliasing {
+        NONE(1), X2(2), X4(4), X8(8);
+
+        @Getter
+        private final int factor;
+
+        @Override
+        public String toString() {
+            return I18n.format("replaymod.gui.rendersettings.antialiasing." + name().toLowerCase());
+        }
+    }
+
     private final RenderMethod renderMethod;
     private final EncodingPreset encodingPreset;
     private final int videoWidth;
@@ -78,9 +93,48 @@ public class RenderSettings {
     private final boolean stabilizeRoll;
     private final ReadableColor chromaKeyingColor;
     private final boolean inject360Metadata;
+    private final AntiAliasing antiAliasing;
 
     private final String exportCommand;
     private final String exportArguments;
 
     private final boolean highPerformance;
+
+    /**
+     * @return the width of the output video during rendering, including the upscale for Anti-Aliasing.
+     */
+    public int getVideoWidth() {
+        return videoWidth * antiAliasing.getFactor();
+    }
+
+    /**
+     * @return the height of the output video during rendering, including the upscale for Anti-Aliasing.
+     */
+    public int getVideoHeight() {
+        return videoHeight * antiAliasing.getFactor();
+    }
+
+    /**
+     * @return the actual width of the output video.
+     */
+    public int getTargetVideoWidth() {
+        return videoWidth;
+    }
+
+    /**
+     * @return the actual height of the output video.
+     */
+    public int getTargetVideoHeight() {
+        return videoHeight;
+    }
+
+    public String getVideoFilters() {
+        if (antiAliasing == AntiAliasing.NONE) {
+            return "";
+        } else {
+            double factor = 1.0 / antiAliasing.getFactor();
+            return String.format("-vf scale=iw*%1$s:ih*%1$s ", factor);
+        }
+    }
+
 }

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

@@ -1,30 +1,39 @@
 package com.replaymod.render;
 
 import com.replaymod.core.ReplayMod;
+import com.replaymod.render.utils.RenderJob;
+import com.replaymod.replay.events.ReplayCloseEvent;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.util.ReportedException;
+import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.common.config.Configuration;
 import net.minecraftforge.fml.common.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;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 
-@Mod(modid = ReplayModRender.MOD_ID, useMetadata = true)
+@Mod(modid = ReplayModRender.MOD_ID,
+        version = "@MOD_VERSION@",
+        acceptedMinecraftVersions = "@MC_VERSION@",
+        useMetadata = true)
 public class ReplayModRender {
     public static final String MOD_ID = "replaymod-render";
 
     @Mod.Instance(MOD_ID)
     public static ReplayModRender instance;
 
-    @Mod.Instance(ReplayMod.MOD_ID)
-    private static ReplayMod core;
+    private ReplayMod core;
 
-    private Logger logger;
+    public static Logger LOGGER;
 
     private Configuration configuration;
+    private final List<RenderJob> renderQueue = new ArrayList<>();
 
     public ReplayMod getCore() {
         return core;
@@ -32,12 +41,20 @@ public class ReplayModRender {
 
     @Mod.EventHandler
     public void preInit(FMLPreInitializationEvent event) {
-        logger = event.getModLog();
+        LOGGER = event.getModLog();
+        core = ReplayMod.instance;
         configuration = new Configuration(event.getSuggestedConfigurationFile());
 
+        MinecraftForge.EVENT_BUS.register(this);
+
         core.getSettingsRegistry().register(Setting.class);
     }
 
+    @SubscribeEvent
+    public void onReplayClose(ReplayCloseEvent.Post event) {
+        renderQueue.clear();
+    }
+
     public File getVideoFolder() {
         String path = core.getSettingsRegistry().get(Setting.RENDER_PATH);
         File folder = new File(path.startsWith("./") ? core.getMinecraft().mcDataDir : null, path);
@@ -52,4 +69,8 @@ public class ReplayModRender {
     public Configuration getConfiguration() {
         return configuration;
     }
+
+    public List<RenderJob> getRenderQueue() {
+        return renderQueue;
+    }
 }

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

@@ -7,17 +7,27 @@ import com.replaymod.render.utils.StreamPipe;
 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;
 import org.apache.commons.io.output.TeeOutputStream;
 import org.lwjgl.util.ReadableDimension;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
 import java.nio.channels.Channels;
 import java.nio.channels.WritableByteChannel;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Optional;
 import java.util.concurrent.TimeUnit;
 
+import static com.replaymod.render.ReplayModRender.LOGGER;
 import static org.apache.commons.lang3.Validate.isTrue;
 
 public class VideoWriter implements FrameConsumer<RGBFrame> {
@@ -43,10 +53,11 @@ public class VideoWriter implements FrameConsumer<RGBFrame> {
                     .replace("%HEIGHT%", String.valueOf(settings.getVideoHeight()))
                     .replace("%FPS%", String.valueOf(settings.getFramesPerSecond()))
                     .replace("%FILENAME%", fileName)
-                    .replace("%BITRATE%", String.valueOf(settings.getBitRate()));
+                    .replace("%BITRATE%", String.valueOf(settings.getBitRate()))
+                    .replace("%FILTERS%", settings.getVideoFilters());
 
-        String executable = settings.getExportCommand().isEmpty() ? "ffmpeg" : settings.getExportCommand();
-        System.out.println("Starting " + settings.getExportCommand() + " with args: " + commandArgs);
+        String executable = settings.getExportCommand().isEmpty() ? findFFmpeg() : settings.getExportCommand();
+        System.out.println("Starting " + executable + " with args: " + commandArgs);
         String[] cmdline = new CommandLine(executable).addArguments(commandArgs).toStrings();
         process = new ProcessBuilder(cmdline).directory(outputFolder).start();
         File exportLogFile = new File(Minecraft.getMinecraft().mcDataDir, "export.log");
@@ -57,6 +68,54 @@ public class VideoWriter implements FrameConsumer<RGBFrame> {
         channel = Channels.newChannel(outputStream);
     }
 
+    private String findFFmpeg() {
+        switch (Util.getOSType()) {
+            case WINDOWS:
+                // Allow windows users to unpack the ffmpeg archive into a sub-folder of their .minecraft folder
+                File inDotMinecraft = new File(Minecraft.getMinecraft().mcDataDir, "ffmpeg/bin/ffmpeg.exe");
+                if (inDotMinecraft.exists()) {
+                    LOGGER.debug("FFmpeg found in .minecraft/ffmpeg");
+                    return inDotMinecraft.getAbsolutePath();
+                }
+                break;
+            case OSX:
+                // The PATH doesn't seem to be set as expected on OSX, therefore we check some common locations ourselves
+                for (String path : new String[]{"/usr/local/bin/ffmpeg", "/usr/bin/ffmpeg"}) {
+                    File file = new File(path);
+                    if (file.exists()) {
+                        LOGGER.debug("Found FFmpeg at {}", path);
+                        return path;
+                    } else {
+                        LOGGER.debug("FFmpeg not located at {}", path);
+                    }
+                }
+                // Homebrew doesn't seem to reliably symlink its installed binaries either
+                File homebrewFolder = new File("/usr/local/Cellar/ffmpeg");
+                String[] homebrewVersions = homebrewFolder.list();
+                if (homebrewVersions != null) {
+                    Optional<File> latestOpt = Arrays.stream(homebrewVersions)
+                            .map(ComparableVersion::new) // Convert file name to comparable version
+                            .sorted(Comparator.reverseOrder()) // Sort for latest version
+                            .map(ComparableVersion::toString) // Convert back to file name
+                            .map(v -> new File(new File(homebrewFolder, v), "bin/ffmpeg")) // Convert to binary files
+                            .filter(File::exists) // Filter invalid installations (missing executable)
+                            .findFirst(); // Take first one
+                    if (latestOpt.isPresent()) {
+                        File latest = latestOpt.get();
+                        LOGGER.debug("Found {} versions of FFmpeg installed with homebrew, chose {}",
+                                homebrewVersions.length, latest);
+                        return latest.getAbsolutePath();
+                    }
+                }
+                break;
+            case LINUX: // Linux users are entrusted to have their PATH configured correctly (most package manager do this)
+            case SOLARIS: // Never heard of anyone running this mod on Solaris having any problems
+            case UNKNOWN: // Unknown OS, just try to use "ffmpeg"
+        }
+        LOGGER.debug("Using default FFmpeg executable");
+        return "ffmpeg";
+    }
+
     @Override
     public void close() throws IOException {
         IOUtils.closeQuietly(outputStream);

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

@@ -0,0 +1,277 @@
+package com.replaymod.render.gui;
+
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.replaymod.render.ReplayModRender;
+import com.replaymod.render.rendering.VideoRenderer;
+import com.replaymod.render.utils.RenderJob;
+import com.replaymod.replay.ReplayHandler;
+import com.replaymod.replaystudio.pathing.path.Timeline;
+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.GuiContainer;
+import de.johni0702.minecraft.gui.container.GuiPanel;
+import de.johni0702.minecraft.gui.container.GuiVerticalList;
+import de.johni0702.minecraft.gui.element.GuiButton;
+import de.johni0702.minecraft.gui.element.GuiLabel;
+import de.johni0702.minecraft.gui.element.GuiTextField;
+import de.johni0702.minecraft.gui.layout.CustomLayout;
+import de.johni0702.minecraft.gui.layout.GridLayout;
+import de.johni0702.minecraft.gui.layout.HorizontalLayout;
+import de.johni0702.minecraft.gui.popup.AbstractGuiPopup;
+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;
+
+public class GuiRenderQueue extends AbstractGuiPopup<GuiRenderQueue> {
+    private final GuiLabel title = new GuiLabel().setI18nText("replaymod.gui.renderqueue.title").setColor(Colors.BLACK);
+    private final GuiVerticalList list = new GuiVerticalList().setDrawShadow(true).setDrawSlider(true);
+    private final GuiButton addButton = new GuiButton().setI18nLabel("replaymod.gui.renderqueue.add").setSize(150, 20);
+    private final GuiButton renameButton = new GuiButton().setI18nLabel("replaymod.gui.rename").setSize(73, 20);
+    private final GuiButton removeButton = new GuiButton().setI18nLabel("replaymod.gui.remove").setSize(73, 20);
+    private final GuiButton renderButton = new GuiButton().setI18nLabel("replaymod.gui.render").setSize(150, 20);
+    private final GuiButton closeButton = new GuiButton().setI18nLabel("replaymod.gui.close").setSize(150, 20).onClick(this::close);
+
+    /*
+
+    |---------------------------------|
+    |       Add       |     Render    |
+    |---------------------------------|
+    | Rename | Remove |     Close     |
+    |---------------------------------|
+
+     */
+    private final GuiPanel buttonPanel = new GuiPanel()
+            .setLayout(new GridLayout().setSpacingX(5).setSpacingY(5).setColumns(2))
+            .addElements(null,
+                    addButton,
+                    renderButton,
+                    new GuiPanel().setLayout(new HorizontalLayout().setSpacing(4)).addElements(null,
+                            renameButton, removeButton),
+                    closeButton);
+
+    private final GuiContainer container;
+    private Entry selectedEntry;
+
+    {
+        popup.setLayout(new CustomLayout<GuiPanel>() {
+            @Override
+            protected void layout(GuiPanel container, int width, int height) {
+                pos(title, width / 2 - width(title) / 2, 0);
+                pos(list, 0, y(title) + height(title) + 5);
+                pos(buttonPanel, width / 2 - width(buttonPanel) / 2, height - height(buttonPanel));
+                size(list, width, y(buttonPanel) - y(list) - 10);
+            }
+
+            @Override
+            public ReadableDimension calcMinSize(GuiContainer<?> container) {
+                ReadableDimension screenSize = GuiRenderQueue.this.container.getMinSize();
+                return new Dimension(screenSize.getWidth() - 40,
+                        screenSize.getHeight() - 20 - buttonPanel.getMinSize().getHeight() - title.getMinSize().getHeight());
+            }
+        }).addElements(null, title, list, buttonPanel);
+    }
+
+    public GuiRenderQueue(GuiContainer container, GuiRenderSettings guiRenderSettings, ReplayHandler replayHandler, Timeline timeline) {
+        super(container);
+        this.container = container;
+        LOGGER.trace("Opening render queue popup");
+
+        setBackgroundColor(Colors.DARK_TRANSPARENT);
+
+        List<RenderJob> queue = ReplayModRender.instance.getRenderQueue();
+
+        for (RenderJob renderJob : queue) {
+            LOGGER.trace("Adding {} to job queue list", renderJob);
+            list.getListPanel().addElements(null, new Entry(renderJob));
+        }
+
+        addButton.onClick(() -> {
+            LOGGER.trace("Add button clicked");
+            // Open popup
+            GuiYesNoPopup popup = GuiYesNoPopup.open(container)
+                    .setYesI18nLabel("replaymod.gui.add").setNoI18nLabel("replaymod.gui.cancel");
+            popup.getInfo().setLayout(new HorizontalLayout(HorizontalLayout.Alignment.CENTER).setSpacing(5));
+            // Add content
+            GuiLabel label = new GuiLabel().setI18nText("replaymod.gui.renderqueue.jobname").setColor(Colors.BLACK);
+            GuiTextField nameField = new GuiTextField().setSize(150, 20).setFocused(true);
+            popup.getInfo().addElements(new HorizontalLayout.Data(0.5), label, nameField);
+            // Disable "Yes" button while name is empty
+            nameField.onTextChanged(old -> popup.getYesButton().setEnabled(!nameField.getText().isEmpty())).onEnter(() -> {
+                if (popup.getYesButton().isEnabled()) {
+                    popup.getYesButton().onClick();
+                }
+            });
+            popup.getYesButton().setDisabled();
+            // Register callback
+            Futures.addCallback(popup.getFuture(), new FutureCallback<Boolean>() {
+                @Override
+                public void onSuccess(@Nullable Boolean result) {
+                    if (result == Boolean.TRUE) {
+                        RenderJob newJob = new RenderJob();
+                        newJob.setName(nameField.getText());
+                        newJob.setSettings(guiRenderSettings.save(false));
+                        newJob.setTimeline(timeline);
+                        LOGGER.trace("Adding new job: {}", newJob);
+                        queue.add(newJob);
+                        list.getListPanel().addElements(null, new Entry(newJob));
+                    } else {
+                        LOGGER.trace("Adding cancelled");
+                    }
+                }
+
+                @Override
+                public void onFailure(Throwable t) {
+                    LOGGER.error("Add Job popup:", t);
+                }
+            });
+        });
+        if (guiRenderSettings != null) {
+            addButton.setEnabled(guiRenderSettings.renderButton.isEnabled());
+        }
+
+        renameButton.onClick(() -> {
+            LOGGER.trace("Rename button clicked for {}", selectedEntry.job);
+            // Open popup
+            GuiYesNoPopup popup = GuiYesNoPopup.open(container)
+                    .setYesI18nLabel("replaymod.gui.rename").setNoI18nLabel("replaymod.gui.cancel");
+            popup.getInfo().setLayout(new HorizontalLayout(HorizontalLayout.Alignment.CENTER).setSpacing(5));
+            // Add content
+            GuiLabel label = new GuiLabel().setI18nText("replaymod.gui.renderqueue.jobname").setColor(Colors.BLACK);
+            GuiTextField nameField = new GuiTextField().setSize(150, 20).setFocused(true)
+                    .setText(selectedEntry.job.getName());
+            popup.getInfo().addElements(new HorizontalLayout.Data(0.5), label, nameField);
+            // Disable "Yes" button while name is empty
+            nameField.onTextChanged(old -> popup.getYesButton().setEnabled(!nameField.getText().isEmpty())).onEnter(() -> {
+                if (popup.getYesButton().isEnabled()) {
+                    popup.getYesButton().onClick();
+                }
+            });
+            // Register callback
+            Futures.addCallback(popup.getFuture(), new FutureCallback<Boolean>() {
+                @Override
+                public void onSuccess(@Nullable Boolean result) {
+                    if (result == Boolean.TRUE) {
+                        LOGGER.trace("Renaming {} to \"{}\"", selectedEntry.job, nameField.getText());
+                        selectedEntry.setName(nameField.getText());
+                    } else {
+                        LOGGER.trace("Renaming cancelled");
+                    }
+                }
+
+                @Override
+                public void onFailure(Throwable t) {
+                    LOGGER.error("Rename Job popup:", t);
+                }
+            });
+        });
+
+        removeButton.onClick(() -> {
+            LOGGER.trace("Remove button clicked for {}", selectedEntry.job);
+            list.getListPanel().removeElement(selectedEntry);
+            queue.remove(selectedEntry.job);
+            selectedEntry = null;
+            updateButtons();
+        });
+
+        renderButton.onClick(() -> {
+            LOGGER.trace("Render button clicked");
+            // Close all GUIs (so settings in GuiRenderSettings are saved)
+            getMinecraft().displayGuiScreen(null);
+            // Start rendering
+            for (RenderJob renderJob : queue) {
+                LOGGER.info("Starting render job {}", renderJob);
+                try {
+                    VideoRenderer videoRenderer = new VideoRenderer(renderJob.getSettings(), replayHandler, renderJob.getTimeline());
+                    videoRenderer.renderVideo();
+                } catch (IOException e) {
+                    LOGGER.error("Rendering video:", e);
+                    GuiErrorScreen errorScreen = new GuiErrorScreen(I18n.format("replaymod.gui.rendering.error.title"),
+                            I18n.format("replaymod.gui.rendering.error.message"));
+                    getMinecraft().displayGuiScreen(errorScreen);
+                    return;
+                } catch (Throwable t) {
+                    CrashReport crashReport = CrashReport.makeCrashReport(t, "Rendering video");
+                    throw new ReportedException(crashReport);
+                }
+            }
+        });
+
+        updateButtons();
+    }
+
+    @Override
+    public void open() {
+        super.open();
+    }
+
+    @Override
+    protected GuiRenderQueue getThis() {
+        return this;
+    }
+
+    public void updateButtons() {
+        renameButton.setEnabled(selectedEntry != null);
+        removeButton.setEnabled(selectedEntry != null);
+        renderButton.setEnabled(!list.getListPanel().getChildren().isEmpty());
+    }
+
+    public class Entry extends AbstractGuiClickableContainer<Entry> {
+        public final GuiLabel label = new GuiLabel(this);
+        public final RenderJob job;
+
+        public Entry(RenderJob job) {
+            this.job = job;
+
+            setLayout(new CustomLayout<Entry>() {
+                @Override
+                protected void layout(Entry container, int width, int height) {
+                    pos(label, 5, height / 2 - height(label) / 2);
+                }
+
+                @Override
+                public ReadableDimension calcMinSize(GuiContainer<?> container) {
+                    return new Dimension(buttonPanel.calcMinSize().getWidth(), 16);
+                }
+            });
+            label.setText(job.getName());
+        }
+
+        @Override
+        protected void onClick() {
+            selectedEntry = this;
+            updateButtons();
+        }
+
+        @Override
+        public void draw(GuiRenderer renderer, ReadableDimension size, RenderInfo renderInfo) {
+            if (selectedEntry == this) {
+                renderer.drawRect(0, 0, size.getWidth(), size.getHeight(), Colors.BLACK);
+                renderer.drawRect(0, 0, 2, size.getHeight(), Colors.WHITE);
+            }
+            super.draw(renderer, size, renderInfo);
+        }
+
+        public void setName(String name) {
+            job.setName(name);
+            label.setText(name);
+        }
+
+        @Override
+        protected Entry getThis() {
+            return this;
+        }
+    }
+}

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

@@ -32,13 +32,14 @@ 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;
 import org.lwjgl.util.Dimension;
+import org.lwjgl.util.ReadableColor;
 import org.lwjgl.util.ReadableDimension;
 
 import javax.annotation.Nullable;
 import java.io.File;
 import java.io.IOException;
-import java.lang.reflect.Type;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Map;
@@ -79,8 +80,8 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
                 }
             }).setMinSize(new Dimension(0, 20)).setValues(RenderSettings.EncodingPreset.values());
 
-    public final GuiNumberField videoWidth = new GuiNumberField().setSize(50, 20).setMinValue(1);
-    public final GuiNumberField videoHeight = new GuiNumberField().setSize(50, 20).setMinValue(1);
+    public final GuiNumberField videoWidth = new GuiNumberField().setSize(50, 20).setMinValue(1).setValidateOnFocusChange(true);
+    public final GuiNumberField videoHeight = new GuiNumberField().setSize(50, 20).setMinValue(1).setValidateOnFocusChange(true);
     public final GuiSlider frameRateSlider = new GuiSlider().onValueChanged(new Runnable() {
         @Override
         public void run() {
@@ -92,7 +93,7 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
             .setLayout(new HorizontalLayout(HorizontalLayout.Alignment.RIGHT).setSpacing(2))
             .addElements(new HorizontalLayout.Data(0.5), videoWidth, new GuiLabel().setText("*"), videoHeight);
 
-    public final GuiNumberField bitRateField = new GuiNumberField().setValue(10).setSize(50, 20);
+    public final GuiNumberField bitRateField = new GuiNumberField().setValue(10).setSize(50, 20).setValidateOnFocusChange(true);
     public final GuiDropdownMenu<String> bitRateUnit = new GuiDropdownMenu<String>()
             .setSize(50, 20).setValues("bps", "kbps", "mbps").setSelected("mbps");
 
@@ -149,13 +150,18 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
     public final GuiCheckbox inject360Metadata = new GuiCheckbox()
             .setI18nLabel("replaymod.gui.rendersettings.360metadata");
 
+    public final GuiDropdownMenu<RenderSettings.AntiAliasing> antiAliasingDropdown = new GuiDropdownMenu<RenderSettings.AntiAliasing>()
+            .setSize(200, 20).setValues(RenderSettings.AntiAliasing.values()).setSelected(RenderSettings.AntiAliasing.NONE);
+
     public final GuiPanel advancedPanel = new GuiPanel().setLayout(new VerticalLayout().setSpacing(15))
             .addElements(null, nametagCheckbox, new GuiPanel().setLayout(
                     new GridLayout().setCellsEqualSize(false).setColumns(2).setSpacingX(5).setSpacingY(15))
                     .addElements(new GridLayout.Data(0, 0.5),
                             new GuiLabel().setI18nText("replaymod.gui.rendersettings.stabilizecamera"), stabilizePanel,
                             chromaKeyingCheckbox, chromaKeyingColor,
-                            inject360Metadata));
+                            inject360Metadata,
+                            new GuiLabel(), // to show the anti-aliasing options in a new line
+                            new GuiLabel().setI18nText("replaymod.gui.rendersettings.antialiasing"), antiAliasingDropdown));
 
     public final GuiTextField exportCommand = new GuiTextField().setI18nHint("replaymod.gui.rendersettings.command")
             .setSize(55, 20).setMaxLength(100);
@@ -179,6 +185,12 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
 
 
     public final GuiPanel buttonPanel = new GuiPanel(contentPanel).setLayout(new HorizontalLayout().setSpacing(4));
+    public final GuiButton queueButton = new GuiButton(buttonPanel).onClick(new Runnable() {
+        @Override
+        public void run() {
+            new GuiRenderQueue(GuiRenderSettings.this, GuiRenderSettings.this, replayHandler, timeline).open();
+        }
+    }).setSize(100, 20).setI18nLabel("replaymod.gui.renderqueue.open");
     public final GuiButton renderButton = new GuiButton(buttonPanel).onClick(new Runnable() {
         @Override
         public void run() {
@@ -198,13 +210,13 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
                 throw new ReportedException(crashReport);
             }
         }
-    }).setSize(148, 20).setI18nLabel("replaymod.gui.render");
+    }).setSize(100, 20).setI18nLabel("replaymod.gui.render");
     public final GuiButton cancelButton = new GuiButton(buttonPanel).onClick(new Runnable() {
         @Override
         public void run() {
             getMinecraft().displayGuiScreen(null);
         }
-    }).setSize(148, 20).setI18nLabel("replaymod.gui.cancel");
+    }).setSize(100, 20).setI18nLabel("replaymod.gui.cancel");
 
     {
         setBackground(Background.NONE);
@@ -261,12 +273,10 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
         this.timeline = timeline;
 
         String json = getConfigProperty(ReplayModRender.instance.getConfiguration()).getString();
-        RenderSettings settings = new GsonBuilder().registerTypeAdapter(RenderSettings.class, new InstanceCreator<RenderSettings>() {
-                    @Override
-                    public RenderSettings createInstance(Type type) {
-                        return getDefaultRenderSettings();
-                    }
-                }).create().fromJson(json, RenderSettings.class);
+        RenderSettings settings = new GsonBuilder()
+                .registerTypeAdapter(RenderSettings.class, (InstanceCreator<RenderSettings>) type -> getDefaultRenderSettings())
+                .registerTypeAdapter(ReadableColor.class, new Gson().getAdapter(Color.class))
+                .create().fromJson(json, RenderSettings.class);
         load(settings);
     }
 
@@ -347,8 +357,8 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
     public void load(RenderSettings settings) {
         renderMethodDropdown.setSelected(settings.getRenderMethod());
         encodingPresetDropdown.setSelected(settings.getEncodingPreset());
-        videoWidth.setValue(settings.getVideoWidth());
-        videoHeight.setValue(settings.getVideoHeight());
+        videoWidth.setValue(settings.getTargetVideoWidth());
+        videoHeight.setValue(settings.getTargetVideoHeight());
         frameRateSlider.setValue(settings.getFramesPerSecond() - 10);
         if (settings.getBitRate() % (1 << 20) == 0) {
             bitRateField.setValue(settings.getBitRate() >> 20);
@@ -380,6 +390,7 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
             chromaKeyingColor.setColor(settings.getChromaKeyingColor());
         }
         inject360Metadata.setChecked(settings.isInject360Metadata());
+        antiAliasingDropdown.setSelected(settings.getAntiAliasing());
         exportCommand.setText(settings.getExportCommand());
         exportArguments.setText(settings.getExportArguments());
 
@@ -401,6 +412,7 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
                 stabilizeRoll.isChecked() && (serialize || stabilizeRoll.isEnabled()),
                 chromaKeyingCheckbox.isChecked() ? chromaKeyingColor.getColor() : null,
                 inject360Metadata.isChecked() && (serialize || inject360Metadata.isEnabled()),
+                antiAliasingDropdown.getSelectedValue(),
                 exportCommand.getText(),
                 exportArguments.getText(),
                 net.minecraft.client.gui.GuiScreen.isCtrlKeyDown()
@@ -415,7 +427,7 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
 
     private RenderSettings getDefaultRenderSettings() {
         return new RenderSettings(RenderSettings.RenderMethod.DEFAULT, RenderSettings.EncodingPreset.MP4_DEFAULT, 1920, 1080, 60, 10 << 20, null,
-                true, false, false, false, null, false, "", RenderSettings.EncodingPreset.MP4_DEFAULT.getValue(), false);
+                true, false, false, false, null, false, RenderSettings.AntiAliasing.NONE, "", RenderSettings.EncodingPreset.MP4_DEFAULT.getValue(), false);
     }
 
     @Override
@@ -431,4 +443,8 @@ public class GuiRenderSettings extends GuiScreen implements Closeable {
         return configuration.get("rendersettings", "settings", "{}",
                 "Last state of the render settings GUI. Internal use only.");
     }
+
+    public ReplayHandler getReplayHandler() {
+        return replayHandler;
+    }
 }

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

@@ -1,6 +1,7 @@
 package com.replaymod.render.rendering;
 
 import com.replaymod.pathing.player.AbstractTimelinePlayer;
+import com.replaymod.pathing.player.ReplayTimer;
 import com.replaymod.pathing.properties.TimestampProperty;
 import com.replaymod.render.RenderSettings;
 import com.replaymod.render.ReplayModRender;
@@ -55,6 +56,7 @@ public class VideoRenderer implements RenderInfo {
     private boolean debugInfoWasShown;
     private Map<SoundCategory, Float> originalSoundLevels;
 
+    private TimelinePlayer timelinePlayer;
     private Future<Void> timelinePlayerFuture;
     private ChunkLoadingRenderGlobal chunkLoadingRenderGlobal;
 
@@ -174,7 +176,8 @@ public class VideoRenderer implements RenderInfo {
     }
 
     private void setup() {
-        timelinePlayerFuture = new TimelinePlayer(replayHandler).start(timeline);
+        timelinePlayer = new TimelinePlayer(replayHandler);
+        timelinePlayerFuture = timelinePlayer.start(timeline);
 
         if (!OpenGlHelper.isFramebufferEnabled()) {
             Display.setResizable(false);
@@ -226,6 +229,8 @@ public class VideoRenderer implements RenderInfo {
         if (!timelinePlayerFuture.isDone()) {
             timelinePlayerFuture.cancel(false);
         }
+        // Tear down of the timeline player might only happen the next tick after it was cancelled
+        timelinePlayer.onTick(new ReplayTimer.UpdatedEvent());
 
         if (!OpenGlHelper.isFramebufferEnabled()) {
             Display.setResizable(true);

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

@@ -0,0 +1,12 @@
+package com.replaymod.render.utils;
+
+import com.replaymod.render.RenderSettings;
+import com.replaymod.replaystudio.pathing.path.Timeline;
+import lombok.Data;
+
+@Data
+public class RenderJob {
+    private String name;
+    private Timeline timeline;
+    private RenderSettings settings;
+}

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

@@ -147,7 +147,7 @@ public class InputReplayTimer extends WrappedTimer {
                 // TODO: Translate magic values to Keyboard.KEY_ constants
 
                 if (key == 32 && Keyboard.isKeyDown(61) && mc.ingameGUI != null) {
-                    mc.ingameGUI.getChatGUI().clearChatMessages();
+                    mc.ingameGUI.getChatGUI().clearChatMessages(false);
                 }
 
                 if (key == 31 && Keyboard.isKeyDown(61)) {

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

@@ -110,12 +110,12 @@ public class ReplayHandler {
 
         channel.close().awaitUninterruptibly();
 
-        if (mc.thePlayer instanceof CameraEntity) {
-            mc.thePlayer.setDead();
+        if (mc.player instanceof CameraEntity) {
+            mc.player.setDead();
         }
 
-        if (mc.theWorld != null) {
-            mc.theWorld.sendQuittingDisconnectingPacket();
+        if (mc.world != null) {
+            mc.world.sendQuittingDisconnectingPacket();
             mc.loadWorld(null);
         }
 
@@ -128,7 +128,7 @@ public class ReplayHandler {
     }
 
     private void setup() {
-        mc.ingameGUI.getChatGUI().clearChatMessages();
+        mc.ingameGUI.getChatGUI().clearChatMessages(true);
 
         NetworkManager networkManager = new NetworkManager(EnumPacketDirection.CLIENTBOUND) {
             @Override
@@ -209,6 +209,9 @@ public class ReplayHandler {
      */
     public void spectateEntity(Entity e) {
         CameraEntity cameraEntity = getCameraEntity();
+        if (cameraEntity == null) {
+            return; // Cannot spectate if we have no camera
+        }
         if (e == null || e == cameraEntity) {
             spectating = null;
             e = cameraEntity;
@@ -241,7 +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.getRenderViewEntity();
+        return mc.player instanceof CameraEntity && mc.player == mc.getRenderViewEntity();
     }
 
     /**
@@ -249,7 +252,7 @@ public class ReplayHandler {
      * @return The camera entity or {@code null} if it does not yet exist
      */
     public CameraEntity getCameraEntity() {
-        return mc.thePlayer instanceof CameraEntity ? (CameraEntity) mc.thePlayer : null;
+        return mc.player instanceof CameraEntity ? (CameraEntity) mc.player : null;
     }
 
     public UUID getSpectatedUUID() {
@@ -329,7 +332,7 @@ public class ReplayHandler {
                 replaySender.setReplaySpeed(0);
 
                 mc.getConnection().getNetworkManager().processReceivedPackets();
-                for (Entity entity : mc.theWorld.loadedEntityList) {
+                for (Entity entity : mc.world.loadedEntityList) {
                     if (entity instanceof EntityOtherPlayerMP) {
                         EntityOtherPlayerMP e = (EntityOtherPlayerMP) entity;
                         e.setPosition(e.otherPlayerMPX, e.otherPlayerMPY, e.otherPlayerMPZ);

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

@@ -6,7 +6,11 @@ import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.core.utils.ModCompat;
-import com.replaymod.replay.camera.*;
+import com.replaymod.replay.camera.CameraController;
+import com.replaymod.replay.camera.CameraControllerRegistry;
+import com.replaymod.replay.camera.CameraEntity;
+import com.replaymod.replay.camera.ClassicCameraController;
+import com.replaymod.replay.camera.VanillaCameraController;
 import com.replaymod.replay.gui.overlay.GuiMarkerTimeline;
 import com.replaymod.replay.gui.screen.GuiModCompatWarning;
 import com.replaymod.replay.handler.GuiHandler;
@@ -28,15 +32,17 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Optional;
 
-@Mod(modid = ReplayModReplay.MOD_ID, useMetadata = true)
+@Mod(modid = ReplayModReplay.MOD_ID,
+        version = "@MOD_VERSION@",
+        acceptedMinecraftVersions = "@MC_VERSION@",
+        useMetadata = true)
 public class ReplayModReplay {
     public static final String MOD_ID = "replaymod-replay";
 
     @Mod.Instance(MOD_ID)
     public static ReplayModReplay instance;
 
-    @Mod.Instance(ReplayMod.MOD_ID)
-    private static ReplayMod core;
+    private ReplayMod core;
 
     private final CameraControllerRegistry cameraControllerRegistry = new CameraControllerRegistry();
 
@@ -51,6 +57,7 @@ public class ReplayModReplay {
     @Mod.EventHandler
     public void preInit(FMLPreInitializationEvent event) {
         logger = event.getModLog();
+        core = ReplayMod.instance;
 
         core.getSettingsRegistry().register(Setting.class);
 
@@ -96,6 +103,7 @@ public class ReplayModReplay {
                         @Override
                         public void onSuccess(NoGuiScreenshot result) {
                             try {
+                                core.printInfoToChat("replaymod.chat.savingthumb");
                                 replayHandler.getReplayFile().writeThumb(result.getImage());
                                 core.printInfoToChat("replaymod.chat.savedthumb");
                             } catch (IOException e) {
@@ -106,6 +114,7 @@ public class ReplayModReplay {
                         @Override
                         public void onFailure(Throwable t) {
                             t.printStackTrace();
+                            core.printWarningToChat("replaymod.chat.failedthumb");
                         }
                     });
                 }

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

@@ -22,8 +22,8 @@ import net.minecraft.network.*;
 import net.minecraft.network.play.server.*;
 import net.minecraft.util.text.ITextComponent;
 import net.minecraft.world.EnumDifficulty;
+import net.minecraft.world.GameType;
 import net.minecraft.world.World;
-import net.minecraft.world.WorldSettings.GameType;
 import net.minecraft.world.WorldType;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
@@ -257,8 +257,8 @@ public class ReplaySender extends ChannelInboundHandlerAdapter {
         // Entity#addedToChunk is not set and it is therefore not updated every tick.
         // To counteract this, we need to manually update it's position if it hasn't been added
         // to any chunk yet.
-        if (mc.theWorld != null) {
-            for (EntityPlayer playerEntity : mc.theWorld.playerEntities) {
+        if (mc.world != null) {
+            for (EntityPlayer playerEntity : mc.world.playerEntities) {
                 if (!playerEntity.addedToChunk && playerEntity instanceof EntityOtherPlayerMP) {
                     playerEntity.onLivingUpdate();
                 }
@@ -292,7 +292,7 @@ public class ReplaySender extends ChannelInboundHandlerAdapter {
                     // If we do not give minecraft time to tick, there will be dead entity artifacts left in the world
                     // Therefore we have to remove all loaded, dead entities manually if we are in sync mode.
                     // We do this after every SpawnX packet and after the destroy entities packet.
-                    if (!asyncMode && mc.theWorld != null) {
+                    if (!asyncMode && mc.world != null) {
                         if (p instanceof SPacketSpawnPlayer
                                 || p instanceof SPacketSpawnObject
                                 || p instanceof SPacketSpawnMob
@@ -300,7 +300,7 @@ public class ReplaySender extends ChannelInboundHandlerAdapter {
                                 || p instanceof SPacketSpawnPainting
                                 || p instanceof SPacketSpawnExperienceOrb
                                 || p instanceof SPacketDestroyEntities) {
-                            World world = mc.theWorld;
+                            World world = mc.world;
                             for (int i = 0; i < world.loadedEntityList.size(); ++i) {
                                 Entity entity = world.loadedEntityList.get(i);
                                 if (entity.isDead) {
@@ -331,7 +331,7 @@ public class ReplaySender extends ChannelInboundHandlerAdapter {
         ByteBuf bb = Unpooled.wrappedBuffer(bytes);
         PacketBuffer pb = new PacketBuffer(bb);
 
-        int i = pb.readVarIntFromBuffer();
+        int i = pb.readVarInt();
 
         Packet p = EnumConnectionState.PLAY.getPacket(EnumPacketDirection.CLIENTBOUND, i);
         p.readPacketData(pb);
@@ -460,7 +460,7 @@ public class ReplaySender extends ChannelInboundHandlerAdapter {
                 @Override
                 @SuppressWarnings("unchecked")
                 public Void call() {
-                    if (mc.theWorld == null || !mc.isCallingFromMinecraftThread()) {
+                    if (mc.world == null || !mc.isCallingFromMinecraftThread()) {
                         synchronized(mc.scheduledTasks) {
                             mc.scheduledTasks.add(ListenableFutureTask.create(this));
                         }

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

@@ -39,7 +39,7 @@ import java.util.function.Function;
 
 /**
  * The camera entity used as the main player entity during replay viewing.
- * During a replay {@link Minecraft#thePlayer} should be an instance of this class.
+ * During a replay {@link Minecraft#player} should be an instance of this class.
  * Camera movement is controlled by a separate {@link CameraController}.
  */
 public class CameraEntity extends EntityPlayerSP {
@@ -156,9 +156,9 @@ public class CameraEntity extends EntityPlayerSP {
             // entity is recreated and we have to spectate a new entity
             UUID spectating = ReplayModReplay.instance.getReplayHandler().getSpectatedUUID();
             if (spectating != null && (view.getUniqueID() != spectating
-                    || view.worldObj != worldObj)
-                    || worldObj.getEntityByID(view.getEntityId()) != view) {
-                view = worldObj.getPlayerEntityByUUID(spectating);
+                    || view.world != world)
+                    || world.getEntityByID(view.getEntityId()) != view) {
+                view = world.getPlayerEntityByUUID(spectating);
                 if (view != null) {
                     mc.setRenderViewEntity(view);
                 } else {
@@ -177,17 +177,17 @@ public class CameraEntity extends EntityPlayerSP {
     @Override
     public void preparePlayerToSpawn() {
         // Make sure our world is up-to-date in case of world changes
-        if (mc.theWorld != null) {
-            worldObj = mc.theWorld;
+        if (mc.world != null) {
+            world = mc.world;
         }
         super.preparePlayerToSpawn();
     }
 
     @Override
-    public void setAngles(float yaw, float pitch) {
+    public void setRotation(float yaw, float pitch) {
         if (mc.getRenderViewEntity() == this) {
             // Only update camera rotation when the camera is the view
-            super.setAngles(yaw, pitch);
+            super.setRotation(yaw, pitch);
         }
     }
 
@@ -252,6 +252,15 @@ public class CameraEntity extends EntityPlayerSP {
         return false;
     }
 
+    @Override
+    public boolean isInvisible() {
+        Entity view = mc.getRenderViewEntity();
+        if (view != this) {
+            return view.isInvisible();
+        }
+        return super.isInvisible();
+    }
+
     @Override
     public ResourceLocation getLocationSkin() {
         Entity view = mc.getRenderViewEntity();
@@ -439,8 +448,8 @@ public class CameraEntity extends EntityPlayerSP {
                     mc.entityRenderer.itemRenderer.itemStackOffHand = player.getItemStackFromSlot(EntityEquipmentSlot.OFFHAND);
 
 
-                    mc.thePlayer.renderArmYaw = mc.thePlayer.prevRenderArmYaw = player.rotationYaw;
-                    mc.thePlayer.renderArmPitch = mc.thePlayer.prevRenderArmPitch = player.rotationPitch;
+                    mc.player.renderArmYaw = mc.player.prevRenderArmYaw = player.rotationYaw;
+                    mc.player.renderArmPitch = mc.player.prevRenderArmPitch = player.rotationPitch;
                 }
             }
         }

src/main/java/com/replaymod/replay/gui/overlay/GuiEditMarkerPopup.java

@@ -16,6 +16,10 @@ import org.lwjgl.input.Keyboard;
 import org.lwjgl.util.ReadablePoint;
 
 public class GuiEditMarkerPopup extends AbstractGuiPopup<GuiEditMarkerPopup> implements Typeable {
+    private static GuiNumberField newGuiNumberField() {
+        return new GuiNumberField().setSize(150, 20).setValidateOnFocusChange(true);
+    }
+
     private final ReplayHandler replayHandler;
     private final Marker marker;
 
@@ -23,15 +27,15 @@ public class GuiEditMarkerPopup extends AbstractGuiPopup<GuiEditMarkerPopup> imp
 
     public final GuiTextField nameField = new GuiTextField().setSize(150, 20);
     // TODO: Replace with a min/sec/msec field
-    public final GuiNumberField timeField = new GuiNumberField().setSize(150, 20).setPrecision(0);
+    public final GuiNumberField timeField = newGuiNumberField().setPrecision(0);
 
-    public final GuiNumberField xField = new GuiNumberField().setSize(150, 20).setPrecision(10);
-    public final GuiNumberField yField = new GuiNumberField().setSize(150, 20).setPrecision(10);
-    public final GuiNumberField zField = new GuiNumberField().setSize(150, 20).setPrecision(10);
+    public final GuiNumberField xField = newGuiNumberField().setPrecision(10);
+    public final GuiNumberField yField = newGuiNumberField().setPrecision(10);
+    public final GuiNumberField zField = newGuiNumberField().setPrecision(10);
 
-    public final GuiNumberField yawField = new GuiNumberField().setSize(150, 20).setPrecision(5);
-    public final GuiNumberField pitchField = new GuiNumberField().setSize(150, 20).setPrecision(5);
-    public final GuiNumberField rollField = new GuiNumberField().setSize(150, 20).setPrecision(5);
+    public final GuiNumberField yawField = newGuiNumberField().setPrecision(5);
+    public final GuiNumberField pitchField = newGuiNumberField().setPrecision(5);
+    public final GuiNumberField rollField = newGuiNumberField().setPrecision(5);
 
     public final GuiPanel inputs = GuiPanel.builder()
             .layout(new GridLayout().setColumns(2).setSpacingX(7).setSpacingY(3))

src/main/java/com/replaymod/replay/gui/overlay/GuiMarkerTimeline.java

@@ -58,7 +58,7 @@ public class GuiMarkerTimeline extends AbstractGuiTimeline<GuiMarkerTimeline> im
 
     protected void drawMarker(GuiRenderer renderer, ReadableDimension size, Marker marker) {
         int visibleLength = (int) (getLength() * getZoom());
-        int markerPos = MathHelper.clamp_int(marker.getTime(), getOffset(), getOffset() + visibleLength);
+        int markerPos = MathHelper.clamp(marker.getTime(), getOffset(), getOffset() + visibleLength);
         double positionInVisible = markerPos - getOffset();
         double fractionOfVisible = positionInVisible / visibleLength;
         int markerX = (int) (BORDER_LEFT + fractionOfVisible * (size.getWidth() - BORDER_LEFT - BORDER_RIGHT));
@@ -99,7 +99,7 @@ public class GuiMarkerTimeline extends AbstractGuiTimeline<GuiMarkerTimeline> im
         int visibleLength = (int) (getLength() * getZoom());
         int contentWidth = lastSize.getWidth() - BORDER_LEFT - BORDER_RIGHT;
         for (Marker marker : replayHandler.getMarkers()) {
-            int markerPos = MathHelper.clamp_int(marker.getTime(), getOffset(), getOffset() + visibleLength);
+            int markerPos = MathHelper.clamp(marker.getTime(), getOffset(), getOffset() + visibleLength);
             double positionInVisible = markerPos - getOffset();
             double fractionOfVisible = positionInVisible / visibleLength;
             int markerX = (int) (BORDER_LEFT + fractionOfVisible * contentWidth);

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

@@ -13,10 +13,10 @@ import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.List;
 
 public class GuiHandler {
     private static final int BUTTON_EXIT_SERVER = 1;
-    private static final int BUTTON_RETURN_TO_GAME = 4;
     private static final int BUTTON_ACHIEVEMENTS = 5;
     private static final int BUTTON_STATS = 6;
     private static final int BUTTON_OPEN_TO_LAN = 7;
@@ -46,7 +46,9 @@ public class GuiHandler {
             // Pause replay when menu is opened
             mod.getReplayHandler().getReplaySender().setReplaySpeed(0);
 
-            for(GuiButton b : new ArrayList<>(event.getButtonList())) {
+            GuiButton achievements = null, stats = null, openToLan = null;
+            List<GuiButton> buttonList = event.getButtonList();
+            for(GuiButton b : new ArrayList<>(buttonList)) {
                 switch (b.id) {
                     // Replace "Exit Server" button with "Exit Replay" button
                     case BUTTON_EXIT_SERVER:
@@ -55,14 +57,38 @@ public class GuiHandler {
                         break;
                     // Remove "Achievements", "Stats" and "Open to LAN" buttons
                     case BUTTON_ACHIEVEMENTS:
+                        buttonList.remove(achievements = b);
+                        break;
                     case BUTTON_STATS:
+                        buttonList.remove(stats = b);
+                        break;
                     case BUTTON_OPEN_TO_LAN:
-                        event.getButtonList().remove(b);
+                        buttonList.remove(openToLan = b);
+                        break;
                 }
-                // Move all buttons except the "Return to game" button upwards
-                if (b.id != BUTTON_RETURN_TO_GAME) {
-                    b.yPosition -= 48;
             }
+            if (achievements != null && stats != null) {
+                moveAllButtonsDirectlyBelowUpwards(buttonList, achievements.yPosition,
+                        achievements.xPosition, stats.xPosition + stats.width);
+            }
+            if (openToLan != null) {
+                moveAllButtonsDirectlyBelowUpwards(buttonList, openToLan.yPosition,
+                        openToLan.xPosition, openToLan.xPosition + openToLan.width);
+            }
+        }
+    }
+
+    /**
+     * Moves all buttons that are within a rectangle below a certain y coordinate upwards by 24 units.
+     * @param buttons List of buttons
+     * @param belowY The Y limit
+     * @param xStart Left x limit of the rectangle
+     * @param xEnd Right x limit of the rectangle
+     */
+    private void moveAllButtonsDirectlyBelowUpwards(List<GuiButton> buttons, int belowY, int xStart, int xEnd) {
+        for (GuiButton button : buttons) {
+            if (button.yPosition >= belowY && button.xPosition <= xEnd && button.xPosition + button.width >= xStart) {
+                button.yPosition -= 24;
             }
         }
     }

src/main/java/com/replaymod/replay/mixin/MixinGuiSpectator.java

@@ -17,7 +17,7 @@ public abstract class MixinGuiSpectator {
     @Inject(method = "onHotbarSelected", at = @At("HEAD"), cancellable = true)
     public void isInReplay(int i, CallbackInfo ci) {
         // Prevent spectator gui from opening while in a replay
-        if (mc.thePlayer instanceof CameraEntity) {
+        if (mc.player instanceof CameraEntity) {
             ci.cancel();
         }
     }

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

@@ -33,8 +33,8 @@ public abstract class MixinPlayerControllerMP {
 
     @Inject(method = "isSpectator", at=@At("HEAD"), cancellable = true)
     private void replayModReplay_isSpectator(CallbackInfoReturnable<Boolean> ci) {
-        if (mc.thePlayer instanceof CameraEntity) { // this check should in theory not be required
-            ci.setReturnValue(mc.thePlayer.isSpectator());
+        if (mc.player instanceof CameraEntity) { // this check should in theory not be required
+            ci.setReturnValue(mc.player.isSpectator());
         }
     }
 }

src/main/java/com/replaymod/replay/mixin/MixinRenderArmorStand.java

@@ -14,7 +14,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 public abstract class MixinRenderArmorStand {
     @Inject(method = "canRenderName", at = @At("HEAD"), cancellable = true)
     private void replayModReplay_canRenderInvisibleName(EntityArmorStand entity, CallbackInfoReturnable<Boolean> ci) {
-        EntityPlayer thePlayer = Minecraft.getMinecraft().thePlayer;
+        EntityPlayer thePlayer = Minecraft.getMinecraft().player;
         if (thePlayer instanceof CameraEntity && entity.isInvisible()) {
             ci.setReturnValue(false);
         }

src/main/java/com/replaymod/replay/mixin/MixinRenderLivingBase.java

@@ -15,7 +15,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 public abstract class MixinRenderLivingBase {
     @Inject(method = "canRenderName", at = @At("HEAD"), cancellable = true)
     private void replayModReplay_canRenderInvisibleName(EntityLivingBase entity, CallbackInfoReturnable<Boolean> ci) {
-        EntityPlayer thePlayer = Minecraft.getMinecraft().thePlayer;
+        EntityPlayer thePlayer = Minecraft.getMinecraft().player;
         if (thePlayer instanceof CameraEntity && entity.isInvisible()) {
             ci.setReturnValue(false);
         }

src/main/java/com/replaymod/replay/mixin/MixinViewFrustum.java

@@ -31,7 +31,7 @@ public abstract class MixinViewFrustum {
     }
 
     /**
-     * Instead of calling {@link RenderChunk#setOrigin(int, int, int)} we recreate the render chunk
+     * Instead of calling {@link RenderChunk#setPosition(int, int, int)} we recreate the render chunk
      * which seems to solve the problem that chunks are invisible when you leave an area and return
      * to it.
      * Any better fixes are welcome.
@@ -43,8 +43,8 @@ public abstract class MixinViewFrustum {
             return;
         }
 
-        int i = MathHelper.floor_double(viewEntityX) - 8;
-        int j = MathHelper.floor_double(viewEntityZ) - 8;
+        int i = MathHelper.floor(viewEntityX) - 8;
+        int j = MathHelper.floor(viewEntityZ) - 8;
         int k = this.countChunksX * 16;
 
         for (int l = 0; l < this.countChunksX; ++l) {
@@ -59,7 +59,7 @@ public abstract class MixinViewFrustum {
                         // Recreate render chunk instead of setting its position
                         (renderChunks[(j1 * this.countChunksY + l1) * this.countChunksX + l] =
                                 renderChunkFactory.create(world, renderGlobal, 0)
-                        ).setOrigin(blockpos.getX(), blockpos.getY(), blockpos.getZ());
+                        ).setPosition(blockpos.getX(), blockpos.getY(), blockpos.getZ());
                     }
                 }
             }

src/main/java/com/replaymod/simplepathing/InterpolatorType.java

@@ -0,0 +1,54 @@
+package com.replaymod.simplepathing;
+
+import com.replaymod.replaystudio.pathing.interpolation.CatmullRomSplineInterpolator;
+import com.replaymod.replaystudio.pathing.interpolation.CubicSplineInterpolator;
+import com.replaymod.replaystudio.pathing.interpolation.Interpolator;
+import com.replaymod.replaystudio.pathing.interpolation.LinearInterpolator;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.util.function.Supplier;
+
+@AllArgsConstructor
+public enum InterpolatorType {
+    DEFAULT("default", null, null),
+    CATMULL_ROM("catmullrom", CatmullRomSplineInterpolator.class, () -> new CatmullRomSplineInterpolator(0.5)),
+    CUBIC("cubic", CubicSplineInterpolator.class, CubicSplineInterpolator::new),
+    LINEAR("linear", LinearInterpolator.class, LinearInterpolator::new);
+
+    @Getter
+    private String localizationKey;
+
+    @Getter
+    private Class<? extends Interpolator> interpolatorClass;
+
+    private Supplier<Interpolator> interpolatorConstructor;
+
+    public String getI18nName() {
+        return String.format("replaymod.gui.editkeyframe.interpolator.%1$s.name", localizationKey);
+    }
+
+    public String getI18nDescription() {
+        return String.format("replaymod.gui.editkeyframe.interpolator.%1$s.desc", localizationKey);
+    }
+
+    public static InterpolatorType fromString(String string) {
+        for (InterpolatorType t : values()) {
+            if (t.getI18nName().equals(string)) return t;
+        }
+        return CATMULL_ROM; //the default
+    }
+
+    public static InterpolatorType fromClass(Class<? extends Interpolator> cls) {
+        for (InterpolatorType type : values()) {
+            if (cls.equals(type.getInterpolatorClass())) {
+                return type;
+            }
+        }
+        return DEFAULT;
+    }
+
+    public Interpolator newInstance() {
+        return interpolatorConstructor.get();
+    }
+}

src/main/java/com/replaymod/simplepathing/ReplayModSimplePathing.java

@@ -1,45 +1,41 @@
 package com.replaymod.simplepathing;
 
-import com.google.gson.stream.JsonReader;
-import com.google.gson.stream.JsonWriter;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.core.events.SettingsChangedEvent;
-import com.replaymod.pathing.properties.CameraProperties;
-import com.replaymod.pathing.properties.SpectatorProperty;
-import com.replaymod.pathing.properties.TimestampProperty;
 import com.replaymod.replay.events.ReplayCloseEvent;
 import com.replaymod.replay.events.ReplayOpenEvent;
-import com.replaymod.replaystudio.pathing.PathingRegistry;
-import com.replaymod.replaystudio.pathing.impl.TimelineImpl;
-import com.replaymod.replaystudio.pathing.interpolation.CubicSplineInterpolator;
-import com.replaymod.replaystudio.pathing.interpolation.Interpolator;
-import com.replaymod.replaystudio.pathing.interpolation.LinearInterpolator;
 import com.replaymod.replaystudio.pathing.path.Keyframe;
-import com.replaymod.replaystudio.pathing.path.Timeline;
+import com.replaymod.simplepathing.SPTimeline.SPPath;
 import com.replaymod.simplepathing.gui.GuiPathing;
 import com.replaymod.simplepathing.preview.PathPreview;
+import lombok.Getter;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import org.apache.logging.log4j.Logger;
+import org.lwjgl.input.Keyboard;
 
-import java.io.IOException;
-
-@Mod(modid = ReplayModSimplePathing.MOD_ID, useMetadata = true)
-public class ReplayModSimplePathing implements PathingRegistry {
+@Mod(modid = ReplayModSimplePathing.MOD_ID,
+        version = "@MOD_VERSION@",
+        acceptedMinecraftVersions = "@MC_VERSION@",
+        useMetadata = true)
+public class ReplayModSimplePathing {
     public static final String MOD_ID = "replaymod-simplepathing";
 
-    @Mod.Instance(ReplayMod.MOD_ID)
-    private static ReplayMod core;
+    @Mod.Instance(MOD_ID)
+    public static ReplayModSimplePathing instance;
 
-    private Logger logger;
+    private ReplayMod core;
+
+    public static Logger LOGGER;
 
     private GuiPathing guiPathing;
 
     @Mod.EventHandler
     public void preInit(FMLPreInitializationEvent event) {
-        logger = event.getModLog();
+        LOGGER = event.getModLog();
+        core = ReplayMod.instance;
 
         core.getSettingsRegistry().register(Setting.class);
 
@@ -47,88 +43,77 @@ public class ReplayModSimplePathing implements PathingRegistry {
 
         PathPreview pathPreview = new PathPreview(this);
         pathPreview.register();
+
+        core.getKeyBindingRegistry().registerKeyBinding("replaymod.input.keyframerepository", Keyboard.KEY_X, () -> {
+            if (guiPathing != null) guiPathing.keyframeRepoButtonPressed();
+        });
+        core.getKeyBindingRegistry().registerKeyBinding("replaymod.input.clearkeyframes", Keyboard.KEY_C, () -> {
+            if (guiPathing != null) guiPathing.clearKeyframesButtonPressed();
+        });
+        core.getKeyBindingRegistry().registerRepeatedKeyBinding("replaymod.input.synctimeline", Keyboard.KEY_V, () -> {
+            if (guiPathing != null) guiPathing.syncTimeButtonPressed();
+        });
+        core.getKeyBindingRegistry().registerRaw(Keyboard.KEY_DELETE, () -> {
+            if (guiPathing != null) guiPathing.deleteButtonPressed();
+        });
     }
 
     @SubscribeEvent
     public void postReplayOpen(ReplayOpenEvent.Post event) {
+        clearCurrentTimeline();
         guiPathing = new GuiPathing(core, this, event.getReplayHandler());
     }
 
     @SubscribeEvent
     public void onReplayClose(ReplayCloseEvent.Post event) {
+        currentTimeline = null;
         guiPathing = null;
-        currentTimeline = createTimeline();
-        currentTimeline.createPath();
-        currentTimeline.createPath();
-        selectedKeyframe = null;
+        selectedPath = null;
     }
 
     @SubscribeEvent
     public void onSettingsChanged(SettingsChangedEvent event) {
-        if (event.getKey() == Setting.LINEAR_INTERPOLATION) {
+        if (event.getKey() == Setting.DEFAULT_INTERPOLATION) {
             if (currentTimeline != null && guiPathing != null) {
-                currentTimeline.applyChange(guiPathing.updateInterpolators());
+                updateDefaultInterpolatorType();
             }
         }
     }
 
-    private Timeline currentTimeline = createTimeline(); { currentTimeline.createPath(); currentTimeline.createPath(); }
-    private Keyframe selectedKeyframe;
+    private SPTimeline currentTimeline;
 
-    public Keyframe getSelectedKeyframe() {
-        return selectedKeyframe;
+    @Getter
+    private SPPath selectedPath;
+    @Getter
+    private long selectedTime;
+
+    public boolean isSelected(Keyframe keyframe) {
+        return selectedPath != null && currentTimeline.getKeyframe(selectedPath, selectedTime) == keyframe;
     }
 
-    public void setSelectedKeyframe(Keyframe selected) {
-        this.selectedKeyframe = selected;
+    public void setSelected(SPPath path, long time) {
+        selectedPath = path;
+        selectedTime = time;
     }
 
-    public void setCurrentTimeline(Timeline currentTimeline) {
-        if (this.currentTimeline != currentTimeline) {
-            selectedKeyframe = null;
-        }
-        this.currentTimeline = currentTimeline;
+    public void setCurrentTimeline(SPTimeline newTimeline) {
+        selectedPath = null;
+        currentTimeline = newTimeline;
+        updateDefaultInterpolatorType();
     }
 
-    public Timeline getCurrentTimeline() {
+    public void clearCurrentTimeline() {
+        setCurrentTimeline(new SPTimeline());
+    }
+
+    public SPTimeline getCurrentTimeline() {
         return currentTimeline;
     }
 
-    @Override
-    public Timeline createTimeline() {
-        Timeline timeline = new TimelineImpl();
-
-        timeline.registerProperty(TimestampProperty.PROPERTY);
-        timeline.registerProperty(CameraProperties.POSITION);
-        timeline.registerProperty(CameraProperties.ROTATION);
-        timeline.registerProperty(SpectatorProperty.PROPERTY);
-
-        return timeline;
-    }
-
-    @Override
-    public void serializeInterpolator(JsonWriter writer, Interpolator interpolator) throws IOException {
-        if (interpolator instanceof LinearInterpolator) {
-            writer.value("linear");
-        } else if (interpolator instanceof CubicSplineInterpolator) {
-            writer.value("cubic-spline");
-        } else {
-            throw new IOException("Unknown interpolator type: " + interpolator);
-        }
-    }
-
-    @Override
-    public Interpolator deserializeInterpolator(JsonReader reader) throws IOException {
-        String type = reader.nextString();
-        switch (type) {
-            case "linear":
-                return new LinearInterpolator();
-            case "cubic-spline":
-                return new CubicSplineInterpolator();
-            default:
-                throw new IOException("Unknown interpolation type: " + type);
-
-        }
+    private void updateDefaultInterpolatorType() {
+        InterpolatorType newDefaultType =
+                InterpolatorType.fromString(core.getSettingsRegistry().get(Setting.DEFAULT_INTERPOLATION));
+        currentTimeline.setDefaultInterpolatorType(newDefaultType);
     }
 
     public ReplayMod getCore() {

src/main/java/com/replaymod/simplepathing/SPTimeline.java

@@ -0,0 +1,680 @@
+package com.replaymod.simplepathing;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Iterables;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+import com.replaymod.pathing.properties.CameraProperties;
+import com.replaymod.pathing.properties.SpectatorProperty;
+import com.replaymod.pathing.properties.TimestampProperty;
+import com.replaymod.replaystudio.pathing.PathingRegistry;
+import com.replaymod.replaystudio.pathing.change.AddKeyframe;
+import com.replaymod.replaystudio.pathing.change.Change;
+import com.replaymod.replaystudio.pathing.change.CombinedChange;
+import com.replaymod.replaystudio.pathing.change.SetInterpolator;
+import com.replaymod.replaystudio.pathing.change.UpdateKeyframeProperties;
+import com.replaymod.replaystudio.pathing.impl.TimelineImpl;
+import com.replaymod.replaystudio.pathing.interpolation.CatmullRomSplineInterpolator;
+import com.replaymod.replaystudio.pathing.interpolation.CubicSplineInterpolator;
+import com.replaymod.replaystudio.pathing.interpolation.Interpolator;
+import com.replaymod.replaystudio.pathing.interpolation.LinearInterpolator;
+import com.replaymod.replaystudio.pathing.path.Keyframe;
+import com.replaymod.replaystudio.pathing.path.Path;
+import com.replaymod.replaystudio.pathing.path.PathSegment;
+import com.replaymod.replaystudio.pathing.path.Timeline;
+import com.replaymod.replaystudio.pathing.property.Property;
+import com.replaymod.replaystudio.util.EntityPositionTracker;
+import com.replaymod.replaystudio.util.Location;
+import com.replaymod.simplepathing.properties.ExplicitInterpolationProperty;
+import lombok.Getter;
+import net.minecraft.crash.CrashReport;
+import net.minecraft.crash.CrashReportCategory;
+import net.minecraft.util.ReportedException;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.Validate;
+import org.apache.commons.lang3.tuple.Triple;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import static com.replaymod.replaystudio.pathing.change.RemoveKeyframe.create;
+import static com.replaymod.simplepathing.ReplayModSimplePathing.LOGGER;
+
+/**
+ * Simplified timeline abstraction used in the SimplePathing module.
+ */
+public class SPTimeline implements PathingRegistry {
+    public enum SPPath {
+        TIME,
+        POSITION,
+    }
+
+    @Getter
+    private final Timeline timeline;
+    @Getter
+    private final Path timePath;
+    @Getter
+    private final Path positionPath;
+
+    @Getter
+    private EntityPositionTracker entityTracker;
+    private InterpolatorType defaultInterpolatorType;
+
+    public SPTimeline() {
+        this(createInitialTimeline());
+    }
+
+    public SPTimeline(Timeline timeline) {
+        this.timeline = timeline;
+        this.timePath = timeline.getPaths().get(SPPath.TIME.ordinal());
+        this.positionPath = timeline.getPaths().get(SPPath.POSITION.ordinal());
+    }
+
+    public Path getPath(SPPath path) {
+        switch (path) {
+            case TIME:
+                return getTimePath();
+            case POSITION:
+                return getPositionPath();
+        }
+        throw new IllegalArgumentException("Unknown path " + path);
+    }
+
+    public Keyframe getKeyframe(SPPath path, long keyframe) {
+        return getPath(path).getKeyframe(keyframe);
+    }
+
+    public void setEntityTracker(EntityPositionTracker entityTracker) {
+        Preconditions.checkState(this.entityTracker == null, "Entity tracker already set");
+        this.entityTracker = entityTracker;
+    }
+
+    public void setDefaultInterpolatorType(InterpolatorType defaultInterpolatorType) {
+        Validate.isTrue(defaultInterpolatorType != InterpolatorType.DEFAULT, "Must not be DEFAULT");
+        this.defaultInterpolatorType = Validate.notNull(defaultInterpolatorType);
+
+        if (entityTracker != null) {
+            timeline.pushChange(updateInterpolators());
+        }
+    }
+
+    public Change setDefaultInterpolator(Interpolator interpolator) {
+        Preconditions.checkState(defaultInterpolatorType != null, "Default interpolator type not set.");
+        Validate.isInstanceOf(defaultInterpolatorType.getInterpolatorClass(), interpolator);
+
+        registerPositionInterpolatorProperties(interpolator);
+
+        Change change = CombinedChange.create(
+                positionPath.getSegments().stream()
+                        // Ignore explicitly set segments
+                        .filter(s -> !s.getStartKeyframe().getValue(ExplicitInterpolationProperty.PROPERTY).isPresent())
+                        // Ignore spectator segments
+                        .filter(s -> !isSpectatorSegment(s))
+                        // Update interpolator for every remaining segment
+                        // This will create a fragmented interpolator which is split by the updateInterpolators call
+                        .map(s -> SetInterpolator.create(s, interpolator)).toArray(Change[]::new)
+        );
+        change.apply(timeline);
+        return CombinedChange.createFromApplied(change, updateInterpolators());
+    }
+
+    public boolean isTimeKeyframe(long time) {
+        return timePath.getKeyframe(time) != null;
+    }
+
+    public boolean isPositionKeyframe(long time) {
+        return positionPath.getKeyframe(time) != null;
+    }
+
+    public boolean isSpectatorKeyframe(long time) {
+        Keyframe keyframe = positionPath.getKeyframe(time);
+        return keyframe != null && keyframe.getValue(SpectatorProperty.PROPERTY).isPresent();
+    }
+
+    public void addPositionKeyframe(long time, double posX, double posY, double posZ,
+                                    float yaw, float pitch, float roll, int spectated) {
+        LOGGER.debug("Adding position keyframe at {} pos {}/{}/{} rot {}/{}/{} entId {}",
+                time, posX, posY, posZ, yaw, pitch, roll, spectated);
+
+        Path path = positionPath;
+
+        Preconditions.checkState(positionPath.getKeyframe(time) == null, "Keyframe already exists");
+
+        Change change = AddKeyframe.create(path, time);
+        change.apply(timeline);
+        Keyframe keyframe = path.getKeyframe(time);
+
+        UpdateKeyframeProperties.Builder builder = UpdateKeyframeProperties.create(path, keyframe);
+        builder.setValue(CameraProperties.POSITION, Triple.of(posX, posY, posZ));
+        builder.setValue(CameraProperties.ROTATION, Triple.of(yaw, pitch, roll));
+        if (spectated != -1) {
+            builder.setValue(SpectatorProperty.PROPERTY, spectated);
+        }
+        UpdateKeyframeProperties updateChange = builder.done();
+        updateChange.apply(timeline);
+        change = CombinedChange.createFromApplied(change, updateChange);
+
+        // If this new keyframe formed the first segment of the path
+        if (path.getSegments().size() == 1) {
+            // then create an initial interpolator of default type
+            PathSegment segment = path.getSegments().iterator().next();
+            Interpolator interpolator = createDefaultInterpolator();
+            SetInterpolator setInterpolator = SetInterpolator.create(segment, interpolator);
+            setInterpolator.apply(timeline);
+            change = CombinedChange.createFromApplied(change, setInterpolator);
+        }
+
+        // Update interpolators for spectator keyframes
+        // while this is overkill, it is far simpler than updating differently for every possible case
+        change = CombinedChange.createFromApplied(change, updateInterpolators());
+
+        Change specPosUpdate = updateSpectatorPositions();
+        specPosUpdate.apply(timeline);
+        change = CombinedChange.createFromApplied(change, specPosUpdate);
+
+        timeline.pushChange(change);
+    }
+
+    public Change updatePositionKeyframe(long time, double posX, double posY, double posZ,
+                                    float yaw, float pitch, float roll) {
+        LOGGER.debug("Updating position keyframe at {} to pos {}/{}/{} rot {}/{}/{}",
+                time, posX, posY, posZ, yaw, pitch, roll);
+
+        Keyframe keyframe = positionPath.getKeyframe(time);
+
+        Preconditions.checkState(keyframe != null, "Keyframe does not exists");
+        Preconditions.checkState(!keyframe.getValue(SpectatorProperty.PROPERTY).isPresent(), "Cannot update spectator keyframe");
+
+        Change change = UpdateKeyframeProperties.create(positionPath, keyframe)
+                .setValue(CameraProperties.POSITION, Triple.of(posX, posY, posZ))
+                .setValue(CameraProperties.ROTATION, Triple.of(yaw, pitch, roll))
+                .done();
+        change.apply(timeline);
+        return change;
+    }
+
+    public void removePositionKeyframe(long time) {
+        LOGGER.debug("Removing position keyframe at {}", time);
+
+        Path path = positionPath;
+        Keyframe keyframe = path.getKeyframe(time);
+
+        Preconditions.checkState(keyframe != null, "No keyframe at that time");
+
+        Change change = create(path, keyframe);
+        change.apply(timeline);
+
+        // Update interpolators for spectator keyframes
+        // while this is overkill, it is far simpler than updating differently for every possible case
+        change = CombinedChange.createFromApplied(change, updateInterpolators());
+
+        Change specPosUpdate = updateSpectatorPositions();
+        specPosUpdate.apply(timeline);
+        change = CombinedChange.createFromApplied(change, specPosUpdate);
+
+        timeline.pushChange(change);
+    }
+
+    public void addTimeKeyframe(long time, int replayTime) {
+        LOGGER.debug("Adding time keyframe at {} time {}", time, replayTime);
+
+        Path path = timePath;
+
+        Preconditions.checkState(path.getKeyframe(time) == null, "Keyframe already exists");
+
+        Change change = AddKeyframe.create(path, time);
+        change.apply(timeline);
+        Keyframe keyframe = path.getKeyframe(time);
+
+        UpdateKeyframeProperties updateChange = UpdateKeyframeProperties.create(path, keyframe)
+                .setValue(TimestampProperty.PROPERTY, replayTime)
+                .done();
+        updateChange.apply(timeline);
+        change = CombinedChange.createFromApplied(change, updateChange);
+
+        // If this new keyframe formed the first segment of the path
+        if (path.getSegments().size() == 1) {
+            // then create an initial interpolator
+            PathSegment segment = path.getSegments().iterator().next();
+            Interpolator interpolator = new LinearInterpolator();
+            interpolator.registerProperty(TimestampProperty.PROPERTY);
+            SetInterpolator setInterpolator = SetInterpolator.create(segment, interpolator);
+            setInterpolator.apply(timeline);
+            change = CombinedChange.createFromApplied(change, setInterpolator);
+        }
+
+        Change specPosUpdate = updateSpectatorPositions();
+        specPosUpdate.apply(timeline);
+        change = CombinedChange.createFromApplied(change, specPosUpdate);
+
+        timeline.pushChange(change);
+    }
+
+    public Change updateTimeKeyframe(long time, int replayTime) {
+        LOGGER.debug("Updating time keyframe at {} to time {}", time, replayTime);
+
+        Keyframe keyframe = timePath.getKeyframe(time);
+
+        Preconditions.checkState(keyframe != null, "Keyframe does not exists");
+
+        Change change = UpdateKeyframeProperties.create(timePath, keyframe)
+                .setValue(TimestampProperty.PROPERTY, replayTime)
+                .done();
+        change.apply(timeline);
+        return change;
+    }
+
+    public void removeTimeKeyframe(long time) {
+        LOGGER.debug("Removing time keyframe at {}", time);
+
+        Path path = timePath;
+        Keyframe keyframe = path.getKeyframe(time);
+
+        Preconditions.checkState(keyframe != null, "No keyframe at that time");
+
+        Change change = create(path, keyframe);
+        change.apply(timeline);
+
+        Change specPosUpdate = updateSpectatorPositions();
+        specPosUpdate.apply(timeline);
+        change = CombinedChange.createFromApplied(change, specPosUpdate);
+
+        timeline.pushChange(change);
+    }
+
+    public Change setInterpolatorToDefault(long time) {
+        LOGGER.debug("Setting interpolator of position keyframe at {} to the default", time);
+
+        Keyframe keyframe = positionPath.getKeyframe(time);
+
+        Preconditions.checkState(keyframe != null, "Keyframe does not exists");
+
+        Change change = UpdateKeyframeProperties.create(positionPath, keyframe)
+                .removeProperty(ExplicitInterpolationProperty.PROPERTY)
+                .done();
+        change.apply(timeline);
+        return CombinedChange.createFromApplied(change, updateInterpolators());
+    }
+
+    public Change setInterpolator(long time, Interpolator interpolator) {
+        LOGGER.debug("Setting interpolator of position keyframe at {} to {}", time, interpolator);
+
+        Keyframe keyframe = positionPath.getKeyframe(time);
+        Preconditions.checkState(keyframe != null, "Keyframe does not exists");
+        PathSegment segment = positionPath.getSegments().stream().filter(s -> s.getStartKeyframe() == keyframe)
+                .findFirst().orElseThrow(() -> new IllegalStateException("Keyframe has no following segment."));
+
+        registerPositionInterpolatorProperties(interpolator);
+
+        Change change = CombinedChange.create(
+                UpdateKeyframeProperties.create(positionPath, keyframe)
+                        .setValue(ExplicitInterpolationProperty.PROPERTY, ObjectUtils.NULL)
+                        .done(),
+                SetInterpolator.create(segment, interpolator)
+        );
+        change.apply(timeline);
+        return CombinedChange.createFromApplied(change, updateInterpolators());
+    }
+
+    public Change moveKeyframe(SPPath spPath, long oldTime, long newTime) {
+        LOGGER.debug("Moving keyframe on {} from {} to {}", spPath, oldTime, newTime);
+        Path path = getPath(spPath);
+        Keyframe keyframe = path.getKeyframe(oldTime);
+
+        Preconditions.checkState(keyframe != null, "No keyframe at specified time");
+
+        // Interpolator of the first segment might be required later if it is the only one
+        Optional<Interpolator> firstInterpolator =
+                path.getSegments().stream().findFirst().map(PathSegment::getInterpolator);
+
+        // The interpolator that will be lost once we remove the old keyframe and has to be restored afterwards
+        Optional<Interpolator> lostInterpolator = path.getSegments().stream().filter(s -> {
+            // If this is the last keyframe,
+            if (Iterables.getLast(path.getKeyframes()) == keyframe) {
+                return s.getEndKeyframe() == keyframe; // the previous interpolator will be lost
+            } else { // otherwise
+                return s.getStartKeyframe() == keyframe; // the following interpolator will be lost
+            }
+        }).findFirst().map(PathSegment::getInterpolator);
+
+        // First remove the old keyframe
+        Change removeChange = create(path, keyframe);
+        removeChange.apply(timeline);
+
+        // and add a new one at the correct time
+        Change addChange = AddKeyframe.create(path, newTime);
+        addChange.apply(timeline);
+
+        // Then copy over all properties
+        UpdateKeyframeProperties.Builder builder = UpdateKeyframeProperties.create(path, path.getKeyframe(newTime));
+        for (Property property : keyframe.getProperties()) {
+            copyProperty(property, keyframe, builder);
+        }
+        Change propertyChange = builder.done();
+        propertyChange.apply(timeline);
+
+
+        Change restoreInterpolatorChange;
+        Keyframe newKf = path.getKeyframe(newTime);
+        if (Iterables.getLast(path.getKeyframes()) != newKf) { // Unless this is the last keyframe
+            // the interpolator of the following segment has been lost and needs to be restored
+            restoreInterpolatorChange = lostInterpolator.<Change>flatMap(interpolator ->
+                    path.getSegments().stream().filter(s -> s.getStartKeyframe() == newKf).findFirst().map(segment ->
+                            SetInterpolator.create(segment, interpolator)
+                    )
+            ).orElseGet(CombinedChange::create);
+        } else { // If it is the last keyframe however,
+            // the interpolator of the previous segment has been lost and needs to be restored
+            restoreInterpolatorChange = path.getSegments().stream().filter(s -> s.getEndKeyframe() == newKf)
+                    .findFirst().flatMap(segment -> lostInterpolator.map(interpolator -> {
+                        // additionally, if the interpolation of this keyframe was set to explicit, that property
+                        // has to be transferred to the start keyframe of the new segment
+                        if (newKf.getValue(ExplicitInterpolationProperty.PROPERTY).isPresent()) {
+                            return CombinedChange.create(
+                                    SetInterpolator.create(segment, interpolator),
+                                    UpdateKeyframeProperties.create(path, segment.getStartKeyframe())
+                                            .setValue(ExplicitInterpolationProperty.PROPERTY, ObjectUtils.NULL).done()
+                            );
+                        } else {
+                            return SetInterpolator.create(segment, interpolator);
+                        }
+            })).orElseGet(CombinedChange::create);
+        }
+        restoreInterpolatorChange.apply(timeline);
+
+        // Finally update the interpolators
+        Change interpolatorUpdateChange;
+        if (spPath == SPPath.POSITION) {
+            // Position / Spectator keyframes need special handling
+            interpolatorUpdateChange = updateInterpolators();
+        } else {
+            // Time keyframes only need updating when only one segment of them exists
+            if (path.getSegments().size() == 1) {
+                assert firstInterpolator.isPresent() : "One segment should have existed before as well";
+                interpolatorUpdateChange = SetInterpolator.create(path.getSegments().iterator().next(), firstInterpolator.get());
+            } else {
+                interpolatorUpdateChange = CombinedChange.create(); // Noop change
+            }
+            interpolatorUpdateChange.apply(timeline);
+        }
+
+        // and update spectator positions
+        Change spectatorChange = updateSpectatorPositions();
+        spectatorChange.apply(timeline);
+
+        return CombinedChange.createFromApplied(removeChange, addChange, propertyChange,
+                restoreInterpolatorChange, interpolatorUpdateChange, spectatorChange);
+    }
+
+    // Helper method because generics cannot be defined on blocks
+    private <T> void copyProperty(Property<T> property, Keyframe from, UpdateKeyframeProperties.Builder to) {
+        from.getValue(property).ifPresent(value -> to.setValue(property, value));
+    }
+
+    private Change updateInterpolators() {
+        Collection<PathSegment> pathSegments = positionPath.getSegments();
+        // Contains updated pathsegment-interpolator mappings, may be changed multiple times over the course of this method
+        Map<PathSegment, Interpolator> updates = new HashMap<>();
+
+        // First, setup spectator interpolators
+        Interpolator interpolator = null;
+        // Iterate through all segments
+        for (PathSegment segment : pathSegments) {
+            if (isSpectatorSegment(segment)) {
+                // If the last segment was a spectator segment, then use its interpolator for this segment as well
+                if (interpolator == null) {
+                    // otherwise create a new interpolator
+                    interpolator = new LinearInterpolator();
+                    interpolator.registerProperty(SpectatorProperty.PROPERTY);
+                }
+                // Now that we have an interpolator, set it for the current segment
+                updates.put(segment, interpolator);
+            } else {
+                // Not a spectator segment, make sure we don't re-use the last interpolator (it would not be continuous)
+                interpolator = null;
+            }
+        }
+
+        // Then, if required, replace old default interpolators with new ones
+        pathSegments.stream()
+                // Ignore explicitly set segments
+                .filter(s -> !s.getStartKeyframe().getValue(ExplicitInterpolationProperty.PROPERTY).isPresent())
+                // Ignore spectator segments
+                .filter(s -> !isSpectatorSegment(s))
+                // Ignore already correct segments, should ignore all if default hasn't changed
+                .filter(s -> !s.getInterpolator().getClass().equals(defaultInterpolatorType.getInterpolatorClass()))
+                // Finally, set the interpolators
+                // This will create one interpolator per segment, they will be merged later
+                .forEach(segment -> updates.put(segment, createDefaultInterpolator()));
+
+        // All interpolators should now be set appropriately but may still be fragmented.
+        // Cleaning that up is a two step process
+
+        // Firstly, all interpolators that are not continuous need to be split up
+        Interpolator lastInterpolator = null;
+        Set<Interpolator> used = Collections.newSetFromMap(new IdentityHashMap<>());
+        for (PathSegment segment : pathSegments) {
+            if (isSpectatorSegment(segment)) {
+                lastInterpolator = null;
+                continue; // Chain broken by spectator segment
+            }
+
+            Interpolator currentInterpolator = updates.getOrDefault(segment, segment.getInterpolator());
+            if (lastInterpolator == currentInterpolator) {
+                continue; // All fine, interpolator is still continuous
+            }
+
+            // New interpolator, make sure it hasn't been used before
+            if (!used.add(interpolator)) {
+                // It has been used before, we need to clone it and use the clone instead
+                // This will create a new interpolator for each segment which will be merged later
+                currentInterpolator = cloneInterpolator(currentInterpolator);
+                updates.put(segment, currentInterpolator);
+            }
+            lastInterpolator = currentInterpolator;
+        }
+
+        // Secondly, all neighbouring interpolators that are equal need to be merged
+        lastInterpolator = null;
+        String lastInterpolatorSerialized = null;
+        for (PathSegment segment : pathSegments) {
+            if (isSpectatorSegment(segment)) {
+                lastInterpolator = null;
+                lastInterpolatorSerialized = null;
+                continue; // Spectator segments are continuous by construction
+            }
+            Interpolator currentInterpolator = updates.getOrDefault(segment, segment.getInterpolator());
+            String serialized = serializeInterpolator(currentInterpolator);
+            if (lastInterpolator != currentInterpolator && serialized.equals(lastInterpolatorSerialized)) {
+                // This interpolator is equal to the last one but not the same, needs merging
+                updates.put(segment, lastInterpolator);
+                continue;
+            }
+            // New interpolator, not related to the previous one, merged by definition
+            lastInterpolator = currentInterpolator;
+            lastInterpolatorSerialized = serialized;
+        }
+
+        Change change = CombinedChange.create(updates.entrySet().stream()
+                .map(e -> SetInterpolator.create(e.getKey(), e.getValue())).toArray(Change[]::new));
+        change.apply(timeline);
+        return change;
+    }
+
+    private boolean isSpectatorSegment(PathSegment segment) {
+        return segment.getStartKeyframe().getValue(SpectatorProperty.PROPERTY).isPresent()
+                && segment.getEndKeyframe().getValue(SpectatorProperty.PROPERTY).isPresent();
+    }
+
+    private Change updateSpectatorPositions() {
+        List<Change> changes = new ArrayList<>();
+        timePath.updateAll();
+        for (Keyframe keyframe : positionPath.getKeyframes()) {
+            Optional<Integer> spectator = keyframe.getValue(SpectatorProperty.PROPERTY);
+            if (spectator.isPresent()) {
+                Optional<Integer> time = timePath.getValue(TimestampProperty.PROPERTY, keyframe.getTime());
+                if (!time.isPresent()) {
+                    continue; // No time keyframes set at this video time, cannot determine replay time
+                }
+                Location expected = entityTracker.getEntityPositionAtTimestamp(spectator.get(), time.get());
+                if (expected == null) {
+                    continue; // We don't have any data on this entity for some reason
+                }
+                Triple<Double, Double, Double> pos = keyframe.getValue(CameraProperties.POSITION).orElse(Triple.of(0D, 0D, 0D));
+                Triple<Float, Float, Float> rot = keyframe.getValue(CameraProperties.ROTATION).orElse(Triple.of(0F, 0F, 0F));
+                Location actual = new Location(pos.getLeft(), pos.getMiddle(), pos.getRight(), rot.getLeft(), rot.getRight());
+                if (!expected.equals(actual)) {
+                    changes.add(UpdateKeyframeProperties.create(positionPath, keyframe)
+                            .setValue(CameraProperties.POSITION, Triple.of(expected.getX(), expected.getY(), expected.getZ()))
+                            .setValue(CameraProperties.ROTATION, Triple.of(expected.getYaw(), expected.getPitch(), 0f)).done()
+                    );
+                }
+            }
+        }
+        return CombinedChange.create(changes.toArray(new Change[changes.size()]));
+    }
+
+    private Interpolator createDefaultInterpolator() {
+        return registerPositionInterpolatorProperties(defaultInterpolatorType.newInstance());
+    }
+
+    private Interpolator registerPositionInterpolatorProperties(Interpolator interpolator) {
+        interpolator.registerProperty(CameraProperties.POSITION);
+        interpolator.registerProperty(CameraProperties.ROTATION);
+        return interpolator;
+    }
+
+    @Override
+    public Timeline createTimeline() {
+        return createTimelineStatic();
+    }
+
+    private static Timeline createInitialTimeline() {
+        Timeline timeline = createTimelineStatic();
+        timeline.createPath();
+        timeline.createPath();
+        return timeline;
+    }
+
+    private static Timeline createTimelineStatic() {
+        Timeline timeline = new TimelineImpl();
+
+        timeline.registerProperty(TimestampProperty.PROPERTY);
+        timeline.registerProperty(CameraProperties.POSITION);
+        timeline.registerProperty(CameraProperties.ROTATION);
+        timeline.registerProperty(SpectatorProperty.PROPERTY);
+        timeline.registerProperty(ExplicitInterpolationProperty.PROPERTY);
+
+        return timeline;
+    }
+
+    @Override
+    public void serializeInterpolator(JsonWriter writer, Interpolator interpolator) throws IOException {
+        if (interpolator instanceof LinearInterpolator) {
+            writer.value("linear");
+        } else if (interpolator instanceof CubicSplineInterpolator) {
+            writer.value("cubic-spline");
+        } else if (interpolator instanceof CatmullRomSplineInterpolator) {
+            writer.beginObject();
+            writer.name("type").value("catmull-rom-spline");
+            writer.name("alpha").value(((CatmullRomSplineInterpolator) interpolator).getAlpha());
+            writer.endObject();
+        } else {
+            throw new IOException("Unknown interpolator type: " + interpolator);
+        }
+    }
+
+    @Override
+    public Interpolator deserializeInterpolator(JsonReader reader) throws IOException {
+        String type;
+        JsonObject args;
+        switch (reader.peek()) {
+            case STRING:
+                type = reader.nextString();
+                args = null;
+                break;
+            case BEGIN_OBJECT:
+                args = new JsonParser().parse(reader).getAsJsonObject();
+                type = args.get("type").getAsString();
+                break;
+            default:
+                throw new IOException("Unexpected token: " + reader.peek());
+        }
+        switch (type) {
+            case "linear":
+                return new LinearInterpolator();
+            case "cubic-spline":
+                return new CubicSplineInterpolator();
+            case "catmull-rom-spline":
+                if (args == null || !args.has("alpha")) {
+                    throw new IOException("Missing alpha value for catmull-rom-spline.");
+                }
+                return new CatmullRomSplineInterpolator(args.get("alpha").getAsDouble());
+            default:
+                throw new IOException("Unknown interpolation type: " + type);
+
+        }
+    }
+
+    /**
+     * Clones an interpolator by de- and re-serializing it.
+     * @param interpolator The interpolator to clone
+     * @return The cloned interpolator
+     */
+    private Interpolator cloneInterpolator(Interpolator interpolator) {
+        Interpolator cloned = deserializeInterpolator(serializeInterpolator(interpolator));
+        interpolator.getKeyframeProperties().forEach(cloned::registerProperty);
+        return cloned;
+    }
+
+    /**
+     * Serializes the specific interpolator to String.
+     * Does <b>not</b> serialize the registered keyframe properties.
+     * @param interpolator The interpolator to serialize.
+     * @return The serialized interpolator
+     */
+    private String serializeInterpolator(Interpolator interpolator) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+        JsonWriter jsonWriter = new JsonWriter(new PrintWriter(baos));
+        try {
+            jsonWriter.beginArray();
+            serializeInterpolator(jsonWriter, interpolator);
+            jsonWriter.endArray();
+            jsonWriter.flush();
+        } catch (IOException e) {
+            CrashReport crash = CrashReport.makeCrashReport(e, "Serializing interpolator");
+            CrashReportCategory category = crash.makeCategory("Serializing interpolator");
+            category.setDetail("Interpolator", interpolator::toString);
+            throw new ReportedException(crash);
+        }
+
+        return baos.toString();
+    }
+
+    private Interpolator deserializeInterpolator(String json) {
+        JsonReader jsonReader = new JsonReader(new StringReader(json));
+        try {
+            jsonReader.beginArray();
+            return deserializeInterpolator(jsonReader);
+        } catch (IOException e) {
+            CrashReport crash = CrashReport.makeCrashReport(e, "De-serializing interpolator");
+            CrashReportCategory category = crash.makeCategory("De-serializing interpolator");
+            category.addCrashSection("Interpolator", json);
+            throw new ReportedException(crash);
+        }
+    }
+}

src/main/java/com/replaymod/simplepathing/Setting.java

@@ -2,9 +2,25 @@ package com.replaymod.simplepathing;
 
 import com.replaymod.core.SettingsRegistry;
 
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
 public final class Setting<T> extends SettingsRegistry.SettingKeys<T> {
     public static final Setting<Boolean> PATH_PREVIEW = make("pathpreview", "pathpreview", true);
-    public static final Setting<Boolean> LINEAR_INTERPOLATION = make("linear_interpolation", "linearinterpolation", false);
+    public static final SettingsRegistry.MultipleChoiceSettingKeys<String> DEFAULT_INTERPOLATION;
+
+    static {
+        String format = "replaymod.gui.editkeyframe.interpolator.%s.name";
+        DEFAULT_INTERPOLATION = new SettingsRegistry.MultipleChoiceSettingKeys<>(
+                "simplepathing", "interpolator", "replaymod.gui.settings.interpolator",
+                String.format(format, InterpolatorType.fromString("invalid returns default").getLocalizationKey())
+        );
+        DEFAULT_INTERPOLATION.setChoices(
+                Arrays.stream(InterpolatorType.values()).filter(i -> i != InterpolatorType.DEFAULT)
+                        .map(i -> String.format(format, i.getLocalizationKey()))
+                        .collect(Collectors.toList())
+        );
+    }
 
     private static <T> Setting<T> make(String key, String displayName, T defaultValue) {
         return new Setting<>(key, displayName, defaultValue);

src/main/java/com/replaymod/simplepathing/gui/GuiEditKeyframe.java

@@ -5,14 +5,27 @@ import com.replaymod.pathing.properties.TimestampProperty;
 import com.replaymod.replay.ReplayModReplay;
 import com.replaymod.replaystudio.pathing.change.Change;
 import com.replaymod.replaystudio.pathing.change.CombinedChange;
-import com.replaymod.replaystudio.pathing.change.UpdateKeyframeProperties;
+import com.replaymod.replaystudio.pathing.interpolation.CatmullRomSplineInterpolator;
+import com.replaymod.replaystudio.pathing.interpolation.CubicSplineInterpolator;
+import com.replaymod.replaystudio.pathing.interpolation.Interpolator;
+import com.replaymod.replaystudio.pathing.interpolation.LinearInterpolator;
 import com.replaymod.replaystudio.pathing.path.Keyframe;
 import com.replaymod.replaystudio.pathing.path.Path;
+import com.replaymod.replaystudio.pathing.path.PathSegment;
+import com.replaymod.simplepathing.InterpolatorType;
+import com.replaymod.simplepathing.SPTimeline;
+import com.replaymod.simplepathing.SPTimeline.SPPath;
+import com.replaymod.simplepathing.Setting;
+import com.replaymod.simplepathing.properties.ExplicitInterpolationProperty;
+import de.johni0702.minecraft.gui.container.AbstractGuiContainer;
 import de.johni0702.minecraft.gui.container.GuiPanel;
 import de.johni0702.minecraft.gui.element.GuiButton;
 import de.johni0702.minecraft.gui.element.GuiLabel;
 import de.johni0702.minecraft.gui.element.GuiNumberField;
+import de.johni0702.minecraft.gui.element.GuiTooltip;
+import de.johni0702.minecraft.gui.element.IGuiClickable;
 import de.johni0702.minecraft.gui.element.IGuiLabel;
+import de.johni0702.minecraft.gui.element.advanced.GuiDropdownMenu;
 import de.johni0702.minecraft.gui.function.Typeable;
 import de.johni0702.minecraft.gui.layout.GridLayout;
 import de.johni0702.minecraft.gui.layout.HorizontalLayout;
@@ -20,10 +33,16 @@ import de.johni0702.minecraft.gui.layout.VerticalLayout;
 import de.johni0702.minecraft.gui.popup.AbstractGuiPopup;
 import de.johni0702.minecraft.gui.utils.Colors;
 import de.johni0702.minecraft.gui.utils.Consumer;
-import org.apache.commons.lang3.tuple.Triple;
+import lombok.Getter;
+import net.minecraft.client.resources.I18n;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.util.ReadablePoint;
 
+import java.util.Map;
+import java.util.Optional;
+
 import static de.johni0702.minecraft.gui.utils.Utils.link;
 
 public abstract class GuiEditKeyframe<T extends GuiEditKeyframe<T>> extends AbstractGuiPopup<T> implements Typeable {
@@ -31,6 +50,11 @@ public abstract class GuiEditKeyframe<T extends GuiEditKeyframe<T>> extends Abst
         return new GuiNumberField().setPrecision(0).setValidateOnFocusChange(true);
     }
 
+    protected static final Logger logger = LogManager.getLogger();
+
+    protected final GuiPathing guiPathing;
+
+    protected final long time;
     protected final Keyframe keyframe;
     protected final Path path;
 
@@ -63,15 +87,16 @@ public abstract class GuiEditKeyframe<T extends GuiEditKeyframe<T>> extends Abst
         setBackgroundColor(Colors.DARK_TRANSPARENT);
 
         popup.setLayout(new VerticalLayout().setSpacing(10))
-                .addElements(new VerticalLayout.Data(0.5), title, inputs, timePanel, buttons);
+                .addElements(new VerticalLayout.Data(0.5, false), title, inputs, timePanel, buttons);
     }
 
-    public GuiEditKeyframe(GuiPathing gui, Path path, Keyframe keyframe, String type) {
+    public GuiEditKeyframe(GuiPathing gui, SPPath path, long time, String type) {
         super(ReplayModReplay.instance.getReplayHandler().getOverlay());
-        this.keyframe = keyframe;
-        this.path = path;
+        this.guiPathing = gui;
+        this.time = time;
+        this.path = gui.getMod().getCurrentTimeline().getPath(path);
+        this.keyframe = this.path.getKeyframe(time);
 
-        long time = keyframe.getTime();
         Consumer<String> updateSaveButtonState = s -> saveButton.setEnabled(canSave());
         timeMinField.setValue(time / 1000 / 60).onTextChanged(updateSaveButtonState);
         timeSecField.setValue(time / 1000 % 60).onTextChanged(updateSaveButtonState);
@@ -81,10 +106,14 @@ public abstract class GuiEditKeyframe<T extends GuiEditKeyframe<T>> extends Abst
         saveButton.onClick(() -> {
             Change change = save();
             long newTime = (timeMinField.getInteger() * 60 + timeSecField.getInteger()) * 1000 + timeMSecField.getInteger();
-            if (newTime != keyframe.getTime()) {
-                change = CombinedChange.createFromApplied(change, gui.moveKeyframe(path, keyframe, newTime));
+            if (newTime != time) {
+                change = CombinedChange.createFromApplied(change,
+                        gui.getMod().getCurrentTimeline().moveKeyframe(path, time, newTime));
+                if (gui.getMod().getSelectedPath() == path && gui.getMod().getSelectedTime() == time) {
+                    gui.getMod().setSelected(path, newTime);
                 }
-            path.getTimeline().pushChange(change);
+            }
+            gui.getMod().getCurrentTimeline().getTimeline().pushChange(change);
             close();
         });
     }
@@ -114,7 +143,7 @@ public abstract class GuiEditKeyframe<T extends GuiEditKeyframe<T>> extends Abst
     protected abstract Change save();
 
     public static class Spectator extends GuiEditKeyframe<Spectator> {
-        public Spectator(GuiPathing gui, Path path, Keyframe keyframe) {
+        public Spectator(GuiPathing gui, SPPath path, long keyframe) {
             super(gui, path, keyframe, "spec");
 
             link(timeMinField, timeSecField, timeMSecField);
@@ -147,10 +176,10 @@ public abstract class GuiEditKeyframe<T extends GuiEditKeyframe<T>> extends Abst
                             timestampMSecField, new GuiLabel().setI18nText("replaymod.gui.milliseconds"));
         }
 
-        public Time(GuiPathing gui, Path path, Keyframe keyframe) {
+        public Time(GuiPathing gui, SPPath path, long keyframe) {
             super(gui, path, keyframe, "time");
 
-            keyframe.getValue(TimestampProperty.PROPERTY).ifPresent(time -> {
+            this.keyframe.getValue(TimestampProperty.PROPERTY).ifPresent(time -> {
                 timestampMinField.setValue(time / 1000 / 60);
                 timestampSecField.setValue(time / 1000 % 60);
                 timestampMSecField.setValue(time % 1000);
@@ -165,11 +194,7 @@ public abstract class GuiEditKeyframe<T extends GuiEditKeyframe<T>> extends Abst
         protected Change save() {
             int time = (timestampMinField.getInteger() * 60 + timestampSecField.getInteger()) * 1000
                     + timestampMSecField.getInteger();
-            Change change = UpdateKeyframeProperties.create(path, keyframe)
-                    .setValue(TimestampProperty.PROPERTY, time)
-                    .done();
-            change.apply(path.getTimeline());
-            return change;
+            return guiPathing.getMod().getCurrentTimeline().updateTimeKeyframe(keyframe.getTime(), time);
         }
 
         @Override
@@ -179,16 +204,19 @@ public abstract class GuiEditKeyframe<T extends GuiEditKeyframe<T>> extends Abst
     }
 
     public static class Position extends GuiEditKeyframe<Position> {
-        public final GuiNumberField xField = newGuiNumberField().setSize(150, 20).setPrecision(10);
-        public final GuiNumberField yField = newGuiNumberField().setSize(150, 20).setPrecision(10);
-        public final GuiNumberField zField = newGuiNumberField().setSize(150, 20).setPrecision(10);
+        public final GuiNumberField xField = newGuiNumberField().setSize(60, 20).setPrecision(5);
+        public final GuiNumberField yField = newGuiNumberField().setSize(60, 20).setPrecision(5);
+        public final GuiNumberField zField = newGuiNumberField().setSize(60, 20).setPrecision(5);
 
-        public final GuiNumberField yawField = newGuiNumberField().setSize(150, 20).setPrecision(5);
-        public final GuiNumberField pitchField = newGuiNumberField().setSize(150, 20).setPrecision(5);
-        public final GuiNumberField rollField = newGuiNumberField().setSize(150, 20).setPrecision(5);
+        public final GuiNumberField yawField = newGuiNumberField().setSize(60, 20).setPrecision(5);
+        public final GuiNumberField pitchField = newGuiNumberField().setSize(60, 20).setPrecision(5);
+        public final GuiNumberField rollField = newGuiNumberField().setSize(60, 20).setPrecision(5);
+
+        public final InterpolationPanel interpolationPanel = new InterpolationPanel();
 
         {
-            inputs.setLayout(new GridLayout().setCellsEqualSize(false).setColumns(4).setSpacingX(3).setSpacingY(5))
+            GuiPanel positionInputs = new GuiPanel()
+                    .setLayout(new GridLayout().setCellsEqualSize(false).setColumns(4).setSpacingX(3).setSpacingY(5))
                     .addElements(new GridLayout.Data(1, 0.5),
                             new GuiLabel().setI18nText("replaymod.gui.editkeyframe.xpos"), xField,
                             new GuiLabel().setI18nText("replaymod.gui.editkeyframe.camyaw"), yawField,
@@ -196,17 +224,20 @@ public abstract class GuiEditKeyframe<T extends GuiEditKeyframe<T>> extends Abst
                             new GuiLabel().setI18nText("replaymod.gui.editkeyframe.campitch"), pitchField,
                             new GuiLabel().setI18nText("replaymod.gui.editkeyframe.zpos"), zField,
                             new GuiLabel().setI18nText("replaymod.gui.editkeyframe.camroll"), rollField);
+
+            inputs.setLayout(new VerticalLayout().setSpacing(10)).addElements(new VerticalLayout.Data(0.5, false),
+                    positionInputs, interpolationPanel);
         }
 
-        public Position(GuiPathing gui, Path path, Keyframe keyframe) {
+        public Position(GuiPathing gui, SPPath path, long keyframe) {
             super(gui, path, keyframe, "pos");
 
-            keyframe.getValue(CameraProperties.POSITION).ifPresent(pos -> {
+            this.keyframe.getValue(CameraProperties.POSITION).ifPresent(pos -> {
                 xField.setValue(pos.getLeft());
                 yField.setValue(pos.getMiddle());
                 zField.setValue(pos.getRight());
             });
-            keyframe.getValue(CameraProperties.ROTATION).ifPresent(rot -> {
+            this.keyframe.getValue(CameraProperties.ROTATION).ifPresent(rot -> {
                 yawField.setValue(rot.getLeft());
                 pitchField.setValue(rot.getMiddle());
                 rollField.setValue(rot.getRight());
@@ -219,17 +250,181 @@ public abstract class GuiEditKeyframe<T extends GuiEditKeyframe<T>> extends Abst
 
         @Override
         protected Change save() {
-            Change change = UpdateKeyframeProperties.create(path, keyframe)
-                    .setValue(CameraProperties.POSITION, Triple.of(xField.getDouble(), yField.getDouble(), zField.getDouble()))
-                    .setValue(CameraProperties.ROTATION, Triple.of(yawField.getFloat(), pitchField.getFloat(), rollField.getFloat()))
-                    .done();
-            change.apply(path.getTimeline());
-            return change;
+            SPTimeline timeline = guiPathing.getMod().getCurrentTimeline();
+            Change positionChange = timeline.updatePositionKeyframe(time,
+                    xField.getDouble(), yField.getDouble(), zField.getDouble(),
+                    yawField.getFloat(), pitchField.getFloat(), rollField.getFloat()
+            );
+            if (interpolationPanel.getSettingsPanel() == null) {
+                // The last keyframe doesn't have interpolator settings because there is no segment following it
+                return positionChange;
+            }
+            Interpolator interpolator = interpolationPanel.getSettingsPanel().createInterpolator();
+            if (interpolationPanel.getInterpolatorType() == InterpolatorType.DEFAULT) {
+                return CombinedChange.createFromApplied(positionChange, timeline.setInterpolatorToDefault(time),
+                        timeline.setDefaultInterpolator(interpolator));
+            } else {
+                return CombinedChange.createFromApplied(positionChange, timeline.setInterpolator(time, interpolator));
+            }
         }
 
         @Override
         protected Position getThis() {
             return this;
         }
+
+        public class InterpolationPanel extends AbstractGuiContainer<InterpolationPanel> {
+
+            @Getter
+            private SettingsPanel settingsPanel;
+
+            private GuiDropdownMenu<InterpolatorType> dropdown;
+
+            public InterpolationPanel() {
+                setLayout(new VerticalLayout());
+
+                dropdown = new GuiDropdownMenu<InterpolatorType>()
+                        .setToString(s -> I18n.format(s.getI18nName()))
+                        .setValues(InterpolatorType.values()).setHeight(20)
+                        .onSelection(i -> setSettingsPanel(dropdown.getSelectedValue()));
+
+                // set hover tooltips
+                for (Map.Entry<InterpolatorType, IGuiClickable> e : dropdown.getDropdownEntries().entrySet()) {
+                    e.getValue().setTooltip(new GuiTooltip().setI18nText(e.getKey().getI18nDescription()));
+                }
+
+                GuiPanel dropdownPanel = new GuiPanel()
+                        .setLayout(new GridLayout().setCellsEqualSize(false).setColumns(2).setSpacingX(3).setSpacingY(5))
+                        .addElements(new GridLayout.Data(1, 0.5),
+                                new GuiLabel().setI18nText("replaymod.gui.editkeyframe.interpolator"), dropdown);
+
+
+                addElements(new VerticalLayout.Data(0.5, false), dropdownPanel);
+
+                Optional<PathSegment> segment = path.getSegments().stream()
+                        .filter(s -> s.getStartKeyframe() == keyframe).findFirst();
+                if (segment.isPresent()) {
+                    Interpolator interpolator = segment.get().getInterpolator();
+                    InterpolatorType type = InterpolatorType.fromClass(interpolator.getClass());
+                    if (keyframe.getValue(ExplicitInterpolationProperty.PROPERTY).isPresent()) {
+                        dropdown.setSelected(type); // trigger the callback once to display settings panel
+                    } else {
+                        setSettingsPanel(InterpolatorType.DEFAULT);
+                        type = InterpolatorType.DEFAULT;
+                    }
+                    if (getInterpolatorTypeNoDefault(type).getInterpolatorClass().isInstance(interpolator)) {
+                        //noinspection unchecked
+                        settingsPanel.loadSettings(interpolator);
+                    }
+                } else {
+                    // Disable dropdown if this is the last keyframe
+                    dropdown.setDisabled();
+                }
+            }
+
+            public void setSettingsPanel(InterpolatorType type) {
+                removeElement(this.settingsPanel);
+
+                switch (getInterpolatorTypeNoDefault(type)) {
+                    case CATMULL_ROM:
+                        settingsPanel = new CatmullRomSettingsPanel();
+                        break;
+                    case CUBIC:
+                        settingsPanel = new CubicSettingsPanel();
+                        break;
+                    case LINEAR:
+                        settingsPanel = new LinearSettingsPanel();
+                        break;
+                }
+
+                addElements(new GridLayout.Data(0.5, 0.5), settingsPanel);
+            }
+
+            protected InterpolatorType getInterpolatorTypeNoDefault(InterpolatorType interpolatorType) {
+                if (interpolatorType == InterpolatorType.DEFAULT || interpolatorType == null) {
+                    InterpolatorType defaultType = InterpolatorType.fromString(
+                            guiPathing.getMod().getCore().getSettingsRegistry().get(Setting.DEFAULT_INTERPOLATION));
+                    return defaultType;
+                }
+                return interpolatorType;
+            }
+
+            public InterpolatorType getInterpolatorType() {
+                return dropdown.getSelectedValue();
+            }
+
+            @Override
+            protected InterpolationPanel getThis() {
+                return this;
+            }
+
+            public abstract class SettingsPanel<I extends Interpolator, T extends SettingsPanel<I, T>> extends AbstractGuiContainer<T> {
+
+                public abstract void loadSettings(I interpolator);
+
+                public abstract I createInterpolator();
+            }
+
+            public class CatmullRomSettingsPanel extends SettingsPanel<CatmullRomSplineInterpolator, CatmullRomSettingsPanel> {
+                public final GuiLabel alphaLabel = new GuiLabel().setColor(Colors.BLACK)
+                        .setI18nText("replaymod.gui.editkeyframe.interpolator.catmullrom.alpha");
+                public final GuiNumberField alphaField = new GuiNumberField().setSize(100, 20).setPrecision(5)
+                        .setMinValue(0).setValidateOnFocusChange(true);
+
+                {
+                    setLayout(new HorizontalLayout(HorizontalLayout.Alignment.CENTER));
+                    addElements(new HorizontalLayout.Data(0.5), alphaLabel, alphaField);
+                }
+
+                @Override
+                public void loadSettings(CatmullRomSplineInterpolator interpolator) {
+                    alphaField.setValue(interpolator.getAlpha());
+                }
+
+                @Override
+                public CatmullRomSplineInterpolator createInterpolator() {
+                    return new CatmullRomSplineInterpolator(alphaField.getDouble());
+                }
+
+                @Override
+                protected CatmullRomSettingsPanel getThis() {
+                    return this;
+                }
+            }
+
+            public class CubicSettingsPanel extends SettingsPanel<CubicSplineInterpolator, CubicSettingsPanel> {
+
+                @Override
+                public void loadSettings(CubicSplineInterpolator interpolator) {
+                }
+
+                @Override
+                public CubicSplineInterpolator createInterpolator() {
+                    return new CubicSplineInterpolator();
+                }
+
+                @Override
+                protected CubicSettingsPanel getThis() {
+                    return this;
+                }
+            }
+
+            public class LinearSettingsPanel extends SettingsPanel<LinearInterpolator, LinearSettingsPanel> {
+
+                @Override
+                public void loadSettings(LinearInterpolator interpolator) {
+                }
+
+                @Override
+                public LinearInterpolator createInterpolator() {
+                    return new LinearInterpolator();
+                }
+
+                @Override
+                protected LinearSettingsPanel getThis() {
+                    return this;
+                }
+            }
+        }
     }
 }

src/main/java/com/replaymod/simplepathing/gui/GuiKeyframeTimeline.java

@@ -1,7 +1,5 @@
 package com.replaymod.simplepathing.gui;
 
-import com.google.common.base.Function;
-import com.google.common.collect.Iterables;
 import com.replaymod.core.ReplayMod;
 import com.replaymod.pathing.properties.CameraProperties;
 import com.replaymod.pathing.properties.SpectatorProperty;
@@ -11,9 +9,10 @@ import com.replaymod.replaystudio.pathing.change.Change;
 import com.replaymod.replaystudio.pathing.path.Keyframe;
 import com.replaymod.replaystudio.pathing.path.Path;
 import com.replaymod.replaystudio.pathing.path.PathSegment;
-import com.replaymod.replaystudio.pathing.path.Timeline;
 import com.replaymod.replaystudio.pathing.property.Property;
 import com.replaymod.simplepathing.ReplayModSimplePathing;
+import com.replaymod.simplepathing.SPTimeline;
+import com.replaymod.simplepathing.SPTimeline.SPPath;
 import de.johni0702.minecraft.gui.GuiRenderer;
 import de.johni0702.minecraft.gui.element.advanced.AbstractGuiTimeline;
 import de.johni0702.minecraft.gui.function.Draggable;
@@ -23,7 +22,6 @@ import org.lwjgl.util.Point;
 import org.lwjgl.util.ReadableDimension;
 import org.lwjgl.util.ReadablePoint;
 
-import javax.annotation.Nullable;
 import java.util.Comparator;
 import java.util.Optional;
 
@@ -37,14 +35,14 @@ public class GuiKeyframeTimeline extends AbstractGuiTimeline<GuiKeyframeTimeline
     private final GuiPathing gui;
 
     /**
-     * The keyframe that was last clicked on using the left mouse button.
+     * The keyframe (time on timeline) that was last clicked on using the left mouse button.
      */
-    private Keyframe lastClickedKeyframe;
+    private long lastClickedKeyframe;
 
     /**
-     * Id of the path of {@link #lastClickedKeyframe}.
+     * Path of {@link #lastClickedKeyframe}.
      */
-    private int lastClickedPath;
+    private SPPath lastClickedPath;
 
     /**
      * The time at which {@link #lastClickedKeyframe} was updated.
@@ -89,18 +87,13 @@ public class GuiKeyframeTimeline extends AbstractGuiTimeline<GuiKeyframeTimeline
 
         renderer.bindTexture(ReplayMod.TEXTURE);
 
-        for (Keyframe keyframe : Iterables.concat(Iterables.transform(mod.getCurrentTimeline().getPaths(), new Function<Path, Iterable<Keyframe>>() {
-            @Nullable
-            @Override
-            public Iterable<Keyframe> apply(@Nullable Path input) {
-                assert input != null;
-                return input.getKeyframes();
-            }
-        }))) {
+        SPTimeline timeline = mod.getCurrentTimeline();
+
+        timeline.getTimeline().getPaths().stream().flatMap(path -> path.getKeyframes().stream()).forEach(keyframe -> {
             if (keyframe.getTime() >= startTime && keyframe.getTime() <= endTime) {
                 double relativeTime = keyframe.getTime() - startTime;
                 int positonX = BORDER_LEFT + (int) (relativeTime / visibleTime * visibleWidth) - KEYFRAME_SIZE / 2;
-                int u = KEYFRAME_TEXTURE_X + (mod.getSelectedKeyframe() == keyframe ? KEYFRAME_SIZE : 0);
+                int u = KEYFRAME_TEXTURE_X + (mod.isSelected(keyframe) ? KEYFRAME_SIZE : 0);
                 int v = KEYFRAME_TEXTURE_Y;
                 if (keyframe.getValue(CameraProperties.POSITION).isPresent()) {
                     if (keyframe.getValue(SpectatorProperty.PROPERTY).isPresent()) {
@@ -113,10 +106,10 @@ public class GuiKeyframeTimeline extends AbstractGuiTimeline<GuiKeyframeTimeline
                     renderer.drawTexturedRect(positonX, BORDER_TOP + KEYFRAME_SIZE, u, v, KEYFRAME_SIZE, KEYFRAME_SIZE);
                 }
             }
-        }
+        });
 
         // Draw colored quads on spectator path segments
-        for (PathSegment segment : mod.getCurrentTimeline().getPaths().get(GuiPathing.POSITION_PATH).getSegments()) {
+        for (PathSegment segment : timeline.getPositionPath().getSegments()) {
             if (segment.getInterpolator() == null
                     || !segment.getInterpolator().getKeyframeProperties().contains(SpectatorProperty.PROPERTY)) {
                 continue; // Not a spectator segment
@@ -125,7 +118,7 @@ public class GuiKeyframeTimeline extends AbstractGuiTimeline<GuiKeyframeTimeline
         }
 
         // Draw red quads on time path segments that would require time going backwards
-        for (PathSegment segment : mod.getCurrentTimeline().getPaths().get(GuiPathing.TIME_PATH).getSegments()) {
+        for (PathSegment segment : timeline.getTimePath().getSegments()) {
             long startTimestamp = segment.getStartKeyframe().getValue(TimestampProperty.PROPERTY).orElseThrow(IllegalStateException::new);
             long endTimestamp = segment.getEndKeyframe().getValue(TimestampProperty.PROPERTY).orElseThrow(IllegalStateException::new);
             if (endTimestamp >= startTimestamp) {
@@ -162,29 +155,28 @@ public class GuiKeyframeTimeline extends AbstractGuiTimeline<GuiKeyframeTimeline
      * @param position The raw position
      * @return Pair of path id and keyframe or null when no keyframe was clicked
      */
-    private Pair<Integer, Keyframe> getKeyframe(ReadablePoint position) {
+    private Pair<SPPath, Long> getKeyframe(ReadablePoint position) {
         int time = getTimeAt(position.getX(), position.getY());
         if (time != -1) {
             Point mouse = new Point(position);
             getContainer().convertFor(this, mouse);
             int mouseY = mouse.getY();
             if (mouseY > BORDER_TOP && mouseY < BORDER_TOP + 2 * KEYFRAME_SIZE) {
-                Timeline timeline = gui.getMod().getCurrentTimeline();
-                int path;
+                SPPath path;
                 if (mouseY <= BORDER_TOP + KEYFRAME_SIZE) {
                     // Position keyframe
-                    path = GuiPathing.POSITION_PATH;
+                    path = SPPath.POSITION;
                 } else {
                     // Time keyframe
-                    path = GuiPathing.TIME_PATH;
+                    path = SPPath.TIME;
                 }
                 int visibleTime = (int) (getZoom() * getLength());
-                int tolerance = visibleTime * KEYFRAME_SIZE / (size.getWidth() - BORDER_LEFT - BORDER_RIGHT) / 2;
-                Optional<Keyframe> keyframe = timeline.getPaths().get(path).getKeyframes().stream()
+                int tolerance = visibleTime * KEYFRAME_SIZE / (getLastSize().getWidth() - BORDER_LEFT - BORDER_RIGHT) / 2;
+                Optional<Keyframe> keyframe = gui.getMod().getCurrentTimeline().getPath(path).getKeyframes().stream()
                         .filter(k -> Math.abs(k.getTime() - time) <= tolerance)
                         .sorted(Comparator.comparing(k -> Math.abs(k.getTime() - time)))
                         .findFirst();
-                return Pair.of(path, keyframe.orElse(null));
+                return Pair.of(path, keyframe.map(Keyframe::getTime).orElse(null));
             }
         }
         return Pair.of(null, null);
@@ -193,30 +185,31 @@ public class GuiKeyframeTimeline extends AbstractGuiTimeline<GuiKeyframeTimeline
     @Override
     public boolean mouseClick(ReadablePoint position, int button) {
         int time = getTimeAt(position.getX(), position.getY());
-        Pair<Integer, Keyframe> pathKeyframePair = getKeyframe(position);
+        Pair<SPPath, Long> pathKeyframePair = getKeyframe(position);
         if (pathKeyframePair.getRight() != null) {
+            SPPath path = pathKeyframePair.getLeft();
             // Clicked on keyframe
-            Keyframe keyframe = pathKeyframePair.getRight();
+            long keyframeTime = pathKeyframePair.getRight();
             if (button == 0) { // Left click
                 long now = Minecraft.getSystemTime();
-                if (lastClickedKeyframe == keyframe) {
+                if (lastClickedKeyframe == keyframeTime) {
                     // Clicked the same keyframe again, potentially a double click
                     if (now - lastClickedTime < DOUBLE_CLICK_INTERVAL) {
                         // Yup, double click, open the edit keyframe gui
-                        Path path = gui.getMod().getCurrentTimeline().getPaths().get(pathKeyframePair.getLeft());
-                        gui.openEditKeyframePopup(path, keyframe);
+                        gui.openEditKeyframePopup(path, keyframeTime);
                         return true;
                     }
                 }
                 // Not a double click, just update the click time and selection
                 lastClickedTime = now;
-                lastClickedKeyframe = keyframe;
-                lastClickedPath = pathKeyframePair.getLeft();
-                gui.getMod().setSelectedKeyframe(lastClickedKeyframe);
+                lastClickedKeyframe = keyframeTime;
+                lastClickedPath = path;
+                gui.getMod().setSelected(lastClickedPath, lastClickedKeyframe);
                 // We might be dragging
                 draggingStartX = position.getX();
                 dragging = true;
             } else if (button == 1) { // Right click
+                Keyframe keyframe = gui.getMod().getCurrentTimeline().getKeyframe(path, keyframeTime);
                 for (Property property : keyframe.getProperties()) {
                     applyPropertyToGame(property, keyframe);
                 }
@@ -226,12 +219,11 @@ public class GuiKeyframeTimeline extends AbstractGuiTimeline<GuiKeyframeTimeline
             // Clicked on timeline but not on any keyframe
             if (button == 0) { // Left click
                 setCursorPosition(time);
-                gui.getMod().setSelectedKeyframe(null);
+                gui.getMod().setSelected(null, 0);
             } else if (button == 1) { // Right click
                 if (pathKeyframePair.getLeft() != null) {
                     // Apply the value of the clicked path at the clicked position
-                    Timeline timeline = gui.getMod().getCurrentTimeline();
-                    Path path = timeline.getPaths().get(pathKeyframePair.getLeft());
+                    Path path = gui.getMod().getCurrentTimeline().getPath(pathKeyframePair.getLeft());
                     path.getKeyframes().stream().flatMap(k -> k.getProperties().stream()).distinct().forEach(
                             p -> applyPropertyToGame(p, path, time));
                 }
@@ -280,12 +272,13 @@ public class GuiKeyframeTimeline extends AbstractGuiTimeline<GuiKeyframeTimeline
             }
         }
         if (actuallyDragging) {
+            if (!gui.ensureEntityTracker(() -> mouseDrag(position, button, timeSinceLastCall))) return true;
             // Threshold passed
-            Path path = gui.getMod().getCurrentTimeline().getPaths().get(lastClickedPath);
+            SPTimeline timeline = gui.getMod().getCurrentTimeline();
             Point mouse = new Point(position);
             getContainer().convertFor(this, mouse);
             int mouseX = mouse.getX();
-            int width = size.getWidth();
+            int width = getLastSize().getWidth();
             int bodyWidth = width - BORDER_LEFT - BORDER_RIGHT;
             double segmentLength = getLength() * getZoom();
             double segmentTime =  segmentLength * (mouseX - BORDER_LEFT) / bodyWidth;
@@ -295,24 +288,21 @@ public class GuiKeyframeTimeline extends AbstractGuiTimeline<GuiKeyframeTimeline
             }
 
             // If there already is a keyframe at the target time, then increase the time by one until there is none
-            while (path.getKeyframe(newTime) != null) {
+            while (timeline.getKeyframe(lastClickedPath, newTime) != null) {
                 newTime++;
             }
 
             // First undo any previous changes
             if (draggingChange != null) {
-                draggingChange.undo(gui.getMod().getCurrentTimeline());
+                draggingChange.undo(timeline.getTimeline());
             }
 
             // Move keyframe to new position and
             // store change for later undoing / pushing to history
-            draggingChange = gui.moveKeyframe(path, lastClickedKeyframe, newTime);
+            draggingChange = timeline.moveKeyframe(lastClickedPath, lastClickedKeyframe, newTime);
 
             // Selected keyframe has been replaced
-            gui.getMod().setSelectedKeyframe(path.getKeyframe(newTime));
-
-            // Path has been changed
-            path.updateAll();
+            gui.getMod().setSelected(lastClickedPath, newTime);
         }
         return true;
     }
@@ -321,7 +311,7 @@ public class GuiKeyframeTimeline extends AbstractGuiTimeline<GuiKeyframeTimeline
     public boolean mouseRelease(ReadablePoint position, int button) {
         if (dragging) {
             if (actuallyDragging) {
-                gui.getMod().getCurrentTimeline().pushChange(draggingChange);
+                gui.getMod().getCurrentTimeline().getTimeline().pushChange(draggingChange);
                 draggingChange = null;
                 actuallyDragging = false;
             }