Esempio n. 1
0
        public float calculateYOffset(AxisAlignedBB other, float offset)
        {
            //Y
            if (other.max.X > min.X && other.min.X < max.X && other.max.Z > min.Z && other.min.Z < max.Z)
            {
                if (offset > 0.0D && other.max.Y <= min.Y)
                {
                    float d1 = min.Y - other.max.Y;

                    if (d1 < offset)
                    {
                        offset = d1;
                    }
                }
                else if (offset < 0.0D && other.min.Y >= this.max.Y)
                {
                    float d0 = max.Y - other.min.Y;

                    if (d0 > offset)
                    {
                        offset = d0;
                    }
                }
            }

            return(offset);
        }
Esempio n. 2
0
        public float calculateXOffset(AxisAlignedBB other, float offset)
        {
            //X
            if (other.max.Y > min.Y && other.min.Y < max.Y && other.max.Z > min.Z && other.min.Z < max.Z)
            {
                if (offset > 0.0D && other.max.X <= min.X)
                {
                    float d1 = min.X - other.max.X;

                    if (d1 < offset)
                    {
                        offset = d1;
                    }
                }
                else if (offset < 0.0D && other.min.X >= max.X)
                {
                    float d0 = max.X - other.min.X;

                    if (d0 > offset)
                    {
                        offset = d0;
                    }
                }
            }

            return(offset);
        }
Esempio n. 3
0
        public List <AxisAlignedBB> getBlockCollisionBoxes(AxisAlignedBB box)
        {
            List <AxisAlignedBB> blocks = new List <AxisAlignedBB>();

            var bb = box.union(box);

            for (int x = (int)bb.min.X, maxX = (int)bb.max.X; x < maxX; x++)
            {
                for (int y = (int)bb.min.Y, maxY = (int)bb.max.Y; y < maxY; y++)
                {
                    for (int z = (int)bb.min.Z, maxZ = (int)bb.max.Z; z < maxZ; z++)
                    {
                        var pos   = new BlockPos(x, y, z);
                        var block = Game.INSTANCE.world.getBlock(pos);
                        if (block == EnumBlock.AIR)
                        {
                            continue;
                        }

                        blocks.Add(
                            ModelManager.getModelForBlock(block, getMetadata(pos)).boundingBox.offset(pos.vector));
                    }
                }
            }

            return(blocks);
        }
Esempio n. 4
0
        private Chunk(ChunkCache cache)
        {
            chunkPos    = cache.chunkPos;
            boundingBox =
                new AxisAlignedBB(Vector3.Zero, Vector3.One * 16 + Vector3.UnitY * 240).offset(chunkPos.vector);

            chunkBlocks = cache.chunkBlocks;
        }
Esempio n. 5
0
        public Chunk(BlockPos chunkPos)
        {
            this.chunkPos = chunkPos;
            boundingBox   =
                new AxisAlignedBB(Vector3.Zero, Vector3.One * 16 + Vector3.UnitY * 240).offset(chunkPos.vector);

            chunkBlocks = new short[16, 256, 16];
        }
Esempio n. 6
0
        public EntityPlayerSP(Vector3 pos) : base(pos)
        {
            camera     = new Camera();
            camera.pos = pos;

            boundingBox =
                new AxisAlignedBB(new Vector3(-0.3f, 0, -0.3f), new Vector3(0.3f, 1.65f, 0.3f)).offset(lastPos = pos);

            hotbar = new ItemStack[9];
        }
Esempio n. 7
0
        public AxisAlignedBB union(AxisAlignedBB other)
        {
            var minX = (int)Math.Floor(MathUtil.Min(min.X, max.X, other.min.X, other.max.X));
            var minY = (int)Math.Floor(MathUtil.Min(min.Y, max.Y, other.min.Y, other.max.Y));
            var minZ = (int)Math.Floor(MathUtil.Min(min.Z, max.Z, other.min.Z, other.max.Z));

            var maxX = (int)Math.Ceiling(MathUtil.Max(min.X, max.X, other.min.X, other.max.X));
            var maxY = (int)Math.Ceiling(MathUtil.Max(min.Y, max.Y, other.min.Y, other.max.Y));
            var maxZ = (int)Math.Ceiling(MathUtil.Max(min.Z, max.Z, other.min.Z, other.max.Z));

            return(new AxisAlignedBB(minX, minY, minZ, maxX, maxY, maxZ));
        }
Esempio n. 8
0
        public virtual void Move()
        {
            var bb_o = boundingBox.union(boundingBox.offset(motion));

            List <AxisAlignedBB> list = Game.INSTANCE.world.getBlockCollisionBoxes(bb_o);

            var m_orig = motion;

            for (int i = 0; i < list.Count; i++)
            {
                var blockBB = list[i];
                motion.Y = blockBB.calculateYOffset(boundingBox, motion.Y);
            }
            boundingBox = boundingBox.offset(motion * Vector3.UnitY);

            for (int i = 0; i < list.Count; i++)
            {
                var blockBB = list[i];
                motion.X = blockBB.calculateXOffset(boundingBox, motion.X);
            }
            boundingBox = boundingBox.offset(motion * Vector3.UnitX);

            for (int i = 0; i < list.Count; i++)
            {
                var blockBB = list[i];
                motion.Z = blockBB.calculateZOffset(boundingBox, motion.Z);
            }
            boundingBox = boundingBox.offset(motion * Vector3.UnitZ);

            setPositionToBB();

            onGround = Math.Abs(m_orig.Y - motion.Y) > 0.00001f && m_orig.Y < 0.0D;

            if (Math.Abs(m_orig.X - motion.X) > 0.00001f)
            {
                motion.X = 0;
            }

            if (Math.Abs(m_orig.Z - motion.Z) > 0.00001f)
            {
                motion.Z = 0;
            }

            if (onGround && motion.Y < 0)
            {
                motion.Y = 0;
            }
        }
