路面

最新推荐文章于 2025-06-20 10:59:52 发布
原创 最新推荐文章于 2025-06-20 10:59:52 发布 · 183 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;

public enum ObjectType
{
    Land,
    Obstacle,
    Corn,
    GravityCorn,
    Randomevent,
    Event,
}
//RoadMngr
public class TestNewRoad : MonoBehaviour
{
    public GameObject road_Parent;
    public GameObject monster_Parent;
    public GameObject propInGame;
    public GameObject corn_Parent;

//    private StopBoss stopBoss;

    void Awake ()
    {
        Init ();
    }

    void Init ()
    {
        GetCommponent getComponent = GetComponent<GetCommponent> ();
        road_Parent = getComponent.defaultGameObject [0];
        monster_Parent = getComponent.defaultGameObject [1];
        propInGame = getComponent.defaultGameObject [2];
        corn_Parent = getComponent.defaultGameObject [3];
    }

    void Start ()
    {
        InitCurParm ();
        sceneRandomList = new ArrayList{ 1, 2, 3, 4 };//随机场景的序号
//        stopBoss = GameObject.FindGameObjectWithTag ("StopBoss").GetComponent<StopBoss> ();
    }

    private int SumWeight;
    private List<int> WeightList;
    private List<int> TimesList;
    int randomNum;
    NewLandEntity tempNewLandEntity;
    private int levelIndex = 0;
    private int elementIndex = 0;

    void InitCurParm ()
    {

        SumWeight = 0;
        WeightList = new List<int> ();
        TimesList = new List<int> ();

        tempNewLandEntity = NewLandParseXML.GetLand (NewLandParseXML.index);
//        GLogger.LogError ("====================================================================NewLandParseXML.index: " + NewLandParseXML.index);
        TimesList.Add (tempNewLandEntity.times0);
        TimesList.Add (tempNewLandEntity.times1);
        TimesList.Add (tempNewLandEntity.times2);
        TimesList.Add (tempNewLandEntity.times3);
        TimesList.Add (tempNewLandEntity.times4);
        TimesList.Add (tempNewLandEntity.times5);
        TimesList.Add (tempNewLandEntity.times6);

        WeightList.Add (SumWeight += tempNewLandEntity.weight0);
        WeightList.Add (SumWeight += tempNewLandEntity.weight1);
        WeightList.Add (SumWeight += tempNewLandEntity.weight2);
        WeightList.Add (SumWeight += tempNewLandEntity.weight3);
        WeightList.Add (SumWeight += tempNewLandEntity.weight4);
        WeightList.Add (SumWeight += tempNewLandEntity.weight5);
        WeightList.Add (SumWeight += tempNewLandEntity.weight6);

        randomNum = (int)(Random.value * SumWeight);
        for (int i = 0; i < WeightList.Count; i++) {
            if (WeightList [i] > randomNum) {
//                GLogger.LogError ("************************************************************************＝＝＝i＝ " + i);
                switch (NewLandParseXML.index) {
                case 0:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;
                case 1:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;
                case 2:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;
                case 3:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;
                case 4:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;
                case 5:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;
                case 6:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;
                case 7:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;
                case 8:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;
                case 9:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;
                case 10:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;
                case 11:
                    levelIndex = i;
                    elementIndex = Random.Range (1, 4);
                    break;

                }
                break;
            }
        }
    }
    //由于中间场景规定的Lv7_0 是中间场景，所以以后要添加7等级的关卡难度要注意！！！
    string GetLevelSplitName ()
    {
//        GLogger.LogError ("=======================================随即路面: "  + levelIndex + "_" + elementIndex);
        string str = levelIndex + "_" + elementIndex;
        return str;
    }

    private float rate = 100f;
    //    private float YOffset = 2.4f;
    private float YOffset = 3.2f;
    private float XOffset = 0;
    private float xOffsetPosition = 0f;
    //2 整体位置偏移量
    private float x = 0;
    private float y = 0;
    private float ExtraPropYOffset = 0.31f;
    private float CornYOffset = 0.35f;
    float scale = 0;
    private bool isLoadNextLand = false;
    private bool isLoadNextElement = false;
    int startLandIndex = 0;
    int startElementIndex = 0;
    bool carIsDead = false;
    float lastLandPositionX = 0f;
    float lastElementPositionX = 0f;
    float curDistance = 0;
    private float addMidSceneDisTimes = 1146;
    //已经添加的中间场景的数量
    private int addedMidSceneNum = 0;
    private bool isChangeBg = false;
    private ArrayList sceneRandomList;
    private int finalLandIndex = 0;
    private int startLandCount = 0;
    private bool isChangeScene = false;
    int midSceneDistance = 3000;
    int currentLeftLand = 0;
    int currentElementLeftLand = 0;
    private List<RandomlandElement> tempElementList;
    public bool isMidScene = false;
    private float secondYOffset = 0.8f;

