OvertakingLegend/Assets/Script/Player/Player.cs

using Config.config;
using DG.Tweening;
using System.Collections;
using UnityEngine;

/// <summary>
/// <20><><EFBFBD><EFBFBD>
/// </summary>
public partial class Player : Car
{
    /// <summary>
    /// <20>ƶ<EFBFBD><C6B6>ٶ<EFBFBD>
    /// </summary>
    public float moveSpeed;

    /// <summary>
    /// Ѫ<><D1AA>
    /// </summary>
    public float hp;

    /// <summary>
    /// <20><><EFBFBD><EFBFBD>Ѫ<EFBFBD><D1AA>
    /// </summary>
    private float maxHp;

    /// <summary>
    /// <20><><EFBFBD>ٶ<EFBFBD>
    /// </summary>
    public float acceleration;

    /// <summary>
    /// <20>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD>
    /// </summary>
    public int moveIndex;

    /// <summary>
    /// <20>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>
    /// </summary>
    [HideInInspector]public bool isChangeLanes;

    /// <summary>
    /// <20>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD>ճ<EFBFBD><D5B3><EFBFBD>
    /// </summary>
    public bool isThrillingOvertaking;

    /// <summary>
    /// <20>Ƿ<EFBFBD>ײ<EFBFBD><D7B2>
    /// </summary>
    public bool isTrafficCollision;

    /// <summary>
    /// <20>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    /// </summary>
    private bool isAddEnergy;

    /// <summary>
    /// <20><><EFBFBD>ڵ<EFBFBD>
    /// </summary>
    public Transform carNode;

    /// <summary>
    /// ·<><C2B7>
    /// </summary>
    [HideInInspector] public SectionRoad sectionRoad;

    /// <summary>
    /// <20><>Ļ<EFBFBD><C4BB><EFBFBD><EFBFBD>
    /// </summary>
    private ScreenOperation screenOperation;

    /// <summary>
    /// <20><><EFBFBD>߼<EFBFBD><DFBC>ⷵ<EFBFBD>ض<EFBFBD><D8B6><EFBFBD>
    /// </summary>
    private RaycastHit raycastHit;

    /// <summary>
    /// <20><><EFBFBD><EFBFBD>
    /// </summary>
    public Animation playerAnim;

    /// <summary>
    /// <20><>Ϸ<EFBFBD><CFB7><EFBFBD><EFBFBD>ͼ
    /// </summary>
    public SpriteRenderer gameBK;


    public ParticleSystem fire;
    public ParticleSystem blackSmoke;
    public ParticleSystem whiteSmoke;

    protected override void Awake()
    {
        base.Awake();
        GetCamear();
        CarInit();
        Init();
        //gameCamear.transform.parent.SetParent(transform.parent);
    }

    private void Update()
    {
        GameOperation();
        //Forward();
        JudgmentOvertakingRay();
        AddedSkillPower();
        skinCar.RightWheelSpin();
        CamearShake();
    }

    private void LateUpdate()
    {
        Forward();
    }

    /// <summary>
    /// <20><>Ϸ<EFBFBD><CFB7><EFBFBD><EFBFBD>
    /// </summary>
    private void GameOperation()
    {
        if (screenOperation != null && !Scenes.Instance.gameScene.isSuspend)
        {
            screenOperation.SliderScreen(() =>
            {
                ChangeLanes(E_DirectionType.Left, 0);
            }, () =>
            {
                ChangeLanes(E_DirectionType.Right, 0);
            });
            screenOperation.DetectDoubleTap(() =>
            {
                skill.ReleaseSkills();
            });
        }
    }