Esempio n. 9
0
        public List <AxisAlignedBB> getIntersectingEntitiesBBs(AxisAlignedBB with)
        {
            List <AxisAlignedBB> bbs = new List <AxisAlignedBB>();

            for (int i = 0; i < _entities.Count; i++)
            {
                var bb = _entities[i].getBoundingBox();

                if (bb.intersectsWith(with))
                {
                    bbs.Add(bb);
                }
            }

            return(bbs);
        }
Esempio n. 10
0
 public bool intersectsWith(AxisAlignedBB other)
 {
     return((min.X < other.max.X && max.X > other.min.X) &&
            (min.Y < other.max.Y && max.Y > other.min.Y) &&
            (min.Z < other.max.Z && max.Z > other.min.Z));
 }
Esempio n. 11
0
        public static bool rayIntersectsBB(Vector3 /*ray*/ origin, Vector3 /*ray*/ direction, AxisAlignedBB bb, out Vector3 hitPosition, out Vector3 hitNormal)
        {
            direction   = direction.Normalized();
            hitNormal   = Vector3.One.Normalized();
            hitPosition = Vector3.Zero;

            float tmin, tmax, tymin, tymax, tzmin, tzmax;
            var   invrd = direction;

            invrd.X = 1.0f / invrd.X;
            invrd.Y = 1.0f / invrd.Y;
            invrd.Z = 1.0f / invrd.Z;

            if (invrd.X >= 0.0f)
            {
                tmin = (bb.min.X - origin.X) * invrd.X;
                tmax = (bb.max.X - origin.X) * invrd.X;
            }
            else
            {
                tmin = (bb.max.X - origin.X) * invrd.X;
                tmax = (bb.min.X - origin.X) * invrd.X;
            }

            if (invrd.Y >= 0.0f)
            {
                tymin = (bb.min.Y - origin.Y) * invrd.Y;
                tymax = (bb.max.Y - origin.Y) * invrd.Y;
            }
            else
            {
                tymin = (bb.max.Y - origin.Y) * invrd.Y;
                tymax = (bb.min.Y - origin.Y) * invrd.Y;
            }

            if ((tmin > tymax) || (tymin > tmax))
            {
                return(false);
            }
            if (tymin > tmin)
            {
                tmin = tymin;
            }
            if (tymax < tmax)
            {
                tmax = tymax;
            }

            if (invrd.Z >= 0.0f)
            {
                tzmin = (bb.min.Z - origin.Z) * invrd.Z;
                tzmax = (bb.max.Z - origin.Z) * invrd.Z;
            }
            else
            {
                tzmin = (bb.max.Z - origin.Z) * invrd.Z;
                tzmax = (bb.min.Z - origin.Z) * invrd.Z;
            }

            if ((tmin > tzmax) || (tzmin > tmax))
            {
                return(false);
            }
            if (tzmin > tmin)
            {
                tmin = tzmin;
            }
            if (tzmax < tmax)
            {
                tmax = tzmax;
            }

            if (tmin < 0)
            {
                tmin = tmax;
            }
            if (tmax < 0)
            {
                return(false);
            }

            float t = tmin;

            hitPosition = origin + t * direction;

            Vector3 AABBCenter = (bb.min + bb.max) * 0.5f;

            Vector3 dir = hitPosition - AABBCenter;

            Vector3 width = bb.max - bb.min;

            width.X = Math.Abs(width.X);
            width.Y = Math.Abs(width.Y);
            width.Z = Math.Abs(width.Z);

            Vector3 ratio = Vector3.One;

            ratio.X = Math.Abs(dir.X / width.X);
            ratio.Y = Math.Abs(dir.Y / width.Y);
            ratio.Z = Math.Abs(dir.Z / width.Z);

            hitNormal = Vector3.Zero;
            int maxDir = 0; // x

            if (ratio.X >= ratio.Y && ratio.X >= ratio.Z)
            { // x is the greatest
                maxDir = 0;
            }
            else if (ratio.Y >= ratio.X && ratio.Y >= ratio.Z)
            { // y is the greatest
                maxDir = 1;
            }
            else if (ratio.Z >= ratio.X && ratio.Z >= ratio.Y)
            { // z is the greatest
                maxDir = 2;
            }

            if (dir[maxDir] > 0)
            {
                hitNormal[maxDir] = 1.0f;
            }
            else
            {
                hitNormal[maxDir] = -1.0f;
            }

            return(true);
        }
Esempio n. 12
0
 protected Entity(Vector3 pos)
 {
     this.pos    = pos;
     boundingBox = AxisAlignedBB.BLOCK_FULL.offset(Vector3.One * -0.5f).offset(pos);
 }