fix: bring changes from 1.20.4 to 1.21.2

Author: hugeblank

gradle.properties

@@ -8,7 +8,7 @@ org.gradle.jvmargs=-Xmx1G
 	loader_version=0.16.10
 
 # Mod Properties
-	mod_version = 1.2.0
+	mod_version = 1.2.1
 	maven_group = dev.hugeblank
 	archives_base_name = asahi
 

src/main/java/dev/hugeblank/asahi/client/InterpolatedTickProperty.java

@@ -0,0 +1,59 @@
+package dev.hugeblank.asahi.client;
+
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.world.tick.TickManager;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class InterpolatedTickProperty {
+
+    private final EvictingList<Double> points = new EvictingList<>(10);
+    private double factor = 1;
+    private double remainder = 0;
+
+    private final String prefix;
+    private final Consumer<Long> setProperty;
+    private final Supplier<Long> getProperty;
+    private final TickManager tickManager;
+
+    public InterpolatedTickProperty(String prefix, Consumer<Long> setProperty, Supplier<Long> getProperty, TickManager tickManager) {
+        this.prefix = prefix;
+        this.setProperty = setProperty;
+        this.getProperty = getProperty;
+        this.tickManager = tickManager;
+    }
+
+    public void tick() {
+        remainder += factor; // add remainder to factor
+        long increment = (long) remainder; // truncate floating value
+        setProperty.accept(getProperty.get() + increment);
+        // subtract the incremented integer, preserving the floating point remainder for later
+        remainder -= increment;
+    }
+
+    public void update(long serverValue) {
+
+        // If the next value would take more than 60 seconds at the current TPS to reach, just skip to the position.
+        if (Math.abs(serverValue-getProperty.get()) >= 60 * tickManager.getTickRate()) {
+            this.factor = 1;
+            setProperty.accept(serverValue);
+        } else {
+            int localDiff = (int) (serverValue - getProperty.get());
+            float minMoveFactor = 1f / tickManager.getTickRate(); // MIN_MOVE_FACTOR
+            points.add((double) (localDiff + tickManager.getTickRate()) / tickManager.getTickRate());
+            double avg = 0, weights = 0; // weighted average
+            int size = points.size();
+            for (int i = 0; i < size; i++) {
+                double weight = size - i + 1;
+                weight *= weight;
+                weights += weight;
+                avg += points.get(i) * weight;
+            }
+            avg /= weights;
+            this.factor = avg < 0 ? Math.min(avg, -minMoveFactor) : Math.max(avg, minMoveFactor);
+            if (FabricLoader.getInstance().isDevelopmentEnvironment())
+                System.out.format("%s: %s server by %d ticks. Speed: %f\n", prefix, (localDiff < 0 ? "ahead of" : "behind"), Math.abs(localDiff), avg);
+        }
+    }
+}

src/main/java/dev/hugeblank/asahi/client/mixin/ClientWorldMixin.java

@@ -1,8 +1,11 @@
 package dev.hugeblank.asahi.client.mixin;
 
-import dev.hugeblank.asahi.client.EvictingList;
-import net.fabricmc.loader.api.FabricLoader;
+import dev.hugeblank.asahi.client.InterpolatedTickProperty;
+import net.minecraft.client.network.ClientPlayNetworkHandler;
+import net.minecraft.client.render.WorldRenderer;
 import net.minecraft.client.world.ClientWorld;
+import net.minecraft.registry.RegistryKey;
+import net.minecraft.registry.entry.RegistryEntry;
 import net.minecraft.world.tick.TickManager;
 import org.spongepowered.asm.mixin.*;
 import org.spongepowered.asm.mixin.injection.At;
