示例#1
0
文件: PixelBox.cs 项目: Vuwij/Macabre
 public PixelBox(PixelBox body)
 {
     this.top    = body.top;
     this.left   = body.left;
     this.right  = body.right;
     this.bottom = body.bottom;
 }
示例#2
0
        public PixelBox MatchCollisionBody(PixelBox input, bool center = true)
        {
            float h = 0.0f;

            if (rampDirection == Direction.NE || rampDirection == Direction.SW)
            {
                h = slope * Vector2.Distance(input.bottom, input.right);
            }
            if (rampDirection == Direction.SE || rampDirection == Direction.NW)
            {
                h = slope * Vector2.Distance(input.bottom, input.left);
            }

            Vector2 inputTopWorldElevated    = (rampDirection == Direction.NW || rampDirection == Direction.NE) ? input.top + new Vector2(0.0f, h) : input.top;
            Vector2 inputbottomWorldElevated = (rampDirection == Direction.SW || rampDirection == Direction.SE) ? input.bottom + new Vector2(0.0f, h) : input.bottom;
            Vector2 inputleftWorldElevated   = (rampDirection == Direction.NW || rampDirection == Direction.SW) ? input.left + new Vector2(0.0f, h) : input.left;
            Vector2 inputrightWorldElevated  = (rampDirection == Direction.NE || rampDirection == Direction.SE) ? input.right + new Vector2(0.0f, h) : input.right;

            if (center)
            {
                inputTopWorldElevated.y    = inputTopWorldElevated.y - h / 2;
                inputbottomWorldElevated.y = inputbottomWorldElevated.y - h / 2;
                inputleftWorldElevated.y   = inputleftWorldElevated.y - h / 2;
                inputrightWorldElevated.y  = inputrightWorldElevated.y - h / 2;
            }

            PixelBox cbody = new PixelBox(inputTopWorldElevated, inputleftWorldElevated, inputrightWorldElevated, inputbottomWorldElevated);

            return(cbody);
        }
示例#3
0
        public bool OnFarSide(PixelBox body)
        {
            bool onTop = centerSegment.AboveSegment(body);

            if (Math.Abs(slope) < float.Epsilon)
            {
                return(false);
            }
            if ((rampDirection == Direction.NE || rampDirection == Direction.NW) && onTop)
            {
                return(true);
            }
            if ((rampDirection == Direction.SE || rampDirection == Direction.SW) && !onTop)
            {
                return(true);
            }
            return(false);
        }
示例#4
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);
        }
示例#5
0
文件: PixelBox.cs 项目: Vuwij/Macabre
        // Extend and Stretch and increase size of collision Body
        public PixelBox Extend(Direction direction, float distance)
        {
            PixelBox copy = new PixelBox(this);

            return(copy);
        }
示例#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
文件: PixelBox.cs 项目: Vuwij/Macabre
        public PixelBoxComparison CompareWith(PixelBox other, float margin = 0.0f)
        {
            PixelBoxComparison bodyComparison = CompareTwoCollisionBodies(this, other, margin);

            return(bodyComparison);
        }
示例#8
0
        protected override void Awake()
        {
            if (noCollision)
            {
                return;
            }

            collider2D = GetComponent <PolygonCollider2D>();

            Debug.Assert(collider2D != null);
            for (int i = 0; i < collider2D.pathCount; ++i)
            {
                Debug.Assert(collider2D.GetPath(i).Length == 4);
            }
            Debug.Assert(transform.parent.GetComponent <PixelRoom>() == null);
            Debug.Assert(transform.parent.GetComponent <PolygonCollider2D>() == null);

            collisionBodies = new PixelBox[collider2D.pathCount];
            for (int i = 0; i < collider2D.pathCount; ++i)
            {
                collisionBodies[i]        = new PixelBox();
                collisionBodies[i].top    = collider2D.GetPath(i)[0];
                collisionBodies[i].bottom = collider2D.GetPath(i)[0];
                collisionBodies[i].left   = collider2D.GetPath(i)[0];
                collisionBodies[i].right  = collider2D.GetPath(i)[0];
            }

            for (int j = 0; j < collider2D.pathCount; ++j)
            {
                for (int i = 0; i < 4; ++i)
                {
                    if (collider2D.GetPath(j)[i].y > collisionBodies[j].top.y)
                    {
                        collisionBodies[j].top = collider2D.GetPath(j)[i];
                    }
                    if (collider2D.GetPath(j)[i].y < collisionBodies[j].bottom.y)
                    {
                        collisionBodies[j].bottom = collider2D.GetPath(j)[i];
                    }
                    if (collider2D.GetPath(j)[i].x < collisionBodies[j].left.x)
                    {
                        collisionBodies[j].left = collider2D.GetPath(j)[i];
                    }
                    if (collider2D.GetPath(j)[i].x > collisionBodies[j].right.x)
                    {
                        collisionBodies[j].right = collider2D.GetPath(j)[i];
                    }
                }
            }

            for (int i = 0; i < collider2D.pathCount; ++i)
            {
                collisionBodies[i].top    += collider2D.offset;
                collisionBodies[i].bottom += collider2D.offset;
                collisionBodies[i].left   += collider2D.offset;
                collisionBodies[i].right  += collider2D.offset;
            }

            collisionBodiesP = new PixelBox[collider2D.pathCount];
            for (int i = 0; i < collider2D.pathCount; ++i)
            {
                collisionBodiesP[i]        = new PixelBox();
                collisionBodiesP[i].top    = collisionBodies[i].top + new Vector2(0, pixelProximity);
                collisionBodiesP[i].bottom = collisionBodies[i].bottom + new Vector2(0, -pixelProximity);
                collisionBodiesP[i].left   = collisionBodies[i].left + new Vector2(-2 * pixelProximity, 0);
                collisionBodiesP[i].right  = collisionBodies[i].right + new Vector2(2 * pixelProximity, 0);
            }
        }
