//运动到卸货点
 public void gotoUnloadPoint()
 {
     if (speedChangeable)
     {
         carMessage.speed = moveSpeed;
     }
     carPathData = GlobalVaribles.trailerGraph.pathMap[carMessage.carEdge.vertexNum1,
                                                       task.unloadGoods_Edge.vertexNum1];
     //若小车已经在最后一条边上
     if (carMessage.carEdge.vertexNum1 == task.unloadGoods_Edge.vertexNum1)
     {
         //判断是否已经到达卸货点
         Vector3 unloadPos1 = new Vector3(task.unloadGoodsPos.x,
                                          task.unloadGoodsPos.y + carMessage.carSize.y / 2, task.unloadGoodsPos.z);
         if (transform.localPosition == unloadPos1)
         {
             carMessage.workState = WorkState.Unloading;
             carMessage.speed     = 0.0f;
             unloadStartTime      = Time.time;
         }
         else
         {
             gotoPos(task.unloadGoodsPos);
         }
     }
     else
     {
         //得到车的下一个节点
         int nextVertexNum = carMessage.carEdge.vertexNum2;
         TrailerGraph.Vertex nextVertex = GlobalVaribles.trailerGraph.vertexes[nextVertexNum];
         gotoVertex(nextVertex);
     }
 }
Beispiel #2
0
 //模拟运动到取货点
 public void gotoLoadPoint()
 {
     if (speedChangeable)
     {
         carMessage.speed = moveSpeed;
     }
     carPathData = GlobalVaribles.trailerGraph.pathMap[carMessage.carEdge.vertexNum1,
                                                       task.loadGoods_Edge.vertexNum1];
     //若小车已经在最后一条边上
     if (carMessage.carEdge.vertexNum1 == task.loadGoods_Edge.vertexNum1)
     {
         //判断是否已经到达取货点
         Vector3 loadPos1 = new Vector3(task.loadGoodsPos.x,
                                        task.loadGoodsPos.y + carMessage.carSize.y / 2, task.loadGoodsPos.z);
         if (carMessage.carPos == loadPos1)
         {
             carMessage.workState = WorkState.Loading;
             carMessage.speed     = 0.0f;//之后车是静止的
         }
         else
         {
             gotoPos(task.loadGoodsPos);
         }
     }
     else
     {
         //得到车的下一个节点
         int nextVertexNum = carMessage.carEdge.vertexNum2;
         TrailerGraph.Vertex nextVertex = GlobalVaribles.trailerGraph.vertexes[nextVertexNum];
         gotoVertex(nextVertex);
     }
 }
    //运动到取货点
    public void gotoLoadPoint()
    {
        if (speedChangeable)
        {
            carMessage.speed = moveSpeed;
        }
        carPathData = GlobalVaribles.trailerGraph.pathMap[carMessage.carEdge.vertexNum1,
                                                          task.loadGoods_Edge.vertexNum1];
        //若小车已经在最后一条边上
        if (carMessage.carEdge.vertexNum1 == task.loadGoods_Edge.vertexNum1)
        {
            //判断是否已经到达取货点
            Vector3 loadPos1 = new Vector3(task.loadGoodsPos.x,
                                           task.loadGoodsPos.y + carMessage.carSize.y / 2, task.loadGoodsPos.z);
            if (transform.localPosition == loadPos1)
            {
                carMessage.workState = WorkState.Loading;
                carMessage.speed     = 0.0f;//之后车是静止的
                loadStartTime        = Time.time;
                //更新可分配的车和任务
                Car carToRemove = new Car();
                foreach (Car c in GlobalVaribles.allocableCars)
                {
                    if (c.carName.Equals(this.carMessage.carName))
                    {
                        carToRemove = c;
                    }
                }
                GlobalVaribles.allocableCars.Remove(carToRemove);

                Task taskRemoveALLT = new Task();
                foreach (Task t in GlobalVaribles.allocableTasks)
                {
                    if (t.taskID == task.taskID)
                    {
                        taskRemoveALLT = t;
                    }
                }
                GlobalVaribles.allocableTasks.Remove(taskRemoveALLT);

                //更新UnAllocableMatch
                GlobalVaribles.UnAllocableMatch.Add(carMessage, task);
            }
            else
            {
                gotoPos(task.loadGoodsPos);
            }
        }
        else
        {
            //得到车的下一个节点
            int nextVertexNum = carMessage.carEdge.vertexNum2;
            TrailerGraph.Vertex nextVertex = GlobalVaribles.trailerGraph.vertexes[nextVertexNum];
            gotoVertex(nextVertex);
        }
    }
    //运动到某个点
    public void gotoVertex(TrailerGraph.Vertex vertex)
    {
        Vector3 vPos1 = vertex.vertexPos;

        vPos1.y = transform.localPosition.y;
        if (!VectorTool.IsCloseEnough(vPos1, transform.localPosition, carMessage.speed))
        {
            //判断车在直线还是曲线
            if (carMessage.carEdge.lineType.Equals(LineType.Curve))//曲线
            {
                //旋转运动
                MyRotateAround(carMessage.carEdge.curveCenter, new Vector3(0, 1, 0), carMessage.speed * Time.deltaTime);
                carMessage.carPos = transform.localPosition;
            }
            else if (carMessage.carEdge.lineType.Equals(LineType.Straight))
            {
                //直线运动
                transform.localPosition = Vector3.MoveTowards(transform.localPosition, vPos1, carMessage.speed * Time.deltaTime);
                carMessage.carPos       = transform.localPosition;
            }
            else
            {
            }
        }
        else//已经到达该点
        {
            transform.localPosition = vPos1;
            carMessage.carPos       = transform.localPosition;

            carPathData = GlobalVaribles.trailerGraph.pathMap[vertex.index, carPathData.pathList[carPathData.pathList.Count - 1].index];
            if (carMessage.workState == WorkState.WayToLoad && vertex.index == task.loadGoods_Edge.vertexNum1)
            {
                carMessage.carEdge = GlobalVaribles.trailerGraph.adjMatrix[vertex.index, task.loadGoods_Edge.vertexNum2];
            }
            else if (carMessage.workState == WorkState.WayToUnload && vertex.index == task.unloadGoods_Edge.vertexNum1)
            {
                carMessage.carEdge = GlobalVaribles.trailerGraph.adjMatrix[vertex.index, task.unloadGoods_Edge.vertexNum2];
            }
            else
            {
                carMessage.carEdge = GlobalVaribles.trailerGraph.adjMatrix[carPathData.pathList[0].index, carPathData.pathList[1].index];
            }
            //进入新的曲线, 更新angled
            carMessage.angled = carMessage.carEdge.startDeg;
            //旋转值的修正
            Vector3 rotation = transform.localEulerAngles;
            rotation.y = carMessage.carEdge.endDeg;
            transform.localEulerAngles = rotation;
            return;
        }
    }