    void Update ()
    {

        if (TempValue.GetInstance ().willOver) {
            curDistance = BossConfig.GetInstant ().bossCurrentDistance;
            LoadNextLand ();
            LoadNextLandElements ();
        } else {
            curDistance = UserInfos.GetInstance ().distance;
            LoadNextLand ();
            LoadNextLandElements ();
        }
            


//        if (isChangeBg) {
//            ChangeBgTexture ();
//        }
    }

    void LoadNextLand ()
    {
        //加载路面
        if (curDistance >= (lastLandPositionX - 12) && !isLoadNextLand) {
            if (carIsDead) {
                startLandIndex += 10;
                LoadLand (startLandIndex);
                carIsDead = false;
            } else {

                if (startLandIndex <= LandConfigParseXML.GetLandList (GetLevelSplitName ()).Count) {
//                        GLogger.LogError ("===================================================== 路面总长 " + LandConfigParseXML.GetLandList (GetLevelSplitName ()).Count);
                    currentLeftLand = LandConfigParseXML.GetLandList (GetLevelSplitName ()).Count - endLandIndex;
//                        GLogger.LogError ("======================================================================剩余路面 ；" + (currentLeftLand));
                    if (currentLeftLand >= 10) {
                        startLandIndex += 10;
                    } else {
                        startLandIndex += currentLeftLand;
                    }
                    LoadLand (startLandIndex);
                }
            }

            isLoadNextLand = true;
            CheckIsRandomNextLand ();
        } else if ((curDistance < (lastLandPositionX - 12)) && isLoadNextLand == true) {
            isLoadNextLand = false;
        }
    }

    void CheckIsRandomNextLand ()
    {
        if (IsLastLand ()) {

//            GLogger.LogError ("*******************************************************************************************lastLandPositionX:::  " + lastLandPositionX);
            float temp = lastLandPositionX / 0.382f;
            if (temp > 500 && temp <= 3000) {
                NewLandParseXML.index = 1;
            } else if (temp > 3000 && temp <= 6000) {
                NewLandParseXML.index = 2;
            } else if (temp > 6000 && temp <= 9000) {
                NewLandParseXML.index = 3;
            } else if (temp > 9000 && temp <= 12000) {
                NewLandParseXML.index = 4;
            } else if (temp > 12000 && temp <= 15000) {
                NewLandParseXML.index = 5;
            } else if (temp > 15000 && temp <= 18000) {
                NewLandParseXML.index = 6;
            } else if (temp > 18000 && temp <= 21000) {
                NewLandParseXML.index = 7;
            } else if (temp > 21000 && temp <= 24000) {
                NewLandParseXML.index = 8;
            } else if (temp > 24000 && temp <= 27000) {
                NewLandParseXML.index = 9;
            } else if (temp > 27000 && temp <= 30000) {
                NewLandParseXML.index = 10;
            } else if (temp > 30000) {
                NewLandParseXML.index = 11;
            }

            finalElementPosition = lastLandPositionX;
//            GLogger.LogError ("========================================================================================finalElementPosition=: " + finalElementPosition);
            startElementIndex = 0;
            endElementIndex = 0;
            startElementCount = 0;

            tempLandPosition = lastLandPositionX;
//            GLogger.LogError ("************************>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>tempLandPosition=: " + tempLandPosition);

            //2、判断是否需要加载中间场景
            if (temp > midSceneDistance) {
                isMidScene = true;
                //添加中间场景,lastLandPositionX、finalElementPosition保持过度场景与前后两个场景之间的悬崖距离
                lastLandPositionX += 10f;
                finalElementPosition += 10f;
                NewMidScene ();
            } else {
                startLandCount = 0;
                startLandIndex = 0;
                endLandIndex = 0;
                InitCurParm ();
                isLoadNextLand = false;
//                GLogger.LogError ("mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm " + GetLevelSplitName ());
            }
        }
    }

    int startIndex = 0;
    int tempIndex = 0;
    int lastTempIndex = 0;

