[PlaybackSerialiser] Added support for relative coord input (MinecraftTAS#184)

- Added more constructors for PlaybackLoadException
- Added tests for coord input

Author: ScribbleTAS

src/main/java/com/minecrafttas/tasmod/playback/tasfile/exception/PlaybackLoadException.java

@@ -1,16 +1,55 @@
 package com.minecrafttas.tasmod.playback.tasfile.exception;
 
+import com.minecrafttas.tasmod.TASmod;
+
 public class PlaybackLoadException extends RuntimeException {
 
+	public PlaybackLoadException(long tick, int subtick, String msg) {
+		this(printTick(tick, subtick)+msg);
+	}
+	
 	public PlaybackLoadException(String msg) {
 		super(msg);
 	}
 
+	public PlaybackLoadException(long tick, int subtick, String msg, Object... args) {
+		this(printTick(tick, subtick)+msg, args);
+	}
+	
 	public PlaybackLoadException(String msg, Object... args) {
 		super(String.format(msg, args));
 	}
 
+	public PlaybackLoadException(long tick, int subtick, Throwable cause) {
+		this(printTick(tick, subtick), cause);
+	}
+	
 	public PlaybackLoadException(Throwable cause) {
 		super(cause);
 	}
+
+	public PlaybackLoadException(long tick, int subtick, Throwable cause, String msg) {
+		this(cause, printTick(tick, subtick)+msg);
+	}
+	
+	public PlaybackLoadException(Throwable cause, String msg) {
+		super(msg, cause, false, false);
+	}
+	
+	public PlaybackLoadException(long tick, int subtick, Throwable cause, String msg, Object... args) {
+		this(cause, printTick(tick, subtick)+msg, args);
+	}
+	
+	public PlaybackLoadException(Throwable cause, String msg, Object... args) {
+		this(cause, String.format(msg, args));
+	}
+	
+	private static String printTick(long tick, int subtick) {
+		return String.format("Tick %s, Subtick %s: ", tick, subtick);
+	}
+	
+	@Override
+	public void printStackTrace() {
+		TASmod.LOGGER.catching(this);;
+	}
 }

src/main/java/com/minecrafttas/tasmod/playback/tasfile/flavor/SerialiserFlavorBase.java

@@ -35,7 +35,7 @@ public abstract class SerialiserFlavorBase {
 	/**
 	 * Debug subtick field for error handling
 	 */
-	protected Integer currentSubtick = null;
+	protected int currentSubtick = 0;
 
 	public abstract String flavorName();
 
@@ -256,7 +256,7 @@ protected void mergeInputs(BigArrayList<String> out, List<String> serialisedKeyb
 
 			out.add(String.format("\t%s|%s|%s|%s", currentSubtick, kb, ms, ca));
 		}
-		currentSubtick = null;
+		currentSubtick = 0;
 	}
 
 	protected String getOrEmpty(String string) {
@@ -267,7 +267,7 @@ protected String getOrEmpty(String string) {
 	 * Joins strings together but ignores empty strings
 	 * 
 	 * @param delimiter The delimiter of the joined string
-	 * @param args The strings to join
+	 * @param args      The strings to join
 	 * @return Joined string
 	 */
 	protected String joinNotEmpty(String delimiter, Iterable<String> args) {
@@ -302,6 +302,8 @@ protected String joinNotEmpty(String delimiter, String... args) {
 	 * 
 	 */
 
+	private TickContainer previousTickContainer = null;
+
 	public boolean deserialiseFlavorName(List<String> headerLines) {
 		for (String line : headerLines) {
 			Matcher matcher = extract("^Flavor: " + flavorName(), line);
@@ -397,9 +399,11 @@ public BigArrayList<TickContainer> deserialise(BigArrayList<String> lines, long
 			List<String> tick = new ArrayList<>();
 			// Extract the tick and set the index
 			i = extractContainer(tick, lines, i);
+			currentTick = i;
 			// Extract container
 			deserialiseContainer(out, tick);
 		}
+		previousTickContainer = null;
 		return out;
 	}
 
@@ -456,6 +460,8 @@ protected void deserialiseContainer(BigArrayList<TickContainer> out, List<String
 		TASmodRegistry.PLAYBACK_FILE_COMMAND.handleOnDeserialiseInline(currentTick, deserialisedContainer, inlineFileCommands);
 		TASmodRegistry.PLAYBACK_FILE_COMMAND.handleOnDeserialiseEndline(currentTick, deserialisedContainer, endlineFileCommands);
 
+		previousTickContainer = deserialisedContainer;
+
 		out.add(deserialisedContainer);
 	}
 
@@ -503,13 +509,14 @@ protected String deserialiseFileCommands(String comment, List<PlaybackFileComman
 			deserialisedFileCommands.add(new PlaybackFileCommand(name, args));
 			comment = matcher.replaceFirst("");
 		}
-		
+
 		return comment;
 	}
 
 	protected VirtualKeyboard deserialiseKeyboard(List<String> keyboardStrings) {
 		VirtualKeyboard out = new VirtualKeyboard();
 
+		currentSubtick = 0;
 		for (String line : keyboardStrings) {
 			Matcher matcher = extract("(.*?);(.*)", line);
 			if (matcher.find()) {
@@ -519,13 +526,18 @@ protected VirtualKeyboard deserialiseKeyboard(List<String> keyboardStrings) {
 				int[] keycodes = deserialiseVirtualKey(keys, VirtualKey.ZERO);
 				out.updateFromState(keycodes, chars);
 			}
+			currentSubtick++;
 		}
 		return out;
 	}
 
 	protected VirtualMouse deserialiseMouse(List<String> mouseStrings) {
 		VirtualMouse out = new VirtualMouse();
 
+		currentSubtick = 0;
+		Integer previousCursorX = previousTickContainer == null? null : previousTickContainer.getMouse().getCursorX();
+		Integer previousCursorY = previousTickContainer== null? null : previousTickContainer.getMouse().getCursorY();
+		
 		for (String line : mouseStrings) {
 			Matcher matcher = extract("(.*?);(.+)", line);
 			if (matcher.find()) {
@@ -538,51 +550,43 @@ protected VirtualMouse deserialiseMouse(List<String> mouseStrings) {
 				Integer cursorY;
 
 				if (functions.length == 3) {
-					try {
-						scrollwheel = Integer.parseInt(functions[0]);
-						cursorX = Integer.parseInt(functions[1]);
-						cursorY = Integer.parseInt(functions[2]);
-					} catch (NumberFormatException e) {
-						throw new PlaybackLoadException(e);
-					}
+					scrollwheel = parseInt("scrollwheel", functions[0]);
+					cursorX = deserialiseRelativeInt("cursorX", functions[1], previousCursorX);
+					cursorY = deserialiseRelativeInt("cursorY", functions[2], previousCursorY);
 				} else {
 					throw new PlaybackLoadException("Mouse functions do not have the correct length");
 				}
 
 				out.updateFromState(keycodes, scrollwheel, cursorX, cursorY);
+				
+				previousCursorX = cursorX;
+				previousCursorY = cursorY;
 			}
+			currentSubtick++;
 		}
 		return out;
 	}
 
 	protected VirtualCameraAngle deserialiseCameraAngle(List<String> cameraAngleStrings) {
 		VirtualCameraAngle out = new VirtualCameraAngle();
 
+		currentSubtick = 0;
+		Float previousPitch = previousTickContainer == null ? null : previousTickContainer.getCameraAngle().getPitch();
+		Float previousYaw = previousTickContainer == null ? null : previousTickContainer.getCameraAngle().getYaw();
+		
 		for (String line : cameraAngleStrings) {
 			Matcher matcher = extract("(.+?);(.+)", line);
 
 			if (matcher.find()) {
 				String cameraPitchString = matcher.group(1);
 				String cameraYawString = matcher.group(2);
 
-				float cameraPitch;
-				float cameraYaw;
-
-				if (isFloat(cameraPitchString))
-					cameraPitch = Float.parseFloat(cameraPitchString);
-				else
-					throw new PlaybackLoadException("The camera pitch is not valid");
-
-				if (isFloat(cameraYawString))
-					cameraYaw = Float.parseFloat(cameraYawString);
-				else
-					throw new PlaybackLoadException("The camera yaw is not valid");
+				float cameraPitch = deserialiseRelativeFloat("camera pitch", cameraPitchString, previousPitch);
+				float cameraYaw = deserialiseRelativeFloat("camera yaw", cameraYawString, previousYaw);
 
 				out.updateFromState(cameraPitch, cameraYaw);
-
-			} else {
-				throw new PlaybackLoadException("The cameraAngle is not valid");
 			}
+			currentSubtick++;
 		}
 		return out;
 	}
@@ -614,6 +618,54 @@ protected int[] deserialiseVirtualKey(String[] keyString, VirtualKey defaultKey)
 		return out;
 	}
 
+	protected int parseInt(String name, String intstring) {
+		try {
+			return Integer.parseInt(intstring);
+		} catch (NumberFormatException e) {
+			throw new PlaybackLoadException(currentTick, currentSubtick, e, "Can't parse integer in %s", name);
+		}
+	}
+
+	protected int deserialiseRelativeInt(String name, String intstring, Integer previous) {
+		int out = 0;
+		if(intstring.startsWith("~")) {
+			intstring = intstring.replace("~", "");
+			int relative = parseInt(name, intstring);
+			if(previous != null) {
+				out = previous + relative;
+			} else {
+				throw new PlaybackLoadException(currentTick, currentSubtick, "Can't process relative value ~%s in %s. Previous value for comparing is not available", intstring, name);
+			}
+		} else {
+			out = parseInt(name, intstring);
+		}
+		return out;
+	}
+	
+	protected float parseFloat(String name, String floatstring) {
+		try {
+			return Float.parseFloat(floatstring);
+		} catch (NumberFormatException e) {
+			throw new PlaybackLoadException(currentTick, currentSubtick, e, "Can't parse float in %s", name);
+		}
+	}
+
+	protected float deserialiseRelativeFloat(String name, String floatstring, Float previous) {
+		float out = 0;
+		if(floatstring.startsWith("~")) {
+			floatstring = floatstring.replace("~", "");
+			float relative = parseFloat(name, floatstring);
+			if(previous != null) {
+				out = previous + relative;
+			} else {
+				throw new PlaybackLoadException(currentTick, currentSubtick, "Can't process relative value ~%s in %s. Previous value for comparing is not available", floatstring, name);
+			}
+		} else {
+			out = parseFloat(name, floatstring);
+		}
+		return out;
+	}
+	
 	protected void splitInputs(List<String> lines, List<String> serialisedKeyboard, List<String> serialisedMouse, List<String> serialisedCameraAngle, List<String> commentsAtEnd, List<List<PlaybackFileCommand>> endlineFileCommands) {
 
 		for (String line : lines) {
@@ -635,10 +687,10 @@ protected void splitInputs(List<String> lines, List<String> serialisedKeyboard,
 			List<PlaybackFileCommand> deserialisedFileCommands = new ArrayList<>();
 			String endlineComment = line.substring(tickMatcher.group(0).length());
 			commentsAtEnd.add(deserialiseEndlineComment(endlineComment, deserialisedFileCommands));
-			
-			if(deserialisedFileCommands.isEmpty())
+
+			if (deserialisedFileCommands.isEmpty())
 				deserialisedFileCommands = null;
-			
+
 			endlineFileCommands.add(deserialisedFileCommands);
 		}
 	}

src/test/java/tasmod/playback/tasfile/SerialiserFlavorBaseTest.java

@@ -627,6 +627,78 @@ void testIsFloat() {
 		assertTrue(isFloat("-145.23"));
 		assertTrue(isFloat(Long.toString(Integer.MAX_VALUE + 1L)));
 	}
+	
+	@Test
+	void testParseInt() {
+		int actual = parseInt("testParseInt", "12");
+		assertEquals(12, actual);
+		
+		this.currentTick = 13;
+		this.currentSubtick = 1;
+		Throwable t = assertThrows(PlaybackLoadException.class, ()->{
+			parseInt("testParseInt", "12.1");
+		});
+		
+		assertEquals("Tick 13, Subtick 1: Can't parse integer in testParseInt", t.getMessage());
+		assertEquals(NumberFormatException.class, t.getCause().getClass());
+		assertEquals("For input string: \"12.1\"", t.getCause().getMessage());
+		this.currentTick = 0;
+		this.currentSubtick = 0;
+	}
+	
+	@Test
+	void testParseFloat() {
+		float actual = parseFloat("testParseFloat", "12.1");
+		assertEquals(12.1f, actual);
+		
+		this.currentTick = 15;
+		this.currentSubtick = 6;
+		Throwable t = assertThrows(PlaybackLoadException.class, ()->{
+			parseFloat("testParseFloat", "12.123h");
+		});
+		
+		assertEquals("Tick 15, Subtick 6: Can't parse float in testParseFloat", t.getMessage());
+		assertEquals(NumberFormatException.class, t.getCause().getClass());
+		assertEquals("For input string: \"12.123h\"", t.getCause().getMessage());
+		this.currentTick = 0;
+		this.currentSubtick = 0;
+	}
+	
+	@Test
+	void testDeserialiseRelativeInt() {
+		int actual = deserialiseRelativeInt("testParseRelativeInt", "12", null);
+		assertEquals(12, actual);
+		
+		actual = deserialiseRelativeInt("test", "~2", 14);
+		assertEquals(16, actual);
+		
+		this.currentTick = 23;
+		this.currentSubtick = 11;
+		Throwable t = assertThrows(PlaybackLoadException.class, ()->{
+			deserialiseRelativeInt("testParseRelativeInt", "~12", null);
+		});
+		assertEquals("Tick 23, Subtick 11: Can't process relative value ~12 in testParseRelativeInt. Previous value for comparing is not available", t.getMessage());
+		this.currentTick = 0;
+		this.currentSubtick = 0;
+	}
+	
+	@Test
+	void testDeserialiseRelativeFloat() {
+		float actual = deserialiseRelativeFloat("testParseRelativeFloat", "12.2", null);
+		assertEquals(12.2f, actual);
+		
+		actual = deserialiseRelativeFloat("test", "~2.4", 14.4f);
+		assertEquals(16.8f, actual);
+		
+		this.currentTick = 20;
+		this.currentSubtick = 2;
+		Throwable t = assertThrows(PlaybackLoadException.class, ()->{
+			deserialiseRelativeFloat("testParseRelativeFloat", "~12.3", null);
+		});
+		assertEquals("Tick 20, Subtick 2: Can't process relative value ~12.3 in testParseRelativeFloat. Previous value for comparing is not available", t.getMessage());
+		this.currentTick = 0;
+		this.currentSubtick = 0;
+	}
 
 	@Test
 	void testStringPaddingEven() {