示例#9
0
        // Returns 1 if in front of the other, returns 1 if object is in front of other
        public int CompareTo(PixelCollider other)
        {
            int comparison = 0;

            if (other == this)
            {
                return(0);
            }

            if (other is MultiBodyPixelCollider && this is MultiBodyPixelCollider)
            {
                MultiBodyPixelCollider a = this as MultiBodyPixelCollider;
                MultiBodyPixelCollider b = other as MultiBodyPixelCollider;

                Debug.Assert(a.collisionBodiesWorld.Count() > 0);
                Debug.Assert(b.collisionBodiesWorld.Count() > 0);

                // Find the front most box of all the boxes

                // TODO: Top sort for more complicated buildings
                for (int i = 0; i < a.collisionBodies.Count(); ++i)
                {
                    for (int j = 0; j < b.collisionBodies.Count(); ++j)
                    {
                        int comp = PixelBox.CompareTwoCollisionBodies(a.collisionBodiesWorld[i], b.collisionBodiesWorld[j], 2.0f).inFront;
                        if (comp == 1)
                        {
                            comparison = 1;
                        }
                        if (comp == -1)
                        {
                            comparison = -1;
                        }
                    }
                }
            }
            else if (other is MultiBodyPixelCollider || this is MultiBodyPixelCollider)
            {
                MultiBodyPixelCollider multi;
                PixelCollider          single;
                if (other is MultiBodyPixelCollider)
                {
                    multi  = other as MultiBodyPixelCollider;
                    single = this;
                }
                else
                {
                    multi  = this as MultiBodyPixelCollider;
                    single = other;
                }

                PixelBox singleBody = single.collisionBodyWorld;

                // If any of the multi are in front of the single, multi wins
                int multiInFront = 0;
                for (int i = 0; i < multi.collisionBodiesWorld.Count(); ++i)
                {
                    int comp = PixelBox.CompareTwoCollisionBodies(multi.collisionBodiesWorld[i], singleBody, 2.0f).inFront;
                    if (comp == 1)
                    {
                        multiInFront = 1;
                    }
                    if (comp == -1)
                    {
                        multiInFront = -1;
                    }
                }

                if (single != this)
                {
                    comparison = multiInFront;
                }
                else
                {
                    if (multiInFront == 1)
                    {
                        comparison = -1;
                    }
                    if (multiInFront == -1)
                    {
                        comparison = 1;
                    }
                }
            }
            else if (other is RampCollider && transform.parent.GetComponent <Character>() != null || this is RampCollider && other.transform.parent.GetComponent <Character>() != null)
            {
                RampCollider       rampCollider      = (RampCollider)((other is RampCollider) ? other : this);
                PixelCollider      characterCollider = (other is RampCollider) ? this : other;
                PixelBoxComparison bodyComparision   = PixelBox.CompareTwoCollisionBodies(characterCollider.collisionBodyWorld, rampCollider.collisionBodyWorld, 0.0f);

                if (characterCollider.within || characterCollider.withinProximityBox)
                {
                    if (other is RampCollider)
                    {
                        comparison = 1;
                    }
                    else
                    {
                        comparison = -1;
                    }
                }
                else
                {
                    Debug.Assert(this.colliderPoints.Length == 4);
                    Debug.Assert(other.colliderPoints.Length == 4);

                    PixelBox a = collisionBodyWorld;
                    PixelBox b = other.collisionBodyWorld;

                    comparison = PixelBox.CompareTwoCollisionBodies(a, b, 10.0f).inFront;
                }
            }
            else
            {
                Debug.Assert(this.colliderPoints.Length == 4);
                Debug.Assert(other.colliderPoints.Length == 4);

                PixelBox a = collisionBodyWorld;
                PixelBox b = other.collisionBodyWorld;

                comparison = PixelBox.CompareTwoCollisionBodies(a, b, 10.0f).inFront;
            }
            return(comparison);
        }
