RoadMap.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;

namespace Jypeli
{
    public class RoadMap
    {
        private Vector[] wayPoints;
        private Angle[] angles = null;

        public double DefaultWidth { get; set; }

        public double DefaultFriction { get; set; }

        public GameObject[] Segments { get; private set; }

        public Func<double, double, Shape, PhysicsObject> CreateSegmentFunction { get; set; }


        public RoadMap( IList<Vector> wayPoints )
        {
            this.DefaultWidth = 10.0;
            this.DefaultFriction = 1.0;
            this.CreateSegmentFunction = CreateSegment;
            this.wayPoints = new Vector[wayPoints.Count];
            wayPoints.CopyTo( this.wayPoints, 0 );
            this.Segments = new GameObject[wayPoints.Count - 1];
        }

        public Angle GetAngle( int wayPointIndex )
        {
            // TODO: calculate this on the fly so that this check becomes unnecessary.
            if ( angles == null )
                throw new Exception( "Call Insert() first" );
            return angles[wayPointIndex];
        }

        public void Insert()
        {
            if ( wayPoints.Length < 2 )
            {
                throw new ArgumentException( "Must have at least 2 points" );
            }

            angles = new Angle[wayPoints.Length];

            Vector first = wayPoints[0];
            Vector second = wayPoints[1];
            Vector toBeginning = ( first - second ).Normalize();
            Vector beginning = first + toBeginning;

            Vector previousLeft, previousRight;
            CalculatePoints( beginning, first, second, out previousLeft, out previousRight );
            angles[0] = ( second - first ).Angle;

            Vector secondToLast = wayPoints[wayPoints.Length - 2];
            Vector last = wayPoints[wayPoints.Length - 1];
            Vector toVeryLast = ( last - secondToLast ).Normalize();
            Vector veryLast = last + toVeryLast;
              
            for ( int i = 1; i < wayPoints.Length; i++ )
            {
                Vector previous = wayPoints[i - 1];
                Vector current = wayPoints[i];
                Vector next;

                Vector toPrevious = ( previous - current ).Normalize();
                Vector toNext;

                if ( i == wayPoints.Length - 1 )
                {
                    next = veryLast;
                    toNext = toVeryLast;
                }
                else
                {
                    next = wayPoints[i + 1];
                    toNext = ( next - current ).Normalize();
                }

                Vector left, right;
                CalculatePoints( previous, current, next, out left, out right );
                angles[i] = ( next - previous ).Angle;

                Vector center = previous + toNext / 2;

                Vector[] vertices = new Vector[4];
                vertices[0] = previousLeft - center;
                vertices[1] = previousRight - center;
                vertices[2] = right - center;
                vertices[3] = left - center;

                IndexTriangle[] triangles = new IndexTriangle[] 
                {
                    new IndexTriangle(0, 3, 1),
                    new IndexTriangle(1, 3, 2) 
                };

                ShapeCache cache = new ShapeCache( vertices, triangles );
                Polygon shape = new Polygon( cache, false );

                PhysicsObject segment = CreateSegmentFunction( 100, 100, shape );
                segment.Position = center;
                Segments[i - 1] = segment;

                previousLeft = left;
                previousRight = right;
            }
        }

        private PhysicsObject CreateSegment( double width, double height, Shape shape )
        {
            PhysicsObject o = PhysicsObject.CreateStaticObject( width, height, shape );
            o.Color = Color.Gray;
            o.IgnoresCollisionResponse = true;
            o.KineticFriction = DefaultFriction;

            if ( Game.Instance is TopDownPhysicsGame )
            {
                TopDownPhysicsGame g = (TopDownPhysicsGame)Game.Instance;
                g.AddSurface( o );
            }
            else
            {
                Game.Instance.Add( o );
            }
            
            return o;
        }

        private void CalculatePoints( Vector previous, Vector current, Vector next, out Vector left, out Vector right )
        {
            Vector toNext = ( next - current ).Normalize();
            Vector toPrevious = ( previous - current ).Normalize();
            Vector direction = ( next - previous ).Normalize();

            Vector perpendicular = new Vector( direction.Y, -direction.X );
            Vector toLeft = -perpendicular;
            Vector toRight = perpendicular;

            left = current + toLeft * DefaultWidth / 2;
            right = current + toRight * DefaultWidth / 2;
        }

        public bool IsInside( Vector point )
        {
            return ListHelpers.ArrayFind( Segments, seg => seg.IsInside( point ) ) != null;
        }
    }
}