    void LoadNextLandElements ()
    {
        //加载路面元素
        if (curDistance > (lastElementPositionX - 14) && !isLoadNextElement) {//finalElementPosition

            if (carIsDead) {
                startElementIndex += 10;
                LoadLandElements (startElementIndex);
                carIsDead = false;
            } else {
                tempElementList = LandConfigParseXML.GetLandElement (GetLevelSplitName ());

//                for (int i = startIndex; i < tempElementList.Count; i++) {
////                    GLogger.LogError ("lastTempIndex " + lastTempIndex + " startIndex " + startIndex + "============================================================");
//                
//                    if (tempElementList [i].x / 100 + lastElementPositionX >= curDistance + 20) {
//                    
//                    GLogger.LogError (((tempElementList [i].x / 100)+ lastElementPositionX) + " >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>lastElementPositionX " + lastElementPositionX);
//                        tempIndex = i;
//
////                        startIndex = tempIndex;
//
//                        startIndex += tempIndex;
//                        if(startIndex >=  tempElementList.Count){
//                            startIndex = tempElementList.Count;
//                        }
//
//                        GLogger.LogError ("tempIndex: " + tempIndex + " >>>>>>>>>>>>>>>>>>>>>" + " startIndex: " + startIndex + ">>**********>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>curDistance + 20 " + (curDistance + 20));
//                        break;
//                    }
//                }

//                int tempValue = tempIndex - lastTempIndex;
//                int tempValue = 9;
                lastTempIndex = tempIndex;

                if (startElementIndex < tempElementList.Count) {

//                    GLogger.LogError ("===================================================== 路面元素总长 " + tempElementList.Count);
                    currentElementLeftLand = tempElementList.Count - endElementIndex;
//                    GLogger.LogError ("======================================================================剩余路面元素 ；" + (currentElementLeftLand));
                    if (currentElementLeftLand > 6) {
                        startElementIndex += 6;
                    } else {
                        startElementIndex += currentElementLeftLand;
                    }
                    LoadLandElements (startElementIndex);
                }
            }

            isLoadNextElement = true;
//            if (IsLastElement ()) {
//                finalElementPosition = lastLandPositionX;
//                GLogger.LogError ("========================================================================================finalElementPosition=: " + finalElementPosition);
//                startElementIndex = 0;
//                endElementIndex = 0;
//                startElementCount = 0;
//            }
//        } else if (curDistance <= (lastElementPositionX - 15) && isLoadNextElement == true) {
        } else if (isLoadNextElement == true) {
            isLoadNextElement = false;
        }
    }

    bool IsLastLand ()
    {
        if (LandConfigParseXML.GetLandList (GetLevelSplitName ()).Count == endLandIndex) {
            return true;
        } else {
            return false;
        }
    }

    bool IsLastElement ()
    {
        if (tempElementList.Count == endElementIndex) {
            return true;
        } else {
            return false;
        }
    }

    private List<RandomlandElement> tempMidElementList;
    private List<RandomLand> tempMidLandList;

    bool NewMidScene ()
    {

        addedMidSceneNum++;
        isChangeBg = true;

        ResetCarInMidScene ();
        SetRandomBgIndex ();

        CarConfig.GetInstance ().isMidScene = true;

        int midIndex = 7;
//        int midElementIndex = Random.Range (1, 6);
        int midElementIndex = 1;
        GameObject ob = null;
        string midName = midIndex + "_" + midElementIndex;

        tempMidElementList = LandConfigParseXML.GetLandElement (midName);
        tempMidLandList = LandConfigParseXML.GetLandList (midName);

        for (int i = 0; i < tempMidLandList.Count; i++) {
            RandomLand land = new RandomLand ();
            land = tempMidLandList [i];

            switch (land.type) {
            case (int)ObjectType.Land:
                x = (land.x - XOffset) / rate - 0 + lastLandPositionX;
                y = -land.y / rate + 1.07f;
                string resourceName = land.resource;
                ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem (resourceName));
                ob.transform.localPosition = new Vector3 (x, y, 5);
                break;
            }
        }
//        lastLandPositionX = ob.transform.localPosition.x;
        float cornScale = 0;
        GameObject elementOb = null;
        for (int i = 0; i < tempMidElementList.Count; i++) {
            RandomlandElement landElement = new RandomlandElement ();
            landElement = tempMidElementList [i];

            switch (landElement.type) {
            case (int)ObjectType.Corn:
                x = (landElement.x - XOffset) / rate - 8 + finalElementPosition;
                y = -landElement.y / rate + YOffset;
                elementOb = Instantiate (ResManager.Load ("Prefab/Monster/Corn/CommomCorn/" + landElement.resource)) as GameObject;
                elementOb.transform.parent = road_Parent.transform;
//                elementOb = NGUITools.AddToChild (corn_Parent, ItemPool.GetInstance ().GetItem (landElement.resource));
//                cornScale = ItemPool.GetInstance ().GetScale (landElement.resource);
                elementOb.transform.localPosition = new Vector3 (x, y + 3.4f, 10f);
//                GLogger.LogError ("*********************************8888888888888888888 " + landElement.resource + " ==== " + cornScale + " *** " + ItemPool.GetInstance ().GetItem (landElement.resource).name + " 00 " + elementOb.transform.localPosition);
//                elementOb.transform.localScale = new Vector3 (0.3f, 0.3f, 1f);

                break;

            case (int)ObjectType.GravityCorn:
                x = (landElement.x - XOffset) / rate - 8 + finalElementPosition;
                y = -landElement.y / rate + YOffset;
                elementOb = Instantiate (ResManager.Load ("Prefab/Monster/Corn/GravityCorn/" + landElement.resource)) as GameObject;
                elementOb.transform.parent = road_Parent.transform;
//                elementOb = NGUITools.AddToChild (corn_Parent, ItemPool.GetInstance ().GetItem (landElement.resource));
//                cornScale = ItemPool.GetInstance ().GetScale (landElement.resource);
                elementOb.transform.localPosition = new Vector3 (x, y + 3.4f, 10f);
//                elementOb.transform.localScale = new Vector3 (cornScale, cornScale, 1f);
                break;

            case (int)ObjectType.Randomevent:
                x = (landElement.x - XOffset) / rate - 8 + finalElementPosition;
                y = -landElement.y / rate + YOffset;

                elementOb = NGUITools.AddToChild (propInGame, ItemPool.GetInstance ().GetItem ("ExtraProp"));
                string str = RandomEventInGame.GetInstance ().GetRandomValue ();
                elementOb.GetComponent<AwardPropInGame> ().SetPropAttribute (str);
                elementOb.transform.localPosition = new Vector3 (x, y + ExtraPropYOffset, 10);
                break;

            case (int)ObjectType.Event:
                x = (landElement.x - XOffset) / rate - 8 + finalElementPosition;
                y = -landElement.y / rate + YOffset;
                elementOb = NGUITools.AddToChild (propInGame, ItemPool.GetInstance ().GetItem ("ExtraProp"));
                elementOb.GetComponent<AwardPropInGame> ().SetPropAttribute (landElement.resource);
                elementOb.transform.localPosition = new Vector3 (x, y + ExtraPropYOffset, 10);
                break;

            }
        }


