Add CNPC+ Api

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

@@ -0,0 +1,557 @@
+package net.minecraft.util.math;
+
+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.MathHelper;
+
+/**
+ * Pasted in from 1.9, with the Vec3d constructor removed
+ */
+@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 = 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;
+    private static final int X_SHIFT = Y_SHIFT + NUM_Y_BITS;
+    private static final long X_MASK = (1L << NUM_X_BITS) - 1L;
+    private static final long Y_MASK = (1L << NUM_Y_BITS) - 1L;
+    private static final long Z_MASK = (1L << NUM_Z_BITS) - 1L;
+
+    public BlockPos(int x, int y, int z)
+    {
+        super(x, y, z);
+    }
+
+    public BlockPos(double x, double y, double z)
+    {
+        super(x, y, z);
+    }
+
+    public BlockPos(Entity source)
+    {
+        this(source.posX, source.posY, source.posZ);
+    }
+
+    public BlockPos(Vec3i source)
+    {
+        this(source.getX(), source.getY(), source.getZ());
+    }
+
+    /**
+     * Add the given coordinates to the coordinates of this BlockPos
+     */
+    public BlockPos add(double x, double y, double z)
+    {
+        return x == 0.0D && y == 0.0D && z == 0.0D ? this : new BlockPos((double)this.getX() + x, (double)this.getY() + y, (double)this.getZ() + z);
+    }
+
+    /**
+     * Add the given coordinates to the coordinates of this BlockPos
+     */
+    public BlockPos add(int x, int y, int z)
+    {
+        return x == 0 && y == 0 && z == 0 ? this : new BlockPos(this.getX() + x, this.getY() + y, this.getZ() + z);
+    }
+
+    /**
+     * Add the given Vector to this BlockPos
+     */
+    public BlockPos add(Vec3i vec)
+    {
+        return vec.getX() == 0 && vec.getY() == 0 && vec.getZ() == 0 ? this : new BlockPos(this.getX() + vec.getX(), this.getY() + vec.getY(), this.getZ() + vec.getZ());
+    }
+
+    /**
+     * Subtract the given Vector from this BlockPos
+     */
+    public BlockPos subtract(Vec3i vec)
+    {
+        return vec.getX() == 0 && vec.getY() == 0 && vec.getZ() == 0 ? this : new BlockPos(this.getX() - vec.getX(), this.getY() - vec.getY(), this.getZ() - vec.getZ());
+    }
+
+    /**
+     * Offset this BlockPos 1 block up
+     */
+    public BlockPos up()
+    {
+        return this.up(1);
+    }
+
+    /**
+     * Offset this BlockPos n blocks up
+     */
+    public BlockPos up(int n)
+    {
+        return this.offset(EnumFacing.UP, n);
+    }
+
+    /**
+     * Offset this BlockPos 1 block down
+     */
+    public BlockPos down()
+    {
+        return this.down(1);
+    }
+
+    /**
+     * Offset this BlockPos n blocks down
+     */
+    public BlockPos down(int n)
+    {
+        return this.offset(EnumFacing.DOWN, n);
+    }
+
+    /**
+     * Offset this BlockPos 1 block in northern direction
+     */
+    public BlockPos north()
+    {
+        return this.north(1);
+    }
+
+    /**
+     * Offset this BlockPos n blocks in northern direction
+     */
+    public BlockPos north(int n)
+    {
+        return this.offset(EnumFacing.NORTH, n);
+    }
+
+    /**
+     * Offset this BlockPos 1 block in southern direction
+     */
+    public BlockPos south()
+    {
+        return this.south(1);
+    }
+
+    /**
+     * Offset this BlockPos n blocks in southern direction
+     */
+    public BlockPos south(int n)
+    {
+        return this.offset(EnumFacing.SOUTH, n);
+    }
+
+    /**
+     * Offset this BlockPos 1 block in western direction
+     */
+    public BlockPos west()
+    {
+        return this.west(1);
+    }
+
+    /**
+     * Offset this BlockPos n blocks in western direction
+     */
+    public BlockPos west(int n)
+    {
+        return this.offset(EnumFacing.WEST, n);
+    }
+
+    /**
+     * Offset this BlockPos 1 block in eastern direction
+     */
+    public BlockPos east()
+    {
+        return this.east(1);
+    }
+
+    /**
+     * Offset this BlockPos n blocks in eastern direction
+     */
+    public BlockPos east(int n)
+    {
+        return this.offset(EnumFacing.EAST, n);
+    }
+
+    /**
+     * Offset this BlockPos 1 block in the given direction
+     */
+    public BlockPos offset(EnumFacing facing)
+    {
+        return this.offset(facing, 1);
+    }
+
+    /**
+     * Offsets this BlockPos n blocks in the given direction
+     */
+    public BlockPos offset(EnumFacing facing, int n)
+    {
+        return n == 0 ? this : new BlockPos(this.getX() + facing.getFrontOffsetX() * n, this.getY() + facing.getFrontOffsetY() * n, this.getZ() + facing.getFrontOffsetZ() * n);
+    }
+
+    /**
+     * Calculate the cross product of this and the given Vector
+     */
+    public BlockPos crossProduct(Vec3i vec)
+    {
+        return new BlockPos(this.getY() * vec.getZ() - this.getZ() * vec.getY(), this.getZ() * vec.getX() - this.getX() * vec.getZ(), this.getX() * vec.getY() - this.getY() * vec.getX());
+    }
+
+    /**
+     * Serialize this BlockPos into a long value
+     */
+    public long toLong()
+    {
+        return ((long)this.getX() & X_MASK) << X_SHIFT | ((long)this.getY() & Y_MASK) << Y_SHIFT | ((long)this.getZ() & Z_MASK) << 0;
+    }
+
+    /**
+     * Create a BlockPos from a serialized long value (created by toLong)
+     */
+    public static BlockPos fromLong(long serialized)
+    {
+        int i = (int)(serialized << 64 - X_SHIFT - NUM_X_BITS >> 64 - NUM_X_BITS);
+        int j = (int)(serialized << 64 - Y_SHIFT - NUM_Y_BITS >> 64 - NUM_Y_BITS);
+        int k = (int)(serialized << 64 - NUM_Z_BITS >> 64 - NUM_Z_BITS);
+        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()));
+        final BlockPos blockpos1 = new BlockPos(Math.max(from.getX(), to.getX()), Math.max(from.getY(), to.getY()), Math.max(from.getZ(), to.getZ()));
+        return new Iterable<BlockPos>()
+        {
+            public Iterator<BlockPos> iterator()
+            {
+                return new AbstractIterator<BlockPos>()
+                {
+                    private BlockPos lastReturned = null;
+                    protected BlockPos computeNext()
+                    {
+                        if (this.lastReturned == null)
+                        {
+                            this.lastReturned = blockpos;
+                            return this.lastReturned;
+                        }
+                        else if (this.lastReturned.equals(blockpos1))
+                        {
+                            return (BlockPos)this.endOfData();
+                        }
+                        else
+                        {
+                            int i = this.lastReturned.getX();
+                            int j = this.lastReturned.getY();
+                            int k = this.lastReturned.getZ();
+
+                            if (i < blockpos1.getX())
+                            {
+                                ++i;
+                            }
+                            else if (j < blockpos1.getY())
+                            {
+                                i = blockpos.getX();
+                                ++j;
+                            }
+                            else if (k < blockpos1.getZ())
+                            {
+                                i = blockpos.getX();
+                                j = blockpos.getY();
+                                ++k;
+                            }
+
+                            this.lastReturned = new BlockPos(i, j, k);
+                            return this.lastReturned;
+                        }
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * 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()));
+        final BlockPos blockpos1 = new BlockPos(Math.max(from.getX(), to.getX()), Math.max(from.getY(), to.getY()), Math.max(from.getZ(), to.getZ()));
+        return new Iterable<BlockPos.MutableBlockPos>()
+        {
+            public Iterator<BlockPos.MutableBlockPos> iterator()
+            {
+                return new AbstractIterator<BlockPos.MutableBlockPos>()
+                {
+                    private BlockPos.MutableBlockPos theBlockPos = null;
+                    protected BlockPos.MutableBlockPos computeNext()
+                    {
+                        if (this.theBlockPos == null)
+                        {
+                            this.theBlockPos = new BlockPos.MutableBlockPos(blockpos.getX(), blockpos.getY(), blockpos.getZ());
+                            return this.theBlockPos;
+                        }
+                        else if (this.theBlockPos.equals(blockpos1))
+                        {
+                            return (BlockPos.MutableBlockPos)this.endOfData();
+                        }
+                        else
+                        {
+                            int i = this.theBlockPos.getX();
+                            int j = this.theBlockPos.getY();
+                            int k = this.theBlockPos.getZ();
+
+                            if (i < blockpos1.getX())
+                            {
+                                ++i;
+                            }
+                            else if (j < blockpos1.getY())
+                            {
+                                i = blockpos.getX();
+                                ++j;
+                            }
+                            else if (k < blockpos1.getZ())
+                            {
+                                i = blockpos.getX();
+                                j = blockpos.getY();
+                                ++k;
+                            }
+
+                            this.theBlockPos.x = i;
+                            this.theBlockPos.y = j;
+                            this.theBlockPos.z = k;
+                            return this.theBlockPos;
+                        }
+                    }
+                };
+            }
+        };
+    }
+
+    public static class MutableBlockPos extends BlockPos
+    {
+        /** Mutable X Coordinate */
+        protected int x;
+        /** Mutable Y Coordinate */
+        protected int y;
+        /** Mutable Z Coordinate */
+        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);
+            this.x = x_;
+            this.y = y_;
+            this.z = z_;
+        }
+
+        /**
+         * Gets the X coordinate.
+         */
+        public int getX()
+        {
+            return this.x;
+        }
+
+        /**
+         * Gets the Y coordinate.
+         */
+        public int getY()
+        {
+            return this.y;
+        }
+
+        /**
+         * Gets the Z coordinate.
+         */
+        public int getZ()
+        {
+            return this.z;
+        }
+
+        /**
+         * Sets the position, MUST not be name 'set' as that causes obfusication conflicts with func_185343_d
+         */
+        public BlockPos.MutableBlockPos setPos(int xIn, int yIn, int zIn)
+        {
+            this.x = xIn;
+            this.y = yIn;
+            this.z = zIn;
+            return 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_);
+        }
+    }
+}