示例#1
0
        public static void Drive(Pose start, ReedsSheppActionSet actions, float unit)
        {
            Pose current = new Pose(start);

            foreach (ReedsSheppAction action in actions.Actions)
            {
                switch (action.Steer)
                {
                case Steer.Straight:
                    current = Straight(current, action.Gear, action.Length, unit);
                    break;

                case Steer.Left:
                    current = TurnLeft(current, action.Gear, action.Length, unit);
                    break;

                case Steer.Right:
                    current = TurnRight(current, action.Gear, action.Length, unit);
                    break;
                }

                if (Debug != null)
                {
                    current.DrawPose(Debug, 2, Color.LightBlue);
                }
            }
        }
示例#2
0
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(backgroundLight ? LIGHT : DARK);

            Matrix p = camera.Projection;
            Matrix v = camera.View;

            if (cameraView == 2)
            {
                float   orientation   = controller != null && controller.InReverse ? car.Pose.Orientation + MathHelper.Pi : car.Pose.Orientation;
                Vector2 position      = Car.GetCenterPosition(car.Pose);
                Vector2 headingVector = new Vector2((float)Math.Cos(orientation), (float)Math.Sin(orientation));
                float   offset        = 14f;
                float   height        = 10f;
                v = Matrix.CreateLookAt(new Vector3(position + -offset * headingVector, height), new Vector3(position + offset * headingVector, 0f), Vector3.UnitZ);
            }
            else if (cameraView == 3)
            {
                float   or            = car.Pose.Orientation + MathHelper.ToRadians(120f);
                Vector2 headingVector = new Vector2((float)Math.Cos(or), (float)Math.Sin(or));
                v = Matrix.CreateLookAt(new Vector3(car.Pose.Position + -10f * headingVector, 5f), new Vector3(Car.GetCenterPosition(car.Pose), 0f), Vector3.UnitZ);
            }
            else if (cameraView == 4)
            {
                float   or            = goalPose.Orientation;
                Vector2 headingVector = new Vector2((float)Math.Cos(or), (float)Math.Sin(or));
                v = Matrix.CreateLookAt(new Vector3(goalPose.Position + 10f * headingVector, 20f), new Vector3(Car.GetCenterPosition(car.Pose), 0f), Vector3.UnitZ);
            }
            else if (cameraView == 5)
            {
                v = Matrix.CreateLookAt(new Vector3(Car.GetCenterPosition(car.Pose), 20f), new Vector3(Car.GetCenterPosition(car.Pose), 0f), Vector3.UnitY);
                if (rotateCar)
                {
                    v *= Matrix.CreateRotationZ(-car.Body.Rotation + MathHelper.PiOver2);
                }
            }

            if (gridDone && (drawGrid || drawVoro || drawHeur))
            {
                basicEffect.World      = Matrix.Identity;
                basicEffect.View       = v;
                basicEffect.Projection = p;
                spriteBatch.Begin(0, null, SamplerState.PointClamp, DepthStencilState.DepthRead, RasterizerState.CullNone, basicEffect);

                if (drawHeur)
                {
                    HybridAStar.Draw(spriteBatch);
                }
                else
                {
                    grid.Draw(spriteBatch, drawVoro);
                }

                spriteBatch.End();
            }

            debug.BeginCustomDraw(ref p, ref v);

            debug.DrawSolidCircle(Car.GetFrontAxlePosition(car.Pose), 0.2f, Color.Green);

            if ((pathSearching && watchSearch || pathSearchingDone && drawSearch) && HybridAStar.Expanded != null && HybridAStar.Expanded.Count > 0)
            {
                LinkedList <HybridAStar.Node> expanded = new LinkedList <HybridAStar.Node>();
                lock (HybridAStar.Expanded)
                {
                    expanded.AddAll(HybridAStar.Expanded);
                }

                float pathLength = expanded.Last.f;
                foreach (HybridAStar.Node n in expanded)
                {
                    if (pathDone && n.rsIndex >= 0)
                    {
                        for (int i = n.rsIndex; i < poses.Count - 1; i++)
                        {
                            debug.DrawSegment(poses[i].Position, poses[i + 1].Position, Color.Purple, 0.02f);
                        }
                    }
                    else if (n.from != null)
                    {
                        Color color;
                        if (n.cell.rev == 0)
                        {
                            color = Color.Lerp(Color.Orange, Color.Green, n.g / pathLength);
                        }
                        else
                        {
                            color = Color.Lerp(Color.Blue, Color.Cyan, n.g / pathLength);
                        }

                        debug.DrawSegment(n.from.pose.Position, n.pose.Position, color, 0.02f);
                    }
                }
            }

            if (pathDone)
            {
                if (drawPath)
                {
                    for (int i = 0; i < poses.Count - 1; i++)
                    {
                        Color c = poses[i].Gear == Gear.Forward ? Color.Blue : Color.Red;
                        debug.DrawSegment(poses[i].Position, poses[i + 1].Position, c, 0.04f);
                        debug.DrawPoint(poses[i].Position, 0.1f, c * 0.5f);
                    }
                }
            }

            if (pathSearchingDone && !pathSmoothDone && (drawSmoothedPath || drawController))
            {
                Smoother.Draw(debug);
            }

            if (pathSmoothDone)
            {
                if (drawFrontPath && controller.FrontPath != null)
                {
                    int num = controller.FrontPath.Count;
                    for (int i = 0; i < num - 1; i++)
                    {
                        if (controller.FrontPath[i].Gear == Gear.Forward)
                        {
                            debug.DrawSegment(controller.FrontPath[i].Position, controller.FrontPath[i + 1].Position, Color.DarkOrange);
                        }
                        else
                        {
                            debug.DrawSegment(controller.ReverseFrontPath[i].Position, controller.ReverseFrontPath[i + 1].Position, Color.Cyan);
                        }
                    }
                }

                if (drawSmoothedPath)
                {
                    for (int i = 0; i < smoothedPath.Count - 1; i++)
                    {
                        debug.DrawSegment(smoothedPath[i].Position, smoothedPath[i + 1].Position, smoothedPath[i].Gear == Gear.Forward ? Color.DarkGreen : Color.Red, 0.04f);
                        //if (Smoother.UnsafeIndices != null && Smoother.UnsafeIndices.Contains(i))
                        //debug.DrawCircle(smoothedPath[i].Position, 0.2f, Color.Orange);
                    }
                }

                if (drawController)
                {
                    controller.Draw(debug);
                }
            }

            if (drawStart)
            {
                startPose.DrawPose(debug, new Color(0f, 1f, 0f, 0.9f), 1.1f);
            }
            if (drawGoal)
            {
                goalPose.DrawPose(debug, new Color(1f, 0f, 0f, 0.9f), 1.1f);
            }

            if (drawCurrent)
            {
                if (pathSmoothDone && controller.State != StanleyFSMController.ControllerState.MissionComplete)
                {
                    debug.DrawCircle(controller.ClosestPoint, 0.1f, controller.InReverse ? Color.Aqua : Color.Orange);
                    if (controller.InReverse)
                    {
                        debug.DrawCircle(controller.FakeFrontAxle, 0.2f, Color.Aqua);
                    }
                }

                car.Pose.DrawPose(debug, 0.2f, Color.Red);
            }

            debug.EndCustomDraw();

            if (drawDebugData)
            {
                debug.RenderDebugData(ref p, ref v);
            }

            if (drawCar)
            {
                car.Draw(v, p);
            }

            if (showDebugInfo)
            {
                string info = String.Format("Speed: {0:0.0}", Math.Round(car.SpeedMPH, 1));
                if (pathSmoothDone)
                {
                    info += String.Format("\nGas: {0:0.00}", Math.Round(currentControls.Gas * 100f, 2));
                    info += String.Format("\nBrake: {0:0.00}", Math.Round(currentControls.Brake * 100f, 2));
                    info += String.Format("\nCTE: {0:0.0000}", Math.Round(controller.CrossTrackError, 4));
                    info += "\n" + controller.State.ToString();
                    info += "\n" + controller.DebugInfo;
                }
                spriteBatch.Begin();
                spriteBatch.DrawString(font, info, new Vector2(8, 4), !backgroundLight ? LIGHT : DARK);
                spriteBatch.End();
            }

            if (showDashboard)
            {
                dashboard.Draw(gameTime);
            }

            base.Draw(gameTime);
        }
示例#3
0
        public static void Drive(Pose start, ReedsSheppActionSet actions, float unit)
        {
            Pose current = new Pose(start);
            foreach (ReedsSheppAction action in actions.Actions)
            {
                switch (action.Steer)
                {
                    case Steer.Straight:
                        current = Straight(current, action.Gear, action.Length, unit);
                        break;

                    case Steer.Left:
                        current = TurnLeft(current, action.Gear, action.Length, unit);
                        break;

                    case Steer.Right:
                        current = TurnRight(current, action.Gear, action.Length, unit);
                        break;
                }

                if (Debug != null)
                    current.DrawPose(Debug, 2, Color.LightBlue);
            }
        }