Significant Projectile Simulator/Trajectories improvements (#5999)

- The projectile simulator is now perfectly accurate (almost, apart from server desyncs and certain edge cases)
- Most of the simulator bugs should be fixed
- Now predicts piercing arrows (only for held crossbows) and projectiles getting deflected (breeze, shield, world border)
- Added a new setting to the Trajectories module to skip rendering the first few ticks of the path for better visibility

Author: Wide-Cat

src/main/java/meteordevelopment/meteorclient/mixin/Vec3dMixin.java

@@ -19,20 +19,26 @@ public abstract class Vec3dMixin implements IVec3d {
     @Shadow @Final @Mutable public double z;
 
     @Override
-    public void meteor$set(double x, double y, double z) {
+    public Vec3d meteor$set(double x, double y, double z) {
         this.x = x;
         this.y = y;
         this.z = z;
+
+        return (Vec3d) (Object) this;
     }
 
     @Override
-    public void meteor$setXZ(double x, double z) {
+    public Vec3d meteor$setXZ(double x, double z) {
         this.x = x;
         this.z = z;
+
+        return (Vec3d) (Object) this;
     }
 
     @Override
-    public void meteor$setY(double y) {
+    public Vec3d meteor$setY(double y) {
         this.y = y;
+
+        return (Vec3d) (Object) this;
     }
 }

src/main/java/meteordevelopment/meteorclient/mixininterface/IVec3d.java

@@ -5,21 +5,27 @@
 
 package meteordevelopment.meteorclient.mixininterface;
 
+import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.math.Vec3i;
 import org.joml.Vector3d;
 
+@SuppressWarnings("UnusedReturnValue")
 public interface IVec3d {
-    void meteor$set(double x, double y, double z);
+    Vec3d meteor$set(double x, double y, double z);
 
-    default void meteor$set(Vec3i vec) {
-        meteor$set(vec.getX(), vec.getY(), vec.getZ());
+    default Vec3d meteor$set(Vec3i vec) {
+        return meteor$set(vec.getX(), vec.getY(), vec.getZ());
     }
 
-    default void meteor$set(Vector3d vec) {
-        meteor$set(vec.x, vec.y, vec.z);
+    default Vec3d meteor$set(Vector3d vec) {
+        return meteor$set(vec.x, vec.y, vec.z);
     }
 
-    void meteor$setXZ(double x, double z);
+    default Vec3d meteor$set(Vec3d pos) {
+        return meteor$set(pos.x, pos.y, pos.z);
+    }
+
+    Vec3d meteor$setXZ(double x, double z);
 
-    void meteor$setY(double y);
+    Vec3d meteor$setY(double y);
 }

src/main/java/meteordevelopment/meteorclient/systems/modules/combat/ArrowDodge.java

@@ -9,12 +9,13 @@
 import meteordevelopment.meteorclient.settings.*;
 import meteordevelopment.meteorclient.systems.modules.Categories;
 import meteordevelopment.meteorclient.systems.modules.Module;
-import meteordevelopment.meteorclient.utils.entity.ProjectileEntitySimulator;
+import meteordevelopment.meteorclient.utils.entity.simulator.ProjectileEntitySimulator;
 import meteordevelopment.meteorclient.utils.misc.Pool;
 import meteordevelopment.orbit.EventHandler;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.projectile.ArrowEntity;
 import net.minecraft.entity.projectile.ProjectileEntity;
+import net.minecraft.entity.projectile.SpectralArrowEntity;
 import net.minecraft.network.packet.c2s.play.PlayerMoveC2SPacket;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
@@ -54,13 +55,6 @@ public class ArrowDodge extends Module {
         .build()
     );
 
-    private final Setting<Boolean> accurate = sgGeneral.add(new BoolSetting.Builder()
-        .name("accurate")
-        .description("Whether or not to calculate more accurate.")
-        .defaultValue(false)
-        .build()
-    );
-
     private final Setting<Boolean> groundCheck = sgGeneral.add(new BoolSetting.Builder()
         .name("ground-check")
         .description("Tries to prevent you from falling to your death.")
@@ -78,7 +72,7 @@ public class ArrowDodge extends Module {
     private final Setting<Boolean> ignoreOwn = sgGeneral.add(new BoolSetting.Builder()
         .name("ignore-own")
         .description("Ignore your own projectiles.")
-        .defaultValue(false)
+        .defaultValue(true)
         .build()
     );
 
@@ -116,16 +110,16 @@ private void onTick(TickEvent.Pre event) {
 
         for (Entity e : mc.world.getEntities()) {
             if (!(e instanceof ProjectileEntity projectile)) continue;
-            if (!allProjectiles.get() && !(projectile instanceof ArrowEntity)) continue;
+            if (!allProjectiles.get() && !(projectile instanceof ArrowEntity || projectile instanceof SpectralArrowEntity)) continue;
             if (ignoreOwn.get()) {
                 Entity owner = projectile.getOwner();
                 if (owner != null && owner.getUuid().equals(mc.player.getUuid())) continue;
             }
 
-            if (!simulator.set(projectile, accurate.get())) continue;
+            if (!simulator.set(projectile)) continue;
             for (int i = 0; i < (simulationSteps.get() > 0 ? simulationSteps.get() : Integer.MAX_VALUE); i++) {
                 points.add(vec3s.get().set(simulator.pos));
-                if (simulator.tick() != null) break;
+                if (simulator.tick().shouldStop) break;
             }
         }
 

src/main/java/meteordevelopment/meteorclient/systems/modules/render/Trajectories.java

@@ -11,14 +11,16 @@
 import meteordevelopment.meteorclient.systems.modules.Categories;
 import meteordevelopment.meteorclient.systems.modules.Module;
 import meteordevelopment.meteorclient.utils.Utils;
-import meteordevelopment.meteorclient.utils.entity.ProjectileEntitySimulator;
+import meteordevelopment.meteorclient.utils.entity.simulator.ProjectileEntitySimulator;
+import meteordevelopment.meteorclient.utils.entity.simulator.SimulationStep;
 import meteordevelopment.meteorclient.utils.misc.Pool;
 import meteordevelopment.meteorclient.utils.render.color.SettingColor;
 import meteordevelopment.orbit.EventHandler;
 import net.minecraft.enchantment.Enchantments;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.entity.projectile.ProjectileEntity;
+import net.minecraft.entity.projectile.TridentEntity;
 import net.minecraft.entity.projectile.WitherSkullEntity;
 import net.minecraft.item.*;
 import net.minecraft.registry.Registries;
@@ -86,6 +88,14 @@ public class Trajectories extends Module {
 
     // Render
 
+    private final Setting<Integer> ignoreFirstTicks = sgRender.add(new IntSetting.Builder()
+        .name("ignore-rendering-first-ticks")
+        .description("Ignores rendering the first given ticks, to make the rest of the path more visible.")
+        .defaultValue(3)
+        .min(0)
+        .build()
+    );
+
     private final Setting<ShapeMode> shapeMode = sgRender.add(new EnumSetting.Builder<ShapeMode>()
         .name("shape-mode")
         .description("How the shapes are rendered.")
@@ -189,22 +199,25 @@ private void calculatePath(PlayerEntity player, float tickDelta) {
 
         // Calculate paths
         if (!simulator.set(player, itemStack, 0, accurate.get(), tickDelta)) return;
-        getEmptyPath().calculate();
+        Path p = getEmptyPath().calculate();
+        if (player == mc.player) p.ignoreFirstTicks();
 
         if (itemStack.getItem() instanceof CrossbowItem && Utils.hasEnchantment(itemStack, Enchantments.MULTISHOT)) {
             if (!simulator.set(player, itemStack, MULTISHOT_OFFSET, accurate.get(), tickDelta)) return; // left multishot arrow
-            getEmptyPath().calculate();
+            p = getEmptyPath().calculate();
+            if (player == mc.player) p.ignoreFirstTicks();
 
             if (!simulator.set(player, itemStack, -MULTISHOT_OFFSET, accurate.get(), tickDelta)) return; // right multishot arrow
-            getEmptyPath().calculate();
+            p = getEmptyPath().calculate();
+            if (player == mc.player) p.ignoreFirstTicks();
         }
     }
 
     private void calculateFiredPath(Entity entity, double tickDelta) {
         for (Path path : paths) path.clear();
 
         // Calculate paths
-        if (!simulator.set(entity, accurate.get())) return;
+        if (!simulator.set(entity)) return;
         getEmptyPath().setStart(entity, tickDelta).calculate();
     }
 
@@ -221,7 +234,10 @@ private void onRender(Render3DEvent event) {
 
         if (firedProjectiles.get()) {
             for (Entity entity : mc.world.getEntities()) {
-                if (entity instanceof ProjectileEntity && (!ignoreWitherSkulls.get() || !(entity instanceof WitherSkullEntity))) {
+                if (entity instanceof ProjectileEntity) {
+                    if (ignoreWitherSkulls.get() && entity instanceof WitherSkullEntity) continue;
+                    if (entity instanceof TridentEntity trident && trident.noClip) continue; // when it's returning via loyalty
+
                     calculateFiredPath(entity, tickDelta);
                     for (Path path : paths) path.render(event);
                 }
@@ -235,31 +251,33 @@ private class Path {
         private boolean hitQuad, hitQuadHorizontal;
         private double hitQuadX1, hitQuadY1, hitQuadZ1, hitQuadX2, hitQuadY2, hitQuadZ2;
 
-        private Entity collidingEntity;
+        private final List<Entity> collidingEntities = new ArrayList<>();
         public Vector3d lastPoint;
+        private int start;
 
         public void clear() {
             vec3s.freeAll(points);
             points.clear();
 
             hitQuad = false;
-            collidingEntity = null;
+            collidingEntities.clear();
             lastPoint = null;
+            start = 0;
         }
 
-        public void calculate() {
+        public Path calculate() {
             addPoint();
 
             for (int i = 0; i < (simulationSteps.get() > 0 ? simulationSteps.get() : Integer.MAX_VALUE); i++) {
-                HitResult result = simulator.tick();
+                SimulationStep result = simulator.tick();
 
-                if (result != null) {
-                    processHitResult(result);
-                    break;
-                }
+                processHitResults(result);
+                if (result.shouldStop) break;
 
                 addPoint();
             }
+
+            return this;
         }
 
         public Path setStart(Entity entity, double tickDelta) {
@@ -276,58 +294,75 @@ private void addPoint() {
             points.add(vec3s.get().set(simulator.pos));
         }
 
-        private void processHitResult(HitResult result) {
-            if (result.getType() == HitResult.Type.BLOCK) {
-                BlockHitResult r = (BlockHitResult) result;
-
-                hitQuad = true;
-                hitQuadX1 = r.getPos().x;
-                hitQuadY1 = r.getPos().y;
-                hitQuadZ1 = r.getPos().z;
-                hitQuadX2 = r.getPos().x;
-                hitQuadY2 = r.getPos().y;
-                hitQuadZ2 = r.getPos().z;
-
-                if (r.getSide() == Direction.UP || r.getSide() == Direction.DOWN) {
-                    hitQuadHorizontal = true;
-                    hitQuadX1 -= 0.25;
-                    hitQuadZ1 -= 0.25;
-                    hitQuadX2 += 0.25;
-                    hitQuadZ2 += 0.25;
-                }
-                else if (r.getSide() == Direction.NORTH || r.getSide() == Direction.SOUTH) {
-                    hitQuadHorizontal = false;
-                    hitQuadX1 -= 0.25;
-                    hitQuadY1 -= 0.25;
-                    hitQuadX2 += 0.25;
-                    hitQuadY2 += 0.25;
-                }
-                else {
-                    hitQuadHorizontal = false;
-                    hitQuadZ1 -= 0.25;
-                    hitQuadY1 -= 0.25;
-                    hitQuadZ2 += 0.25;
-                    hitQuadY2 += 0.25;
+        private void processHitResults(SimulationStep step) {
+            for (int i = 0; i < step.hitResults.length; i++) {
+                HitResult result = step.hitResults[i];
+                if (result.getType() == HitResult.Type.BLOCK) {
+                    BlockHitResult r = (BlockHitResult) result;
+
+                    hitQuad = true;
+                    hitQuadX1 = r.getPos().x;
+                    hitQuadY1 = r.getPos().y;
+                    hitQuadZ1 = r.getPos().z;
+                    hitQuadX2 = r.getPos().x;
+                    hitQuadY2 = r.getPos().y;
+                    hitQuadZ2 = r.getPos().z;
+
+                    if (r.getSide() == Direction.UP || r.getSide() == Direction.DOWN) {
+                        hitQuadHorizontal = true;
+                        hitQuadX1 -= 0.25;
+                        hitQuadZ1 -= 0.25;
+                        hitQuadX2 += 0.25;
+                        hitQuadZ2 += 0.25;
+                    }
+                    else if (r.getSide() == Direction.NORTH || r.getSide() == Direction.SOUTH) {
+                        hitQuadHorizontal = false;
+                        hitQuadX1 -= 0.25;
+                        hitQuadY1 -= 0.25;
+                        hitQuadX2 += 0.25;
+                        hitQuadY2 += 0.25;
+                    }
+                    else {
+                        hitQuadHorizontal = false;
+                        hitQuadZ1 -= 0.25;
+                        hitQuadY1 -= 0.25;
+                        hitQuadZ2 += 0.25;
+                        hitQuadY2 += 0.25;
+                    }
+
+                    points.add(Utils.set(vec3s.get(), result.getPos()));
                 }
+                else if (result.getType() == HitResult.Type.ENTITY) {
+                    Entity entity = ((EntityHitResult) result).getEntity();
+                    collidingEntities.add(entity);
 
-                points.add(Utils.set(vec3s.get(), result.getPos()));
+                    if (step.shouldStop && i == step.hitResults.length - 1) {
+                        points.add(Utils.set(vec3s.get(), result.getPos()));
+                    }
+                }
             }
-            else if (result.getType() == HitResult.Type.ENTITY) {
-                collidingEntity = ((EntityHitResult) result).getEntity();
+        }
 
-                points.add(Utils.set(vec3s.get(), result.getPos()).add(0, collidingEntity.getHeight() / 2, 0));
-            }
+        public void ignoreFirstTicks() {
+            start = points.size() <= ignoreFirstTicks.get() ? 0 : ignoreFirstTicks.get();
         }
 
         public void render(Render3DEvent event) {
             // Render path
-            for (Vector3d point : points) {
+            for (int i = start; i < points.size(); i++) {
+                Vector3d point = points.get(i);
+
                 if (lastPoint != null) {
                     event.renderer.line(lastPoint.x, lastPoint.y, lastPoint.z, point.x, point.y, point.z, lineColor.get());
-                    if (renderPositionBox.get())
-                        event.renderer.box(point.x - positionBoxSize.get(), point.y - positionBoxSize.get(), point.z - positionBoxSize.get(),
-                            point.x + positionBoxSize.get(), point.y + positionBoxSize.get(), point.z + positionBoxSize.get(), positionSideColor.get(), positionLineColor.get(), shapeMode.get(), 0);
+                    if (renderPositionBox.get()) {
+                        event.renderer.box(
+                            point.x - positionBoxSize.get(), point.y - positionBoxSize.get(), point.z - positionBoxSize.get(),
+                            point.x + positionBoxSize.get(), point.y + positionBoxSize.get(), point.z + positionBoxSize.get(),
+                            positionSideColor.get(), positionLineColor.get(), shapeMode.get(), 0
+                        );
+                    }
                 }
+
                 lastPoint = point;
             }
 
@@ -338,7 +373,7 @@ public void render(Render3DEvent event) {
             }
 
             // Render entity
-            if (collidingEntity != null) {
+            for (Entity collidingEntity : collidingEntities) {
                 double x = (collidingEntity.getX() - collidingEntity.lastX) * event.tickDelta;
                 double y = (collidingEntity.getY() - collidingEntity.lastY) * event.tickDelta;
                 double z = (collidingEntity.getZ() - collidingEntity.lastZ) * event.tickDelta;