From 44bb5992ce5713a204df76e22b749fbc9df7fb09 Mon Sep 17 00:00:00 2001
From: Kezz <1526243+kezz@users.noreply.github.com>
Date: Fri, 25 Nov 2022 21:05:42 +0000
Subject: [PATCH] Add Tick TemporalUnit (#5445)

---
 LICENSE.md                                   |   1 +
 patches/api/0411-Add-Tick-TemporalUnit.patch | 135 +++++++++++++++++++
 2 files changed, 136 insertions(+)
 create mode 100644 patches/api/0411-Add-Tick-TemporalUnit.patch

diff --git a/LICENSE.md b/LICENSE.md
index b08a4d228..ae592616d 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -52,4 +52,5 @@ Doc <nachito94@msn.com>
 Nick Hensel <nickhensel25@icloud.com>
 vytskalt <vytskalt@protonmail.com>
 TheFruxz <cedricspitzer@outlook.de>
+Kieran Wallbanks <kieran.wallbanks@gmail.com>
 ```
diff --git a/patches/api/0411-Add-Tick-TemporalUnit.patch b/patches/api/0411-Add-Tick-TemporalUnit.patch
new file mode 100644
index 000000000..4b8cbf258
--- /dev/null
+++ b/patches/api/0411-Add-Tick-TemporalUnit.patch
@@ -0,0 +1,135 @@
+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..900f39c0c5c6f4f2c89e0b4dade0d26b367c4f57
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/util/Tick.java
+@@ -0,0 +1,94 @@
++package io.papermc.paper.util;
++
++import net.kyori.adventure.util.Ticks;
++import org.jetbrains.annotations.NotNull;
++
++import java.time.Duration;
++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(), INSTANCE.milliseconds));
++    }
++
++    @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(amount, this);
++    }
++
++    @Override
++    public long between(@NotNull Temporal start, @NotNull Temporal end) {
++        return start.until(end, this);
++    }
++}
+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..9a48f7a82636d4047a3f5fefe69bb88c2f5aaaef
+--- /dev/null
++++ b/src/test/java/io/papermc/paper/util/TickTest.java
+@@ -0,0 +1,23 @@
++package io.papermc.paper.util;
++
++import java.time.Duration;
++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)));
++    }
++}