yichael_smartbow/Assets/SmartBowGame/ArrowNew.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;

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

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

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

    public static HashSet<ArrowNew> arrowSet = new HashSet<ArrowNew>();

    void Awake()
    {
        arrowSet.Add(this);
        //GameMgr.ins.gameMode.PauseTimeCounting(this);
        //箭模型平时属于ArmBow层，因为ArmBow层在飞行镜头中不被渲染，所以箭出去后要切换layer
        //this.transform.Find("Head/_hunse_jian").gameObject.layer = 0;
    }

    void OnDestroy()
    {
        arrowSet.Remove(this);
        //if (GameMgr.ins) GameMgr.ins.gameMode.ResumeTimeCounting(this);
    }

    void Start()
    {
        int _scale = 5;
        mySpeed = speed;
        mySpeed *= _scale; //默认用5倍

        if (playerIndex == 0)
        {
            Billboard.ins?.SetArrowSpeed(speed);
            Billboard.ins?.SetArrowSpeedScale(_scale);
            Billboard.ins?.ShowSpeed();

        }
        else if (playerIndex == 1)
        {
            Billboard.ins?.Second_SetArrowSpeed(speed);
            Billboard.ins?.Second_SetArrowSpeedScale(_scale);
            Billboard.ins?.Second_ShowSpeed();
        }

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

        //if (absoluteRay.transform)
        //{
        //    //记录射线有没有击中靶子
        //    rayHitTargetBody = absoluteRay.transform.GetComponent<TargetBody>();
        //    //把瞄准点画成红圈，渲染在靶子上
        //    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);
        //arrowCameraComp = cameraTF.gameObject.AddComponent<ArrowCamera>();
        //arrowCameraComp.arrow = this;

        this.activeEffectTrail(true);
    }

    /**在箭飞行前初始化&如果瞄准射线的落点在靶子上时，才调用该函数 */
    void SetUpBeforFly()
    {
        //基础角
        float baseAngleX = FormatAngleX(this.transform.eulerAngles.x);
        //最大可调整的角度差
        float maxDeltaAngleX = 5;
        //最终角
        float finalAngleX = baseAngleX;
        //额外偏移误差角
        float offsetAngleX = FormatAngleX(this.finalAngleAfterOffset.x) - baseAngleX;
        float offsetAngleY = FormatAngleY(this.finalAngleAfterOffset.y - this.transform.eulerAngles.y);
        if (DebugArrowOffsetAngle.ins)
        {
            offsetAngleX *= DebugArrowOffsetAngle.ins.GetOffsetScaleValue();
            offsetAngleY *= DebugArrowOffsetAngle.ins.GetOffsetScaleValue();
        }
        else
        {
            offsetAngleX *= shootOffsetAngleScale;
            offsetAngleY *= shootOffsetAngleScale;
        }
        DebugArrowOffsetAngle2.ins?.SetOffsetAngles(offsetAngleX, offsetAngleY);

        if (absoluteRay.transform)
        {
            bool plusOffsetAngleY = false;
            //看能否通过调整发射角让箭落在靶子的瞄准点上
            CalculateParabolaAngle(absoluteRay.point);
            //瞄准的是不是Target层
            bool isTargetLayer = IsTargetLayer(absoluteRay.transform.gameObject);
            //Debug.Log("isTargetLayer:" + isTargetLayer);
            //绝对发射角无解
            if (!hasParabolaAngle)
            {
                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 + offsetAngleX, -89, 89);
                    plusOffsetAngleY = true;
                    if (Math.Abs(offsetAngle) < 0.001)
                    {
                        canPerfectHit = true;
                    }
                    if (rayHitTargetBody && Mathf.RoundToInt(rayHitTargetBody.GetDistance()) >= 50 && UnityEngine.Random.value < 0.5)
                    {
                        canUseSideCamera = true;
                    }
                }
                else
                {
                    finalAngleX = Mathf.Clamp(baseAngleX + maxDeltaAngleX, -89, 89);
                    if (isTargetLayer) AimLoadChecker.ins?.ShowOutTip();
                }
            }
            finalPoint = absoluteRay.point;
            if (plusOffsetAngleY)
            {
                Vector3 myPos = this.transform.position;
                Vector3 pointer = finalPoint - myPos;
                pointer = Quaternion.AngleAxis(offsetAngleY, Vector3.up) * pointer;
                finalPoint = myPos + pointer;
                this.transform.LookAt(finalPoint);
            }
        }
        else
        {
            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;
    }

    /**UnityY轴旋转只有0°~360°，两个Y轴旋转相减求得的夹角时会出现>180的情况，该函数就是为了解决这问题 */
    float FormatAngleY(float value)
    {
        if (Mathf.Abs(value) > 180)
        {
            if (value < 0)
            {
                return 360f + value;
            }
            if (value > 0)
            {
                return value - 360f;
            }
        }
        return value;
    }

    bool IsTargetLayer(GameObject gameObject)
    {
        if (playerIndex == 0)
        {
            return (1 << gameObject.layer) == LayerMask.GetMask("Target1");

        }
        else if (playerIndex == 1)
        {
            return (1 << gameObject.layer) == LayerMask.GetMask("Target2");

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

        }
    }

    public Transform Head()
    {
        return this.transform.Find("Head");
    }

    /**发射角有无解 */
    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();
            }
        }
    }
    void Update()
    {
        UpdateFlyLogic();
    }

    void FlyTimeOut()
    {
        Destroy(gameObject);
        GameController.ins.HitTarget(0);
        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 = dy;
        nextPosition = shootOutPosition + nextPosition;
        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;

        //忽略和区分对应的target1和target2层级
        int _ignoreMask = playerIndex == 0 ? (1 << 6):(1<<7);
        bool raycastResult = Physics.Raycast(ray, out raycastHit, deltaDistance, _ignoreMask);
        if (raycastResult)
        {
            this.transform.position = raycastHit.point;
            OnHitAnyInFlyLogic(raycastHit);
        }
    }

    public class HitType
    {
        public static int None = 0;
        public static int TargetInRing = 1; //击中了靶子，且在得分环内
        public static int TargetOutRing = 2; //击中了靶子，但不在得分环内
        public static int NotTarget = 4; //击中非目标对象
        public static int Animal = 5; //击中动物
    }
    [NonSerialized] public int hitType = HitType.None;
    [NonSerialized] public Transform raycastHitTransform; //射线击中的目标变换
    [NonSerialized] public string[] hitTargetAnimalInfo;
    //飞行逻辑中检测到碰撞
    void OnHitAnyInFlyLogic(RaycastHit raycastHit)
    {
        Head().position = raycastHit.point;
        transform.SetParent(raycastHit.transform.parent);
        string targetName = raycastHit.transform.gameObject.name;
        raycastHitTransform = raycastHit.transform;
        if (targetName == "TargetBody")
        {
            Vector3 hitPoint = raycastHit.point;
            if (rayHitTargetBody && canPerfectHit)
            {
                hitPoint = absoluteRay.point;
                Head().position = hitPoint;
            }
            raycastHit.transform.GetComponent<TargetBodyNew>().Hit(this, hitPoint, playerIndex);
        }
        else if (raycastHit.transform.GetComponent<TargetOutBound>())
        { //撞到空气墙当作超时处理
            FlyTimeOut();
        }
        else
        {
            Hit();
            GameController.ins.HitTarget(0);
        }
    }

    public void Hit()
    {
        isHit = true;

        if (GameDebug.ins) GameDebug.ins.ShowRes(absoluteRay.point, this.Head().position);

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

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

    //进入下一轮射击
    [NonSerialized] public bool hasDoneNextShoot = false;
    public void nextShoot()
    {
        if (hasDoneNextShoot) return;
        hasDoneNextShoot = true;

        //try
        //{
        //    //if (AimHandler.ins) AimHandler.ins.Ban9AxisCalculate(false);
        //    //把瞄准点画成红圈，渲染在靶子上（取消）
        //    if (rayHitTargetBody)
        //    {
        //        Transform redCircle = rayHitTargetBody.transform.Find("RedCircle");
        //        redCircle.gameObject.SetActive(false);
        //    }
        //    //最新一箭击中后会发光标记（取消）
        //    ArrowLightSick.RecoveryAll();
        //}
        //catch (System.Exception e) { Debug.LogError(e.Message + "\n" + e.StackTrace); }

        //if (!GameMgr.ins.gameMode.DoNextShoot()) return;
        //this.armBow.readyShoot();
    }

    #region 箭的特效
    void activeEffectCyclone(bool value)
    {
        transform.Find("Head/EF_kuosanquan").gameObject.SetActive(value);
        if (!value) return;
        ParticleSystemRenderer ps = transform.Find("Head/EF_kuosanquan/kuosan").GetComponent<ParticleSystemRenderer>();
        ParticleSystemRenderer ps1 = 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)
    {
        transform.Find("Head/EF_baodian").gameObject.SetActive(value);
    }
    void activeEffectTrail(bool value)
    {
        transform.Find("EF_tuowei").gameObject.SetActive(value);
        transform.Find("EF_tuowei/Trail").GetComponent<TrailRenderer>().time = 1.6f / mySpeed;
    }
    #endregion
}