    /// <summary>
    /// <20><>ʼ<EFBFBD><CABC>
    /// </summary>
    public void Init()
    {
        skill.Clear();
        isDie = false;
        e_carSizeType = ConfigManager.Instance.GetE_CarSizeType(UserDataManager.Instance.userData.useCar);
        hp = ConfigManager.Instance.Tables.TbSkinCarConfig.Get(UserDataManager.Instance.userData.useCar).Hp;
        maxHp = hp;
        moveSpeed = GameNumericalValue.PlayerMoveSpeed;
        acceleration = GameNumericalValue.PlayerAcceleration;
        fire.gameObject.SetActive(false);
        SetColl();
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϸ<EFBFBD><CFB7><EFBFBD><EFBFBD>
    /// </summary>
    public void SetGameBK(LevelConfig levelConfig)
    {
        switch (levelConfig.Theme)
        {
            case "Country":
                gameBK.sprite = YooAssetManager.Instance.LoadAssetSync<Sprite>(PackagesName.GameData, "CountryBK");
                break;
            case "City":
                gameBK.sprite = YooAssetManager.Instance.LoadAssetSync<Sprite>(PackagesName.GameData, "CityBK");
                break;
            case "MountainousRegion":
                gameBK.sprite = YooAssetManager.Instance.LoadAssetSync<Sprite>(PackagesName.GameData, "MountainousRegionBK");
                break;
            case "Desert":
                gameBK.sprite = YooAssetManager.Instance.LoadAssetSync<Sprite>(PackagesName.GameData, "DesertBK");
                break;
        }
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>
    /// </summary>
    public void CarInit()
    {
        if (skinCar != null)
        {
            Destroy(skinCar.gameObject);
        }
        skinCar = Instantiate(YooAssetManager.Instance.LoadAssetSync<GameObject>(PackagesName.GameData, UserDataManager.Instance.userData.useCar)).GetComponent<SkinCar>();
        skinCar.transform.SetParent(carNode);
        skinCar.transform.localPosition = Vector3.zero;
        skinCar.transform.localEulerAngles = Vector3.zero;
        skinCar.SetAllLight(true);
    }

    /// <summary>
    /// <20>л<EFBFBD><D0BB><EFBFBD><EFBFBD><EFBFBD>
    /// </summary>
    public void CutCar(int index)
    {
        if (skinCar != null)
        {
            Destroy(skinCar.gameObject);
        }
        skinCar = Instantiate(YooAssetManager.Instance.LoadAssetSync<GameObject>(PackagesName.GameData, "Car_" + index)).GetComponent<SkinCar>();
        skinCar.transform.SetParent(carNode);
        skinCar.transform.localPosition = Vector3.zero;
        skinCar.transform.localEulerAngles = Vector3.zero;
        skinCar.transform.localScale = Vector3.zero;
        skinCar.transform.DOScale(Vector3.one * 1.2f, 0.2f).OnComplete(() =>
        {
            skinCar.transform.DOScale(Vector3.one * 0.8f, 0.1f).OnComplete(() =>
            {
                skinCar.transform.DOScale(Vector3.one, 0.1f);
            });
        });
        skinCar.SetAllLight(true);
        SetShopCamear(ConfigManager.Instance.GetE_CarSizeType("Car_" + index));
    }

    /// <summary>
    /// <20><>ʻ<EFBFBD><CABB>Ч
    /// </summary>
    public void RunningSound(bool isOpen)
    {
        if (isOpen)
        {
            switch (e_carSizeType)
            {
                case E_CarSizeType.Big:
                    AudioManager.Instance.PlaySound(YooAssetManager.Instance.LoadAssetSync<AudioClip>(PackagesName.GameData, "BigTrolleyDrive"), true);
                    break;
                case E_CarSizeType.little:
                    AudioManager.Instance.PlaySound(YooAssetManager.Instance.LoadAssetSync<AudioClip>(PackagesName.GameData, "littleTrolleyDrive"), true);
                    break;
            }
        }
        else
        {
            switch (e_carSizeType)
            {
                case E_CarSizeType.Big:
                    AudioManager.Instance.ClearIndividually("BigTrolleyDrive", true, 0.5f);
                    break;
                case E_CarSizeType.little:
                    AudioManager.Instance.ClearIndividually("littleTrolleyDrive", true, 0.5f);
                    break;
            }
        }
    }

    /// <summary>
    /// Ư<><C6AF>
    /// </summary>
    public void Drifting()
    {
        AudioManager.Instance.PlaySound(YooAssetManager.Instance.LoadAssetSync<AudioClip>(PackagesName.GameData, "Drifting"));
        GameObject fx_brakeObj = CachePoolManager.Instance.Take(YooAssetManager.Instance.LoadAssetSync<GameObject>(PackagesName.GameData, "fx_brake"));
        fx_brakeObj.transform.SetParent(skinCar.transform);
        fx_brakeObj.transform.localPosition = new Vector3(-1, 0, -2);
        fx_brakeObj.transform.localEulerAngles = new Vector3(0, -90, -90);
        fx_brakeObj.transform.localScale = Vector3.one * 3;
        playerAnim.Play("Player_Drifting");
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD>ʼ
    /// </summary>
    public void FireInit()
    {
        fire.gameObject.SetActive(false);
        blackSmoke.gameObject.SetActive(false);
        whiteSmoke.gameObject.SetActive(false);
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD>Ѫ<EFBFBD><D1AA>
    /// </summary>
    public void SetHp()
    {
        hp = maxHp;
    }

    /// <summary>
    /// <20><>ʼ<EFBFBD><CABC>Ϸ
    /// </summary>
    public void SetPlay()
    {
        if (screenOperation == null)
        {
            screenOperation = new ScreenOperation();
        }
        sectionRoad = Scenes.Instance.gameScene.mapManager.currentSectionRoad;
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD>
    /// </summary>
    public void SetMoveIndex(int index)
    {
        moveIndex = index;
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD>·<EFBFBD><C2B7>
    /// </summary>
    public void SetSectionRoad(SectionRoad sectionRoad)
    {
        this.sectionRoad = sectionRoad;
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת
    /// </summary>
    public void SetNode()
    {
        switch (Scenes.Instance.e_GameState)
        {
            case E_GameState.Gameing:
                carNode.transform.localEulerAngles = new Vector3(0, 90, 0);
                break;
            case E_GameState.Start:
                carNode.transform.localEulerAngles = new Vector3(0, 0, 0);
                break;
        }
    }

    /// <summary>
    /// <20><>ǰ<EFBFBD><C7B0>ʻ
    /// </summary>
    private void Forward()
    {
        if (Scenes.Instance.gameScene != null && Scenes.Instance.e_GameState == E_GameState.Gameing && !isDie || Scenes.Instance.e_GameState == E_GameState.GameVictory)
        {
            if (GuidanceManger.Instance.isAcceleratedSpeed)
            {
                moveSpeed += Time.deltaTime * acceleration;
            }
            if (isSprint)
            {
                moveSpeed = Mathf.Clamp(moveSpeed, 60, 1000);
            }
            else
            {
                moveSpeed = Mathf.Clamp(moveSpeed, 60, 100);
            }
            transform.Translate(transform.forward * moveSpeed * Time.deltaTime, Space.World);
        }
    }

    /// <summary>
    /// <20>ƶ<EFBFBD>
    /// </summary>
    public override void ChangeLanes(E_DirectionType e_DirectionType, float speed)
    {
        if (isChangeLanes || !GuidanceManger.Instance.isSlide) return;
        float recordLaneChangeDistance = 0;
        float yaw = 0;//<2F><>ͷ
        bool isCanMove = false;
        switch (e_DirectionType)
        {
            case E_DirectionType.Left:
                moveIndex--;
                if (moveIndex < sectionRoad.minIndex)
                {
                    moveIndex = sectionRoad.minIndex;
                }
                else
                {
                    isCanMove = true;
                }
                recordLaneChangeDistance = laneChangeDistance;
                yaw = -20;
                break;
            case E_DirectionType.Right:
                moveIndex++;
                if (moveIndex > sectionRoad.maxIndex)
                {
                    moveIndex = sectionRoad.maxIndex;
                }
                else
                {
                    isCanMove = true;
                }
                recordLaneChangeDistance = -laneChangeDistance;
                yaw = 20;
                break;
        }
        if (isCanMove)
        {
            GuidanceManger.Instance.ChannelChangeguidanceOver();
            AudioManager.Instance.PlaySound(YooAssetManager.Instance.LoadAssetSync<AudioClip>(PackagesName.GameData, "Whistle"));
            carNode.DOKill();
            isChangeLanes = true;
            transform.DOMoveZ(this.transform.position.z + recordLaneChangeDistance, GameNumericalValue.ChangeLanesSpeed).OnComplete(() =>
            {
                isChangeLanes = false;
            });
            carNode.DOLocalRotate(new Vector3(0, yaw, 0), 0.2f).OnComplete(() =>
            {
                carNode.DOLocalRotate(new Vector3(0, 0, 0), 0.1f);
            });
        }
    }

    /// <summary>
    /// <20>ж<EFBFBD><D0B6>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD>ճ<EFBFBD><D5B3><EFBFBD>
    /// </summary>
    public void JudgmentOvertakingRay()
    {
        if (isSprint || isInvincible|| !GuidanceManger.Instance.isEnableNormalMode) return;
        Debug.DrawRay(skinCar.judgmentOvertakingRay.position, transform.forward * GameNumericalValue.JudgmentOvertakingDistance);
        if (Physics.Raycast(new Ray(skinCar.judgmentOvertakingRay.position, transform.forward), out raycastHit, GameNumericalValue.JudgmentOvertakingDistance))
        {
            if (raycastHit.collider.tag == "PropCart")
            {
                if (!isTrafficCollision)
                {
                    isThrillingOvertaking = true;
                }
                else
                {
                    isThrillingOvertaking = false;
                }
            }
        }
        else
        {
            if (isThrillingOvertaking)
            {
                DelayedProcessingManager.Instance.DelayDoFrame(this, 10, () =>
                {
                    if (!isTrafficCollision)
                    {
                        AudioManager.Instance.PlaySound(YooAssetManager.Instance.LoadAssetSync<AudioClip>(PackagesName.GameData, "DangerousOvertaking"));
                        StartCoroutine(IE_JudgmentOvertakingSlowMotion());
                        int judgmentOvertakingNumber = Scenes.Instance.gameScene.GetJudgmentOvertakingNumber();
                        Scenes.Instance.gameScene.SetTotaiJudgmentOvertakingNumbe();
                        UserDataManager.Instance.AddMoney(GameNumericalValue.OvertakingCoin * judgmentOvertakingNumber);
                        UIManager.Instance.GetUI<GameUI>().SetEventType(E_ShowEventType.JudgmentOvertaking, (GameNumericalValue.JudgmentOvertakingAwardMoney * judgmentOvertakingNumber).ToString());
                        UIManager.Instance.GetUI<GameUI>().SetCloseCall(judgmentOvertakingNumber);
                        Scenes.Instance.gameScene.SetdangerousOvertakingScore(GameNumericalValue.OvertakingIntegral * judgmentOvertakingNumber);
                    }
                });
                isThrillingOvertaking = false;
            }
        }
    }

    /// <summary>
    /// <20><><EFBFBD>ճ<EFBFBD><D5B3><EFBFBD><EFBFBD>ӵ<EFBFBD>ʱ<EFBFBD><CAB1>
    /// </summary>
    /// <returns></returns>
    private IEnumerator IE_JudgmentOvertakingSlowMotion()
    {
        if (!Scenes.Instance.gameScene.isSpeedbreaker)
        {
            Time.timeScale = 0.2f;
            UIManager.Instance.GetUI<GameUI>().SetDangerousOvertaking();
            yield return new WaitForSecondsRealtime(0.5f);
            Time.timeScale = 1f;
        }
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    /// </summary>
    public void AddedSkillPower()
    {
        Debug.DrawRay(skinCar.transform.position + Vector3.up, transform.right * GameNumericalValue.addEnergyDistance);
        Debug.DrawRay(skinCar.transform.position + Vector3.up, -transform.right * GameNumericalValue.addEnergyDistance);
        if (Scenes.Instance.e_GameState == E_GameState.Gameing&& !isAddEnergy)
        {
            if (Physics.Raycast(new Ray(skinCar.transform.position + Vector3.up, transform.right), out raycastHit, GameNumericalValue.addEnergyDistance))
            {
                if (raycastHit.collider.tag == "PropCart")
                {
                    isAddEnergy = true;
                }
            }

            if (Physics.Raycast(new Ray(skinCar.transform.position + Vector3.up, -transform.right), out raycastHit, GameNumericalValue.addEnergyDistance))
            {
                if (raycastHit.collider.tag == "PropCart")
                {
                    isAddEnergy = true;
                }
            }

            if (isAddEnergy)
            {
                AddEnergy();
                AudioManager.Instance.PlaySound(YooAssetManager.Instance.LoadAssetSync<AudioClip>(PackagesName.GameData, "OvertakingSound_" + Random.Range(1, 6)));
                DelayedProcessingManager.Instance.DelayDoSecond(this, 0.1f, () =>
                {
                    isAddEnergy = false;
                });
            }
        }
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD>
    /// </summary>
    private void CarAccident(Collision other)
    {
        if (other.gameObject.tag == "PropCart" && !isSprint && !isInvincible)
        {
            AudioManager.Instance.PlaySound(YooAssetManager.Instance.LoadAssetSync<AudioClip>(PackagesName.GameData, "TrafficCollision_" + Random.Range(1, 4)));
            NPCCar npcCart = other.gameObject.GetComponent<NPCCar>();
            if (npcCart.isDie) return;
            UIManager.Instance.GetUI<GameUI>().SetCloseCall(false);
            SetShakeValue(0.5f, 2);
            GameObject fx_bump = CachePoolManager.Instance.Take(YooAssetManager.Instance.LoadAssetSync<GameObject>(PackagesName.GameData, "fx_bump"));
            fx_bump.transform.localScale = Vector3.one * 8;
            fx_bump.transform.position = other.contacts[0].point;
            fx_bump.transform.localEulerAngles = other.contacts[0].normal;

            float angle = Vector3.Angle(this.transform.forward, other.transform.position - this.transform.position);
            Scenes.Instance.gameScene.SetJudgmentOvertakingNumber();
            GetRelativePosition(this.transform, other.transform);
            npcCart.ShootFly(this.transform);

            isTrafficCollision = true;
            carNode.DOBlendablePunchRotation(new Vector3(0, 20, 0), 1f).OnComplete(() =>
            {
                carNode.DOLocalRotate(Vector3.zero, 0.2f);
            });
            DelayedProcessingManager.Instance.DelayDoSecond(this, 1, () =>
            {
                isTrafficCollision = false;
            });
        }
    }

    /// <summary>
    /// ײ<><D7B2><EFBFBD><EFBFBD>
    /// </summary>
    private void StrikeCaR(Collision other)
    {
        if (other.gameObject.tag == "PropCart" && isSprint)
        {
            AudioManager.Instance.PlaySound(YooAssetManager.Instance.LoadAssetSync<AudioClip>(PackagesName.GameData, "TrafficCollision_" + Random.Range(1, 4)));
            NPCCar npcCart = other.gameObject.GetComponent<NPCCar>();
            if (npcCart.isDie) return;
            npcCart.ShootFly(this.transform);
            UIManager.Instance.GetUI<GameUI>().SetEventType(E_ShowEventType.Strike, 350.ToString());
            SetShakeValue(0.5f, 3);
            GameObject coin = CachePoolManager.Instance.Take(YooAssetManager.Instance.LoadAssetSync<GameObject>(PackagesName.GameData, "fx_coin"));
            coin.transform.position = other.contacts[0].point + transform.forward * 5;
            coin.transform.localScale = Vector3.one * 10;
        }
    }

    /// <summary>
    ///ײ<><D7B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    /// </summary>
    private void StrikeTrain(Collision other)
    {
        if (other.gameObject.tag == "Train" && !isInvincible)
        {
            if (isSprint)
            {
                AudioManager.Instance.PlaySound(YooAssetManager.Instance.LoadAssetSync<AudioClip>(PackagesName.GameData, "TrafficCollision_" + Random.Range(1, 4)));
                Train train = other.gameObject.GetComponentInParent<Train>();
                train.ShootFly(this.transform);
                UIManager.Instance.GetUI<GameUI>().SetEventType(E_ShowEventType.Strike, 350.ToString());
                SetShakeValue(0.5f, 3);
                GameObject coin = CachePoolManager.Instance.Take(YooAssetManager.Instance.LoadAssetSync<GameObject>(PackagesName.GameData, "fx_coin"));
                coin.transform.position = other.contacts[0].point + transform.forward * 5;
                coin.transform.localScale = Vector3.one * 10;
            }
            else
            {
                Wounded(1000);
                SetShakeValue(0.5f, 3);
            }
        }
    }

    /// <summary>
    /// <20>õ<EFBFBD>ײ<EFBFBD><D7B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    /// </summary>
    /// <param name="objectA"></param>
    /// <param name="objectB"></param>
    public void GetRelativePosition(Transform objectA, Transform objectB)
    {
        float angle = Vector3.Angle(this.transform.forward, objectB.transform.position - this.transform.position);
        if (angle >= 90 && angle < 110 || angle <= 90 && angle > 70)
        {
            print("<22><><EFBFBD><EFBFBD>");
            Wounded(20);
            UserDataManager.Instance.RemoveMoney(GameNumericalValue.SideAccidentDeduction);
            UIManager.Instance.GetUI<GameUI>().SetEventType(E_ShowEventType.Side, 20.ToString());
        }
        else if (angle > 110 && angle < 170 || angle < 70 && angle > 5)
        {
            print("б<><D0B1>");
            Wounded(35);
            UserDataManager.Instance.RemoveMoney(GameNumericalValue.BevelAccidentDeduction);
            UIManager.Instance.GetUI<GameUI>().SetEventType(E_ShowEventType.Bevel, 35.ToString());
        }
        else if (angle >= 0 && angle < 5f)
        {
            print("׷β");
            Wounded(100);
            UserDataManager.Instance.RemoveMoney(GameNumericalValue.RearEndAccidentDeduction);
            UIManager.Instance.GetUI<GameUI>().SetEventType(E_ShowEventType.RearEnd, 100.ToString());
        }
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD>
    /// </summary>
    private void ArriveEnd(Collision collision)
    {
        if (collision.gameObject.tag == "End")
        {
            TurnToWinCamear();
            Scenes.Instance.gameScene.Victory();
        }
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD>
    /// </summary>
    /// <param name="value"></param>
    private void Wounded(float value)
    {
        Scenes.Instance.gameScene.SetGetCarAccidentNumbe();
        if (UserDataManager.Instance.userData.guidance.isOverInitialEntry)
        {
            hp -= value;
            fire.gameObject.SetActive(false);
            blackSmoke.gameObject.SetActive(false);
            whiteSmoke.gameObject.SetActive(false);
            fire.Stop();
            blackSmoke.Stop();
            whiteSmoke.Stop();
            if (hp <= 30 || hp <= 0)
            {
                //ð<><C3B0>
                fire.gameObject.SetActive(true);
                fire.Play();
            }
            else if (hp <= 50)
            {
                //ð<><C3B0><EFBFBD><EFBFBD>
                blackSmoke.gameObject.SetActive(true);
                blackSmoke.Play();
            }
            else if (hp < 100)
            {
                //ð<><C3B0><EFBFBD><EFBFBD>
                whiteSmoke.gameObject.SetActive(true);
                whiteSmoke.Play();
            }

            if (hp <= 0)
            {
                Die();
            }
        }
        else
        {
            skinCar.Flashing("White",null);
        }
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD>
    /// </summary>
    private void Die()
    {
        DelayedProcessingManager.Instance.Clear();
        AudioManager.Instance.PlaySound(YooAssetManager.Instance.LoadAssetSync<AudioClip>(PackagesName.GameData, "Boom"));
        RunningSound(false);
        isDie = true;
        YooAssetManager.Instance.LoadAssetAsync<GameObject>(PackagesName.GameData, "fx_explosion", (obj) =>
        {
            GameObject fx_explosion = CachePoolManager.Instance.Take(obj);
            fx_explosion.transform.position = transform.position + Vector3.up * 0.5f;
            fx_explosion.transform.localScale = Vector3.one * 2;
        });
        TurnToDieCamear();
        Scenes.Instance.gameScene.GameOver();
    }

    /// <summary>
    /// <20><><EFBFBD><EFBFBD>
    /// </summary>
    public void Resurgence()
    {
        (Vector3, int) data = sectionRoad.GetBirthPoint();
        transform.position = data.Item1;
        moveIndex = data.Item2;
        isDie = false;
        fire.gameObject.SetActive(false);
        fire.Stop();
        hp = maxHp;
        UIManager.Instance.AsynShowUI<GameUI>();
        TurnToGameCamear();
        skill.Clear();
        FullEnergy();
    }

    private void OnCollisionEnter(Collision collision)
    {
        CarAccident(collision);
        StrikeCaR(collision);
        ArriveEnd(collision);
        StrikeTrain(collision);
        if(collision.transform.tag== "Roadblock")
        {
            collision.gameObject.GetComponent<Roadblock>().ShootFly(this.transform);
            AudioManager.Instance.PlaySound(YooAssetManager.Instance.LoadAssetSync<AudioClip>(PackagesName.GameData, "BumpBarrier"));
        }
    }

    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.tag == "RoadGrowth")
        {
            Scenes.Instance.gameScene.mapManager.Exchange();
        }
        if (other.gameObject.tag == "Wall")
        {
            Wounded(1000);
        }
    }
}