示例#1
0
        public PixelLine Shift(Direction direction, float distance)
        {
            PixelLine pixelLine = new PixelLine(this);

            pixelLine.p1 = PixelPoint.Shift(this.p1, direction, distance);
            pixelLine.p2 = PixelPoint.Shift(this.p2, direction, distance);
            return(pixelLine);
        }
示例#2
0
        public static float DistanceOrthographic(PixelLine line, Vector2 pt)
        {
            float m    = (line.p2.y - line.p1.y) / (line.p2.x - line.p1.x); // Slope of parallel lines
            float i1   = line.p1.y - line.p1.x * m;                         // Intercept 1
            float i2   = pt.y - pt.x * m;                                   // Intercept 2
            float dist = (i2 - i1) / 2 / Mathf.Abs(m / Mathf.Sqrt(m * m + 1));

            return(dist);
        }
示例#3
0
        public static float Distance(PixelLine l1, PixelLine l2)
        {
            float m    = (l1.p2.y - l1.p1.y) / (l1.p2.x - l1.p1.x); // Slope of parallel lines
            float i1   = l1.p1.y - l1.p1.x * m;                     // Intercept 1
            float i2   = l2.p1.y - l2.p1.x * m;                     // Intercept 2
            float dist = (i2 - i1) / Mathf.Sqrt(m * m + 1);

            return(dist);
        }
示例#4
0
文件: PixelBox.cs 项目: Vuwij/Macabre
        // Within the body
        public bool WithinCollisionBody(Vector2 position, float margin = 0.0f)
        {
            if (PixelLine.DistanceOrthographic(lineNW, position) >= margin)
            {
                return(false);
            }

            if (PixelLine.DistanceOrthographic(lineNE, position) >= margin)
            {
                return(false);
            }

            if (PixelLine.DistanceOrthographic(lineSW, position) <= -margin)
            {
                return(false);
            }

            if (PixelLine.DistanceOrthographic(lineSE, position) <= -margin)
            {
                return(false);
            }

            return(true);
        }
