yichael_smartbow/Assets/BowArrow/Scripts/Game/Arrow.cs

using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
/* 箭对象 */
public class Arrow : MonoBehaviour
{
    private Rigidbody newRigidbody;
    public Vector3 shootOutPosition;
    public float flyTime = 0;
    public bool isHit = false;
    public RaycastHit absoluteRay;
    public float offsetAngle;
    private float mySpeed = 0;
    public bool simulatedParabola = false; //模拟抛物线 
    public ArmBow armBow;
    public static float speed = GameMgr.RealSizeToGameSize(60);

    void Awake()
    {
        GameMgr.ins.gameMode.PauseTimeCounting(this);
    }

    void Start()
    {
        newRigidbody = this.gameObject.AddComponent<Rigidbody>();

        mySpeed = speed;
        Billboard.ins?.SetArrowSpeed(speed);
        if (GameAssistUI.ins) {
            mySpeed *= GameAssistUI.ins.shootScaleValue;
            Billboard.ins?.SetArrowSpeedScale(GameAssistUI.ins.shootScaleValue);
        }
        Billboard.ins?.ShowSpeed();

        if (absoluteRay.transform && absoluteRay.transform.gameObject.name == "TargetBody") {
            //把瞄准点画成红圈，渲染在靶子上
            Transform redCircle = TargetBody.ins.transform.Find("RedCircle");
            redCircle.gameObject.SetActive(true);
            redCircle.transform.position = -redCircle.transform.forward * 0.001f + absoluteRay.point;
        }
        if (absoluteRay.transform && absoluteRay.transform.gameObject.name == "TargetBody") {  
            SetUpBeforFly();
        }

        newRigidbody.velocity = this.transform.forward * mySpeed;
        newRigidbody.collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic;
        newRigidbody.drag = 0;
        newRigidbody.angularDrag = 0;

        Transform cameraTF = this.transform.Find("Camera");
        cameraTF.gameObject.SetActive(true);
        cameraTF.gameObject.AddComponent<ArrowCamera>().arrow = this;

        this.activeEffectTrail(true);

        //是update运动，则禁用物理运动
        if (useUpdatePhysics) {
            this.GetComponent<BoxCollider>().enabled = false;
            Destroy(newRigidbody);
        }
    }