@@ -16,57 +19,28 @@ public abstract class ClientWorldMixin{
 
     @Shadow @Final private TickManager tickManager;
 
-    @Shadow private boolean shouldTickTimeOfDay;
-
-    @Unique private final EvictingList<Double> points = new EvictingList<>(10);
-    @Unique private double factor = 0D;
-    @Unique private double remainder = 0D;
+    @Unique private InterpolatedTickProperty timeProperty;
+    @Unique private InterpolatedTickProperty dayTimeProperty;
+    @Unique private boolean tickTimeOfDay = true;
 
+    @Inject(at=@At("TAIL"), method = "<init>")
+    private void init(ClientPlayNetworkHandler networkHandler, ClientWorld.Properties properties, RegistryKey registryRef, RegistryEntry dimensionType, int loadDistance, int simulationDistance, WorldRenderer worldRenderer, boolean debugWorld, long seed, int seaLevel, CallbackInfo ci) {
+        this.timeProperty = new InterpolatedTickProperty("time", this.clientWorldProperties::setTime, this.clientWorldProperties::getTime, tickManager);
+        this.dayTimeProperty = new InterpolatedTickProperty("timeOfDay", this.clientWorldProperties::setTimeOfDay, this.clientWorldProperties::getTimeOfDay, tickManager);
+    }
 
-    // Poor man's non-nuclear redirect
-    @Inject(at=@At("HEAD"), method = "tickTime", cancellable = true, order = 10000)
-    private void tickTime(CallbackInfo ci) {
-        remainder += factor; // add remainder to factor
-        long increment = (long) remainder; // truncate floating value
-        clientWorldProperties.setTime(clientWorldProperties.getTime() + increment);
-        if (this.shouldTickTimeOfDay)
-            clientWorldProperties.setTimeOfDay(clientWorldProperties.getTimeOfDay() + increment);
-        // subtract the incremented integer, preserving the floating point remainder for later
-        remainder -= increment;
+    @Inject(at=@At("HEAD"), method = "tickTime", cancellable = true)
+    public void tickTime(CallbackInfo ci) {
+        timeProperty.tick();
+        if (tickTimeOfDay) dayTimeProperty.tick();
         ci.cancel();
     }
 
     @Inject(at=@At("HEAD"), method = "setTime", cancellable = true, order = 10000)
     public void setTime(long time, long timeOfDay, boolean tickTimeOfDay, CallbackInfo ci) {
-        float tickRate = tickManager.getTickRate(); // Get the TPS
-        int localDiff = (int) (time - clientWorldProperties.getTime());
-        // If the next position is greater than where the cycle would be 60 seconds from now, just snap to the position.
-        // We do this instead of rapidly speeding the cycle up to its true position (i.e. after sleeping).
-        if (Math.abs(localDiff) >= 60*tickRate) {
-            clientWorldProperties.setTime(time);
-            if (tickTimeOfDay || clientWorldProperties.getTimeOfDay() != timeOfDay)
-                // Only snap the time of day when necessary.
-                // (When doDaylightCycle == true, if the time of day is out of sync from the server)
-                clientWorldProperties.setTimeOfDay(timeOfDay);
-        } else {
-            float minMoveFactor = 1f/tickRate; // Create a minimum move factor, so that the sun never appears frozen.
-            points.add((double) (localDiff + tickRate) / tickRate); // Project where the sun will be in the next second
-            // Get the weighted average of the last n ticks
-            // (see EvictingList instantiation for n)
-            double avg = 0, weights = 0;
-            int size = points.size();
-            for (int i = 0; i < size; i++) {
-                double weight = size - i + 1;
-                weight *= weight;
-                weights += weight;
-                avg += points.get(i)*weight;
-            }
-            avg /= weights;
-            factor = avg < 0 ? Math.min(avg, -minMoveFactor) : Math.max(avg, minMoveFactor);
-            if (FabricLoader.getInstance().isDevelopmentEnvironment())
-                System.out.println((localDiff < 0 ? "ahead of" : "behind") + " server by " + Math.abs(localDiff) + " ticks. Speed: " + avg);
-        }
-        this.shouldTickTimeOfDay = tickTimeOfDay;
+        this.tickTimeOfDay = tickTimeOfDay;
+        timeProperty.update(time);
+        dayTimeProperty.update(timeOfDay);
         ci.cancel();
     }
 }