示例#5
0
文件: PixelBox.cs 项目: Vuwij/Macabre
        public static PixelBoxComparison CompareTwoCollisionBodies(PixelBox a, PixelBox b, float margin = 0.0f, bool debug = false)
        {
            Vector2 atopWorld    = a.top;
            Vector2 abottomWorld = a.bottom;
            Vector2 aleftWorld   = a.left;
            Vector2 arightWorld  = a.right;

            Vector2 btopWorld    = b.top;
            Vector2 bbottomWorld = b.bottom;
            Vector2 bleftWorld   = b.left;
            Vector2 brightWorld  = b.right;

            PixelBoxComparison collisionBodyComparision = new PixelBoxComparison();

            bool aTopLeft     = PixelLine.DistanceOrthographic(a.lineNW, b.lineSE) >= -margin;
            bool aTopRight    = PixelLine.DistanceOrthographic(a.lineNE, b.lineSW) >= -margin;
            bool aBottomRight = PixelLine.DistanceOrthographic(b.lineNW, a.lineSE) >= -margin;
            bool aBottomLeft  = PixelLine.DistanceOrthographic(b.lineNE, a.lineSW) >= -margin;

            bool aTopRightWithin    = PixelLine.DistanceOrthographic(b.lineNE, a.lineNE) <= margin;
            bool aTopLeftWithin     = PixelLine.DistanceOrthographic(b.lineNW, a.lineNW) <= margin;
            bool aBottomLeftWithin  = PixelLine.DistanceOrthographic(a.lineSW, b.lineSW) <= margin;
            bool aBottomRightWithin = PixelLine.DistanceOrthographic(a.lineSE, b.lineSE) <= margin;

            collisionBodyComparision.NEinside = aTopRightWithin;
            collisionBodyComparision.NWinside = aTopLeftWithin;
            collisionBodyComparision.SEinside = aBottomRightWithin;
            collisionBodyComparision.SWinside = aBottomLeftWithin;

            collisionBodyComparision.NEoutside = aBottomLeft;
            collisionBodyComparision.NWoutside = aBottomRight;
            collisionBodyComparision.SEoutside = aTopLeft;
            collisionBodyComparision.SWoutside = aTopRight;


            // Debugging Tools
            if (debug)
            {
                if (aTopRightWithin)
                {
                    b.lineNE.Draw(Color.blue, 1.0f);
                }
                if (aTopLeftWithin)
                {
                    b.lineNW.Draw(Color.blue, 1.0f);
                }
                if (aBottomLeftWithin)
                {
                    b.lineSW.Draw(Color.blue, 1.0f);
                }
                if (aBottomRightWithin)
                {
                    b.lineSE.Draw(Color.blue, 1.0f);
                }
            }

            // Sides Vertical
            if (aTopLeft)
            {
                collisionBodyComparision.NWvertical |= (aleftWorld.x < brightWorld.x && aleftWorld.y < brightWorld.y);
            }

            if (aTopRight)
            {
                collisionBodyComparision.NEvertical |= (arightWorld.x > bleftWorld.x && arightWorld.y < bleftWorld.y);
            }

            if (aBottomRight)
            {
                collisionBodyComparision.SEvertical |= (bleftWorld.x < arightWorld.x && bleftWorld.y < arightWorld.y);
            }

            if (aBottomLeft)
            {
                collisionBodyComparision.SWvertical |= (brightWorld.x > aleftWorld.x && brightWorld.y < aleftWorld.y);
            }

            // Corners Exclusive
            if (aTopLeft && aTopRight)
            {
                collisionBodyComparision.Nexclusive = true;
            }
            if (aTopLeft && aBottomLeft)
            {
                collisionBodyComparision.Wexclusive = true;
            }
            if (aBottomLeft && aBottomRight)
            {
                collisionBodyComparision.Sexclusive = true;
            }
            if (aBottomRight && aTopRight)
            {
                collisionBodyComparision.Eexclusive = true;
            }

            // Sides Inclusive
            if (aTopLeft && (aBottomLeftWithin || aTopRightWithin))
            {
                collisionBodyComparision.NWinclusive = true;
            }
            if (aBottomRight && (aBottomLeftWithin || aTopRightWithin))
            {
                collisionBodyComparision.SEinclusive = true;
            }
            if (aTopRight && (aTopLeftWithin || aBottomRightWithin))
            {
                collisionBodyComparision.NEinclusive = true;
            }
            if (aBottomLeft && (aBottomRightWithin || aTopLeftWithin))
            {
                collisionBodyComparision.SWinclusive = true;
            }

            // Sides Exclusive
            if (aTopLeft && !aTopRight && !aBottomLeft)
            {
                collisionBodyComparision.NWexclusive = true;
            }
            if (aTopRight && !aTopLeft && !aBottomRight)
            {
                collisionBodyComparision.NEexclusive = true;
            }
            if (aBottomLeft && !aBottomRight && !aTopLeft)
            {
                collisionBodyComparision.SEexclusive = true;
            }
            if (aBottomRight && !aBottomLeft && !aTopRight)
            {
                collisionBodyComparision.SWexclusive = true;
            }

            // Above and Below
            if (arightWorld.x < brightWorld.x && aleftWorld.x > bleftWorld.x && (aBottomLeftWithin && aBottomRightWithin))
            {
                collisionBodyComparision.aAbove = true;
            }

            if (arightWorld.x < brightWorld.x && aleftWorld.x > bleftWorld.x && (aTopLeftWithin && aTopRightWithin))
            {
                collisionBodyComparision.aBelow = true;
            }

            return(collisionBodyComparision);
        }
示例#6
0
文件: PixelBox.cs 项目: Vuwij/Macabre
        // Within Range of a collisionBody
        public bool WithinRange(PixelBox other, Direction direction, float distance = 0.4f, float negDistance = 2.0f)
        {
            PixelBoxComparison comparison = this.CompareWith(other);

            if (direction == Direction.NW)
            {
                if (PixelLine.DistanceOrthographic(lineNW, other.lineSE) < distance &&
                    PixelLine.DistanceOrthographic(lineNW, other.lineSE) > -negDistance &&
                    left.x < (other.right.x) && top.x > (other.bottom.x) &&
                    left.y < (other.right.y) && top.y > (other.bottom.y))
                {
                    return(true);
                }
                return(false);
            }
            else if (direction == Direction.NE)
            {
                if (PixelLine.DistanceOrthographic(lineNE, other.lineSW) < distance &&
                    PixelLine.DistanceOrthographic(lineNE, other.lineSW) > -negDistance &&
                    top.x < (other.bottom.x) && right.x > (other.left.x) &&
                    top.y > (other.bottom.y) && right.y < (other.left.y))
                {
                    return(true);
                }
                return(false);
            }
            else if (direction == Direction.SW)
            {
                if (PixelLine.DistanceOrthographic(lineSW, other.lineNE) > -distance &&
                    PixelLine.DistanceOrthographic(lineSW, other.lineNE) < negDistance &&
                    left.x < (other.right.x) && bottom.x > (other.top.x) &&
                    left.y > (other.right.y) && bottom.y < (other.top.y))
                {
                    return(true);
                }
                return(false);
            }
            else if (direction == Direction.SE)
            {
                if (PixelLine.DistanceOrthographic(lineSE, other.lineNW) > -distance &&
                    PixelLine.DistanceOrthographic(lineSE, other.lineNW) < negDistance &&
                    bottom.x < (other.top.x) && right.x > (other.left.x) &&
                    bottom.y < (other.top.y) && right.y > (other.left.y))
                {
                    return(true);
                }
                return(false);
            }
            else if (direction == Direction.All)
            {
                if (PixelLine.DistanceOrthographic(lineNW, other.lineSE) < distance &&
                    PixelLine.DistanceOrthographic(lineNW, other.lineSE) > -negDistance &&
                    left.x < (other.right.x) && top.x > (other.bottom.x) &&
                    left.y < (other.right.y) && top.y > (other.bottom.y))
                {
                    return(true);
                }
                if (PixelLine.DistanceOrthographic(lineNE, other.lineSW) < distance &&
                    PixelLine.DistanceOrthographic(lineNE, other.lineSW) > -negDistance &&
                    top.x < (other.bottom.x) && right.x > (other.left.x) &&
                    top.y > (other.bottom.y) && right.y < (other.left.y))
                {
                    return(true);
                }
                if (PixelLine.DistanceOrthographic(lineSW, other.lineNE) > -distance &&
                    PixelLine.DistanceOrthographic(lineSW, other.lineNE) < negDistance &&
                    left.x < (other.right.x) && bottom.x > (other.top.x) &&
                    left.y > (other.right.y) && bottom.y < (other.top.y))
                {
                    return(true);
                }
                if (PixelLine.DistanceOrthographic(lineSE, other.lineNW) > -distance &&
                    PixelLine.DistanceOrthographic(lineSE, other.lineNW) < negDistance &&
                    bottom.x < (other.top.x) && right.x > (other.left.x) &&
                    bottom.y < (other.top.y) && right.y > (other.left.y))
                {
                    return(true);
                }
                return(false);
            }
            return(false);
        }
