public void Setup( RouteElement roadElement, bool canStopOnIt, IRoadElement previous, IRoadElement next, PriorityType priorityType )
{
this.SetRouteElement( roadElement.RoadElement );
this._canStopOnIt = canStopOnIt;
this._routeElement = roadElement;
this._next = next;
}
private BuildRoute ConvertRoute( BuildMode.Controls.Route route, BuilderContext context, IRoadElement routeOwner )
{
return new BuildRoute( this.GetRouteElements( route, context, routeOwner ) )
{
Probability = route.Probability,
Name = route.Name,
Owner = routeOwner,
};
}
public float Lenght( IRoadElement previous, IRoadElement next )
{
if ( this._lane.Prev != previous || this._lane.Next != next )
{
throw new ArgumentNullException();
}
return Vector2.Distance( this._lane.Prev.BuildControl.Location, this._lane.Next.BuildControl.Location );
}
public Car Create( IRoadElement startElement )
{
var randomRoute = this.GetRandomRoute( startElement );
var condcutors = this._routeToConductorConverter.Convert( randomRoute ).ToArray();
var car = new Car( condcutors )
{
Width = UnitConverter.FromMeter( Widht ),
Lenght = UnitConverter.FromMeter( Length ),
BreakingForce = UnitConverter.FromKmPerHour( 10.0f ) / UnitConverter.FromSecond( 1.0f ),
AccelerateForce = UnitConverter.FromKmPerHour( 10.0f ) / UnitConverter.FromSecond( 1.0f ),
MaxSpeed = this.ToVirtualUnitSpeed( 60.0f ),
Velocity = this.ToVirtualUnitSpeed( 10.0f ),
CarId = ++_carId,
};
return car;
}
private IEnumerable<RouteElement> GetRouteElements( BuildMode.Controls.Route route, BuilderContext context, IRoadElement routeOwner )
{
return route.Items.Select( ( index, prev, current, next ) =>
{
var nextElement = next != null ? next.Control : null;
var prevElement = prev != null ? prev.Control : null;
if ( prevElement == null && index == 0 )
{
prevElement = routeOwner.BuildControl;
}
return new RouteElement
{
PriorityType = current.PriorityType,
RoadElement = this.GetRoadElement( context, current.Control ),
Length = this.GetLength( prevElement, current, nextElement ),
CanStopOnIt = current.CanStop,
};
} );
}
private IEnumerable<RouteElement> GetRandomRoute( IRoadElement startElement )
{
var result = new List<RouteElement>
{
new RouteElement
{
CanStopOnIt = true,
PriorityType = PriorityType.None,
RoadElement = startElement
}
};
result.AddRange( startElement.Routes.GetRandomRoute( this._rng ) );
while ( true )
{
var nextRoute = result.Last().RoadElement.Routes.GetRandomRoute( this._rng ).ToArray();
if ( nextRoute.Length == 0 ) { break; }
result.AddRange( nextRoute );
}
return result;
}
private void SetRouteElement( IRoadElement element )
{
var laneCorner = element as LaneCorner;
if ( laneCorner == null ) { throw new ArgumentException( "Wrong road element" ); }
this._laneCorner = laneCorner;
}
public bool CanStop( IRoadElement previous, IRoadElement next )
{
return true;
}
private void SetRouteElement( IRoadElement element )
{
var carInserter = element as CarsInserter;
if ( carInserter == null ) { throw new ArgumentException( "Wrong road element" ); }
this._carInserter = carInserter;
}
public bool CanCreate( IRoadElement roadElement )
{
return this._conductorFactory.Any( s => s.CanCreate( roadElement ) );
}
public float Lenght( IRoadElement previous, IRoadElement next )
{
return Constans.PointSize;
}
public IRoadInformation Create( IRoadElement roadElement )
{
var factory = this._conductorFactory.FirstOrDefault( f => f.CanCreate( roadElement ) );
if ( factory == null ) { throw new ArgumentException( "Can't create conductor for given road element", "roadElement" ); }
return factory.Create( roadElement );
}
public Vector2 GetCarDirection( Car car, IRoadElement nextPoint )
{
return this._lane.RoadLaneBlock.RightEdge.Location - car.Location;
}
public void SetConnection( IRoadElement roadElement )
{
if ( roadElement == null ) { return; }
this._connections.Add( roadElement );
}
public void AddControl( IRoadElement element )
{
this._elementsToDraw.Add( element );
}
public float GetCarDistanceTo( Car car, IRoadElement nextPoint )
{
Debug.Assert( this._lane.Next == nextPoint );
return Vector2.Distance( car.Location, nextPoint.BuildControl.Location );
}
public float GetCarDistanceTo( Car car, IRoadElement nextPoint )
{
return Constans.PointSize;
}
public Vector2 GetCarDirection( Car car, IRoadElement nextPoint )
{
return car.Direction;
// return nextPoint.BuildControl.Location - car.Location;
}
public StandardDrawer( IRoadElement owner )
{
Contract.Requires( owner != null );
this._owner = owner;
}
public void SetRouteElement( IRoadElement element )
{
var junctionEdge = element as JunctionEdge;
if ( junctionEdge == null ) { throw new ArgumentException( "Wrong road element" ); }
this._junctionEdge = junctionEdge;
}
protected virtual BuildRoute[] ConvertRoutes( Routes routes, BuilderContext obj, IRoadElement owner )
{
return this._converter.Convert( routes.AvailableRoutes, obj, owner ).ToArray();
}
public void AddRoadElement( IRoadElement roadElement )
{
this._roadElements.Add( roadElement );
this._controlers.ForEach( s => s.AddControl( roadElement ) );
}
public void SetReversConnection( IRoadElement roadElement )
{
if ( roadElement == null ) { return; }
this._reversConnection.Add( roadElement );
}
public IEnumerable<BuildRoute> Convert( IEnumerable<BuildMode.Controls.Route> buildRoutes, BuilderContext context, IRoadElement routeOwner )
{
return buildRoutes.Select( route => this.ConvertRoute( route, context, routeOwner ) );
}
public float Lenght( IRoadElement previous, IRoadElement next )
{
Debug.Assert( previous is JunctionEdge );
Debug.Assert( next is JunctionEdge );
return Vector2.Distance( previous.BuildControl.Location, next.BuildControl.Location );
}
private Tuple<int,JunctionEdge> GetEdgeConnectedWith( IRoadElement roadElement )
{
var item = this._laneJunction.Edges.Select( (e,i ) => new { Index = i, Edge = e} ).Where( s => s.Edge.ConnectedEdge == roadElement ).FirstOrDefault();
if( item == null ) { return null; }
return Tuple.Create( item.Index, item.Edge );
}