    /**在箭飞行前初始化&如果瞄准射线的落点在靶子上时，才调用该函数 */
    void SetUpBeforFly()
    {
        //看能否通过调整发射角让箭落在靶子的瞄准点上
        CalculateParabolaAngle(absoluteRay.point); 

        if (!hasParabolaAngle) { //发射角无解，就提示用户
            if (AimLoadChecker.ins) AimLoadChecker.ins.ShowOutTip();
            return;
        }
        //来到这里，证明发射角有解，该解姑且叫它绝对角

        //因为Unity引擎的规则，向上时359~270度，向下是0~90度
        //为了方便数学运算，换算成 向上时0~90度，向下是0~-90度
        float baseAngleX = this.transform.eulerAngles.x;
        if (baseAngleX > 180) baseAngleX = baseAngleX - 360;
        baseAngleX *= -1;

        //绝对角
        float absoluteAngleX = parabolaAngleInRadian / Mathf.PI * 180;

        //客户要求绝对角跟原本角度相差不能超过 maxDeltaAngleX
        float deltaAngleX = absoluteAngleX - baseAngleX;
        float maxDeltaAngleX = 5;

        //最终的角还要加上偏移角度，偏移角也是客户要求加，单纯是为了增加误差，简单模式偏移角度为0
        float finalAngleX = this.offsetAngle;
        //如果绝对角跟原本角度相差超过 maxDeltaAngleX，就不能用绝对角了，直接在原本角度上加上最大差角
        if (Mathf.Abs(deltaAngleX) > maxDeltaAngleX) {
            finalAngleX += baseAngleX;
            finalAngleX += deltaAngleX > 0 ? maxDeltaAngleX : -maxDeltaAngleX;
            if (AimLoadChecker.ins) AimLoadChecker.ins.ShowOutTip(); 
        } else {//不超过就最好，直接用绝对角
            finalAngleX += absoluteAngleX;
        }

        //拆分两轴的速度
        float vy = Mathf.Sin(finalAngleX / 180 * Mathf.PI) * this.mySpeed;
        float vx = Mathf.Cos(finalAngleX / 180 * Mathf.PI) * this.mySpeed;
        //x轴距离
        float deltaX = Mathf.Sqrt(
            Mathf.Pow(absoluteRay.point.x - this.shootOutPosition.x, 2) + 
            Mathf.Pow(absoluteRay.point.z - this.shootOutPosition.z, 2)
        );
        //x方向的耗时
        float tx = deltaX / vx;
        //最终y轴的位移
        float dy = vy * tx + 0.5f * Physics.gravity.y * tx * tx;

        float tbRadius = 0.62f;//靶子半径
        //之所以这样比较，是因为发射位置跟靶子中心是等高的，靶子半径是已知的
        if (Mathf.Abs(dy) < tbRadius) { //在靶子范围内，则用update运算物理
            finalPoint = absoluteRay.point;
            finalPoint.y = absoluteRay.transform.parent.position.y + dy;
            useUpdatePhysics = true;
            parabolaAngleInRadian = finalAngleX / 180 * Mathf.PI;
            RandomUseSideCamera();
        } else { //否则，调下角度就好，到时候用unity物理运算
            Vector3 eulerAngle = this.transform.eulerAngles;
            eulerAngle.x = -finalAngleX;
            this.transform.eulerAngles = eulerAngle;
        }
    }

    void RandomUseSideCamera() {
        //有几率进入侧面镜头观看         
        float distance = TargetBody.ins.GetDistance();
        if (Mathf.RoundToInt(distance) >= 50) {
            if (Random.value < 0.5) simulatedParabola = true;
        }
    }

    /**发射角有无解 */
    bool hasParabolaAngle = false;
    /**发射角弧度解 */
    float parabolaAngleInRadian = 0;
    /**
        求弓箭发射到指定坐标所需要的角度。
        已知初速度大小V,重力g，起始坐标（a1,a2）,目标坐标（b1,b2）。
        解：
        1、列出关系式
        Δx = b1 - a1;
        Δy = b2 - a2;
        Vx = V * cos(angle)
        Vy = V * sin(angle)
        Vy * t + 1/2 * g * t^2 = Δy
        Vx * t = Δx
        t = Δx / Vx
        2、推导过程
        (V * sin(angle)) * Δx / (V * cos(angle)) + 1/2 * g * Δx^2 / (V^2*cos(angle)^2) = Δy
        tan(angle) * Δx + 1/2 * g * Δx^2 / (V^2*cos(angle)^2) = Δy
        tan(angle) * Δx + 1/2 * g * (Δx^2 / V^2) * (1 + tan(angle)^2) = Δy
        3、根据求根公式得出结论
        a = 1/2 * g * Δx^2 / V^2
        b = Δx
        c = a -  Δy
        d = tan(angle) = (-b ± (b^2 - 4*a*c)^0.5) / (2*a)
        angle = atan(d) 
        有无根的判别式，有根则b^2-4*a*c>=0
    */
    void CalculateParabolaAngle(Vector3 destination)
    {
        float deltaX = Vector2.Distance(
            new Vector2(destination.x, destination.z), 
            new Vector2(this.transform.position.x, this.transform.position.z)
        );
        float deltaY = destination.y - this.transform.position.y;
        float a = 0.5f * Physics.gravity.y * Mathf.Pow(deltaX, 2) / Mathf.Pow(this.mySpeed, 2);
        float b = deltaX;
        float c = a - deltaY;
        hasParabolaAngle = Mathf.Pow(b, 2) - 4 * a * c >= 0;
        if (hasParabolaAngle) {
            float res1 = (-b + Mathf.Pow(Mathf.Pow(b, 2) - 4*a*c, 0.5f)) / (2 * a);
            float res2 = (-b - Mathf.Pow(Mathf.Pow(b, 2) - 4*a*c, 0.5f)) / (2 * a);
            parabolaAngleInRadian = Mathf.Min(Mathf.Atan(res1), Mathf.Atan(res2));
        }   
    }