示例#10
0
        public virtual MovementRestriction CheckForCollision()
        {
            Debug.Assert(!(this is MultiBodyPixelCollider));

            Vector3 castStart = transform.position;

            castStart.z = -10.0f;

            RaycastHit2D[] castStar = Physics2D.CircleCastAll(castStart, GameSettings.inspectRadius * 10.0f, Vector2.zero);

            MovementRestriction restriction = new MovementRestriction();

            // Collided with floor
            PixelRoom floor = transform.parent.parent.GetComponent <PixelRoom>();

            Debug.Assert(floor != null);
            Debug.Assert(floor.colliderPoints.Length == 4);

            PixelBoxComparison cbc = PixelBox.CompareTwoCollisionBodies(collisionBodyWorld, floor.collisionbodyWorld, -2.0f);

            if (!cbc.SEinside)
            {
                restriction.restrictSE = true;
            }
            if (!cbc.SWinside)
            {
                restriction.restrictSW = true;
            }
            if (!cbc.NEinside)
            {
                restriction.restrictNE = true;
            }
            if (!cbc.NWinside)
            {
                restriction.restrictNW = true;
            }

            // Collided with other object
            foreach (RaycastHit2D raycastHit in castStar)
            {
                PixelCollider otherPixelCollider = raycastHit.collider.GetComponent <PixelCollider>();
                if (otherPixelCollider == null)
                {
                    continue;
                }
                if (otherPixelCollider.noCollision)
                {
                    continue;
                }
                if (otherPixelCollider.ParentIsContainer())
                {
                    continue;
                }
                if (!OtherPixelColliderSameParent(otherPixelCollider))
                {
                    continue;
                }

                Transform otherTransform = otherPixelCollider.gameObject.transform;

                if (otherPixelCollider is MultiBodyPixelCollider)
                {
                    MultiBodyPixelCollider multi = otherPixelCollider as MultiBodyPixelCollider;
                    foreach (PixelBox cbody in multi.collisionBodiesWorld)
                    {
                        cbody.Draw(Color.white, 1.0f);
                        if (collisionBodyWorld.WithinRange(cbody, Direction.NW, 0.4f))
                        {
                            restriction.restrictNW = true;
                        }
                        if (collisionBodyWorld.WithinRange(cbody, Direction.NE, 0.4f))
                        {
                            restriction.restrictNE = true;
                        }
                        if (collisionBodyWorld.WithinRange(cbody, Direction.SW, 0.4f))
                        {
                            restriction.restrictSW = true;
                        }
                        if (collisionBodyWorld.WithinRange(cbody, Direction.SE, 0.4f))
                        {
                            restriction.restrictSE = true;
                        }
                    }
                }
                else if (otherPixelCollider is RampCollider)
                {
                    Debug.Assert(otherPixelCollider.colliderPoints.Length == 4);
                    RampCollider rampCollider = (RampCollider)otherPixelCollider;
                    otherPixelCollider.collisionBodyWorld.Draw(Color.white, 1.0f);

                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.NW, 0.4f))
                    {
                        restriction.restrictNW = true;
                    }
                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.NE, 0.4f))
                    {
                        restriction.restrictNE = true;
                    }
                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.SW, 0.4f))
                    {
                        restriction.restrictSW = true;
                    }
                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.SE, 0.4f))
                    {
                        restriction.restrictSE = true;
                    }

                    // Comparison with actual box
                    PixelBoxComparison bodyComparison      = PixelBox.CompareTwoCollisionBodies(collisionBodyWorld, rampCollider.collisionBodyWorld, 0.0f, true);
                    PixelBoxComparison proximityComparison = PixelBox.CompareTwoCollisionBodies(collisionBodyWorld, rampCollider.proximityBodyWorld, 0.0f, true);

                    // Close to the ramp collision (remove the wall collision) and prevent glitches
                    Direction proximityDirection = Direction.All;

                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.SE, navigationMargin, navigationMargin) &&
                        rampCollider.rampDirection == Direction.SE)
                    {
                        proximityDirection = Direction.SE;
                    }
                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.SW, navigationMargin, navigationMargin) &&
                        rampCollider.rampDirection == Direction.SW)
                    {
                        proximityDirection = Direction.SW;
                    }
                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.NE, navigationMargin, navigationMargin) &&
                        rampCollider.rampDirection == Direction.NE)
                    {
                        proximityDirection = Direction.NE;
                    }
                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.NW, navigationMargin, navigationMargin) &&
                        rampCollider.rampDirection == Direction.NW)
                    {
                        proximityDirection = Direction.NW;
                    }

                    // Entered the ramp
                    bool closeToRamp = proximityDirection != Direction.All;

                    // Free the character to go in that direction
                    if (proximityComparison.inside)
                    {
                        if (rampCollider.rampDirection == Direction.NE)
                        {
                            restriction.restrictNE = false;
                        }
                        else if (rampCollider.rampDirection == Direction.NW)
                        {
                            restriction.restrictNW = false;
                        }
                        else if (rampCollider.rampDirection == Direction.SE)
                        {
                            restriction.restrictSE = false;
                        }
                        else if (rampCollider.rampDirection == Direction.SW)
                        {
                            restriction.restrictSW = false;
                        }
                    }

                    // Check if entered ramp
                    withinProximityBox = rampCollider.proximityBodyWorld.WithinCollisionBody(transform.position);
                    if (withinProximityBox)
                    {
                        within = rampCollider.collisionBodyWorld.WithinCollisionBody(transform.position);

                        if (bodyComparison.overlap)
                        {
                            // Remove glitch caused by going to the side of the walls
                            if (rampCollider.rampDirection == Direction.NE || rampCollider.rampDirection == Direction.SW)
                            {
                                if (!proximityComparison.NWinside)
                                {
                                    restriction.restrictNW = true;
                                }
                                if (!proximityComparison.SEinside)
                                {
                                    restriction.restrictSE = true;
                                }
                            }
                            else if (rampCollider.rampDirection == Direction.NW || rampCollider.rampDirection == Direction.SE)
                            {
                                if (!proximityComparison.NEinside)
                                {
                                    restriction.restrictNE = true;
                                }
                                if (!proximityComparison.SWinside)
                                {
                                    restriction.restrictSW = true;
                                }
                            }
                        }

                        if (within)
                        {
                            rampCollider.OnEffectorEnter();
                        }
                        else
                        {
                            rampCollider.OnEffectorExit();
                        }
                    }

                    if (within)
                    {
                        // Draw the ramps
                        rampCollider.collisionBodyRampedWorld.Draw(Color.magenta, 2.0f);
                        PixelBox cramped = rampCollider.MatchCollisionBody(collisionBodyWorld);
                        cramped.Draw(Color.magenta, 2.0f);

                        // Ramp Collision mechanics
                        restriction.restrictNE = false;
                        restriction.restrictNW = false;
                        restriction.restrictSE = false;
                        restriction.restrictSW = false;

                        // Collision with side of ramp
                        PixelBoxComparison cbcRamp = PixelBox.CompareTwoCollisionBodies(cramped, rampCollider.collisionBodyRampedWorld, -2.0f);
                        if (!cbcRamp.SEinside && rampCollider.rampDirection != Direction.NW)
                        {
                            restriction.restrictSE = true;
                        }
                        if (!cbcRamp.SWinside && rampCollider.rampDirection != Direction.NE)
                        {
                            restriction.restrictSW = true;
                        }
                        if (!cbcRamp.NEinside && rampCollider.rampDirection != Direction.SW)
                        {
                            restriction.restrictNE = true;
                        }
                        if (!cbcRamp.NWinside && rampCollider.rampDirection != Direction.SE)
                        {
                            restriction.restrictNW = true;
                        }

                        restriction.slopeDirection = rampCollider.rampDirection;
                        restriction.slope          = rampCollider.slope;

                        // Check for room entry
                        PixelStair pixelStair = otherPixelCollider.transform.parent.GetComponent <PixelStair>();
                        if (pixelStair != null)
                        {
                            bool above = rampCollider.OnFarSide(cramped);
                            if (above)
                            {
                                restriction.enteredDoor = pixelStair;
                            }
                        }
                    }
                }
                else
                {
                    otherPixelCollider.collisionBodyWorld.Draw(Color.white, 1.0f);

                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.NW, 0.4f))
                    {
                        restriction.restrictNW = true;
                    }
                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.NE, 0.4f))
                    {
                        restriction.restrictNE = true;
                    }
                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.SW, 0.4f))
                    {
                        restriction.restrictSW = true;
                    }
                    if (collisionBodyWorld.WithinRange(otherPixelCollider.collisionBodyWorld, Direction.SE, 0.4f))
                    {
                        restriction.restrictSE = true;
                    }
                }
            }

            return(restriction);
        }
示例#11
0
 public bool WithinRampCollider(PixelBox body)
 {
     return(false);
 }
示例#12
0
 public bool AboveSegment(PixelBox body)
 {
     return(DistanceOrthographic(this, body.center) > 0);
 }