示例#7
0
        public HashSet <WayPoint> GetNavigationalMesh(Vector2 startPosition, int stepSize = 0, float margin = 0.0f)
        {
            if (stepSize == 0)
            {
                stepSize = this.stepSize;
            }

            if (navigationMesh.Count != 0)
            {
                foreach (WayPoint w in navigationMesh)
                {
                    w.distance = float.MaxValue;
                    w.previous = null;
                }
                return(new HashSet <WayPoint>(navigationMesh));
            }

            if (System.Math.Abs(margin) < 0.01f)
            {
                Character player = GameObject.Find("Player").GetComponent <Character>();
                margin = player.GetComponentInChildren <PixelCollider>().navigationMargin;
            }

            if (top == Vector2.zero)
            {
                this.gameObject.SetActive(true);
                this.gameObject.SetActive(false);
            }

            Debug.Assert(top != Vector2.zero);
            Debug.Assert(bottom != Vector2.zero);
            Debug.Assert(left != Vector2.zero);
            Debug.Assert(right != Vector2.zero);

            // Should all be positive
            float topLeftDist     = -PixelLine.DistanceOrthographic(collisionbodyWorld.lineNW, startPosition);
            float topRightDist    = -PixelLine.DistanceOrthographic(collisionbodyWorld.lineNE, startPosition);
            float bottomLeftDist  = PixelLine.DistanceOrthographic(collisionbodyWorld.lineSW, startPosition);
            float bottomRightDist = PixelLine.DistanceOrthographic(collisionbodyWorld.lineSE, startPosition);

            Debug.DrawLine(topWorld, leftWorld, Color.blue, 10.0f);
            Debug.DrawLine(leftWorld, bottomWorld, Color.blue, 10.0f);
            Debug.DrawLine(bottomWorld, rightWorld, Color.blue, 10.0f);
            Debug.DrawLine(rightWorld, topWorld, Color.blue, 10.0f);

            Vector2 topLeftPoint     = startPosition + new Vector2(-topLeftDist / 2.23606f * 2, topLeftDist / 2.23606f);
            Vector2 topRightPoint    = startPosition + new Vector2(topRightDist / 2.23606f * 2, topRightDist / 2.23606f);
            Vector2 bottomLeftPoint  = startPosition + new Vector2(-bottomLeftDist / 2.23606f * 2, -bottomLeftDist / 2.23606f);
            Vector2 bottomRightPoint = startPosition + new Vector2(bottomRightDist / 2.23606f * 2, -bottomRightDist / 2.23606f);

            Debug.Assert(topLeftDist >= 0);
            Debug.Assert(topRightDist >= 0);
            Debug.Assert(bottomLeftDist >= 0);
            Debug.Assert(bottomRightDist >= 0);

            float stepSizeLength = (new Vector2(stepSize * 2, stepSize)).magnitude;

            int topLeftSteps     = Mathf.FloorToInt((topLeftDist - margin) / stepSizeLength);
            int topRightSteps    = Mathf.FloorToInt((topRightDist - margin) / stepSizeLength);
            int bottomLeftSteps  = Mathf.FloorToInt((bottomLeftDist - margin) / stepSizeLength);
            int bottomRightSteps = Mathf.FloorToInt((bottomRightDist - margin) / stepSizeLength);

            topLeftSteps     = topLeftSteps >= 0 ? topLeftSteps : 0;
            topRightSteps    = topRightSteps >= 0 ? topRightSteps : 0;
            bottomLeftSteps  = bottomLeftSteps >= 0 ? bottomLeftSteps : 0;
            bottomRightSteps = bottomRightSteps >= 0 ? bottomRightSteps : 0;

            WayPoint[,] wayPointArray = new WayPoint[bottomLeftSteps + topRightSteps + 1, bottomRightSteps + topLeftSteps + 1];

            for (int i = -bottomLeftSteps; i <= topRightSteps; ++i)
            {
                for (int j = -bottomRightSteps; j <= topLeftSteps; ++j)
                {
                    Vector2  point    = startPosition + new Vector2(stepSize * 2, stepSize) * i + new Vector2(-stepSize * 2, stepSize) * j;
                    WayPoint wayPoint = new WayPoint(point);
                    wayPointArray[i + bottomLeftSteps, j + bottomRightSteps] = wayPoint;
                }
            }

            for (int i = -bottomLeftSteps; i <= topRightSteps; ++i)
            {
                for (int j = -bottomRightSteps; j <= topLeftSteps; ++j)
                {
                    if (i != -bottomLeftSteps)
                    {
                        wayPointArray[i - 1 + bottomLeftSteps, j + bottomRightSteps].neighbours.Add(wayPointArray[i + bottomLeftSteps, j + bottomRightSteps]);
                    }

                    if (i != topRightSteps)
                    {
                        wayPointArray[i + 1 + bottomLeftSteps, j + bottomRightSteps].neighbours.Add(wayPointArray[i + bottomLeftSteps, j + bottomRightSteps]);
                    }

                    if (j != -bottomRightSteps)
                    {
                        wayPointArray[i + bottomLeftSteps, j - 1 + bottomRightSteps].neighbours.Add(wayPointArray[i + bottomLeftSteps, j + bottomRightSteps]);
                    }

                    if (j != topLeftSteps)
                    {
                        wayPointArray[i + bottomLeftSteps, j + 1 + bottomRightSteps].neighbours.Add(wayPointArray[i + bottomLeftSteps, j + bottomRightSteps]);
                    }
                }
            }

            // Remove all waypoints with pixel colliders
            for (int c = 0; c < transform.childCount; ++c)
            {
                Transform t = transform.GetChild(c);

                // Remove all movable objects
                if (t.GetComponent <MovableObject>())
                {
                    continue;
                }

                PixelCollider[] pixelColliders = t.GetComponentsInChildren <PixelCollider>();

                foreach (PixelCollider pixelCollider in pixelColliders)
                {
                    if (pixelCollider != null && pixelCollider.isActiveAndEnabled)
                    {
                        List <WayPoint> badWayPoints = new List <WayPoint>();
                        for (int i = -bottomLeftSteps; i <= topRightSteps; ++i)
                        {
                            for (int j = -bottomRightSteps; j <= topLeftSteps; ++j)
                            {
                                if (wayPointArray[i + bottomLeftSteps, j + bottomRightSteps] == null)
                                {
                                    continue;
                                }

                                if (pixelCollider.CheckForWithinCollider(wayPointArray[i + bottomLeftSteps, j + bottomRightSteps].position, margin))
                                {
                                    foreach (WayPoint n in wayPointArray[i + bottomLeftSteps, j + bottomRightSteps].neighbours)
                                    {
                                        n.neighbours.Remove(wayPointArray[i + bottomLeftSteps, j + bottomRightSteps]);
                                    }
                                    wayPointArray[i + bottomLeftSteps, j + bottomRightSteps] = null;
                                }
                            }
                        }
                    }
                }
            }

            for (int i = -bottomLeftSteps; i <= topRightSteps; ++i)
            {
                for (int j = -bottomRightSteps; j <= topLeftSteps; ++j)
                {
                    if (wayPointArray[i + bottomLeftSteps, j + bottomRightSteps] != null)
                    {
                        navigationMesh.Add(wayPointArray[i + bottomLeftSteps, j + bottomRightSteps]);
                    }
                }
            }

            return(new HashSet <WayPoint>(navigationMesh));
        }
示例#8
0
 public PixelLine(PixelLine pixelLine)
 {
     this.p1 = pixelLine.p1;
     this.p2 = pixelLine.p2;
 }