    void OnDestroy() {
        GameMgr.ins.gameMode.ResumeTimeCounting(this);
        if (this.newRigidbody) 
        {
            Destroy(this.newRigidbody);
        }
    }

    void FixedUpdate()
    {
        if (newRigidbody) {
            transform.forward = newRigidbody.velocity.normalized;
        }
        if (!isHit && flyTime >= 0) {
            flyTime += Time.deltaTime;
            if (flyTime > 14) {
                Destroy(gameObject);
                GameMgr.ins.gameMode.HitTarget(0);
                AudioMgr.ins.PlayCheer(false);
                nextShoot();
            }
            this.UpdateRotate();
        }
        // this.UpdateShake();
    }

    void Update() {
        UpdateFlyWithoutPhysics();
    }

    bool useUpdatePhysics = false;
    float flyTimeWithoutPhysics = 0;
    Vector3 finalPoint = default;
    /**更新箭的飞行轨迹（非Unity物理运算）*/
    void UpdateFlyWithoutPhysics() {
        if (!useUpdatePhysics || isHit) return;
        flyTimeWithoutPhysics += Time.deltaTime;
        Vector3 destination = finalPoint;
        float deltaX = Mathf.Sqrt(
            Mathf.Pow(destination.x - shootOutPosition.x, 2) +
            Mathf.Pow(destination.z - shootOutPosition.z, 2)
        );
        float vx = Mathf.Cos(parabolaAngleInRadian) * mySpeed;
        float t = deltaX / vx;
        if (flyTimeWithoutPhysics < t) {
            t = flyTimeWithoutPhysics;
        }
        float vy = Mathf.Sin(parabolaAngleInRadian) * mySpeed + Physics.gravity.y * t;
        float dy = Mathf.Sin(parabolaAngleInRadian) * mySpeed * t + 0.5f * Physics.gravity.y * Mathf.Pow(t, 2);
        float dx = vx * t;
        Vector3 nextPosition = new Vector3(destination.x - shootOutPosition.x, 0, destination.z - shootOutPosition.z);
        nextPosition = nextPosition.normalized * dx;
        nextPosition.y = shootOutPosition.y + dy;
        this.transform.position = nextPosition;
        Vector3 eulerAngles = this.transform.eulerAngles;
        float angleX = Mathf.Atan(vy / vx) / Mathf.PI * 180;
        eulerAngles.x = -angleX;
        this.transform.eulerAngles = eulerAngles;
        //箭头到达目标点时，触发碰撞（之所以用以下，是因为箭的锚点在尾部，而箭的长度接近1.1）
        if (Vector3.Distance(nextPosition, destination) < 1.1f) {
            this.transform.SetParent(TargetBody.ins.transform);
            TargetBody.ins.Hit(this, destination);
        }
    }

    public void Hit() {
        if (GameDebug.ins) GameDebug.ins.ShowRes(absoluteRay.point, this.getHeadPosition());
        gameObject.GetComponent<BoxCollider>().enabled = false;
        if (newRigidbody) {
            newRigidbody.useGravity = false;
            newRigidbody.velocity = Vector3.zero;
            Destroy(newRigidbody);
            newRigidbody = null;
        }
        isHit = true;
        // this.Shake();
        this.activeEffectCyclone(false);
        this.activeEffectBomb(true);
        this.activeEffectTrail(false);

        //最新一箭击中后会发光标记
        ArrowLightSick.RecoveryAll();
        this.GetComponentInChildren<ArrowLightSick>().Hit();
    }

