private void UpdateDensityAndSpeed(ITrafficLight trafficLight, ITrafficData oldTrafficData,
ITrafficData trafficData, double seconds)
{
/*if (Math.Abs(trafficData.TrafficDensity) < Epsilon)
* {
* return;
* }*/
if (trafficLight.State == TrafficLightState.Red)
{
var hours = seconds / 3600.0;
var length = trafficData.TrafficSpeed * 1000.0 * hours;
var nofCars = length / 100.0 * 25 * trafficData.TrafficDensity;
var newDensity = oldTrafficData.TrafficDensity + nofCars / 25.0;
/*if (newDensity > 1)
* {
* newDensity = 1;
* }*/
trafficData.TrafficDensity = newDensity;
trafficData.TrafficSpeed = 0.0;
}
else
{
var hours = seconds / 3600.0;
var length = trafficData.TrafficSpeed * 1000.0 * hours;
var nofCars = length / 100.0 * 25 * trafficData.TrafficDensity;
var newDensity = oldTrafficData.TrafficDensity - nofCars / 25.0;
if (newDensity < trafficData.TrafficDensity)
{
newDensity = trafficData.TrafficDensity;
}
trafficData.TrafficDensity = newDensity;
}
}
private async Task ChangeDateTimeToCurrent(ITrafficLight trafficLight)
{
await Task.Run(() =>
{
trafficLight.Date = DateTime.UtcNow;
});
}
public async Task InitiateTrafficLightAsync()
{
IDictionary <enmLightState, StateDuration> DicStateDurations = new Dictionary <enmLightState, StateDuration>();
DicStateDurations.Add(enmLightState.Green, new StateDuration()
{
MinDuration = int.Parse(this.txtGreenMinDuration.Text), MaxDuration = int.Parse(this.txtGreenMaxDuration.Text)
});
DicStateDurations.Add(enmLightState.Red, new StateDuration()
{
MinDuration = int.Parse(this.txtRedMinDuration.Text), MaxDuration = int.Parse(this.txtRedMaxDuration.Text)
});
DicStateDurations.Add(enmLightState.Yellow, new StateDuration()
{
MinDuration = int.Parse(this.txtYellowMinDuration.Text), MaxDuration = int.Parse(this.txtYellowMaxDuration.Text)
});
DicStateDurations.Add(enmLightState.YellowRed, new StateDuration()
{
MinDuration = 5, MaxDuration = 5
});
this.trafficLight = new TrafficLight.Domain.TrafficLight(DicStateDurations);
this.trafficLight.OnStateChanged += TrafficLight_OnStateChanged;
RefreshState(this.trafficLight.CurrentState);
}
public async Task ScheduleStateChange(ITrafficLight trafficLight)
{
Console.WriteLine(this.color);
await Task.Delay(TimeSpan.FromSeconds(this.durationInSeconds));
trafficLight.SetState(this.lightFactory.GetNextState(this.color));
}
private void Start()
{
if (tlc == null)
{
tlc = GetComponentInParent <ITrafficLight>();
}
}
/// <summary>
/// Add traffic light to list
/// </summary>
/// <param name="tl">Traffic light instance</param>
public void AddTrafficLight(ITrafficLight tl)
{
if (CurrentPowerLevel - tl.PowerConsumption > 0)
{
CurrentPowerLevel = CurrentPowerLevel - tl.PowerConsumption;
TrafficLights.Add(tl);
}
}
/// <summary>
/// Turn off traffic light connected to power station
/// </summary>
/// <param name="id">Id of traffic light</param>
public void PowerOffTrafficLightById(int id)
{
ITrafficLight tl = TrafficLights.Find(x => x.Id == id);
if (tl != null)
{
tl.PowerOff();
}
}
private double GetTrafficDataMark(ITrafficLight trafficLight, ITrafficData trafficData)
{
if (trafficLight.State == TrafficLightState.Green)
{
return(trafficData.TrafficDensity + 1 / trafficData.TrafficSpeed);
}
return(0.0);
}
/// <summary>
/// Remove traffic light from list by id
/// </summary>
/// <param name="id">Id of traffic light</param>
public void RemoveTrafficLightById(int id)
{
ITrafficLight tl = TrafficLights.Find(x => x.Id == id);
if (tl != null)
{
tl.PowerOff();
TrafficLights.Remove(tl);
CurrentPowerLevel = CurrentPowerLevel + tl.PowerConsumption;
}
}
protected TrafficLightDrawerBase(
int leftOffset,
int topOffset,
ITrafficLight trafficLight,
Action <Point> prepareConsoleAction)
{
Console.OutputEncoding = Encoding.UTF8;
Console.CursorVisible = false;
_zoneOffset = new Point(leftOffset, topOffset);
_trafficLight = trafficLight;
_prepareConsoleAction = prepareConsoleAction;
_trafficLight.LightStateChanged += TrafficLightOnLightStateChanged;
}
/// <summary>TODO</summary>
public static async Task <Unit> ExecuteTrafficLight <T>
(this ITrafficLight <T> e)
{
e.ContractedNotNull("e");
Contract.Ensures(Contract.Result <Task <Unit> >() != null); // not supported for async/await
try {
var trafficLightState = await LightStates <T> .Start(e)(e);
while (trafficLightState != null)
{
trafficLightState = await trafficLightState()(e);
}
} catch (OperationCanceledException) {; }
return(Unit._);
}
public ITrafficLightDrawer Create(int leftOffset, int topOffset, ITrafficLight trafficLight)
{
switch (trafficLight.GetType().Name)
{
case nameof(StandartTrafficLightController):
return(new StandartTrafficLightDrawer(leftOffset, topOffset, trafficLight));
case nameof(PedestrianTrafficLightController):
return(new PedestrianTrafficLightDrawer(leftOffset, topOffset, trafficLight));
case nameof(LeftSectionStandartTrafficLightController):
return(new LeftSectionStandartTrafficLightDrawer(leftOffset, topOffset, trafficLight));
default:
throw new NotSupportedException();
}
}
public static void Main(string[] args)
{
ITrafficLightDrawerFactory factory = new TrafficLightDrawerFactory();
var trafficLights = new ITrafficLight[]
{
new PedestrianTrafficLightController(10, 4),
new StandartTrafficLightController(5, 1, 10),
new LeftSectionStandartTrafficLightController(4, 1, 6, 3),
};
var drawers = trafficLights
.Select((tl, i) => factory.Create(4, i * 6 + 1, tl));
foreach (var trafficLightDrawer in drawers)
{
trafficLightDrawer.Start();
}
Console.ReadLine();
}
private double GetMarkFromTrafficData(ITrafficLight trafficLight, ITrafficData trafficData)
{
/* if (trafficLight.State == TrafficLightState.Green)
* {
* if (Math.Abs(trafficData.TrafficSpeed) > 0.0001)
* {
* return trafficData.TrafficDensity + 1 / trafficData.TrafficSpeed;
* }
* else {
* return trafficData.TrafficDensity;
* }
* }
*
* return 0.0;*/
if (Math.Abs(trafficData.TrafficSpeed) > 0.0001)
{
return(trafficData.TrafficDensity + 1 / trafficData.TrafficSpeed);
}
return(trafficData.TrafficDensity);
}
protected virtual void AfterAdd(ITrafficLight trafficLight)
{
}
public App(ITrafficLight trafficLight, IInput input, IOutput output)
{
_trafficLight = trafficLight;
_input = input;
_output = output;
}
protected override void AfterAdd(ITrafficLight trafficLight)
{
trafficLight.StateExpirationEvent += OnTrafficLightStateExpired;
}
public TrafficLightManager(ILogger logger, ITrafficLight lights)
{
_logger = logger;
Lights = lights;
}
public PolarTrafficLightCluster(ITrafficLight masterTrafficLight)
{
MasterTrafficLight = masterTrafficLight;
masterTrafficLight.StateExpirationEvent += OnTrafficLightStateExpired;
}
public App(ITrafficLight trafficLight, IInput input)
{
_trafficLight = trafficLight;
_input = input;
}
public PedestrianTrafficLightDrawer(int leftOffset, int topOffset, ITrafficLight trafficLight)
: base(leftOffset, topOffset, trafficLight, PrepareConsole)
{
}
public LeftSectionStandartTrafficLightDrawer(int leftOffset, int topOffset, ITrafficLight trafficLight)
: base(leftOffset, topOffset, trafficLight, PrepareConsole)
{
}
