Forward-Porting 1.18.2 changes

build.gradle

@@ -11,7 +11,7 @@ plugins {
     id "dev.architectury.loom" version "1.3.355" apply false
     id 'io.github.juuxel.loom-vineflower' version '1.11.0' apply false
     // Kotlin
-    id "org.jetbrains.kotlin.jvm" version "1.9.10" apply false
+    id "org.jetbrains.kotlin.jvm" version "2.1.0" apply false
     id 'com.matthewprenger.cursegradle' version '1.4.0' apply false
     id "com.modrinth.minotaur" version "2.4.3" apply false
 }
@@ -132,6 +132,20 @@ subprojects {
                     includeGroup "com.rbasamoyai"
                 }
             }
+            maven { // FTB Stuffs
+                url "https://maven.saps.dev/releases"
+                content {
+                    includeGroup "dev.latvian.mods"
+                    includeGroup "dev.ftb.mods"
+                }
+            }
+            maven { // FTB Stuffs
+                url "https://maven.saps.dev/snapshots"
+                content {
+                    includeGroup "dev.latvian.mods"
+                    includeGroup "dev.ftb.mods"
+                }
+            }
         }
     }
 

common/build.gradle

@@ -1,6 +1,6 @@
 
 dependencies {
-    annotationProcessor(implementation("com.github.LlamaLad7:MixinExtras:0.1.1"))
+    annotationProcessor(implementation("io.github.llamalad7:mixinextras-common:0.3.5"))
 
     compileOnly 'com.google.code.findbugs:jsr305:3.0.2'
     // We depend on fabric loader here to use the fabric @Environment annotations
@@ -11,31 +11,38 @@ dependencies {
 
     modCompileOnly("curse.maven:sodium-394468:3669187")
 
+    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.1.0")
+
     // vs-core
     implementation("org.valkyrienskies.core:impl:${rootProject.vs_core_version}") {
         exclude module: "netty-buffer"
         exclude module: "fastutil"
+        exclude module: "kotlin-stdlib"
     }
 
-    implementation("org.valkyrienskies.core:api:${rootProject.vs_core_version}")
-    implementation("org.valkyrienskies.core:api-game:${rootProject.vs_core_version}")
-    implementation("org.valkyrienskies.core:util:${rootProject.vs_core_version}")
+    implementation("org.valkyrienskies.core:api:${rootProject.vs_core_version}") {
+        exclude module: "kotlin-stdlib"
+    }
+    implementation("org.valkyrienskies.core:api-game:${rootProject.vs_core_version}") {
+        exclude module: "kotlin-stdlib"
+    }
+    implementation("org.valkyrienskies.core:util:${rootProject.vs_core_version}") {
+        exclude module: "kotlin-stdlib"
+    }
 
     // FTB Stuffs
-    modCompileOnly("curse.maven:ftb-util-404465:4210935")
-    modCompileOnly("curse.maven:ftb-teams-404468:4229138")
-    modCompileOnly("curse.maven:ftb-chunks-314906:4229120")
+    modCompileOnly("dev.ftb.mods:ftb-chunks:1802.3.19-build.362") { transitive = false }
 
     // Weather2 1.18
     modCompileOnly("curse.maven:weather-storms-tornadoes-237746:4426524")
 
     //Common create compat,
     //We just use a version from a platform and hope the classes exist on both versions and mixins apply correctly
     modCompileOnly("com.simibubi.create:create-fabric-${minecraft_version}:${create_fabric_version}")
-        { exclude group: 'com.github.AlphaMode', module: 'fakeconfigtoml' }
+        { exclude group: 'com.github.AlphaMode', module: 'fakeconfigtoml'}
     modCompileOnly("net.fabricmc.fabric-api:fabric-api:${fabric_api_version}")
     modCompileOnly("com.jozufozu.flywheel:flywheel-fabric-${minecraft_version}:${flywheel_version_fabric}")
-    modCompileOnly("io.github.fabricators_of_create:Porting-Lib:${port_lib_version}+${minecraft_version}")
+    modCompileOnly("io.github.fabricators_of_create:Porting-Lib:1.2.1451-beta+1.18.2")
     modCompileOnly("com.rbasamoyai:createbigcannons-fabric-${minecraft_version}:${createbigcannons_version}")
 
     //Bluemap fabric 1.18

common/gradle.properties

@@ -1,2 +1 @@
-port_lib_version=1.2.677-beta
 port_lib_hash=cca931b

common/src/main/java/org/valkyrienskies/mod/mixin/client/MixinMinecraft.java

@@ -103,6 +103,17 @@ public ClientShipWorldCore getShipObjectWorld() {
     @Shadow
     public abstract ClientPacketListener getConnection();
 
+    @Inject(
+        method = "tick",
+        at = @At("HEAD")
+    )
+    public void preTick(final CallbackInfo ci) {
+        // Tick the ship world and then drag entities
+        if (!pause && shipObjectWorld != null && level != null && getConnection() != null) {
+            //EntityDragger.INSTANCE.dragEntitiesWithShips(level.entitiesForRendering(), true);
+        }
+    }
+
     @Inject(
         method = "tick",
         at = @At("TAIL")
@@ -112,7 +123,8 @@ public void postTick(final CallbackInfo ci) {
         if (!pause && shipObjectWorld != null && level != null && getConnection() != null) {
             shipObjectWorld.tickNetworking(getConnection().getConnection().getRemoteAddress());
             shipObjectWorld.postTick();
-            EntityDragger.INSTANCE.dragEntitiesWithShips(level.entitiesForRendering());
+            //EntityDragger.INSTANCE.dragEntitiesWithShips(level.entitiesForRendering());
+            EntityDragger.INSTANCE.dragEntitiesWithShips(level.entitiesForRendering(), false);
         }
     }
 

common/src/main/java/org/valkyrienskies/mod/mixin/client/renderer/MixinEntityRenderer.java

@@ -0,0 +1,48 @@
+package org.valkyrienskies.mod.mixin.client.renderer;
+
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.entity.EntityRenderer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.phys.AABB;
+import org.joml.Vector3d;
+import org.joml.Vector3dc;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.valkyrienskies.core.api.ships.ClientShip;
+import org.valkyrienskies.mod.common.VSGameUtilsKt;
+import org.valkyrienskies.mod.common.util.EntityDraggingInformation;
+import org.valkyrienskies.mod.common.util.IEntityDraggingInformationProvider;
+
+@Mixin(EntityRenderer.class)
+public class MixinEntityRenderer {
+
+    /**
+     * This is necessary to avoid the vanilla flickering that occurs when entities are at high speeds.
+     * <p>
+     * Presumably, it is caused by the culling AABB only being updated on a subsequent tick, so we bypass that.
+     * @param instance
+     * @param original
+     * @return
+     */
+    @WrapOperation(method = "shouldRender", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/Entity;getBoundingBoxForCulling()Lnet/minecraft/world/phys/AABB;"))
+    private AABB redirectAABBConstructor(Entity instance, Operation<AABB> original) {
+        if (instance instanceof IEntityDraggingInformationProvider dragProvider && dragProvider.getDraggingInformation().isEntityBeingDraggedByAShip()) {
+            EntityDraggingInformation dragInfo = dragProvider.getDraggingInformation();
+            ClientShip ship = VSGameUtilsKt.getShipObjectWorld((ClientLevel) instance.level).getAllShips().getById(dragInfo.getLastShipStoodOn());
+            if (ship == null) {
+                return original.call(instance);
+            }
+            if (dragInfo.getLastShipStoodOn() != null && (dragInfo.getRelativePositionOnShip() != null || dragInfo.getServerRelativePlayerPosition() != null)) {
+                Vector3dc positionToTransform = dragInfo.bestRelativeEntityPosition();
+                if (positionToTransform != null) {
+                    Vector3dc transformed = ship.getRenderTransform().getShipToWorld().transformPosition(positionToTransform,
+                        new Vector3d());
+                    return instance.getDimensions(instance.getPose()).makeBoundingBox(transformed.x(), transformed.y(), transformed.z()).inflate(0.5D);
+                }
+            }
+        }
+        return original.call(instance);
+    }
+}

common/src/main/java/org/valkyrienskies/mod/mixin/client/renderer/MixinGameRenderer.java

@@ -158,7 +158,7 @@ private void preRender(final float tickDelta, final long startTime, final boolea
                     ((IEntityDraggingInformationProvider) entity).getDraggingInformation();
                 final Long lastShipStoodOn = entityDraggingInformation.getLastShipStoodOn();
                 // Then try getting [entityShouldBeHere] from [entityDraggingInformation]
-                if (lastShipStoodOn != null && entityDraggingInformation.isEntityBeingDraggedByAShip()) {
+                if (lastShipStoodOn != null && entityDraggingInformation.isEntityBeingDraggedByAShip()) { //for testing
                     final ClientShip shipObject =
                         VSGameUtilsKt.getShipObjectWorld(clientWorld).getLoadedShips().getById(lastShipStoodOn);
                     if (shipObject != null) {
@@ -200,6 +200,10 @@ private void preRender(final float tickDelta, final long startTime, final boolea
                     entity.xo = (entityShouldBeHere.x() - (entity.getX() * tickDelta)) / (1.0 - tickDelta);
                     entity.yo = (entityShouldBeHere.y() - (entity.getY() * tickDelta)) / (1.0 - tickDelta);
                     entity.zo = (entityShouldBeHere.z() - (entity.getZ() * tickDelta)) / (1.0 - tickDelta);
+                    //why the fuck do we do this
+
+                    //what if i just...
+                    //dont
                 }
             }
         }

common/src/main/java/org/valkyrienskies/mod/mixin/entity/MixinEntity.java

@@ -5,7 +5,9 @@
 import net.minecraft.CrashReport;
 import net.minecraft.CrashReportCategory;
 import net.minecraft.ReportedException;
+import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.util.Mth;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.EntityType;
@@ -33,6 +35,7 @@
 import org.valkyrienskies.core.api.ships.properties.ShipTransform;
 import org.valkyrienskies.mod.common.entity.ShipMountedToData;
 import org.valkyrienskies.mod.common.VSGameUtilsKt;
+import org.valkyrienskies.mod.common.util.EntityDragger;
 import org.valkyrienskies.mod.common.util.EntityDraggingInformation;
 import org.valkyrienskies.mod.common.util.IEntityDraggingInformationProvider;
 import org.valkyrienskies.mod.common.util.VectorConversionsMCKt;
@@ -127,11 +130,67 @@ private void preGetEyePosition(final float partialTicks, final CallbackInfoRetur
 
     /**
      * @reason Needed for players to pick blocks correctly when mounted to a ship
+     *
+     * Needed, because before we only fixed the clientside one.
+     */
+    @Inject(method = "getEyePosition()Lnet/minecraft/world/phys/Vec3;", at = @At("HEAD"), cancellable = true)
+    private void preGetEyePositionServer(final CallbackInfoReturnable<Vec3> cir) {
+        final ShipMountedToData shipMountedToData = VSGameUtilsKt.getShipMountedToData(Entity.class.cast(this), null);
+        if (shipMountedToData == null) {
+            return;
+        }
+        final LoadedShip shipMountedTo = shipMountedToData.getShipMountedTo();
+
+        final ShipTransform shipTransform;
+        if (shipMountedTo instanceof ClientShip) {
+            shipTransform = ((ClientShip) shipMountedTo).getRenderTransform();
+        } else {
+            shipTransform = shipMountedTo.getShipTransform();
+        }
+        final Vector3dc basePos = shipTransform.getShipToWorldMatrix()
+            .transformPosition(shipMountedToData.getMountPosInShip(), new Vector3d());
+        final Vector3dc eyeRelativePos = shipTransform.getShipCoordinatesToWorldCoordinatesRotation().transform(
+            new Vector3d(0.0, getEyeHeight(), 0.0)
+        );
+        final Vec3 newEyePos = VectorConversionsMCKt.toMinecraft(basePos.add(eyeRelativePos, new Vector3d()));
+        cir.setReturnValue(newEyePos);
+    }
+
+    /**
+     * @reason Needed for players to pick blocks correctly when mounted to a ship
+     *
+     * Additionally, this has to have dragging information included or it breaks. This is because of reasons that I literally
+     * do not know or understand, but minecraft's rendering pipeline is like that.
      */
     @Inject(method = "calculateViewVector", at = @At("HEAD"), cancellable = true)
     private void preCalculateViewVector(final float xRot, final float yRot, final CallbackInfoReturnable<Vec3> cir) {
         final LoadedShip shipMountedTo = VSGameUtilsKt.getShipMountedTo(Entity.class.cast(this));
         if (shipMountedTo == null) {
+            if (Entity.class.cast(this) instanceof final ServerPlayer sPlayer && sPlayer instanceof final IEntityDraggingInformationProvider dragProvider) {
+                if (dragProvider.getDraggingInformation().isEntityBeingDraggedByAShip() && dragProvider.getDraggingInformation().getServerRelativePlayerYaw() != null) {
+                    final Ship shipDraggedBy = VSGameUtilsKt.getAllShips(level).getById(dragProvider.getDraggingInformation().getLastShipStoodOn());
+                    if (shipDraggedBy != null) {
+                        final float realYRot = (float) EntityDragger.INSTANCE.serversideWorldEyeRotationOrDefault(sPlayer, shipDraggedBy, yRot);
+                        final float f = xRot * (float) (Math.PI / 180.0);
+                        final float g = -realYRot * (float) (Math.PI / 180.0);
+                        final float h = Mth.cos(g);
+                        final float i = Mth.sin(g);
+                        final float j = Mth.cos(f);
+                        final float k = Mth.sin(f);
+                        final Vector3dc originalViewVector = new Vector3d(i * j, -k, h * j);
+
+                        final ShipTransform shipTransform;
+                        if (shipDraggedBy instanceof ClientShip) {
+                            shipTransform = ((ClientShip) shipDraggedBy).getRenderTransform();
+                        } else {
+                            shipTransform = shipDraggedBy.getShipTransform();
+                        }
+                        final Vec3 newViewVector = VectorConversionsMCKt.toMinecraft(
+                            shipTransform.getShipCoordinatesToWorldCoordinatesRotation().transform(originalViewVector, new Vector3d()));
+                        cir.setReturnValue(newViewVector);
+                    }
+                }
+            }
             return;
         }
         final float f = xRot * (float) (Math.PI / 180.0);
@@ -153,6 +212,28 @@ private void preCalculateViewVector(final float xRot, final float yRot, final Ca
         cir.setReturnValue(newViewVector);
     }
 
+    /**
+     * @reason Without this and that other mixin, things don't render correctly at high speeds.
+     * @see org.valkyrienskies.mod.mixin.client.renderer.MixinEntityRenderer
+     */
+    @Inject(method = "shouldRender", at = @At("HEAD"), cancellable = true)
+    private void onShouldRender(double d, double e, double f, CallbackInfoReturnable<Boolean> cir) {
+        if (this.draggingInformation.isEntityBeingDraggedByAShip() && this.level.isClientSide) {
+            final ClientShip ship = VSGameUtilsKt.getShipObjectWorld((ClientLevel) this.level).getAllShips().getById(this.draggingInformation.getLastShipStoodOn());
+            if (ship != null) {
+                final ShipTransform shipTransform = ship.getRenderTransform();
+                if (this.draggingInformation.getRelativePositionOnShip() != null) {
+                    Vector3dc redir = shipTransform.getShipToWorld().transformPosition(this.draggingInformation.getRelativePositionOnShip(), new Vector3d());
+                    double distX = redir.x() - d;
+                    double distY = redir.y() - e;
+                    double distZ = redir.z() - f;
+                    double sqrDist = distX * distX + distY * distY + distZ * distZ;
+                    cir.setReturnValue(shouldRenderAtSqrDistance(sqrDist));
+                }
+            }
+        }
+    }
+
     // region shadow functions and fields
     @Shadow
     public Level level;
@@ -183,6 +264,12 @@ private void preCalculateViewVector(final float xRot, final float yRot, final Ca
     @Shadow
     public abstract EntityType<?> getType();
 
+    @Shadow
+    private float yRot;
+
+    @Shadow
+    public abstract boolean shouldRenderAtSqrDistance(double d);
+
     @Override
     @NotNull
     public EntityDraggingInformation getDraggingInformation() {

common/src/main/java/org/valkyrienskies/mod/mixin/feature/ai/goal/JitteredLinearRetryAccessor.java

@@ -0,0 +1,14 @@
+package org.valkyrienskies.mod.mixin.feature.ai.goal;
+
+import java.util.Random;
+import net.minecraft.world.entity.ai.behavior.AcquirePoi.JitteredLinearRetry;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(JitteredLinearRetry.class)
+public interface JitteredLinearRetryAccessor {
+    @Invoker("<init>")
+    static JitteredLinearRetry create(Random random, long l) {
+        throw new AssertionError();
+    }
+}

common/src/main/java/org/valkyrienskies/mod/mixin/feature/ai/goal/MixinMoveToBlockGoal.java

@@ -0,0 +1,25 @@
+package org.valkyrienskies.mod.mixin.feature.ai.goal;
+
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Position;
+import net.minecraft.world.entity.PathfinderMob;
+import net.minecraft.world.entity.ai.goal.MoveToBlockGoal;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.valkyrienskies.mod.common.VSGameUtilsKt;
+
+@Mixin(MoveToBlockGoal.class)
+public class MixinMoveToBlockGoal {
+    @Shadow
+    @Final
+    protected PathfinderMob mob;
+
+    @WrapOperation(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/core/BlockPos;closerToCenterThan(Lnet/minecraft/core/Position;D)Z"))
+    private boolean onCloserToCenterThan(BlockPos instance, Position position, double v, Operation<Boolean> original) {
+        return original.call(new BlockPos(VSGameUtilsKt.toWorldCoordinates(this.mob.level, instance)), position, v);
+    }
+}

common/src/main/java/org/valkyrienskies/mod/mixin/feature/ai/goal/MixinMoveToTargetSink.java

@@ -0,0 +1,20 @@
+package org.valkyrienskies.mod.mixin.feature.ai.goal;
+
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import com.llamalad7.mixinextras.sugar.Local;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Vec3i;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.ai.behavior.MoveToTargetSink;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.valkyrienskies.mod.common.VSGameUtilsKt;
+
+@Mixin(MoveToTargetSink.class)
+public class MixinMoveToTargetSink {
+    @WrapOperation(method = "reachedTarget", at = @At(value = "INVOKE", target = "Lnet/minecraft/core/BlockPos;distManhattan(Lnet/minecraft/core/Vec3i;)I"))
+    private int onDistManhattan(BlockPos instance, Vec3i vec3i, Operation<Integer> original, @Local(argsOnly = true) Mob mob) {
+        return original.call(new BlockPos(VSGameUtilsKt.toWorldCoordinates(mob.level, instance)), vec3i);
+    }
+}

common/src/main/java/org/valkyrienskies/mod/mixin/feature/ai/goal/MixinValidateNearbyPoi.java

@@ -0,0 +1,21 @@
+package org.valkyrienskies.mod.mixin.feature.ai.goal;
+
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import com.llamalad7.mixinextras.sugar.Local;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Position;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.ai.behavior.ValidateNearbyPoi;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.valkyrienskies.mod.common.VSGameUtilsKt;
+
+@Mixin(ValidateNearbyPoi.class)
+public class MixinValidateNearbyPoi {
+    @WrapOperation(method = "checkExtraStartConditions", at = @At(value = "INVOKE", target = "Lnet/minecraft/core/BlockPos;closerToCenterThan(Lnet/minecraft/core/Position;D)Z"))
+    private boolean onCloserToCenterThan(BlockPos instance, Position position, double v, Operation<Boolean> original, @Local
+        LivingEntity livingEntity) {
+        return original.call(new BlockPos(VSGameUtilsKt.toWorldCoordinates(livingEntity.level, instance)), position, v);
+    }
+}