SpringJoint2D介绍

SpringJoint2D是Unity中的一个组件，用于模拟弹簧的物理效果。它可以将两个物体连接在一起，并在物体之间施加力或阻力，从而模拟弹簧的伸缩和振动。

SpringJoint2D可以用于模拟多种物理效果，例如弹簧、绳索、链条等。在游戏开发中，常用于实现弹射物、绳索物理、角色动作等效果。

SpringJoint2D方法

属性

anchor：连接两个物体的锚点，以本地坐标系表示。
connectedAnchor：连接的另一个物体的锚点，以本地坐标系表示。
autoConfigureDistance：是否自动计算连接的距离。
distance：连接的距离。
dampingRatio：阻尼比，用于控制弹簧的振动。
frequency：弹簧的频率，用于控制弹簧的振动。

方法

GetReactionForce(float2D timeStep)：获取连接两个物体施加的力。
GetReactionTorque(float2D timeStep)：获取连接两个物体施加的扭矩。

SpringJoint2D举例子

例子1：实现弹簧效果

public class Spring : MonoBehaviour
{
    
    
    public Rigidbody2D connectedBody;
    public float distance;
    public float dampingRatio;
    public float frequency;

    private void Start()
    {
    
    
        var joint = gameObject.AddComponent<SpringJoint2D>();
        joint.connectedBody = connectedBody;
        joint.distance = distance;
        joint.dampingRatio = dampingRatio;
        joint.frequency = frequency;
    }
}

在上面的例子中，我们创建了一个Spring脚本，并将其附加到一个物体上。在Start方法中，我们通过AddComponent方法添加了一个SpringJoint2D组件，并设置了连接的物体、距离、阻尼比和频率，从而实现了弹簧效果。

例子2：实现绳索物理

public class Rope : MonoBehaviour
{
    
    
    public Rigidbody2D connectedBody;
    public float distance;
    public float dampingRatio;
    public float frequency;
    public int segmentCount;

    private void Start()
    {
    
    
        var startJoint = gameObject.AddComponent<SpringJoint2D>();
        startJoint.connectedBody = connectedBody;
        startJoint.autoConfigureDistance = false;
        startJoint.distance = distance;
        startJoint.dampingRatio = dampingRatio;
        startJoint.frequency = frequency;

        var lastSegment = gameObject;
        for (int i = 0; i < segmentCount; i++)
        {
    
    
            var segment = new GameObject("Segment " + i);
            var joint = segment.AddComponent<SpringJoint2D>();
            joint.connectedBody = lastSegment.GetComponent<Rigidbody2D>();

            if (i == segmentCount - 1)
            {
    
    
                joint.connectedBody = connectedBody;
            }

            joint.autoConfigureDistance = false;
            joint.distance = distance / segmentCount;
            joint.dampingRatio = dampingRatio;
            joint.frequency = frequency;
            segment.transform.position = lastSegment.transform.position - new Vector3(0, distance / segmentCount, 0);

            lastSegment = segment;
        }

        var endJoint = lastSegment.AddComponent<SpringJoint2D>();
        endJoint.connectedBody = connectedBody;
        endJoint.autoConfigureDistance = false;
        endJoint.distance = distance / segmentCount;
        endJoint.dampingRatio = dampingRatio;
        endJoint.frequency = frequency;
    }
}

在上面的例子中，我们创建了一个Rope脚本，并将其附加到一个物体上。在Start方法中，我们通过AddComponent方法添加了一个SpringJoint2D组件，并设置了连接的物体、距离、阻尼比和频率，从而实现了绳索的起始部分。

接着，我们创建了多个物体，并将它们连接在一起，形成一条绳索。在连接每个物体时，我们都添加了一个SpringJoint2D组件，并设置了连接的物体、距离、阻尼比和频率，从而实现了绳索的中间部分。

最后，我们在绳索的末尾添加了一个SpringJoint2D组件，并设置了连接的物体、距离、阻尼比和频率，从而实现了绳索的末尾部分。

例子3：实现角色动作

public class Character : MonoBehaviour
{
    
    
    public Rigidbody2D body;
    public float jumpForce;
    public float moveSpeed;
    public float maxDistance;
    public float dampingRatio;
    public float frequency;

    private SpringJoint2D currentJoint;

    private void Update()
    {
    
    
        if (Input.GetKeyDown(KeyCode.Space))
        {
    
    
            if (currentJoint != null)
            {
    
    
                Destroy(currentJoint);
            }

            var mousePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            var direction = (mousePosition - transform.position).normalized;
            var distance = Vector2.Distance(mousePosition, transform.position);

            if (distance > maxDistance)
            {
    
    
                distance = maxDistance;
            }

            currentJoint = gameObject.AddComponent<SpringJoint2D>();
            currentJoint.connectedBody = body;
            currentJoint.autoConfigureDistance = false;
            currentJoint.distance = distance;
            currentJoint.dampingRatio = dampingRatio;
            currentJoint.frequency = frequency;
            currentJoint.anchor = Vector2.zero;
            currentJoint.connectedAnchor = (mousePosition - body.transform.position).normalized * -currentJoint.distance;

            body.velocity = Vector2.zero;
            body.AddForce(direction * jumpForce, ForceMode2D.Impulse);
        }

        var horizontalInput = Input.GetAxis("Horizontal");
        var verticalInput = Input.GetAxis("Vertical");
        body.velocity = new Vector2(horizontalInput * moveSpeed, body.velocity.y);
    }
}

在上面的例子中，我们创建了一个Character脚本，并将其附加到一个角色物体上。在Update方法中，我们监听了玩家的输入，并在按下空格键时执行跳跃操作。

跳跃操作的实现方式是，创建一个SpringJoint2D组件，并将其连接到角色物体和另一个物体上。另一个物体的位置是根据鼠标点击位置计算出来的，并且距离角色物体的距离有一个最大值。

在连接两个物体时，我们设置了SpringJoint2D组件的距离、阻尼比和频率，从而实现了弹簧效果。同时，我们还给SpringJoint2D组件设置了锚点和连接点，从而控制了弹簧的位置和方向。

最后，我们还对角色的移动进行了控制，通过改变角色物体的速度实现。

详解unity中的SpringJoint2D