    public Vector3 getHeadPosition() {
        return this.transform.Find("Head").position;
    }

    /**箭矢旋转 */
    private Vector3 rotateV3 = new Vector3(0, 0, 1400);
    private void UpdateRotate() {
        this.transform.Find("Head").Rotate(rotateV3 * Time.deltaTime, Space.Self);
    }

    /**箭矢震动 */
    private bool shaking = false;
    private float shakeTime = 0;
    private float shakeTimeMax = 0.5f;
    private float shakeRange = 5;
    private int shakeDirection = 1;
    private Vector3 shakeAngles = new Vector3();

    private void Shake() 
    {
        this.shaking = true;
        this.shakeTime = 0;
        this.shakeDirection = 1;
    }

    private void UpdateShake() 
    {
        if (!this.shaking) { 
            return;
        }
        Transform transform = this.transform.Find("Head").transform;
        float shakeRangeNow = (1 - this.shakeTime / this.shakeTimeMax) * this.shakeRange;
        if (shakeRangeNow <= 0) {//震动结束
            this.shaking = false;
            this.shakeAngles.x = 0;
        } else {
            this.shakeAngles.x = -this.shakeDirection * shakeRangeNow;
            this.shakeDirection *= -1;
        }
        transform.localEulerAngles = this.shakeAngles;
        this.shakeTime += Time.deltaTime;
    }

    //进入下一轮射击
    public bool hasDoneNextShoot = false;
    public void nextShoot() {
        if (hasDoneNextShoot) return;
        hasDoneNextShoot = true;
        GameMgr.ins.gameMode.ResumeTimeCounting(this);
        if (!GameMgr.ins.gameMode.DoNextShoot()) return;
        if (AimHandler.ins) AimHandler.ins.BanControlObjRotate(false);
        this.armBow.readyShoot();

        //把瞄准点画成红圈，渲染在靶子上（取消）
        Transform redCircle = TargetBody.ins.transform.Find("RedCircle");
        redCircle.gameObject.SetActive(false);
        //最新一箭击中后会发光标记（取消）
        ArrowLightSick.RecoveryAll();
    }

    void OnCollisionEnter(Collision collision) {
        if ((1 << collision.gameObject.layer) != LayerMask.GetMask("Target")) 
        {
            this.Hit();
            GameMgr.ins.gameMode.HitTarget(0);
            AudioMgr.ins.PlayCheer(false);
        }
        this.transform.SetParent(collision.transform.parent);
    }

    public void activeEffectCyclone(bool value)
    {
        this.transform.Find("Head/EF_kuosanquan").gameObject.SetActive(value);
        if (!value) return;
        ParticleSystemRenderer ps = this.transform.Find("Head/EF_kuosanquan/kuosan").GetComponent<ParticleSystemRenderer>();
        ParticleSystemRenderer ps1 = this.transform.Find("Head/EF_kuosanquan/kuosan (1)").GetComponent<ParticleSystemRenderer>();
        DOTween.To(() => ps.minParticleSize, value => {
            ps.minParticleSize = value;
            ps.maxParticleSize = value;
        }, 0.4f, 0.6f);
        DOTween.To(() => ps1.minParticleSize, value => {
            ps1.minParticleSize = value;
            ps1.maxParticleSize = value;
        }, 0.8f, 0.6f);
    }

    void activeEffectBomb(bool value) 
    {
        this.transform.Find("Head/EF_baodian").gameObject.SetActive(value);
    }

    void activeEffectTrail(bool value)
    {
        this.transform.Find("EF_tuowei").gameObject.SetActive(value);
        this.transform.Find("EF_tuowei/Trail").GetComponent<TrailRenderer>().time = 1.6f / mySpeed;
    }
}