Beispiel #5
0
    //运动到某个点
    public void gotoVertex(TrailerGraph.Vertex vertex)
    {
        Vector3 vPos1 = vertex.vertexPos;

        vPos1.y = carMessage.carPos.y;
        if (!VectorTool.IsCloseEnough(vPos1, carMessage.carPos, carMessage.speed))
        {
            //判断车在直线还是曲线
            if (carMessage.carEdge.lineType.Equals(LineType.Curve))//曲线
            {
                //模拟旋转运动
                SimuRotateAround(curveRadius, carMessage.carEdge.curveCenter, carMessage.speed * GlobalVaribles.frameTime);
            }
            else if (carMessage.carEdge.lineType.Equals(LineType.Straight))
            {
                //模拟直线运动
                SimuMoveTowards(vPos1, carMessage.speed * GlobalVaribles.frameTime);
            }
            else
            {
            }
        }
        else//已经到达该点
        {
            carMessage.carPos = vPos1;
            carPathData       = GlobalVaribles.trailerGraph.pathMap[vertex.index, carPathData.pathList[carPathData.pathList.Count - 1].index];
            if (carMessage.workState == WorkState.WayToLoad && vertex.index == task.loadGoods_Edge.vertexNum1)
            {
                carMessage.carEdge = GlobalVaribles.trailerGraph.adjMatrix[vertex.index, task.loadGoods_Edge.vertexNum2];
            }
            else if (carMessage.workState == WorkState.WayToUnload && vertex.index == task.unloadGoods_Edge.vertexNum1)
            {
                carMessage.carEdge = GlobalVaribles.trailerGraph.adjMatrix[vertex.index, task.unloadGoods_Edge.vertexNum2];
            }
            else
            {
                carMessage.carEdge = GlobalVaribles.trailerGraph.adjMatrix[carPathData.pathList[0].index, carPathData.pathList[1].index];
            }
            carMessage.angled = carMessage.carEdge.startDeg;
            return;
        }
    }
    //判断两车前后关系
    public bool isFront(GameObject target)
    {
        //本车到目标车的路径距离,目标车到本车的路径距离
        float s2t, t2s;

        s2t = t2s = 0.0f;
        Car targetCar = target.GetComponent <ShowCarMessage>().carMessage;

        //车所在边
        TrailerGraph.Vertex selfVertex1   = GlobalVaribles.trailerGraph.vertexes[carMessage.carEdge.vertexNum1];
        TrailerGraph.Vertex selfVertex2   = GlobalVaribles.trailerGraph.vertexes[carMessage.carEdge.vertexNum2];
        TrailerGraph.Vertex targetVertex1 = GlobalVaribles.trailerGraph.vertexes[targetCar.carEdge.vertexNum1];
        TrailerGraph.Vertex targetVertex2 = GlobalVaribles.trailerGraph.vertexes[targetCar.carEdge.vertexNum2];
        if (targetCar.carEdge.Equals(carMessage.carEdge))//2车在同一条边上
        {
            t2s = Vector3.Distance(targetCar.carPos, targetVertex2.vertexPos);
            s2t = Vector3.Distance(carMessage.carPos, selfVertex2.vertexPos);
        }
        else  //不在同一条边,分别计算两车经过轨道到达彼此的距离,距离短的那个在后面
        {
            s2t += Vector3.Distance(targetCar.carPos, targetVertex2.vertexPos);
            t2s += Vector3.Distance(carMessage.carPos, selfVertex2.vertexPos);

            s2t += GlobalVaribles.trailerGraph.pathMap[carMessage.carEdge.vertexNum2, targetCar.carEdge.vertexNum1].shortLength;
            t2s += GlobalVaribles.trailerGraph.pathMap[targetCar.carEdge.vertexNum2, carMessage.carEdge.vertexNum1].shortLength;

            s2t += Vector3.Distance(targetCar.carPos, targetVertex1.vertexPos);
            t2s += Vector3.Distance(carMessage.carPos, selfVertex1.vertexPos);
        }
        if (s2t <= t2s)
        {
            return(true);
        }
        else
        {
            return(false);
        }
    }
    //车的运动函数
    public void CarMovement()
    {
        if (task != null)//有任务了
        {
            switch (carMessage.workState)
            {
            case WorkState.Empty:
                carMessage.workState = WorkState.WayToLoad;
                carPathData          = GlobalVaribles.trailerGraph.pathMap[carMessage.carEdge.vertexNum1,
                                                                           task.loadGoods_Edge.vertexNum1];
                if (speedChangeable)
                {
                    carMessage.speed = moveSpeed;
                }
                break;

            case WorkState.WayToLoad:
                gotoLoadPoint();
                break;

            case WorkState.Loading:
                loadingGoods();
                break;

            case WorkState.WayToUnload:
                gotoUnloadPoint();
                break;

            case WorkState.Unloading:
                unloadingGoods();
                break;

            default:
                break;
            }
        }
        else
        {
            switch (carMessage.workState)
            {
            case WorkState.Empty:
                break;

            case WorkState.WayToLoad:
                carMessage.workState = WorkState.Empty;
                carMessage.speed     = 0;
                carPathData          = null;
                break;

            case WorkState.Loading:
                break;

            case WorkState.WayToUnload:
                break;

            case WorkState.Unloading:
                break;

            default:
                break;
            }
            if (carPathData != null)
            {
                int nextVertexNum = carMessage.carEdge.vertexNum2;//得到车要运动到的下一个节点
                TrailerGraph.Vertex nextVertex = GlobalVaribles.trailerGraph.vertexes[nextVertexNum];
                if (speedChangeable)
                {
                    carMessage.speed = moveSpeed;
                }
                gotoVertex(nextVertex);
            }
        }
    }