Kam Is God

src/main/java/net/minecraft/util/math/BlockPos.java

@@ -1,18 +1,32 @@
 package net.minecraft.util.math;
 
-import com.google.common.collect.AbstractIterator;
 import java.util.Iterator;
+import java.util.List;
+
+import javax.annotation.concurrent.Immutable;
+
+import net.minecraft.util.Vec3i;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import com.google.common.collect.AbstractIterator;
+import com.google.common.collect.Lists;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
 import net.minecraft.entity.Entity;
 import net.minecraft.util.EnumFacing;
-import net.minecraft.util.Vec3;
-import net.minecraft.util.Vec3i;
+import net.minecraft.util.MathHelper;
 
-/** This code is owned by Minecraft */
-
-public class BlockPos extends Vec3i{
+/**
+ */
+@Immutable
+public class BlockPos extends Vec3i
+{
+    private static final Logger LOGGER = LogManager.getLogger();
     /** The BlockPos with all coordinates 0 */
     public static final BlockPos ORIGIN = new BlockPos(0, 0, 0);
-    private static final int NUM_X_BITS = 1 + 25;//MathHelper.calculateLogBaseTwo(MathHelper.roundUpToPowerOfTwo(30000000));
+    private static final int NUM_X_BITS = 26; //1 + MathHelper.calculateLogBaseTwo(MathHelper.roundUpToPowerOfTwo(30000000)); //Manually calculated because of crash
     private static final int NUM_Z_BITS = NUM_X_BITS;
     private static final int NUM_Y_BITS = 64 - NUM_X_BITS - NUM_Z_BITS;
     private static final int Y_SHIFT = 0 + NUM_Z_BITS;
@@ -36,11 +50,6 @@ public class BlockPos extends Vec3i{
         this(source.posX, source.posY, source.posZ);
     }
 
-    public BlockPos(Vec3 source)
-    {
-        this(source.xCoord, source.yCoord, source.zCoord);
-    }
-
     public BlockPos(Vec3i source)
     {
         this(source.getX(), source.getY(), source.getZ());
@@ -217,6 +226,9 @@ public class BlockPos extends Vec3i{
         return new BlockPos(i, j, k);
     }
 
+    /**
+     * Create an Iterable that returns all positions in the box specified by the given corners
+     */
     public static Iterable<BlockPos> getAllInBox(BlockPos from, BlockPos to)
     {
         final BlockPos blockpos = new BlockPos(Math.min(from.getX(), to.getX()), Math.min(from.getY(), to.getY()), Math.min(from.getZ(), to.getZ()));
@@ -270,6 +282,21 @@ public class BlockPos extends Vec3i{
         };
     }
 
+    /**
+     * Returns a version of this BlockPos that is guaranteed to be immutable.
+     *
+     * <p>When storing a BlockPos given to you for an extended period of time, make sure you
+     * use this in case the value is changed internally.</p>
+     */
+    public BlockPos toImmutable()
+    {
+        return this;
+    }
+
+    /**
+     * Like getAllInBox but reuses a single MutableBlockPos instead. If this method is used, the resulting BlockPos
+     * instances can only be used inside the iteration loop.
+     */
     public static Iterable<BlockPos.MutableBlockPos> getAllInBoxMutable(BlockPos from, BlockPos to)
     {
         final BlockPos blockpos = new BlockPos(Math.min(from.getX(), to.getX()), Math.min(from.getY(), to.getY()), Math.min(from.getZ(), to.getZ()));
@@ -325,35 +352,25 @@ public class BlockPos extends Vec3i{
         };
     }
 
-    /**
-     * Returns a version of this BlockPos that is guaranteed to be Immutable.
-     * In most cases this will return 'this', but if 'this' is an instance of
-     * MutableBlockPos it will return a new instance of BlockPos with the same values.
-     *
-     * When storing a parameter given to you for an extended period of time, make sure you
-     * use this in case the value is changed internally.
-     *
-     * @return An immutable BlockPos.
-     */
-    public BlockPos getImmutable()
-    {
-        return this;
-    }
-
-    public static final class MutableBlockPos extends BlockPos
+    public static class MutableBlockPos extends BlockPos
     {
         /** Mutable X Coordinate */
-        private int x;
+        protected int x;
         /** Mutable Y Coordinate */
-        private int y;
+        protected int y;
         /** Mutable Z Coordinate */
-        private int z;
+        protected int z;
 
         public MutableBlockPos()
         {
             this(0, 0, 0);
         }
 
+        public MutableBlockPos(BlockPos pos)
+        {
+            this(pos.getX(), pos.getY(), pos.getZ());
+        }
+
         public MutableBlockPos(int x_, int y_, int z_)
         {
             super(0, 0, 0);
@@ -363,7 +380,7 @@ public class BlockPos extends Vec3i{
         }
 
         /**
-         * Get the X coordinate
+         * Gets the X coordinate.
          */
         public int getX()
         {
@@ -371,7 +388,7 @@ public class BlockPos extends Vec3i{
         }
 
         /**
-         * Get the Y coordinate
+         * Gets the Y coordinate.
          */
         public int getY()
         {
@@ -379,7 +396,7 @@ public class BlockPos extends Vec3i{
         }
 
         /**
-         * Get the Z coordinate
+         * Gets the Z coordinate.
          */
         public int getZ()
         {
@@ -387,13 +404,9 @@ public class BlockPos extends Vec3i{
         }
 
         /**
-         * Set the values
-         *
-         * @param xIn The X value
-         * @param yIn The Y value
-         * @param zIn The Z value
+         * Sets the position, MUST not be name 'set' as that causes obfusication conflicts with func_185343_d
          */
-        public BlockPos.MutableBlockPos set(int xIn, int yIn, int zIn)
+        public BlockPos.MutableBlockPos setPos(int xIn, int yIn, int zIn)
         {
             this.x = xIn;
             this.y = yIn;
@@ -401,6 +414,143 @@ public class BlockPos extends Vec3i{
             return this;
         }
 
-        @Override public BlockPos getImmutable() { return new BlockPos(this); }
+        public BlockPos.MutableBlockPos setPos(double p_189532_1_, double p_189532_3_, double p_189532_5_)
+        {
+            return this.setPos(MathHelper.floor_double(p_189532_1_), MathHelper.floor_double(p_189532_3_), MathHelper.floor_double(p_189532_5_));
+        }
+
+        @SideOnly(Side.CLIENT)
+        public BlockPos.MutableBlockPos setPos(Entity p_189535_1_)
+        {
+            return this.setPos(p_189535_1_.posX, p_189535_1_.posY, p_189535_1_.posZ);
+        }
+
+        public BlockPos.MutableBlockPos setPos(Vec3i p_189533_1_)
+        {
+            return this.setPos(p_189533_1_.getX(), p_189533_1_.getY(), p_189533_1_.getZ());
+        }
+
+        public BlockPos.MutableBlockPos move(EnumFacing p_189536_1_)
+        {
+            return this.move(p_189536_1_, 1);
+        }
+
+        public BlockPos.MutableBlockPos move(EnumFacing p_189534_1_, int p_189534_2_)
+        {
+            return this.setPos(this.x + p_189534_1_.getFrontOffsetX() * p_189534_2_, this.y + p_189534_1_.getFrontOffsetY() * p_189534_2_, this.z + p_189534_1_.getFrontOffsetZ() * p_189534_2_);
+        }
+
+        public void setY(int yIn)
+        {
+            this.y = yIn;
+        }
+
+        /**
+         * Returns a version of this BlockPos that is guaranteed to be immutable.
+         *
+         * <p>When storing a BlockPos given to you for an extended period of time, make sure you
+         * use this in case the value is changed internally.</p>
+         */
+        public BlockPos toImmutable()
+        {
+            return new BlockPos(this);
+        }
+    }
+
+    public static final class PooledMutableBlockPos extends BlockPos.MutableBlockPos
+    {
+        private boolean released;
+        private static final List<BlockPos.PooledMutableBlockPos> POOL = Lists.<BlockPos.PooledMutableBlockPos>newArrayList();
+
+        private PooledMutableBlockPos(int xIn, int yIn, int zIn)
+        {
+            super(xIn, yIn, zIn);
+        }
+
+        public static BlockPos.PooledMutableBlockPos retain()
+        {
+            return retain(0, 0, 0);
+        }
+
+        public static BlockPos.PooledMutableBlockPos retain(double xIn, double yIn, double zIn)
+        {
+            return retain(MathHelper.floor_double(xIn), MathHelper.floor_double(yIn), MathHelper.floor_double(zIn));
+        }
+
+        @SideOnly(Side.CLIENT)
+        public static BlockPos.PooledMutableBlockPos retain(Vec3i vec)
+        {
+            return retain(vec.getX(), vec.getY(), vec.getZ());
+        }
+
+        public static BlockPos.PooledMutableBlockPos retain(int xIn, int yIn, int zIn)
+        {
+            synchronized (POOL)
+            {
+                if (!POOL.isEmpty())
+                {
+                    BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos = (BlockPos.PooledMutableBlockPos)POOL.remove(POOL.size() - 1);
+
+                    if (blockpos$pooledmutableblockpos != null && blockpos$pooledmutableblockpos.released)
+                    {
+                        blockpos$pooledmutableblockpos.released = false;
+                        blockpos$pooledmutableblockpos.set(xIn, yIn, zIn);
+                        return blockpos$pooledmutableblockpos;
+                    }
+                }
+            }
+
+            return new BlockPos.PooledMutableBlockPos(xIn, yIn, zIn);
+        }
+
+        public void release()
+        {
+            synchronized (POOL)
+            {
+                if (POOL.size() < 100)
+                {
+                    POOL.add(this);
+                }
+
+                this.released = true;
+            }
+        }
+
+        public BlockPos.PooledMutableBlockPos set(int xIn, int yIn, int zIn)
+        {
+            if (this.released)
+            {
+                BlockPos.LOGGER.error("PooledMutableBlockPosition modified after it was released.", new Throwable());
+                this.released = false;
+            }
+
+            return (BlockPos.PooledMutableBlockPos)super.setPos(xIn, yIn, zIn);
+        }
+
+        @SideOnly(Side.CLIENT)
+        public BlockPos.PooledMutableBlockPos set(Entity p_189537_1_)
+        {
+            return (BlockPos.PooledMutableBlockPos)super.setPos(p_189537_1_);
+        }
+
+        public BlockPos.PooledMutableBlockPos set(double xIn, double yIn, double zIn)
+        {
+            return (BlockPos.PooledMutableBlockPos)super.setPos(xIn, yIn, zIn);
+        }
+
+        public BlockPos.PooledMutableBlockPos set(Vec3i vec)
+        {
+            return (BlockPos.PooledMutableBlockPos)super.setPos(vec);
+        }
+
+        public BlockPos.PooledMutableBlockPos offsetMutable(EnumFacing facing)
+        {
+            return (BlockPos.PooledMutableBlockPos)super.move(facing);
+        }
+
+        public BlockPos.PooledMutableBlockPos movePos(EnumFacing p_189538_1_, int p_189538_2_)
+        {
+            return (BlockPos.PooledMutableBlockPos)super.move(p_189538_1_, p_189538_2_);
+        }
     }
 }

src/main/java/noppes/npcs/ai/pathfinder/FlyPathFinder.java

@@ -7,7 +7,9 @@ import net.minecraft.init.Blocks;
 import net.minecraft.pathfinding.PathFinder;
 import net.minecraft.util.IntHashMap;
 import net.minecraft.util.MathHelper;
+import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IBlockAccess;
+import noppes.npcs.entity.EntityNPCInterface;
 
 public class FlyPathFinder extends PathFinder
 {
@@ -57,62 +59,105 @@ public class FlyPathFinder extends PathFinder
     /**
      * Internal implementation of creating a path from an entity to a point
      */
-    private FlyPathEntity createEntityPathTo(Entity p_75857_1_, double p_75857_2_, double p_75857_4_, double p_75857_6_, float p_75857_8_)
+//    private FlyPathEntity createEntityPathTo(Entity p_75857_1_, double p_75857_2_, double p_75857_4_, double p_75857_6_, float p_75857_8_)
+//    {
+//        this.path.clearPath();
+//        this.pointMap.clearMap();
+//        boolean flag = this.isPathingInWater;
+//        int i = MathHelper.floor_double(p_75857_1_.boundingBox.minY + 0.5D);
+//
+//        if (this.canEntityDrown && p_75857_1_.isInWater())
+//        {
+//            i = (int)p_75857_1_.boundingBox.minY;
+//
+//            for (Block block = this.worldMap.getBlock(MathHelper.floor_double(p_75857_1_.posX), i, MathHelper.floor_double(p_75857_1_.posZ)); block == Blocks.flowing_water || block == Blocks.water; block = this.worldMap.getBlock(MathHelper.floor_double(p_75857_1_.posX), i, MathHelper.floor_double(p_75857_1_.posZ)))
+//            {
+//                ++i;
+//            }
+//
+//            flag = this.isPathingInWater;
+//            this.isPathingInWater = false;
+//        }
+//
+//        FlyPathPoint pathpoint2 = this.openPoint(MathHelper.floor_double(p_75857_1_.boundingBox.minX), i, MathHelper.floor_double(p_75857_1_.boundingBox.minZ));
+//        FlyPathPoint pathpoint = this.openPoint(MathHelper.floor_double(p_75857_2_ - (double)(p_75857_1_.width / 2.0F)), MathHelper.floor_double(p_75857_4_), MathHelper.floor_double(p_75857_6_ - (double)(p_75857_1_.width / 2.0F)));
+//        FlyPathPoint pathpoint1 = new FlyPathPoint(MathHelper.floor_float(p_75857_1_.width + 1.0F), MathHelper.floor_float(p_75857_1_.height + 1.0F), MathHelper.floor_float(p_75857_1_.width + 1.0F));
+//        FlyPathEntity pathentity = this.addToPath(p_75857_1_, pathpoint2, pathpoint, pathpoint1, p_75857_8_);
+//        this.isPathingInWater = flag;
+//        return pathentity;
+//    }
+
+    private FlyPathEntity createEntityPathTo(Entity entityIn, double x, double y, double z, float distance)
     {
         this.path.clearPath();
         this.pointMap.clearMap();
-        boolean flag = this.isPathingInWater;
-        int i = MathHelper.floor_double(p_75857_1_.boundingBox.minY + 0.5D);
-
-        if (this.canEntityDrown && p_75857_1_.isInWater())
-        {
-            i = (int)p_75857_1_.boundingBox.minY;
-
-            for (Block block = this.worldMap.getBlock(MathHelper.floor_double(p_75857_1_.posX), i, MathHelper.floor_double(p_75857_1_.posZ)); block == Blocks.flowing_water || block == Blocks.water; block = this.worldMap.getBlock(MathHelper.floor_double(p_75857_1_.posX), i, MathHelper.floor_double(p_75857_1_.posZ)))
-            {
-                ++i;
-            }
-
-            flag = this.isPathingInWater;
-            this.isPathingInWater = false;
-        }
-
-        FlyPathPoint pathpoint2 = this.openPoint(MathHelper.floor_double(p_75857_1_.boundingBox.minX), i, MathHelper.floor_double(p_75857_1_.boundingBox.minZ));
-        FlyPathPoint pathpoint = this.openPoint(MathHelper.floor_double(p_75857_2_ - (double)(p_75857_1_.width / 2.0F)), MathHelper.floor_double(p_75857_4_), MathHelper.floor_double(p_75857_6_ - (double)(p_75857_1_.width / 2.0F)));
-        FlyPathPoint pathpoint1 = new FlyPathPoint(MathHelper.floor_float(p_75857_1_.width + 1.0F), MathHelper.floor_float(p_75857_1_.height + 1.0F), MathHelper.floor_float(p_75857_1_.width + 1.0F));
-        FlyPathEntity pathentity = this.addToPath(p_75857_1_, pathpoint2, pathpoint, pathpoint1, p_75857_8_);
-        this.isPathingInWater = flag;
+        FlyPathPoint pathpoint = this.getPathPointTo(entityIn);
+        FlyPathPoint pathpoint1 = this.getPathPointToCoords(entityIn, x, y, z);
+        FlyPathEntity pathentity = addToPath(entityIn, pathpoint, pathpoint1, distance);
         return pathentity;
     }
 
+    public FlyPathPoint getPathPointTo(Entity entity)
+    {
+        int i;
+
+        if (((EntityNPCInterface) entity).ai.canSwim && entity.isInWater())
+        {
+            i = (int)entity.boundingBox.minY;
+            BlockPos.MutableBlockPos blockpos$mutableblockpos = new BlockPos.MutableBlockPos(MathHelper.floor_double(entity.posX), i, MathHelper.floor_double(entity.posZ));
+
+            for (Block block = this.worldMap.getBlock(blockpos$mutableblockpos.getX(), blockpos$mutableblockpos.getY(), blockpos$mutableblockpos.getZ());
+                 block == Blocks.flowing_water || block == Blocks.water;
+                 block = this.worldMap.getBlock(blockpos$mutableblockpos.getX(), blockpos$mutableblockpos.getY(), blockpos$mutableblockpos.getZ()))
+            {
+                ++i;
+                blockpos$mutableblockpos.setPos(MathHelper.floor_double(entity.posX), i, MathHelper.floor_double(entity.posZ));
+            }
+        }
+        else
+        {
+            i = MathHelper.floor_double(entity.boundingBox.minY + 0.5D);
+        }
+
+        BlockPos blockpos1 = new BlockPos(entity);
+
+        return this.openPoint(blockpos1.getX(), i, blockpos1.getZ());
+    }
+
+    public FlyPathPoint getPathPointToCoords(Entity entityIn, double x, double y, double z)
+    {
+        return openPoint(MathHelper.floor_double(x), MathHelper.floor_double(y), MathHelper.floor_double(z));
+    }
+
+
     /**
      * Adds a path from start to end and returns the whole path (args: unused, start, end, unused, maxDistance)
      */
-    private FlyPathEntity addToPath(Entity p_75861_1_, FlyPathPoint p_75861_2_, FlyPathPoint p_75861_3_, FlyPathPoint p_75861_4_, float p_75861_5_)
+    private FlyPathEntity addToPath(Entity entityIn, FlyPathPoint pathpointStart, FlyPathPoint pathpointEnd, float maxDistance)
     {
-        p_75861_2_.totalPathDistance = 0.0F;
-        p_75861_2_.distanceToNext = p_75861_2_.distanceToSquared(p_75861_3_);
-        p_75861_2_.distanceToTarget = p_75861_2_.distanceToNext;
+        pathpointStart.totalPathDistance = 0.0F;
+        pathpointStart.distanceToNext = pathpointStart.distanceToSquared(pathpointEnd);
+        pathpointStart.distanceToTarget = pathpointStart.distanceToNext;
         this.path.clearPath();
-        this.path.addPoint(p_75861_2_);
-        FlyPathPoint pathpoint3 = p_75861_2_;
+        this.path.addPoint(pathpointStart);
+        FlyPathPoint pathpoint3 = pathpointStart;
 
         while (!this.path.isPathEmpty())
         {
             FlyPathPoint pathpoint4 = this.path.dequeue();
 
-            if (pathpoint4.equals(p_75861_3_))
+            if (pathpoint4.equals(pathpointEnd))
             {
-                return this.createEntityPath(p_75861_2_, p_75861_3_);
+                return this.createEntityPath(pathpointStart, pathpointEnd);
             }
 
-            if (pathpoint4.distanceToSquared(p_75861_3_) < pathpoint3.distanceToSquared(p_75861_3_))
+            if (pathpoint4.distanceToSquared(pathpointEnd) < pathpoint3.distanceToSquared(pathpointEnd))
             {
                 pathpoint3 = pathpoint4;
             }
 
             pathpoint4.isFirst = true;
-            int i = this.findPathOptions(p_75861_1_, pathpoint4, p_75861_4_, p_75861_3_, p_75861_5_);
+            int i = this.findPathOptions(this.pathOptions, entityIn, pathpoint4, pathpointEnd, maxDistance);
 
             for (int j = 0; j < i; ++j)
             {
@@ -123,7 +168,7 @@ public class FlyPathFinder extends PathFinder
                 {
                     pathpoint5.previous = pathpoint4;
                     pathpoint5.totalPathDistance = f1;
-                    pathpoint5.distanceToNext = pathpoint5.distanceToSquared(p_75861_3_);
+                    pathpoint5.distanceToNext = pathpoint5.distanceToSquared(pathpointEnd);
 
                     if (pathpoint5.isAssigned())
                     {
@@ -138,13 +183,13 @@ public class FlyPathFinder extends PathFinder
             }
         }
 
-        if (pathpoint3 == p_75861_2_)
+        if (pathpoint3 == pathpointStart)
         {
             return null;
         }
         else
         {
-            return this.createEntityPath(p_75861_2_, pathpoint3);
+            return this.createEntityPath(pathpointStart, pathpoint3);
         }
     }
 
@@ -152,77 +197,177 @@ public class FlyPathFinder extends PathFinder
      * populates pathOptions with available points and returns the number of options found (args: unused1, currentPoint,
      * unused2, targetPoint, maxDistance)
      */
-    private int findPathOptions(Entity p_75860_1_, FlyPathPoint p_75860_2_, FlyPathPoint p_75860_3_, FlyPathPoint p_75860_4_, float p_75860_5_)
+    public int findPathOptions(FlyPathPoint[] pathOptions, Entity entityIn, FlyPathPoint currentPoint, FlyPathPoint targetPoint, float maxDistance)
     {
         int i = 0;
-        byte b0 = 0;
+        FlyPathPoint pathpoint = this.openPoint(currentPoint.xCoord, currentPoint.yCoord, currentPoint.zCoord + 1);
+        FlyPathPoint pathpoint1 = this.openPoint(currentPoint.xCoord - 1, currentPoint.yCoord, currentPoint.zCoord);
+        FlyPathPoint pathpoint2 = this.openPoint(currentPoint.xCoord + 1, currentPoint.yCoord, currentPoint.zCoord);
+        FlyPathPoint pathpoint3 = this.openPoint(currentPoint.xCoord, currentPoint.yCoord, currentPoint.zCoord - 1);
+        FlyPathPoint pathpoint4 = this.openPoint(currentPoint.xCoord, currentPoint.yCoord + 1, currentPoint.zCoord);
+        FlyPathPoint pathpoint5 = this.openPoint(currentPoint.xCoord, currentPoint.yCoord - 1, currentPoint.zCoord);
 
-        if (this.getVerticalOffset(p_75860_1_, p_75860_2_.xCoord, p_75860_2_.yCoord + 1, p_75860_2_.zCoord, p_75860_3_) == 1)
+        if (pathpoint != null && !pathpoint.isFirst && pathpoint.distanceTo(targetPoint) < maxDistance)
         {
-            b0 = 1;
+            pathOptions[i++] = pathpoint;
         }
 
-        for(int y = -1; y <= 1; y ++) {
-            FlyPathPoint pathpoint3 = this.getSafePoint(p_75860_1_, p_75860_2_.xCoord, p_75860_2_.yCoord + y, p_75860_2_.zCoord + 1, p_75860_3_, b0); //A
-            FlyPathPoint pathpoint4 = this.getSafePoint(p_75860_1_, p_75860_2_.xCoord - 1, p_75860_2_.yCoord + y, p_75860_2_.zCoord, p_75860_3_, b0); //D
-            FlyPathPoint pathpoint5 = this.getSafePoint(p_75860_1_, p_75860_2_.xCoord + 1, p_75860_2_.yCoord + y, p_75860_2_.zCoord, p_75860_3_, b0); //B
-            FlyPathPoint pathpoint6 = this.getSafePoint(p_75860_1_, p_75860_2_.xCoord, p_75860_2_.yCoord + y, p_75860_2_.zCoord - 1, p_75860_3_, b0); //C
+        if (pathpoint1 != null && !pathpoint1.isFirst && pathpoint1.distanceTo(targetPoint) < maxDistance)
+        {
+            pathOptions[i++] = pathpoint1;
+        }
 
-            FlyPathPoint pathpoint7 = this.getSafePoint(p_75860_1_, p_75860_2_.xCoord, p_75860_2_.yCoord + y, p_75860_2_.zCoord, p_75860_3_, b0);
+        if (pathpoint2 != null && !pathpoint2.isFirst && pathpoint2.distanceTo(targetPoint) < maxDistance)
+        {
+            pathOptions[i++] = pathpoint2;
+        }
 
-            FlyPathPoint pathpoint8 = this.getSafePoint(p_75860_1_, p_75860_2_.xCoord + 1, p_75860_2_.yCoord + y, p_75860_2_.zCoord + 1, p_75860_3_, b0); //2
-            FlyPathPoint pathpoint9 = this.getSafePoint(p_75860_1_, p_75860_2_.xCoord - 1, p_75860_2_.yCoord + y, p_75860_2_.zCoord - 1, p_75860_3_, b0); //4
-            FlyPathPoint pathpoint10 = this.getSafePoint(p_75860_1_, p_75860_2_.xCoord + 1, p_75860_2_.yCoord + y, p_75860_2_.zCoord - 1, p_75860_3_, b0); //3
-            FlyPathPoint pathpoint11 = this.getSafePoint(p_75860_1_, p_75860_2_.xCoord - 1, p_75860_2_.yCoord + y, p_75860_2_.zCoord + 1, p_75860_3_, b0); //1
+        if (pathpoint3 != null && !pathpoint3.isFirst && pathpoint3.distanceTo(targetPoint) < maxDistance)
+        {
+            pathOptions[i++] = pathpoint3;
+        }
 
-            if (pathpoint3 != null && !pathpoint3.isFirst && pathpoint3.distanceTo(p_75860_4_) < p_75860_5_) {
-                this.pathOptions[i++] = pathpoint3;
+        if (pathpoint4 != null && !pathpoint4.isFirst && pathpoint4.distanceTo(targetPoint) < maxDistance)
+        {
+            pathOptions[i++] = pathpoint4;
+        }
+
+        if (pathpoint5 != null && !pathpoint5.isFirst && pathpoint5.distanceTo(targetPoint) < maxDistance)
+        {
+            pathOptions[i++] = pathpoint5;
+        }
+
+        boolean flag = pathpoint3 == null;
+        boolean flag1 = pathpoint == null;
+        boolean flag2 = pathpoint2 == null;
+        boolean flag3 = pathpoint1 == null;
+        boolean flag4 = pathpoint4 == null;
+        boolean flag5 = pathpoint5 == null;
+
+        if (flag && flag3)
+        {
+            FlyPathPoint pathpoint6 = this.openPoint(currentPoint.xCoord - 1, currentPoint.yCoord, currentPoint.zCoord - 1);
+
+            if (pathpoint6 != null && !pathpoint6.isFirst && pathpoint6.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint6;
             }
+        }
 
-            if (pathpoint4 != null && !pathpoint4.isFirst && pathpoint4.distanceTo(p_75860_4_) < p_75860_5_) {
-                this.pathOptions[i++] = pathpoint4;
+        if (flag && flag2)
+        {
+            FlyPathPoint pathpoint7 = this.openPoint(currentPoint.xCoord + 1, currentPoint.yCoord, currentPoint.zCoord - 1);
+
+            if (pathpoint7 != null && !pathpoint7.isFirst && pathpoint7.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint7;
             }
+        }
 
-            if (pathpoint5 != null && !pathpoint5.isFirst && pathpoint5.distanceTo(p_75860_4_) < p_75860_5_) {
-                this.pathOptions[i++] = pathpoint5;
+        if (flag1 && flag3)
+        {
+            FlyPathPoint pathpoint8 = this.openPoint(currentPoint.xCoord - 1, currentPoint.yCoord, currentPoint.zCoord + 1);
+
+            if (pathpoint8 != null && !pathpoint8.isFirst && pathpoint8.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint8;
             }
+        }
 
-            if (pathpoint6 != null && !pathpoint6.isFirst && pathpoint6.distanceTo(p_75860_4_) < p_75860_5_) {
-                this.pathOptions[i++] = pathpoint6;
+        if (flag1 && flag2)
+        {
+            FlyPathPoint pathpoint9 = this.openPoint(currentPoint.xCoord + 1, currentPoint.yCoord, currentPoint.zCoord + 1);
+
+            if (pathpoint9 != null && !pathpoint9.isFirst && pathpoint9.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint9;
             }
+        }
 
-            if (pathpoint7 != null && !pathpoint7.isFirst && pathpoint7.distanceTo(p_75860_4_) < p_75860_5_) {
-                this.pathOptions[i++] = pathpoint7;
+        if (flag && flag4)
+        {
+            FlyPathPoint pathpoint10 = this.openPoint(currentPoint.xCoord, currentPoint.yCoord + 1, currentPoint.zCoord - 1);
+
+            if (pathpoint10 != null && !pathpoint10.isFirst && pathpoint10.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint10;
             }
+        }
 
-            if (pathpoint3 != null && !pathpoint3.isFirst && pathpoint3.distanceTo(p_75860_4_) < p_75860_5_ &&
-                    pathpoint5 != null && !pathpoint5.isFirst && pathpoint5.distanceTo(p_75860_4_) < p_75860_5_ &&
-                    pathpoint8 != null && !pathpoint8.isFirst && pathpoint8.distanceTo(p_75860_4_) < p_75860_5_) {
-                this.pathOptions[i++] = pathpoint8;
+        if (flag1 && flag4)
+        {
+            FlyPathPoint pathpoint11 = this.openPoint(currentPoint.xCoord, currentPoint.yCoord + 1, currentPoint.zCoord + 1);
+
+            if (pathpoint11 != null && !pathpoint11.isFirst && pathpoint11.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint11;
             }
+        }
 
-            if (pathpoint6 != null && !pathpoint6.isFirst && pathpoint6.distanceTo(p_75860_4_) < p_75860_5_ &&
-                    pathpoint4 != null && !pathpoint4.isFirst && pathpoint4.distanceTo(p_75860_4_) < p_75860_5_ &&
-                    pathpoint9 != null && !pathpoint9.isFirst && pathpoint9.distanceTo(p_75860_4_) < p_75860_5_) {
-                this.pathOptions[i++] = pathpoint9;
+        if (flag2 && flag4)
+        {
+            FlyPathPoint pathpoint12 = this.openPoint(currentPoint.xCoord + 1, currentPoint.yCoord + 1, currentPoint.zCoord);
+
+            if (pathpoint12 != null && !pathpoint12.isFirst && pathpoint12.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint12;
             }
+        }
 
-            if (pathpoint6 != null && !pathpoint6.isFirst && pathpoint6.distanceTo(p_75860_4_) < p_75860_5_ &&
-                    pathpoint5 != null && !pathpoint5.isFirst && pathpoint5.distanceTo(p_75860_4_) < p_75860_5_ &&
-                    pathpoint10 != null && !pathpoint10.isFirst && pathpoint10.distanceTo(p_75860_4_) < p_75860_5_) {
-                this.pathOptions[i++] = pathpoint10;
+        if (flag3 && flag4)
+        {
+            FlyPathPoint pathpoint13 = this.openPoint(currentPoint.xCoord - 1, currentPoint.yCoord + 1, currentPoint.zCoord);
+
+            if (pathpoint13 != null && !pathpoint13.isFirst && pathpoint13.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint13;
             }
+        }
 
-            if (pathpoint3 != null && !pathpoint3.isFirst && pathpoint3.distanceTo(p_75860_4_) < p_75860_5_ &&
-                    pathpoint4 != null && !pathpoint4.isFirst && pathpoint4.distanceTo(p_75860_4_) < p_75860_5_ &&
-                    pathpoint11 != null && !pathpoint11.isFirst && pathpoint11.distanceTo(p_75860_4_) < p_75860_5_) {
-                this.pathOptions[i++] = pathpoint11;
+        if (flag && flag5)
+        {
+            FlyPathPoint pathpoint14 = this.openPoint(currentPoint.xCoord, currentPoint.yCoord - 1, currentPoint.zCoord - 1);
+
+            if (pathpoint14 != null && !pathpoint14.isFirst && pathpoint14.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint14;
+            }
+        }
+
+        if (flag1 && flag5)
+        {
+            FlyPathPoint pathpoint15 = this.openPoint(currentPoint.xCoord, currentPoint.yCoord - 1, currentPoint.zCoord + 1);
+
+            if (pathpoint15 != null && !pathpoint15.isFirst && pathpoint15.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint15;
+            }
+        }
+
+        if (flag2 && flag5)
+        {
+            FlyPathPoint pathpoint16 = this.openPoint(currentPoint.xCoord + 1, currentPoint.yCoord - 1, currentPoint.zCoord);
+
+            if (pathpoint16 != null && !pathpoint16.isFirst && pathpoint16.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint16;
+            }
+        }
+
+        if (flag3 && flag5)
+        {
+            FlyPathPoint pathpoint17 = this.openPoint(currentPoint.xCoord - 1, currentPoint.yCoord - 1, currentPoint.zCoord);
+
+            if (pathpoint17 != null && !pathpoint17.isFirst && pathpoint17.distanceTo(targetPoint) < maxDistance)
+            {
+                pathOptions[i++] = pathpoint17;
             }
         }
 
         return i;
     }
 
+
     /**
      * Returns a point that the entity can safely move to
      */