游戏中常用的运动曲线

2020-05-10

前言

抛物线运动在游戏开发中是比较常用的一个知识点，典型的射击类游戏炮弹的运动轨迹，我们就来回顾一下基本的物理公式吧，s = vt+1/2 a t * t。为了让策划可以调整炮弹的运动曲线轨迹，就做一个方便调节的工具。还有一种曲线游戏中比较常用的就是贝塞尔曲线，例如我做过的一个需求就是轰炸机飞行轨迹就用到贝塞尔曲线，这里用的是二阶贝塞尔曲线，下面就介绍这两种常用曲线的应用效果。

工具运行效果

计算公式

以上是抛物线运动公式，下面是二阶贝塞尔曲线公式，想要了解详细的贝塞尔曲线

抛物线运动编辑工具

ParabolaTool

using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.Rendering;

[CustomEditor(typeof(ParabolaEditor))]
public class ParabolaTool : Editor
{
    [MenuItem("Tools/Parabola")]
    static void MakeParampola()
    {
        if (MakeEnv())
        {
            var obj = AssetDatabase.LoadAssetAtPath<GameObject>("Assets/Demo/ParabolaEdit/Parabola/Editor/Parabola.prefab");
            var go = GameObject.Instantiate(obj) as GameObject;
            go.transform.position = Vector3.zero;
            go.transform.rotation = Quaternion.identity;
            Selection.activeGameObject = go;

            var camera = Camera.main;
            if (camera)
            {
                camera.transform.position = new Vector3(-29,8 -70);
            }
        }
    }

    public static bool MakeEnv()
    {
        if (!EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo())
        {
            return false;
        }
        else
        {
            EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
            GraphicsSettings.renderPipelineAsset = null;
            var light = GameObject.FindObjectOfType<Light>();
            light.transform.localEulerAngles = new Vector3(100, 0, 0);
            return true;
        }
    }

    ParabolaEditor parabola;

    private void OnEnable()
    {
        parabola = target as ParabolaEditor;
    }

    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
        EditorGUILayout.Space();
        EditorGUILayout.LabelField("其他程序生成信息");
        double a = parabola.RuntimeParabola(out var dir, out float speed);
        EditorGUILayout.LabelField("水平分速度:", speed.ToString("f2"));
        EditorGUILayout.LabelField("垂直加速度:", a.ToString("f2"));
        EditorGUILayout.Space();
        var ori = parabola.original.transform.position;
        var des = parabola.destination.transform.position;
        var start = new Vector2(ori.x, ori.z);
        var end = new Vector2(des.x, des.z);
        float dist = Vector2.Distance(start, end); //水平距离
        EditorGUILayout.LabelField("总距离:", Vector3.Distance(des, ori).ToString("f2")); //3D距离
        EditorGUILayout.LabelField("水平方向距离:", dist.ToString("f2"));
        EditorGUILayout.LabelField("垂直方向距离:", (ori.y - des.y).ToString("f2")); //垂直距离 Y高度差

        var go = parabola.go;
        if (go != null)
        {
            EditorGUILayout.Space();
            EditorGUILayout.LabelField("当前位置:", go.transform.position.ToString());
            Repaint(); //重绘
        }
    }
}

ParabolaEditor

#if UNITY_EDITOR
using System;
using UnityEngine;

public class ParabolaEditor : MonoBehaviour
{
    [Header("起始点")]
    public Transform original;
    [Header("结束点")]
    public Transform destination;
    [Header("向上速度")]
    public int vy;
    [Header("轨迹点数")]
    public int count;
    [Header("运动时间")]
    public float time;
    //垂直加速度
    private double acc;
    private Vector2 h_dir; //水平方向
    private float h_speed; //水平速度
    private bool play;
    private float start; //开始时间
    [HideInInspector]
    public GameObject go;

    private void TodoStart()
    {
        if (go == null)
            go = GameObject.Instantiate(original.gameObject);
        go.transform.position = original.position;
        //计算出垂直加速度
        acc = RuntimeParabola(out h_dir, out h_speed);
        play = true;
        start = Time.time;
    }