        if (midSceneDistance >= 12000) {
            midSceneDistance += 2000;
        } else {
            midSceneDistance += 3000;
        }

        lastLandPositionX = ob.transform.localPosition.x + 11f;
        finalElementPosition = lastLandPositionX;
        tempLandPosition = lastLandPositionX;
        startLandCount = 0;
        startLandIndex = 0;
        endLandIndex = 0;
        InitCurParm ();
        isLoadNextLand = false;

        return true;
    }

    /// <summary>
    /// 改变游戏背景Texture Update
    /// </summary>
    //    void ChangeBgTexture ()
    //    {
    //        int temp = (int)((UserInfos.GetInstance ().distance) / (addMidSceneDisTimes + 18));
    //        if (addedMidSceneNum <= 0 || temp <= addedMidSceneNum - 1) {
    //            return;
    //        }
    //        isChangeBg = false;
    //    }

    int sceneIndex = 1;

    int SetRandomBgIndex ()
    {
        int tempId = 0;
        if ((curDistance / 0.382f) > 12000) {
            int tempIndex = Random.Range (0, sceneRandomList.Count);
            tempId = (int)sceneRandomList [tempIndex];
            sceneRandomList.RemoveAt (tempIndex);
        } else {
            tempId = (int)sceneRandomList [sceneIndex];
            sceneIndex++;
            if (sceneIndex >= 4) {
                sceneIndex = 0;
            }
        }

        if (sceneRandomList.Count <= 0) {
            sceneRandomList.Add (1);
            sceneRandomList.Add (2);
            sceneRandomList.Add (3);
            sceneRandomList.Add (4);
        }

        TempValue.GetInstance ().curLandType = tempId - 1;
        return tempId;
    }

    /// <summary>
    /// 0、暂停前一个场景的Boss
    /// 1、判断跑过中间场景的次数
    /// 2、在中间场景重新设置汽车配置
    /// 3、在中间场景，不再积蓄飞行模式
    /// </summary>
    void ResetCarInMidScene ()
    {
        TempValue.GetInstance ().isPlayBackgroundAnim = false;
        //暂停前一个场景的Boss
        GameObject.FindGameObjectWithTag ("Player").GetComponent<CarControlor> ().ChangeBossAccordingToNextLevel (false);
        CarConfig.GetInstance ().throughMidScenetimes++;//统计路过中间场景的次数
    }

    int endLandIndex = 0;
    float tempLandPosition = 0;

    void LoadLand (int landCount)
    {
        int tempEndIndex = 0;

        GameObject ob = null;
//        GLogger.LogError ("*******************************************landCount> " + landCount);
//        GLogger.LogError ("===================================================startLandCount> " + startLandCount);
        RandomLand land = new RandomLand ();
        for (int i = startLandCount; i < landCount; i++) {

            land = LandConfigParseXML.GetLandList (GetLevelSplitName ()) [i];

            switch (land.type) {
            case (int)ObjectType.Land:
                x = (land.x - XOffset) / rate - xOffsetPosition + tempLandPosition;
                y = -land.y / rate + YOffset;
                string resourceName = land.resource;

                switch (TempValue.GetInstance ().curLandType) {
                case (int)Land_type.Dusk_land:

                    ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem (resourceName));
                    ob.transform.localPosition = new Vector3 (x, y, 5);
                    break;
                case (int)Land_type.Ground_land:

                    switch (resourceName) {
                    case "Dusk_land_End_1":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Ground_land_End_1"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_End_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Ground_land_End_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_1":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Ground_land_Mid_1"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_1_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Ground_land_Mid_1_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_1_3":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Ground_land_Mid_1_3"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Ground_land_Mid_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_2_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Ground_land_Mid_2_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_2_3":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Ground_land_Mid_2_3"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Start_1":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Ground_land_Start_1"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Start_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Ground_land_Start_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Cliff":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Cliff"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "MinCliff":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("MinCliff"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    }


                    break;
                case (int)Land_type.Night_land:

                    switch (resourceName) {
                    case "Dusk_land_End_1":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Night_land_End_1"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_End_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Night_land_End_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_1":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Night_land_Mid_1"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_1_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Night_land_Mid_1_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_1_3":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Night_land_Mid_1_3"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Night_land_Mid_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_2_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Night_land_Mid_2_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_2_3":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Night_land_Mid_2_3"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Start_1":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Night_land_Start_1"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Start_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Night_land_Start_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Cliff":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Cliff"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "MinCliff":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("MinCliff"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    }

                    break;
                case (int)Land_type.Rain_land:

                    switch (resourceName) {
                    case "Dusk_land_End_1":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Rain_land_End_1"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_End_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Rain_land_End_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_1":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Rain_land_Mid_1"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_1_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Rain_land_Mid_1_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_1_3":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Rain_land_Mid_1_3"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Rain_land_Mid_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_2_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Rain_land_Mid_2_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Mid_2_3":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Rain_land_Mid_2_3"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Start_1":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Rain_land_Start_1"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Dusk_land_Start_2":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Rain_land_Start_2"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "Cliff":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("Cliff"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    case "MinCliff":
                        ob = NGUITools.AddToChild (road_Parent, ItemPool.GetInstance ().GetItem ("MinCliff"));
                        ob.transform.localPosition = new Vector3 (x, y, 5);
                        break;
                    }

                    break;
                }

                if (resourceName == "MinCliff" || resourceName == "Cliff") {
                    ob.GetComponent<SpriteRenderer> ().enabled = false;
                }

                tempEndIndex = i + 1;
                break;
            }
        }
        endLandIndex = tempEndIndex;
        startLandCount = landCount;
        lastLandPositionX = ob.transform.localPosition.x + 0;

    }

    int endElementIndex = 0;
    int startElementCount = 0;
    float finalElementPosition = 0;
    float monsterTempYOffset = 0f;

    void LoadLandElements (int landElementCount)
    {
        if (landElementCount > tempElementList.Count) {
            return;
        }

        int tempEndElementsIndex = 0;
//        GLogger.LogError (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>landElementCount> " + landElementCount);
//        GLogger.LogError (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>startElementCountstartElementCount > " + startElementCount);
        GameObject ob = null;
        for (int i = startElementCount; i < landElementCount; i++) {

            RandomlandElement landElement = new RandomlandElement ();
            landElement = tempElementList [i];

            switch (landElement.type) {
            case (int)ObjectType.Obstacle:
//                x = (landElement.x - XOffset) / rate - xOffsetPosition + lastElementPositionX;
                x = (landElement.x - XOffset) / rate - xOffsetPosition + finalElementPosition;
//                x = (landElement.x - XOffset) / rate - xOffsetPosition + lastLandPositionX;
                y = -landElement.y / rate + YOffset;

                switch (landElement.resource) {

                case "mouse":
                    switch (TempValue.GetInstance ().curLandType) {

                    case (int)Land_type.Dusk_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("MouseRun"));
                        scale = ItemPool.GetInstance ().GetScale ("MouseRun");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;
                    case (int)Land_type.Ground_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("Ground_Apple"));
                        scale = ItemPool.GetInstance ().GetScale ("Ground_Apple");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;
                    case (int)Land_type.Night_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("Night_Duck"));
                        scale = ItemPool.GetInstance ().GetScale ("Night_Duck");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;
                    case (int)Land_type.Rain_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("Rain_Frog_Jump"));
                        scale = ItemPool.GetInstance ().GetScale ("Rain_Frog_Jump");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;

                    }
                    break;

                case "stone":
                    switch (TempValue.GetInstance ().curLandType) {

                    case (int)Land_type.Dusk_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("Stone1"));
                        scale = ItemPool.GetInstance ().GetScale ("Stone1");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;
                    case (int)Land_type.Ground_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("Ground_Bone"));
                        scale = ItemPool.GetInstance ().GetScale ("Ground_Bone");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;
                    case (int)Land_type.Night_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("Night_Grass"));
                        scale = ItemPool.GetInstance ().GetScale ("Night_Grass");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;
                    case (int)Land_type.Rain_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("Rain_Puddles_Wave"));
                        scale = ItemPool.GetInstance ().GetScale ("Rain_Puddles_Wave");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;
                    }
                    break;

                case "sunflower":
                    switch (TempValue.GetInstance ().curLandType) {

                    case (int)Land_type.Dusk_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("SunflowerRun"));
                        scale = ItemPool.GetInstance ().GetScale ("SunflowerRun");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;
                    case (int)Land_type.Ground_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("Ground_Pumpkin"));
                        scale = ItemPool.GetInstance ().GetScale ("Ground_Pumpkin");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;
                    case (int)Land_type.Night_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("Night_Cactus"));
                        scale = ItemPool.GetInstance ().GetScale ("Night_Cactus");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;
                    case (int)Land_type.Rain_land:
                        ob = NGUITools.AddToChild (monster_Parent, ItemPool.GetInstance ().GetItem ("Rain_Wind_Sway"));
                        scale = ItemPool.GetInstance ().GetScale ("Rain_Wind_Sway");
                        ob.transform.localScale = new Vector3 (scale, scale, 1);
                        ob.transform.localPosition = new Vector3 (x, y + monsterTempYOffset, 5);
                        break;
                    }
                    break;
                }

                break;

            case (int)ObjectType.Corn:
                x = (landElement.x - XOffset) / rate - xOffsetPosition + finalElementPosition;
                y = -landElement.y / rate + YOffset;
                ob = Instantiate (ResManager.Load ("Prefab/Monster/Corn/CommomCorn/" + landElement.resource)) as GameObject;
                ob.transform.parent = road_Parent.transform;
                ob.transform.localPosition = new Vector3 (x, y + CornYOffset, 10);


