示例#1
0
    /// <summary>
    ///
    /// </summary>
    /// <param name="colliderToCheck"></param>
    /// <returns></returns>
    public override bool ColliderIntersectHorizontally(CustomCollider2D colliderToCheck)
    {
        if (rigid.Velocity.x == 0)
        {
            return(false);
        }

        if (CircleColliderCollisionsAtBounds(horizontalBoundsFromVelocity, colliderToCheck))
        {
            if (colliderToCheck is CustomBoxCollider2D)
            {
                Vector2 pointOfCollision = IntersectionPointNonstaticRectOnStaticCircle(((CustomBoxCollider2D)colliderToCheck), this, false);

                this.transform.position = new Vector3(pointOfCollision.x, this.transform.position.y, this.transform.position.z);

                return(true);
            }
            else if (colliderToCheck is CustomCircleCollider2D)
            {
                CustomCircleCollider2D customcircleToCheck = (CustomCircleCollider2D)colliderToCheck;

                Vector2 collisionPoint = IntersectionPointCircleOnCircle(this, customcircleToCheck, false);
                this.transform.position = new Vector3(collisionPoint.x, this.transform.position.y, this.transform.position.z);
            }
            else if (colliderToCheck is CustomCapsuleCollider2D)
            {
                CustomCapsuleCollider2D capCollider = (CustomCapsuleCollider2D)colliderToCheck;

                Vector2 collisionPoint = IntersectionPointStaticCapsuleNonstaticCircle(capCollider, this, false);
                this.transform.position = new Vector3(collisionPoint.x, this.transform.position.y, this.transform.position.z);
            }
            return(true);
        }
        return(false);
    }
    /// <summary>
    ///
    /// </summary>
    /// <param name="upperCircle"></param>
    /// <param name="lowerCircle"></param>
    /// <param name="collidedVertically"></param>
    /// <returns></returns>
    public static Vector2 IntersectionPointCircleOnCircle(CustomCircleCollider2D nonstaticCircle, CustomCircleCollider2D staticCircle, bool collidedVertically = true)
    {
        Vector2 collisionPoint = CollisionPointCircleOnCircleBounds(nonstaticCircle.bounds, staticCircle.bounds);

        if (collidedVertically)
        {
            return(IntersectionPointColliderVerticalAtXPoint(nonstaticCircle, staticCircle, collisionPoint.x));
        }
        else
        {
            return(IntersectionPointColliderHorizontalAtYPoint(nonstaticCircle, staticCircle, collisionPoint.y));
        }
    }
    /// <summary>
    ///
    /// </summary>
    /// <param name="staticCapsule"></param>
    /// <param name="nonstaticCircle"></param>
    /// <param name="collidedVertically"></param>
    /// <returns></returns>
    public static Vector2 IntersectionPointStaticCapsuleNonstaticCircle(CustomCapsuleCollider2D staticCapsule, CustomCircleCollider2D nonstaticCircle, bool collidedVertically = true)
    {
        Vector2 capCenter = staticCapsule.GetCenter();
        Vector2 cCenter   = nonstaticCircle.GetCenter();

        Vector2 collisionPoint;

        if (collidedVertically)
        {
            if (cCenter.y < capCenter.y)
            {
                collisionPoint = CollisionPointCircleOnCircleBounds(staticCapsule.bounds.bottomCircleBounds, nonstaticCircle.bounds);
            }
            else
            {
                collisionPoint = CollisionPointCircleOnCircleBounds(staticCapsule.bounds.topCircleBounds, nonstaticCircle.bounds);
            }
            return(IntersectionPointColliderVerticalAtXPoint(nonstaticCircle, staticCapsule, collisionPoint.x));
        }
        else
        {
            if (cCenter.y > staticCapsule.bounds.rectBounds.topLeft.y)
            {
                collisionPoint = CollisionPointCircleOnCircleBounds(staticCapsule.bounds.topCircleBounds, nonstaticCircle.bounds);
            }
            else if (cCenter.y < staticCapsule.bounds.rectBounds.bottomLeft.y)
            {
                collisionPoint = CollisionPointCircleOnCircleBounds(staticCapsule.bounds.bottomCircleBounds, nonstaticCircle.bounds);
            }
            else
            {
                collisionPoint = cCenter;
            }
            return(IntersectionPointColliderHorizontalAtYPoint(nonstaticCircle, staticCapsule, collisionPoint.y));
        }
    }
    public Vector2 IntersectionPointStaticRectOnNonstaticCircle(CustomBoxCollider2D staticRect, CustomCircleCollider2D nonstaticCircle, bool collidedVertically)
    {
        BoundsRect   r1 = staticRect.bounds;
        BoundsCircle c1 = nonstaticCircle.bounds;

        Vector2 centerPointOfCircle = c1.center;
        Vector2 collisionPoint;

        if (collidedVertically)
        {
            if (centerPointOfCircle.x < r1.bottomLeft.x)
            {
                collisionPoint.x = r1.bottomLeft.x;
            }
            else if (centerPointOfCircle.x > r1.bottomRight.x)
            {
                collisionPoint.x = r1.bottomRight.x;
            }
            else
            {
                collisionPoint.x = centerPointOfCircle.x;
            }
            return(IntersectionPointColliderVerticalAtXPoint(nonstaticCircle, staticRect, collisionPoint.x));
        }
        else
        {
            if (centerPointOfCircle.y < r1.bottomLeft.y)
            {
                collisionPoint.y = r1.bottomLeft.y;
            }
            else if (centerPointOfCircle.y > r1.topLeft.y)
            {
                collisionPoint.y = r1.topLeft.y;
            }
            else
            {
                collisionPoint.y = centerPointOfCircle.y;
            }
            return(IntersectionPointColliderHorizontalAtYPoint(nonstaticCircle, staticRect, collisionPoint.y));
        }
    }