    void Update()
    {
        if (play)
        {
            float t = Time.time - start;
            Vector2 st = new Vector2(original.position.x, original.position.z);
            var h1 = st + h_dir * h_speed * t; //帧事件内水平位置
            var v1 = original.position.y - (float)(0.5f * acc * t * t) + vy * t; //帧时内垂直位置
            go.transform.position = new Vector3(h1.x, v1, h1.y); //实时坐标
            if (t >= time)
            {
                play = false;
            }
        }

        if (Input.GetKeyUp(KeyCode.Space))
        {
            TodoStart();
        }
    }

    private void OnDrawGizmos()
    {
        if (original && destination)
        {
            Gizmos.color = Color.red;
            CalParabola(out var v_s); //获取3D路点列表
            int len = v_s.Length;
            for (int i = 0; i < len - 1; i++)
            {
                Gizmos.DrawLine(v_s[i], v_s[i + 1]); //每个点之间连线
            }
            Gizmos.color = Color.cyan;
            for (int i = 0; i < len; i++)
            {
                Gizmos.DrawSphere(v_s[i], 1); //绘制圆形
            }
        }
    }

    //计算垂直加速度
    public double RuntimeParabola(out Vector2 h_dir, out float h_speed)
    {
        //获取水平方向的距离
        float h = h_dis(out var dir, out Vector2 start);
        h_dir = dir; //水平方向的单位向量
        h_speed = h / time; //水平方向的速度
        float s = destination.position.y - original.position.y;//垂直方向高度差
        return Math.Abs((vy * time - s) / (0.5 * time * time)); //计算出加速度  s = vt+(1/2)at*t
    }

    //计算3D路点
    private void CalParabola(out Vector3[] ps)
    {
        //计算水平距离
        float h = h_dis(out var dir, out Vector2 start);
        //计算水平速度
        float vx = h / time;
        //垂直距离
        float s = destination.position.y - original.position.y;
        ps = new Vector3[count + 1];
        //计算垂直加速度g
        double a = Math.Abs((vy * time - s) / (0.5 * time * time));
        for (int i = 0; i < count + 1; i++)
        {
            float t = (time * i) / count; //每隔一个路点的时间
            var h1 = start + dir * vx * t; //水平方向的2d坐标
            var v1 = original.position.y - (float)(0.5 * a * (t * t)) + vy * t;  //v1-position.y = vt-0.5*a*t*t
            ps[i] = new Vector3(h1.x, v1, h1.y); //每一个点的坐标
        }
    }

    /// <summary>
    /// 计算水平方向的距离
    /// </summary>
    /// <param name="dir">水平方向的单位向量</param>
    /// <param name="start">开始位置</param>
    /// <returns></returns>
    private float h_dis(out Vector2 dir, out Vector2 start)
    {
        start = new Vector2(original.position.x, original.position.z);
        var end = new Vector2(destination.position.x, destination.position.z);
        dir = (end - start).normalized;
        return Vector2.Distance(end, start);
    }
}
#endif

贝塞尔曲线

using UnityEngine;
[RequireComponent(typeof(LineRenderer))]
public class Bezier : MonoBehaviour
{
    public Transform[] controlPoints;
    public LineRenderer lineRenderer;
    private int layerOrder = 0;
    private int _segmentNum = 50;

    void Start()
    {
        if (!lineRenderer)
        {
            lineRenderer = GetComponent<LineRenderer>();
        }
        lineRenderer.sortingLayerID = layerOrder;
    }

    void Update()
    {
        DrawCurve();
    }

    void DrawCurve()
    {
        for (int i = 1; i <= _segmentNum; i++)
        {
            float t = i / (float)_segmentNum;
            int nodeIndex = 0;
            Vector3 pixel = CalculateCubicBezierPoint(t, controlPoints[nodeIndex].position,
                controlPoints[nodeIndex + 1].position, controlPoints[nodeIndex + 2].position);
            lineRenderer.positionCount = i;
            lineRenderer.SetPosition(i - 1, pixel);
        }
    }

    Vector3 CalculateCubicBezierPoint(float t, Vector3 p0, Vector3 p1, Vector3 p2)
    {
        float u = 1 - t;
        float tt = t * t;
        float uu = u * u;

        Vector3 p = uu * p0;
        p += 2 * u * t * p1;
        p += tt * p2;
        return p;
    }
}

丁小未