//                ob = NGUITools.AddToChild (corn_Parent, ItemPool.GetInstance ().GetItem (landElement.resource));
////                cornScale = ItemPool.GetInstance ().GetScale (landElement.resource);
//                ob.transform.localPosition = new Vector3 (x, y + CornYOffset, 10);
//                ob.transform.localScale = new Vector3 (0.3f, 0.3f, 1f);

                break;

            case (int)ObjectType.GravityCorn:
                x = (landElement.x - XOffset) / rate - xOffsetPosition + finalElementPosition;
                y = -landElement.y / rate + YOffset;
                ob = Instantiate (ResManager.Load ("Prefab/Monster/Corn/GravityCorn/" + landElement.resource)) as GameObject;
                ob.transform.parent = road_Parent.transform;
                ob.transform.localPosition = new Vector3 (x, y + CornYOffset, 10);

//                ob = NGUITools.AddToChild (corn_Parent, ItemPool.GetInstance ().GetItem (landElement.resource));
//                //                cornScale = ItemPool.GetInstance ().GetScale (landElement.resource);
//                ob.transform.localPosition = new Vector3 (x, y + CornYOffset, 10);
//                ob.transform.localScale = new Vector3 (0.3f, 0.3f, 1f);
                break;

            case (int)ObjectType.Randomevent:
                x = (landElement.x - XOffset) / rate - xOffsetPosition + finalElementPosition;
                y = -landElement.y / rate + YOffset;

                ob = NGUITools.AddToChild (propInGame, ItemPool.GetInstance ().GetItem ("ExtraProp"));

                //                ob = Instantiate (ResManager.Load ("Prefab/ExtraProp/ExtraProp")) as GameObject;
                string str = RandomEventInGame.GetInstance ().GetRandomValue ();
                ob.GetComponent<AwardPropInGame> ().SetPropAttribute (str);
                //                ob.transform.parent = road_Parent.transform;
                ob.transform.localPosition = new Vector3 (x, y + ExtraPropYOffset, 10);
                break;

            case (int)ObjectType.Event:
                x = (landElement.x - XOffset) / rate - xOffsetPosition + finalElementPosition;
                y = -landElement.y / rate + YOffset;
                ob = NGUITools.AddToChild (propInGame, ItemPool.GetInstance ().GetItem ("ExtraProp"));
                //                ob = Instantiate (ResManager.Load ("Prefab/ExtraProp/ExtraProp")) as GameObject;
                ob.GetComponent<AwardPropInGame> ().SetPropAttribute (landElement.resource);
                //                ob.transform.parent = road_Parent.transform;
                ob.transform.localPosition = new Vector3 (x, y + ExtraPropYOffset, 10);
                break;
            }
            tempEndElementsIndex = i + 1;
        }
        endElementIndex = tempEndElementsIndex;
        startElementCount = landElementCount;
        lastElementPositionX = ob.transform.localPosition.x;
