1

我目前正在为我正在学习的一门课程做一个项目。我正在用 unity3D 制作一个 2D 游戏，我有一个小问题，每次我运行游戏时，我的角色都会不断地从地图上掉下来，即使我已经为我的角色和前景添加了一个刚体 2D 和一个 boxCollider2D。附上代码，它是用 C# 编写的，有点长。非常感谢你提前..

enter code here 
using System;
using UnityEngine;
using System.Collections;

public class CharacterController2D : MonoBehaviour 
{
private const float SkinWidth = .02f;
private const int TotalHorizontalRays = 8;
private const int TotalVerticalRays = 4;

private static readonly float SlopeLimitTanget = Mathf.Tan (75f * Mathf.Deg2Rad);

public LayerMask PlatformMask;
public ControllerParameters2D DefaultParameters;


public ControllerState2D State { get; private set; }
public Vector2 Velocity { get { return _velocity; }}
public bool HandleCollisions { get; set; }
//Return overrideparamteres if it is not null, if it is null it will return DefaultParameters
public ControllerParameters2D Parameters { get { return _overrideParameters ?? DefaultParameters; } }
public GameObject StandingOn { get; private set;}
public Vector3 PlatformVelocity { get; private set;}

public bool CanJump 
    { 
        get 
        {
            if(Parameters.JumpRestrictions == ControllerParameters2D.JumpBehavior.CanJumpAnywhere)
                return _jumpIn <= 0;

            if(Parameters.JumpRestrictions == ControllerParameters2D.JumpBehavior.CanJumpOnGround)
                return State.IsGrounded;

            return false;
        }
    }


private Vector2 _velocity;
private Transform _transform;
private Vector3 _localScale;
private BoxCollider2D _boxCollider;
private ControllerParameters2D _overrideParameters;
private float _jumpIn;
private GameObject _lastStandingOn;
private Vector3
        _activeGlobalPlatformPoint,
        _activeLocalPlatformPoint;

private Vector3
        _raycastTopLeft,
        _raycastBottomRight,
        _raycastBottomLeft;

private float _verticalDistanceBetweenRays,
_horizonatalDistanceBetweenRays;

public void Awake()
{
    HandleCollisions = true;
    State = new ControllerState2D();
    _transform = transform;
    _localScale = transform.localScale;
    _boxCollider = GetComponent <BoxCollider2D>();

    // Absolute Value
    var colliderWidth = _boxCollider.size.x * Mathf.Abs(transform.localScale.x) - (2 * SkinWidth);
    _horizonatalDistanceBetweenRays = colliderWidth / (TotalVerticalRays - 1);

    var colliderHeight = _boxCollider.size.y * Mathf.Abs( transform.localScale.y ) - (2 * SkinWidth);
    _verticalDistanceBetweenRays = colliderHeight / (TotalHorizontalRays - 1);
}

public void AddForce(Vector2 force)
{
    _velocity = force;
}

public void SetForce(Vector2 force)
{
    _velocity += force;
}

public void SetHorizontalForce(float x)
{
    _velocity.x = x;
}

public void SetVerticalForce(float y)
{
    _velocity.y = y;
}

public void Jump()
{
    AddForce(new Vector2(0, Parameters.JumpMagnitude));
    _jumpIn = Parameters.JumpFrequency;
}

public void LateUpdate()
{
    _jumpIn -= Time.deltaTime;
    //We force the player to go up or down based on the gravity
    _velocity.y += Parameters.Gravity * Time.deltaTime; 
    //Move the characther per his velocity scaled by time
    Move (Velocity * Time.deltaTime);
}

// Ensures the player doesn't fall off the map or move through the wall
private void Move(Vector2 deltaMovement)
{
    var wasGrounded = State.IsCollidingBelow;
    State.Reset();

    if(HandleCollisions)
    {
        HandlePlatforms();
        CalculateRayOrigins();

        if(deltaMovement.y < 0 && wasGrounded)
            HandleVerticalSlope(ref deltaMovement);

        if(Mathf.Abs(deltaMovement.x) > .001f)
            MoveHorizontally(ref deltaMovement);

        MoveVertically(ref deltaMovement);

        CorrectHorizontalPlacement(ref deltaMovement, true);
        CorrectHorizontalPlacement(ref deltaMovement, false);
    }

    _transform.Translate(deltaMovement, Space.World);

    if (Time.deltaTime > 0)
        _velocity = deltaMovement / Time.deltaTime;

    _velocity.x = Mathf.Min (_velocity.x, Parameters.MaxVelocity.x);
    _velocity.y = Mathf.Min (_velocity.y, Parameters.MaxVelocity.y);

    if(State.IsMovingUpSlope)
        _velocity.y = 0;

    //Standing on the platform  
    if(StandingOn != null)
    {
            _activeGlobalPlatformPoint = transform.position;
            _activeLocalPlatformPoint = StandingOn.transform.InverseTransformPoint(transform.position);

            Debug.DrawLine(transform.position, _activeGlobalPlatformPoint);
            Debug.DrawLine(transform.position, _activeLocalPlatformPoint + StandingOn.transform.position);

            if(_lastStandingOn != StandingOn)
            {
                //If the last thing we are standing on is not null, send a message to leave it
                if(_lastStandingOn != null)
                    _lastStandingOn.SendMessage("ControllerExist2D", this, SendMessageOptions.DontRequireReceiver);

                //Inform what we are standing on that we have entered
                StandingOn.SendMessage("ControllerEnter2D", this, SendMessageOptions.DontRequireReceiver);
                _lastStandingOn = StandingOn;
            }

            //Invoke the platform that we are standing on it
            else if (StandingOn != null)
                StandingOn.SendMessage("ControllerStay2D", this, SendMessageOptions.DontRequireReceiver); 
    }
    else if (_lastStandingOn != null)
    {
        _lastStandingOn.SendMessage("ControllerExit2D", this, SendMessageOptions.DontRequireReceiver);
        _lastStandingOn = null;
    }
}

private void HandlePlatforms()
{
        //Calculate the velocity of the platform
        if(StandingOn != null)
        {
            var newGlobalPlatformPoint = StandingOn.transform.TransformPoint(_activeLocalPlatformPoint);
            var moveDistance = newGlobalPlatformPoint - _activeGlobalPlatformPoint;
            //Sticks the player on the platform, wherever the platform teleport the players stays on it
            if(moveDistance != Vector3.zero)
                transform.Translate(moveDistance, Space.World);

            PlatformVelocity = (newGlobalPlatformPoint - _activeGlobalPlatformPoint) / Time.deltaTime;
        }
        else
            PlatformVelocity = Vector3.zero;

        StandingOn = null;
}

private void CorrectHorizontalPlacement(ref Vector2 deltaMovement, bool isRight)
{
        var halfwidth = (_boxCollider.size.x * _localScale.x) / 2f;
        var rayOrigin = isRight ? _raycastBottomRight : _raycastBottomLeft;

        if(isRight)
            rayOrigin.x -= (halfwidth - SkinWidth);
        else
            rayOrigin.x += (halfwidth - SkinWidth);

        var rayDirection = isRight ? Vector2.right : -Vector2.right;
        var offset = 0f;

        for(var i = 1; i <= TotalHorizontalRays - 1; i++)
        {
            var rayVector = new Vector2(deltaMovement.x + rayOrigin.x, deltaMovement.y + rayOrigin.y + (i * _verticalDistanceBetweenRays));
            Debug.DrawRay(rayVector, rayDirection * halfwidth, isRight ? Color.cyan : Color.magenta);

            var raycastHit = Physics2D.Raycast(rayVector, rayDirection, halfwidth, PlatformMask);
            if(!raycastHit)
                continue;


            offset = isRight ? ((raycastHit.point.x - _transform.position.x) - halfwidth) : (halfwidth - (_transform.position.x - raycastHit.point.x));
        }

        deltaMovement.x += offset;
}

private void CalculateRayOrigins()
{
        var size = new Vector2 (_boxCollider.size.x * Mathf.Abs (_localScale.x), _boxCollider.size.y * Mathf.Abs (_localScale.y)) / 2;
        var center = new Vector2(_boxCollider.center.x * _localScale.x, _boxCollider.center.y * _localScale.y);

        //Location of the player, then we add the box collider to it relative to the center of the player
        _raycastTopLeft = _transform.position + new Vector3 (center.x - size.x + SkinWidth, center.y + size.y - SkinWidth);
        _raycastBottomRight = _transform.position + new Vector3 (center.x + size.x - SkinWidth, center.y - size.y + SkinWidth); //Going right
        _raycastBottomLeft = _transform.position + new Vector3 (center.x - size.x + SkinWidth, center.y - size.y + SkinWidth); //Going left and down-up
}

//Cast rays to the left or to the right depending on the player's movement
//Determining how far the player can go either to the left, or to the right
private void MoveHorizontally(ref Vector2 deltaMovement) 
{
        var isGoingRight = deltaMovement.x > 0;
        //The distance between the starting point and the final destination
        var rayDistance = Mathf.Abs (deltaMovement.x) + SkinWidth;
        //Where is the player going? right or left
        var rayDirection = isGoingRight ? Vector2.right : -Vector2.right;
        //Right? we start from bottom right. Left? we start fro, bottom left
        var rayOrigin = isGoingRight ? _raycastBottomRight : _raycastBottomLeft;

        //Determines how many rays we want to shoot out to the left or to the right
        for(var i = 0; i < TotalHorizontalRays; i++)
        {
            var rayVector = new Vector2(rayOrigin.x, rayOrigin.y + (i * _verticalDistanceBetweenRays));
            //Visual representation about the rays
            Debug.DrawRay(rayVector, rayDirection * rayDistance, Color.red);
            //Checks if the player hit something or not
            var rayCastHit = Physics2D.Raycast(rayVector, rayOrigin, rayDistance, PlatformMask);
            if(!rayCastHit) //If there was a raycast then do something, otherwise continue to loop
                continue;

            //We return true if we are on a horizotnal slope, and check if we are going right or left or hit something while going up
            if(i == 0 && HandleHorizontalSlope(ref deltaMovement, Vector2.Angle(rayCastHit.normal, Vector2.up), isGoingRight))
                break;

            //If we hit something then we can only go that far forward
            deltaMovement.x = rayCastHit.point.x - rayVector.x;
            rayDistance = Mathf.Abs(deltaMovement.x);

            if(isGoingRight)
            {
                //If we are going right, then we have to substract the skinwidth
                deltaMovement.x -= SkinWidth;
                State.IsCollidingRight = true;
            }
            else
            {   
                //The oppoiste of the if statement, if we are going left, we add the skinwidth
                deltaMovement.x += SkinWidth;
                State.IsCollidingLeft = true;
            }
            //Handles error collision, if the player hits something and go through it 
            if(rayDistance < SkinWidth + .0001f)
                break;
        }
}

private void MoveVertically(ref Vector2 deltaMovement)
{   
        //Check to see if going up or down
        var isGoingUp = deltaMovement.y > 0;
        var rayDistance = Mathf.Abs (deltaMovement.y) + SkinWidth;
        var rayDirection = isGoingUp ? Vector2.up : -Vector2.up;
        var rayOrigin = isGoingUp ? _raycastTopLeft : _raycastBottomLeft;

        rayOrigin.x += deltaMovement.x;

        var standingOnDistance = float.MaxValue;
        for(var Count = 0; Count < TotalVerticalRays; Count++)
        {
            var rayVector = new Vector2(rayOrigin.x + (Count * _horizonatalDistanceBetweenRays), rayOrigin.y);
            Debug.DrawRay(rayVector, rayDirection * rayDistance, Color.red);

            var raycastHit = Physics2D.Raycast(rayVector, rayDirection, rayDistance, PlatformMask);
            //If the player hit nothing then keep going.
            if(raycastHit)
            {
                continue;
            }

            if(!isGoingUp)
            {
                var verticalDistanceToHit = _transform.position.y - raycastHit.point.y;
                if(verticalDistanceToHit < standingOnDistance)
                {
                    standingOnDistance = verticalDistanceToHit;
                    //Platform we are standing on
                    StandingOn = raycastHit.collider.gameObject;
                }
            }
            //Determine the furthest distance we can move down or up without hitting anything
            deltaMovement.y = raycastHit.point.y - rayVector.y;
            rayDistance = Mathf.Abs(deltaMovement.y);

            if(isGoingUp)
            {
                deltaMovement.y -= SkinWidth;
                State.IsCollidingAbove = true;
            }
            else
            {
                deltaMovement.y += SkinWidth;
                State.IsCollidingBelow = true;
            }

            if(!isGoingUp && deltaMovement.y > .0001f)
            {
                State.IsMovingUpSlope = true;
            }

            if(rayDistance < SkinWidth + .0001f)
            {
                break;
            }
        }
}

private void HandleVerticalSlope(ref Vector2 deltaMovement)
{   
        //Give us the center of the vertical rays;
        var center = (_raycastBottomLeft.x + _raycastBottomRight.x) / 2;
        var direction = -Vector2.up;

        var slopeDistance = SlopeLimitTanget * (_raycastBottomRight.x - center);
        var slopeRayVector = new Vector2 (center, _raycastBottomLeft.y);

        Debug.DrawRay(slopeRayVector, direction * slopeDistance, Color.yellow);

        var raycastHit = Physics2D.Raycast (slopeRayVector, direction, slopeDistance, PlatformMask);
        if (!raycastHit)
                return;

        // ReSharper disable CompareOfFloatsByEqualityOperator

        var isMovingDownSlope = Mathf.Sign (raycastHit.normal.x) == Mathf.Sign (deltaMovement.x);
        if(!isMovingDownSlope)
            return;

        var angle = Vector2.Angle (raycastHit.normal, Vector2.up);
        if(Mathf.Abs(angle) < .0001f)
            return; //Which means there we are not on a slope, we are on something else

        State.IsMovingDownSlope = true;
        State.SlopeAngle = angle;
        deltaMovement.y = raycastHit.point.y - slopeRayVector.y;
}

private bool HandleHorizontalSlope(ref Vector2 deltaMovement, float angle, bool isGoingRight)
{
        //We do not want to move to an angle of 90
        if(Mathf.RoundToInt(angle) == 90)
            return false;

        if(angle > Parameters.SlopeLimit)
        {
            deltaMovement.x = 0;
            return true;
        }

        if(deltaMovement.y > .07f)
            return true;

        deltaMovement.x += isGoingRight ? -SkinWidth : SkinWidth;
        deltaMovement.y = Mathf.Abs (Mathf.Tan (angle * Mathf.Deg2Rad) * deltaMovement.x);
        State.IsMovingUpSlope = true;
        State.IsCollidingBelow = true;
        return true;
}

public void OnTriggerEnter2D(Collider2D other)
{
    var parameters = other.gameObject.GetComponent<ControllerPhysicsVolume2D>();

    if(parameters == null)
        return;


    _overrideParameters = parameters.Parameters;
}

public void OnTriggerExit2D(Collider2D other)
{
    var parameters = other.gameObject.GetComponent<ControllerPhysicsVolume2D>();
    if(parameters == null)
        return;

    _overrideParameters = null;
}

}

4

1 回答 1

0

正如@Terrance 所说，您真的不需要编写自己的代码逻辑来进行碰撞检测。

其次，我注意到您的代码中OnTriggerEnter2D的OnTriggerExit2D方法，这也指出了您的所有 boxCollider2d 都已isTrigger检查选项的一件事。因此，我建议您取消选中isTrigger玩家和地面上的选项，因为 TRIGGER 永远不会阻止两个对象相互交叉（如果您不希望两个对象通过，则需要在它们的碰撞器上取消选中“isTrigger”彼此）。并使用方法OnCollisionEnter2D和OnCollisionExit2D来检测碰撞。

触发器和对撞机有什么区别：

以现实世界为例，对撞机是有形的物体，例如您自己和您站立的地板都是实心和有形的。

虽然触发器是无形的，但触发器的示例可以是穿行安全门；这些门从内部是空心的，任何人都可以毫无阻碍地通过，但是如果您在自己身上佩戴任何金属物体并穿过门之间的“空心区域”，门就会触发警报。因此，就游戏世界而言，您可以说门的中空区域有一个触发器。

于 2015-06-29T19:49:23.490 回答