Paper/patches/api/0393-Add-Tick-TemporalUnit.patch

158 lines
5.3 KiB
Diff
Raw Normal View History

2022-11-25 22:05:42 +01:00
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Kieran Wallbanks <kieran.wallbanks@gmail.com>
Date: Fri, 2 Apr 2021 17:28:58 +0100
Subject: [PATCH] Add Tick TemporalUnit
diff --git a/src/main/java/io/papermc/paper/util/Tick.java b/src/main/java/io/papermc/paper/util/Tick.java
new file mode 100644
index 0000000000000000000000000000000000000000..10430f02e1d1e654383154c04473f07469bc7fee
2022-11-25 22:05:42 +01:00
--- /dev/null
+++ b/src/main/java/io/papermc/paper/util/Tick.java
@@ -0,0 +1,95 @@
2022-11-25 22:05:42 +01:00
+package io.papermc.paper.util;
+
+import net.kyori.adventure.util.Ticks;
+import org.jetbrains.annotations.NotNull;
+
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
2022-11-25 22:05:42 +01:00
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalUnit;
+import java.util.Objects;
+
+/**
+ * A TemporalUnit that represents the target length of one server tick. This is defined
+ * as 50 milliseconds. Note that this class is not for measuring the length that a tick
+ * took, rather it is used for simple conversion between times and ticks.
+ * @see #tick()
+ */
+public final class Tick implements TemporalUnit {
+ private static final Tick INSTANCE = new Tick(Ticks.SINGLE_TICK_DURATION_MS);
+
+ private final long milliseconds;
+
+ /**
+ * Gets the instance of the tick temporal unit.
+ * @return the tick instance
+ */
+ public static @NotNull Tick tick() {
+ return INSTANCE;
+ }
+
+ /**
+ * Creates a new tick.
+ * @param length the length of the tick in milliseconds
+ * @see #tick()
+ */
+ private Tick(long length) {
+ this.milliseconds = length;
+ }
+
+ /**
+ * Creates a duration from an amount of ticks. This is shorthand for
+ * {@link Duration#of(long, TemporalUnit)} called with the amount of ticks and
+ * {@link #tick()}.
+ * @param ticks the amount of ticks
+ * @return the duration
+ */
+ public static @NotNull Duration of(long ticks) {
+ return Duration.of(ticks, INSTANCE);
+ }
+
+ /**
+ * Gets the number of whole ticks that occur in the provided duration. Note that this
+ * method returns an {@code int} as this is the unit that Minecraft stores ticks in.
+ * @param duration the duration
+ * @return the number of whole ticks in this duration
+ * @throws ArithmeticException if the duration is zero or an overflow occurs
+ */
+ public int fromDuration(@NotNull Duration duration) {
+ Objects.requireNonNull(duration, "duration cannot be null");
+ return Math.toIntExact(Math.floorDiv(duration.toMillis(), this.milliseconds));
2022-11-25 22:05:42 +01:00
+ }
+
+ @Override
+ public @NotNull Duration getDuration() {
+ return Duration.ofMillis(this.milliseconds);
+ }
+
+ // Note: This is a workaround in order to allow calculations with this duration.
+ // See: Duration#add
+ @Override
+ public boolean isDurationEstimated() {
+ return false;
+ }
+
+ @Override
+ public boolean isDateBased() {
+ return false;
+ }
+
+ @Override
+ public boolean isTimeBased() {
+ return true;
+ }
+
+ @SuppressWarnings("unchecked") // following ChronoUnit#addTo
+ @Override
+ public <R extends Temporal> @NotNull R addTo(@NotNull R temporal, long amount) {
+ return (R) temporal.plus(getDuration().multipliedBy(amount));
2022-11-25 22:05:42 +01:00
+ }
+
+ @Override
+ public long between(@NotNull Temporal start, @NotNull Temporal end) {
+ return start.until(end, ChronoUnit.MILLIS) / this.milliseconds;
2022-11-25 22:05:42 +01:00
+ }
+}
diff --git a/src/test/java/io/papermc/paper/util/TickTest.java b/src/test/java/io/papermc/paper/util/TickTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d6d0564e07c0886648000490337272e1740ea21
2022-11-25 22:05:42 +01:00
--- /dev/null
+++ b/src/test/java/io/papermc/paper/util/TickTest.java
@@ -0,0 +1,44 @@
2022-11-25 22:05:42 +01:00
+package io.papermc.paper.util;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+
2022-11-25 22:05:42 +01:00
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class TickTest {
+
+ @Test
+ public void testTickLength() {
+ assertEquals(50, Duration.of(1, Tick.tick()).toMillis());
+ assertEquals(100, Duration.of(2, Tick.tick()).toMillis());
+ }
+
+ @Test
+ public void testTickFromDuration() {
+ assertEquals(0, Tick.tick().fromDuration(Duration.ofMillis(0)));
+ assertEquals(0, Tick.tick().fromDuration(Duration.ofMillis(10)));
+ assertEquals(1, Tick.tick().fromDuration(Duration.ofMillis(60)));
+ assertEquals(2, Tick.tick().fromDuration(Duration.ofMillis(100)));
+ }
+
+ @Test
+ public void testAddTickToInstant() {
+ Instant now = Instant.now();
+ assertEquals(now, now.plus(0, Tick.tick()));
+ assertEquals(now.plus(50, ChronoUnit.MILLIS), now.plus(1, Tick.tick()));
+ assertEquals(now.plus(100, ChronoUnit.MILLIS), now.plus(2, Tick.tick()));
+ assertEquals(now.plus(150, ChronoUnit.MILLIS), now.plus(3, Tick.tick()));
+ }
+
+ @Test
+ public void testTicksBetweenInstants() {
+ Instant now = Instant.now();
+ assertEquals(0, now.until(now.plus(20, ChronoUnit.MILLIS), Tick.tick()));
+ assertEquals(1, now.until(now.plus(50, ChronoUnit.MILLIS), Tick.tick()));
+ assertEquals(1, now.until(now.plus(60, ChronoUnit.MILLIS), Tick.tick()));
+ assertEquals(2, now.until(now.plus(100, ChronoUnit.MILLIS), Tick.tick()));
+ }
2022-11-25 22:05:42 +01:00
+}