//        finalElementPosition = ob.transform.localPosition.x;
    }
}
woshispl
关注
Unreal 和 Unity 3D 各有什么特点？如何选择？
SiKi学院的博客
11-17 6947
Unreal Engine VS Unity Unity是实时3D互动内容创作和运营平台。包括游戏开发、美术、建筑、汽车设计、影视在内的所有创作者，借助Unity将创意变成现实。Unity平台提供一整套完善的软件解决方案，可用于创作、运营和变现任何实时互动的2D和3D内容，支持平台包括手机、平板电脑、PC、游戏主机、增强现实和虚拟现实设备。
Midscene.js：重新定义UI自动化的新时代工具
我码玄黄的博客
01-24 4560
Midscene.js是创新的UI自动化解决方案，通过AI简化脚本编写与维护，提供交互、提取、断言三种方法，支持LLM和UI-TARS模型，可从Chrome商店下载或GitHub获取源码，使用需配置OPENAI_API_KEY等。
Midscene.js测试工具：打破项目UI自动化编写和维护困扰
我的博客
02-07 6600
同时我邀请你进入我们的软件测试学习交流平台，大家可以一起探讨交流软件测试，共同学习软件测试技术、面试等软件测试方方面面，了解测试行业的最新趋势，助你快速进阶Python自动化测试/测试开发，稳住当前职位同时走向高薪之路。说起UI自动化测试框架，大家脑海中最先想到的是Playwright、Cypress等这样成熟的产品，但是要将自动化脚本做到稳定并且持续维护的团队却是屈指可数的，因为经常会面临选择器繁琐复杂、与 HTML 结构的耦合度高，以及界面难以进行断言等问题。
Midscene.js介绍和使用
m0_54119099的博客
02-19 1万+
本篇博客主要对 Midscene 作了介绍，也给出了本人在使用 Midscene 过程中遇到的问题及摸索到的解决方案。
人工智能丨Midscene：让UI自动化测试变得更简单
ceshiren_com的博客
01-26 2848
Midscene是一个基于多模态大语言模型的UI自动化测试框架。它允许测试人员使用自然语言描述测试步骤，从而大大降低了编写测试脚本的门槛。无论是定位页面元素、执行交互操作还是验证页面状态，Midscene都能通过理解自然语言指令来自动完成这些任务。Midscene作为一款基于自然语言处理的UI自动化测试框架，为测试人员提供了一种更加简单和直观的方式来编写和执行测试用例。通过自然语言交互，Midscene大大降低了编写测试脚本的门槛，提高了测试效率，并使得测试结果更加易于理解和展示。
基于MATLAB的路面裂缝检测
m0_59833680的博客
08-18 9222
基于MATLAB的路面裂缝检测 第一章 绪论1.1引言 本章介绍本论文的研究目的与意义、国内外研究现状，论文的研究内容和组织结构。其中： 1.2节介绍本文的立题依据与研究意义。 1.3节综述了国内外关于路面裂缝检测的研究现状和进展。 1.4节提出本文的研究目标、研究内容、研究方法及拟解决的关键问题。 1.5节简述了本文的组织结构安排。1.2 研究的背景与意义 目前，我国高等级公路的建设取得空...
ADAMS三维路面重构
weixin_43261805的博客
11-08 5302
自己做的课题中有一部分是研究机器人在路面上行走时的振动问题，之前在做的时候是通过建立动力学方程来进行建模，之后给模型输入相应的输入。这个过程比较繁琐，首先是需要进行整个机器人的力学方程，当机器人比较复杂时或者为提高精度，整个力学方程就变得非常复杂；而且当需要的输入量或者输出量增加时，将直接导致模型参数矩阵维度的升高，整个建模求解过程会变得非常复杂。后来看到一些文献中用ADAMS或者其他已经成熟的动...
基于OpenCV的路面质量检测
热门推荐
小白学视觉
10-26 1万+
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达本期我们将展示一种对路面类型和质量进行分类的方法及其步骤。为了测试这种方法，我们使用了我们制作的RT...
路面语义分割
小白学视觉
12-02 5438
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达检测坑洼，水坑，不同类型的地形等本期是关于路面语义分割方法的。因此，这里的重点是路面模式，例如：车辆...
Carsim路面动画
weixin_42031364的博客
02-25 4144
说明 道路中动画的设置仅仅只是为了美观或者更好的说明路面情况，路面附着系数设置参考我的另一篇博客 参考路面附着系数的博客，动画设置同样分为常见的均一、对开、对接路面设置 ~~ 画重点 ~~ 注意下面动画设置中每个参数的含义 1：均一路面 简单的可以单独设置一条路（注意路肩的方向） 2：对开路面 在设置的时候注意横纵向坐标，下面的道路前半段是均一道路，后半段是对开道路；若需设置成均一——对开—...
路面输入建模Simulink
m0_72748751的博客
05-06 4658
通常把路面相对于基准平面高度沿道路走向长度的变化称为路面不平度。关于路面不平度模型最常用的方法为滤波白噪声法，该方法计算简单、意义明确、易于建模实现。Gq​nGq​n0​n0​n​−w其中，n为路面空间频率，单位为m−1；n0​为参考空间频率n0​0.1m−1；Gq​n0​为路面不平度系数，用来表征不同路面等级，单位是m3；w为频率指数，这里取值为 2。标准根据Gq​n0​。
Carsim中路面附着系数设定
weixin_42031364的博客
02-23 8387
** 路面附着系数的设定是在Carsim中建立仿真环境的非常重要的一步，且Carsim中的路面附着系数不能根据设定的动画自动改变，需要全部手动设定，下面就常见的均一路面、对开路面、对接路面的附着系数的设定进行解释 ** 1：均一路面 最简单的路面 2：对接路面 首先看一下3D图 接下来看一下路面设置参数 针对上述对接路面，【0，3】之间的路面附着系数是0.5；【3，+∞】之间是0.2 同样可...
空间路面matlab,基于Matlab的三维随机路面联合建模与仿真研究
weixin_42400619的博客
03-17 2874
摘要：为了给虚拟样机仿真分析与研究提供复杂三维路面环境，论文基于单点FFT路面不平度时域模型，建立了三维FFT随机路面数学模型，并实现了其在Matlab中的仿真；依据三角网格法理论，建立了生成三维路面文件的通用模型，包括节点的生成和单元生成算法，并导入Adams形成所需的三维路面仿真环境。最后，论文应用上述方法生成C级路面，对所选择的车辆样机进行了行驶平顺性仿真，与GB规范对比分析得到了该车行驶平...
【理论】车辆四轮路面不平度时域再现
CrazyRabbit的博客
07-06 9916
半主动悬架开发过程中需要的等级路面生成方法
unity制作一个无尽的路面
allenwithno3的博客
04-10 9407
车在格子状的路面跑，无论路有多大，最后走会走完；一个解决的方法是，让路成为相机（或是车）的子物体，这样就不会走到尽头，同时调整路面的UV，让路看起来真的像是再后退一样（相对于车）；用到的方法是SetTextureOffset;      public GameObject plane; public float uvSpeed; private GameObject dad...
道路路面泥泞，坑洼，裂缝，路面损坏，马路牙检测 YOLO标记资源整理
yolo模型训练找我，AI游戏合作找我
11-26 1万+
可识别常见的路面泥泞，坑洼，裂缝，路面损坏，马路牙等多种路面状况。过滤空值： 要求至少 90% 的图像包含注释。色调： -12° 至 +12° 之间。自动调整对比度： 使用对比度拉伸。亮度： 0% 至 +15% 之间。灰度： 适用于 8% 的图像。每个训练示例的输出： 3。validation集。
基于Matlab/Simulink随机路面建模
最新发布
m0_75028507的博客
06-20 2274
本文研究了基于滤波白噪声法的路面时域建模方法，用于车辆悬架系统振动特性分析。通过Matlab/Simulink平台建立了随机路面模型，采用路面功率谱密度（PSD）描述路面不平度特征。研究重点包括：1）推导路面位移功率谱的拟合表达式；2）构建滤波白噪声路面时域模型；3）分析模块参数设置对仿真结果的影响。该方法克服了传统试验方法的局限性，为悬架系统性能评估提供了高效、低成本的路面激励模拟方案。仿真结果验证了该模型的有效性，为车辆底盘设计提供了重要支撑。
基于机器视觉的路面裂缝检测方法研究与实现
TuTu998的博客
09-01 4327
基于MATLAB的路面裂缝检测系统[过程图，源码] 课题背景裂缝是最常见的路面损坏，可能会危及公路和高速公路的安全。在路面裂缝变的更糟糕之前及时进行修补，可以大大节省路面维修的资金。路面裂缝是评估道路状况，并进行必要的道路维修的重要信息。在过去的二十年，由于基于图像的路面裂缝检测技术提供了一个安全，高效，经济的方式，各种图像处理方法已被提出的路面裂缝检测。基于假设沿裂缝的强度通常低于背景的强度，周...
路面坑洼检测中的视觉算法
whaosoft143ai的博客
11-20 5603
3D道路成像和路面坑洼检测的经典工作综述。论文链接：https://arxiv.org/pdf/2204.13590.pdf计算机视觉算法在3D道路成像和路面坑洼检测中的应用已有二十多年的历史。这里先介绍了用于2D和3D道路数据采集的传感系统，包括摄像机、激光扫描仪和微软Kinect。还讨论了基于计算机视觉的路面坑洼检测方法目前面临的挑战和未来的发展趋势: 经典的基于2D图像处理和基于3D点云建模和分割的方法已经成为历史;whaosoft aiot http://143ai.com
Carsim 对开路面和对接路面
小兮学习日记
01-01 5253
请问将对接路面的摩擦系数改成这个后，再次点击3D map 出现这个报错 应该是怎么处理～ ​ ​对接路面举例： 前面0-50m是一段摩擦系数为0.85的良好路面（表中第一段路的数据要匹配） 后面50-100m是一段摩擦系数为0.2的冰雪路面（表中第二段路的数据要匹配） ​ ​注解：对开路面就是轮子两边的路面的附着系数不一样；对接路面就是说汽车从一个附着系数的路面开到另一种附着系数的路面。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值