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

using System;
using UnityEngine;
using DG.Tweening;
/* 箭对象 */
public class Arrow : MonoBehaviour
{   
    //飞行时间统计
    [NonSerialized] public float flyTime = 0;
    //标识—是否击中了什么
    [NonSerialized] public bool isHit = false;
    //箭的初速度（私用）    
    private float mySpeed = 0;
    //箭的初速度（公用）
    public static float speed = GameMgr.RealSizeToGameSize(60);

    //箭射出时从弓传过来的参数
    #region 
        //手臂弓
        [NonSerialized] public ArmBow armBow;
        //射出时的起始坐标
        [NonSerialized] public Vector3 shootOutPosition;
        //绝对射线
        [NonSerialized] public RaycastHit absoluteRay;
        //制作误差偏移角（强行制造误差，为了增加游戏难度，该偏移角的大小根据难度而定）
        [NonSerialized] public float offsetAngle;
    #endregion

    //射线击中的靶子
    TargetBody rayHitTargetBody;
    //能够完美击中射线点
    bool canPerfectHit;
    //能否使用侧面镜头
    [NonSerialized] public bool canUseSideCamera;

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

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

    void Start()
    {
        Destroy(gameObject.GetComponent<BoxCollider>());

        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) {
            TargetBody targetBody = absoluteRay.transform.GetComponent<TargetBody>();
            rayHitTargetBody = targetBody??null;
            //把瞄准点画成红圈，渲染在靶子上
            if (rayHitTargetBody) {
                Transform redCircle = rayHitTargetBody.transform.Find("RedCircle");
                redCircle.gameObject.SetActive(true);
                redCircle.transform.position = -redCircle.transform.forward * 0.001f + absoluteRay.point;
            }
        }
        SetUpBeforFly();

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

        this.activeEffectTrail(true);
    }

    /**在箭飞行前初始化&如果瞄准射线的落点在靶子上时，才调用该函数 */
    void SetUpBeforFly()
    {
        //基础角
        float baseAngleX = FormatAngleX(this.transform.eulerAngles.x);
        //最大可调整的角度差
        float maxDeltaAngleX = 5;
        //最终角
        float finalAngleX;

        if (absoluteRay.transform) {
            //看能否通过调整发射角让箭落在靶子的瞄准点上
            CalculateParabolaAngle(absoluteRay.point); 
            //瞄准的是不是Target层
            bool isTargetLayer = IsTargetLayer(absoluteRay.transform.gameObject);
            //绝对发射角无解
            if (!hasParabolaAngle) {
                finalAngleX = Mathf.Clamp(baseAngleX + maxDeltaAngleX + this.offsetAngle, -89, 89);
                if (isTargetLayer) AimLoadChecker.ins?.ShowOutTip();
            } else {
                //来到这里，证明发射角有解，该解姑且叫它绝对角
                float absoluteAngleX = parabolaAngleInRadian / Mathf.PI * 180;
                //客户要求绝对角跟原本角度相差不能超过 maxDeltaAngleX
                float deltaAngleX = absoluteAngleX - baseAngleX;
                
                //如果绝对角跟原本角度相差不超过maxDeltaAngleX
                if (Mathf.Abs(deltaAngleX) < maxDeltaAngleX) {
                    finalAngleX = Mathf.Clamp(absoluteAngleX + offsetAngle, -89, 89);
                    if (Math.Abs(offsetAngle) < 0.01) {
                        canPerfectHit = true;
                    }
                    if (rayHitTargetBody && Mathf.RoundToInt(rayHitTargetBody.GetDistance()) >= 50 && UnityEngine.Random.value < 0.5) {
                        canUseSideCamera = true;
                    }
                } else {
                    finalAngleX = Mathf.Clamp(baseAngleX + maxDeltaAngleX + this.offsetAngle, -89, 89);
                    if (isTargetLayer) AimLoadChecker.ins?.ShowOutTip();
                }
            }
            finalPoint = absoluteRay.point;
        } else {
            finalAngleX = baseAngleX;
            finalPoint = this.transform.position + this.transform.forward * 100;
        }

        parabolaAngleInRadian = finalAngleX / 180 * Mathf.PI;
    }

    /*
    因为Unity引擎的规则，向上时359~270度，向下是0~90度
    为了方便数学运算，换算成 向上时0~90度，向下是0~-90度
    */
    float FormatAngleX(float value)
    {
        if (value > 180) value = 360 - value;
        else value = -value;
        return value;
    }

    bool IsTargetLayer(GameObject gameObject) {
        return (1 << gameObject.layer) == LayerMask.GetMask("Target");
    }

    /**发射角有无解 */
    [NonSerialized] public 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 FixedUpdate()
    {
        if (!isHit && flyTime >= 0) {
            flyTime += Time.deltaTime;
            if (flyTime > 14) {
                FlyTimeOut();
            }
            this.UpdateRotate();
        }
    }

    void Update() {
        UpdateFlyLogic();
    }

    void FlyTimeOut() {
        Destroy(gameObject);
        GameMgr.ins.gameMode.HitTarget(0);
        AudioMgr.ins.PlayCheer(false);
        nextShoot();
    }

    float logicFlyTime = 0;
    Vector3 finalPoint;
    /**飞行帧逻辑（运动学） */
    void UpdateFlyLogic() {
        if (isHit) return;
        logicFlyTime += Time.deltaTime;
        Vector3 destination = finalPoint;
        float vx = Mathf.Cos(parabolaAngleInRadian) * mySpeed;
        float t = logicFlyTime;
        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;
        Vector3 oldPosition =  this.transform.position;
        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;

        float deltaDistance = Vector3.Distance(oldPosition, nextPosition);
        Ray ray = new Ray(oldPosition, nextPosition - oldPosition);
        RaycastHit raycastHit;
        bool raycastResult = Physics.Raycast(ray, out raycastHit, deltaDistance);
        if (raycastResult) {
            OnHitAnyInFlyLogic(raycastHit);
        }
    }

    //飞行逻辑中检测到碰撞
    void OnHitAnyInFlyLogic(RaycastHit raycastHit) {
        this.transform.Find("Head").position = raycastHit.point;
        this.transform.SetParent(raycastHit.transform.parent);
        string targetName = raycastHit.transform.gameObject.name;
        if (targetName == "TargetBody") {
            Vector3 hitPoint = raycastHit.point;
            if (rayHitTargetBody && canPerfectHit) {
                hitPoint = absoluteRay.point;
                this.transform.Find("Head").position = hitPoint;
            }
            raycastHit.transform.GetComponent<TargetBody>().Hit(this, hitPoint);
        } else if (raycastHit.transform.GetComponent<TargetOutBound>()) {
            FlyTimeOut();
        } else {
            Hit();
            GameMgr.ins.gameMode.HitTarget(0);
            AudioMgr.ins.PlayCheer(false);
        }
    }

    public void Hit() {
        isHit = true;
        
        GameDebug.ins?.ShowRes(absoluteRay.point, this.transform.Find("Head").position);

        //控制箭的特效显示
        this.activeEffectCyclone(false);
        this.activeEffectBomb(true);
        this.activeEffectTrail(false);

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

    //进入下一轮射击
    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();

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

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

    //---------箭矢特效---------

    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;
    }
}