public async Task SyncDeparturesAsync(Crossing crossing, DateTime date, int days, CancellationToken cancellationToken = default)
{
var vehicleResults = new Dictionary <DateTime, DepartureInfo[]>();
var vehicles = ((Vehicle[])Enum.GetValues(typeof(Vehicle))).Where(x => x.GetAttribute().IncludeInAvailability);
await Task.WhenAll(vehicles.Select(async vehicle =>
{
cancellationToken.ThrowIfCancellationRequested();
using (var session = _browserSessionFactory.CreateSession())
{
var bookingDetails = await session.GoToAsync <BookingDetailsPage>();
await bookingDetails.EnterDetailsAsync(crossing, vehicle, date);
var departureSelect = await session.GoToAsync <DepartureSelectPage>();
var departures = await departureSelect.GetDeparturesAsync(date, days, cancellationToken);
lock (vehicleResults)
{
PatchAvailability(vehicleResults, vehicle, departures);
}
}
}));
await Task.WhenAll(vehicleResults.Select(x => _cache.SetDeparturesAsync(crossing, x.Key, x.Value, cancellationToken)));
}
public CrossingIndicator(Texture2D onTexture, Texture2D offTexture, Crossing referenceCrossing, string target)
{
_onTexture = onTexture;
_offTexture = offTexture;
this.referenceCrossing = referenceCrossing;
this.target = target;
}
static void Main()
{
Crossing crossing = new Crossing();
Console.WriteLine(crossing.State);
// output: light A = red
// output: light B = green
crossing.PushButton(Trigger.Button1);
// output: light A = red
// output: light B = orange
// output: light A = green
// output: light B = red
crossing.PushButton(Trigger.Button1);
crossing.PushButton(Trigger.Button2);
// output: light A = orange
// output: light B = red
// output: light A = red
// output: light B = green
crossing.PushButton(Trigger.Button2);
}
public async Task <DepartureInfo[]> GetDeparturesAsync(Crossing crossing, DateTime date, int days, bool allowIncompleteDays, CancellationToken cancellationToken = default)
{
var hits = await Task.WhenAll(
Enumerable.Range(0, days)
.Select(x => date.AddDays(x))
.Select(x => _cache.GetStringAsync(ComputeKey(crossing, x), cancellationToken)));
if (!allowIncompleteDays && hits.Any(x => x == null))
{
return(null);
}
var entries = hits.Where(x => x != null).Select(json => JsonConvert.DeserializeObject <Entry>(json)).OrderBy(x => x.Date);
var departures = entries.SelectMany(x => x.Departures).OrderBy(x => x.Departure).ToArray();
var vehicles = (Vehicle[])Enum.GetValues(typeof(Vehicle));
var expectedNumberOfVehicles = vehicles.Count(x => x.GetAttribute().IncludeInAvailability);
if (departures.Any(x => x.Availability.Count != expectedNumberOfVehicles))
{
return(null);
}
return(departures);
}
public SingleRoute GetRouteFromMidRoad(MobileUnit obj, Road currentRoad, Crossing target)
{
string subquery1 = string.Format(query, currentRoad.Source.ID, target.ID);
string subquery2 = string.Format(query, currentRoad.Target.ID, target.ID);
return(PgRoutingCommons.GetRouteFromMidRoad(subquery1, subquery2, obj, currentRoad, target));
}
private void pictureBoxGrid_DragDrop(object sender, DragEventArgs e)
{
// TODO Abdullah
RoadObject roadObject = null; // Declaration
Image draggedImage = (Image)e.Data.GetData(DataFormats.Bitmap); // Get Imaged Draged
Point draggedPointer = RoundXY(pictureBoxGrid.PointToClient(new Point(e.X, e.Y))); // Where to draw Image
if (draggedImage == pictureBox_CrossingA.Image)
{
roadObject = new Crossing(draggedPointer, CrossingType.CrossingWithoutPedestrian, draggedImage);
roadObject.bitmap = new Bitmap(draggedImage);
simulator.AddCrossing(roadObject);
Console.WriteLine("Crossing A was Drawn");
}
else if (draggedImage == pictureBox_CrossingB.Image)
{
roadObject = new Crossing(draggedPointer, CrossingType.CrossingWithPedestrian, draggedImage);
roadObject.bitmap = new Bitmap(draggedImage);
simulator.AddCrossing(roadObject);
Console.WriteLine("Crossing B was Drawn");
}
else
{
MessageBox.Show("Non of the crossings");
Console.WriteLine("Crossing xyz was Drawn");
}
clear();
drawGrid();
drawRoadObjects(simulator.RoadObjects);
render();
}
public PixelCollection NextGeneration()
{
Selection.Execute(PixelCollection, ScoringTable, PixelsToSelect);
Crossing.Execute(PixelCollection, PixelsToSelect, HowManyChildren);
Mutation.Execute(PixelCollection, MutationRate);
return(PixelCollection);
}
bool ObstacleExists()
{
Collider[] hitColliders = Physics.OverlapSphere(_collisionChecker.position, CautionSize);
bool colFound = false;
foreach (var col in hitColliders)
{
switch (col.tag)
{
case "Car":
Car otherCar = col.GetComponent <Car>();
if (otherCar != this && otherCar._currentLane == _currentLane)
{
colFound = true;
}
break;
case "Obstacle":
Crossing crossing = col.GetComponentInChildren <Crossing>();
if (crossing != null)
{
if (crossing.inUse)
{
colFound = true;
}
}
break;
}
}
return(colFound);
}
void Awake()
{
_crossing = GetComponentInParent <Crossing>();
_posA = _crossing.walkwayStart.position;
_posB = _crossing.walkwayEnd.position;
StartCoroutine(WaitRoutine());
}
public Feeder(int feederID, Crossing crossing, Simulation simulation)
{
this.simulation = simulation;
this.FeederID = feederID;
this.crossing = crossing;
random = new Random();
CarsComingIn = new Car[5];
CarsGoingOut = new Car[5];
StopPointsComingIn = new List<Point>();
StopPointsGoingOut = new List<Point>();
switch (this.FeederID)
{
case 1:
for (int i = 4; i > -1; i--)
{
this.StopPointsGoingOut.Add(new Point(Convert.ToInt16(i + "7"), 112));
}
for (int i = 12; i < 53; i += 10)
{
this.StopPointsComingIn.Add(new Point(i, 82));
}
break;
case 2:
for (int i = 4; i > -1; i--)
{
this.StopPointsGoingOut.Add(new Point(82, Convert.ToInt16(i + "7")));
}
for (int i = 12; i < 53; i += 10)
{
this.StopPointsComingIn.Add(new Point(112, Convert.ToInt16(i)));
}
break;
case 3:
for (int i = 146; i < 187; i += 10)
{
this.StopPointsGoingOut.Add(new Point(i, 82));
}
for (int i = 186; i > 145; i -= 10)
{
this.StopPointsComingIn.Add(new Point(i, 112));
}
break;
case 4:
for (int i = 146; i < 187; i += 10)
{
this.StopPointsGoingOut.Add(new Point(112, i));
}
for (int i = 192; i > 151; i -= 10)
{
this.StopPointsComingIn.Add(new Point(82, i));
}
break;
}
}
/**
* Checks cross count according to path rule to define is it point inside shape or not.
* @param cross - the point cross count
* @return true if point is inside path, or false otherwise
*/
bool isInside(int cross)
{
if (rule == WIND_NON_ZERO)
{
return(Crossing.isInsideNonZero(cross));
}
return(Crossing.isInsideEvenOdd(cross));
}
public void Bt_CS(object sender, RoutedEventArgs e)
{
Crossing crossing = new Crossing();
crossing.checkCrossing(figure[6], figure[7]);
CS.Text = crossing.PSV.ToString();
ShowReport(crossing.CrossingReport());
}
// Update is called once per frame
void Update()
{
Crossing messageBody = new Crossing()
{
Message = "Hoi", TimeStamp = DateTime.Now
};
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: false, basicProperties: null, body: Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(messageBody)));
}
public Task SetDeparturesAsync(Crossing crossing, DateTime date, DepartureInfo[] departures, CancellationToken cancellationToken = default)
{
var json = JsonConvert.SerializeObject(new Entry()
{
Date = date,
Departures = departures
});
return(_cache.SetStringAsync(ComputeKey(crossing, date), json, EntryOptions, cancellationToken));
}
public Task EnterDetailsAsync(Crossing crossing, Vehicle vehicle, DateTime date)
{
return(ExecuteWithRetry(async() =>
{
await PopulateBookingFlowRadioAsync(LocalVehicleOneWayRadio);
await PopulateOutboundAsync(crossing, date, vehicle.GetAttribute().OptionValue, 1);
await GoToNextStepAsync();
}));
}
private void Update(Story story, ref PositionTable <int> ans, PositionTable <int> perm)
{
if (ans == null)
{
ans = perm.Clone <int>();
}
else if (Crossing.Count(story, ans) > Crossing.Count(story, perm))
{
ans = perm.Clone <int>();
}
}
public void rotatePointTest()
{
Crossing crossing1 = new Crossing(new Point(), CrossingType.CrossingWithoutPedestrian);
System.Drawing.Point test = new System.Drawing.Point(0, 0);
System.Drawing.Point result = crossing1.rotatePoint(Orientation.Degree0, test);
Assert.AreEqual(result, new System.Drawing.Point(0, 0));
test = new System.Drawing.Point(0, 0);
result = crossing1.rotatePoint(Orientation.Degree90, test);
Assert.AreEqual(result, new System.Drawing.Point(0, 142));
}
/// <summary>
/// Update the Crossing field.
/// </summary>
/// <param name="dataModelClient">The client channel to the shared data model.</param>
/// <param name="workingOrderRow">The record that is to be updated.</param>
/// <param name="value">The value of the IsInstutitionMatch field.</param>
private void UpdateCrossing(WorkingOrderRow workingOrderRow, object newValue)
{
// Update the Crossing field.
Crossing crossing = (Boolean)newValue ? Crossing.AlwaysMatch : Crossing.NeverMatch;
Object submittedTime = crossing == Crossing.AlwaysMatch ? (Object)DateTime.UtcNow : (Object)null;
CrossingRow crossingRow = DataModel.Crossing.CrossingKeyCrossingCode.Find(crossing);
FluidTrade.Core.ThreadPoolHelper.QueueUserWorkItem(UpdateField, new Func <MethodResponseErrorCode>(() =>
TradingSupportWebService.UpdateWorkingOrder(new WorkingOrderRecord(workingOrderRow)
{
CrossingCode = crossingRow.CrossingId, SubmittedUTCTime = submittedTime
})));
}
public void getGlobalOrientationFromLocalTest()
{
Crossing crossing1 = new Crossing(new Point(), CrossingType.CrossingWithoutPedestrian);
Orientation test = crossing1.getGlobalOrientationFromLocal(Orientation.Degree0, Orientation.Degree0);
Assert.AreEqual(test, Orientation.Degree0);
test = crossing1.getGlobalOrientationFromLocal(Orientation.Degree90, Orientation.Degree0);
Assert.AreEqual(test, Orientation.Degree90);
test = crossing1.getGlobalOrientationFromLocal(Orientation.Degree90, Orientation.Degree90);
Assert.AreEqual(test, Orientation.Degree180);
test = crossing1.getGlobalOrientationFromLocal(Orientation.Degree270, Orientation.Degree180);
Assert.AreEqual(test, Orientation.Degree90);
}
protected async Task PopulateOutboundAsync(Crossing crossing, DateTime departure, int adults, int children, int seniors, int infants)
{
await PopulateOutboundCrossingAsync(crossing);
await PopulateOutboundDepartureCalendarAsync(departure);
await PopulateOutboundAdultsSelectAsync(adults);
await PopulateOutboundChildrenSelectAsync(children);
await _session.InvokeOnSelectElementAsync(OutboundSeniorsSelect, x => x.SelectByValue(seniors.ToString()));
await _session.InvokeOnSelectElementAsync(OutboundInfantsSelect, x => x.SelectByValue(infants.ToString()));
}
public TrackSection(string name, string trafficSignalName, Crossing type,
int length, TrackSection front = null, TrackSection back = null,
TrackSection right = null, TrackSection left = null)
{
Name = name;
Signal = new TrafficSignal(trafficSignalName);
Type = type;
SectionOnFront = front;
SectionOnBack = back;
SectionOnRight = right;
SectionOnLeft = left;
}
public PositionTable <int> Calculate(Story story)
{
// location tree => location constraint list
List <int> locationList = new List <int>();
BuildLocationList(story, story.LocationRoot, locationList);
int[] invertedLocationList = new int[locationList.Count];
for (int i = 0; i < locationList.Count; ++i)
{
invertedLocationList[locationList[i]] = i;
}
PositionTable <int> perm = new PositionTable <int>(story.Characters.Count, story.FrameCount);
for (int i = 0; i < story.Characters.Count; ++i)
{
for (int j = 0; j < story.FrameCount; ++j)
{
perm[i, j] = -1;
}
}
CalculateInitialFrame(story, perm, invertedLocationList, 0);
// sweep forward
for (int frame = 1; frame < story.FrameCount; ++frame)
{
RecalculateFrame(story, perm, invertedLocationList, frame, frame - 1);
}
for (int i = 0; i < 10; ++i)
{
for (int frame = story.FrameCount - 2; frame >= 0; --frame)
{
RecalculateFrameFreeSideRemembered(story, perm, invertedLocationList, frame, frame + 1);
}
for (int frame = 1; frame < story.FrameCount; ++frame)
{
RecalculateFrameFreeSideRemembered(story, perm, invertedLocationList, frame, frame - 1);
}
}
for (int frame = story.FrameCount - 2; frame >= 0; --frame)
{
RecalculateFrameFreeSideRemembered(story, perm, invertedLocationList, frame, frame + 1);
}
Debug.WriteLine("Crossing:{0}", Crossing.Count(story, perm));
return(perm);
}
public (Stack <Edge <T> >, Corner) FindEdges(MeshCell <T> cornerCell)
{
Edge <T> firstEdge = GetFirstEdgeOfBoundary(cornerCell);
Crossing firstCrossing = FindFirstCrossing(firstEdge);
Stack <Edge <T> > edges = default(Stack <Edge <T> >);
Corner corner = default(Corner);
bool stop = false;
CrossingFinder first = new CrossingFinder(firstCrossing.First);
CrossingFinder second = new CrossingFinder(firstCrossing.Second);
CrossingFinder third = new CrossingFinder(firstCrossing.Third);
while (!stop)
{
if (first.MoveForwardAndCheckForCrossing())
{
stop = true;
edges = first.Visited;
corner = new Corner
{
FirstEdge = firstCrossing.Third.Twin.BoundaryEdgeNumber,
SecondEdge = first.Crossing.First.BoundaryEdgeNumber
};
}
else if (second.MoveForwardAndCheckForCrossing())
{
stop = true;
edges = second.Visited;
corner = new Corner
{
FirstEdge = firstCrossing.First.Twin.BoundaryEdgeNumber,
SecondEdge = second.Crossing.First.BoundaryEdgeNumber
};
}
else if (third.MoveForwardAndCheckForCrossing())
{
stop = true;
edges = third.Visited;
corner = new Corner
{
FirstEdge = firstCrossing.Second.Twin.BoundaryEdgeNumber,
SecondEdge = third.Crossing.First.BoundaryEdgeNumber
};
}
}
return(edges, corner);
}
// REWORK ALL THIS LOGIC
private void handleAlarm(Sensor sensor)
{
sensorLayer.RaiseAlarm(sensor);
Crossing nearestCrossing = crossingLayer.GetNearestTo(sensor.EsriPosition);
lock (rangerLayer.DataLock)
{
List <Ranger> freeRangers = rangerLayer.Elements.Where(x => x.State != MobileUnitState.EN_ROUTE).ToList();
if (freeRangers.Count > 0)
{
List <Graphic> freeRangersGraphics = freeRangers.Select(x => x.Graphic).ToList();
MapPoint pt = GeoUtil.GetNearestCoordinateInGraphicsCollection(nearestCrossing.EsriPosition, freeRangersGraphics);
Ranger ranger = rangerLayer.ByPosition(pt);
viewModel.LeadMobileToCrossing(ranger, nearestCrossing);
}
}
}
public async Task <IActionResult> GetDepartures(Crossing crossing, DateTime?date, int?days = 1)
{
date = date ?? LaesoeTime.Now.Date;
if (Request.GetTypedHeaders().CacheControl?.NoCache != true)
{
var departures = await _cache.GetDeparturesAsync(crossing, date.Value, days.Value, false, HttpContext.RequestAborted);
if (departures != null)
{
return(Ok(departures));
}
}
await _crawlDeparturesProcessor.SyncDeparturesAsync(crossing, date.Value, days.Value, HttpContext.RequestAborted);
var result = await _cache.GetDeparturesAsync(crossing, date.Value, days.Value, true, HttpContext.RequestAborted);
return(Ok(result));
}
protected async Task PopulateReturnAsync(Crossing crossing, DateTime departure, string vehicleOptionValue, int passengers, int?vehicleLength = null)
{
if (vehicleOptionValue == null)
{
throw new ApiException(ApiStatus.VehicleNotFound);
}
await PopulateReturnCrossingAsync(crossing);
await PopulateReturnDepartureCalendarAsync(departure);
await _session.InvokeOnSelectElementAsync(ReturnPassengersSelect, x => x.SelectByValue(passengers.ToString()));
await _session.InvokeOnSelectElementAsync(ReturnVehicleSelect, x => x.SelectByValue(vehicleOptionValue));
if (vehicleLength != null)
{
await _session.InvokeOnElementAsync(ReturnVehicleLength, x => x.SendKeys(vehicleLength.ToString()));
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
if (Keyboard.GetState().IsKeyDown(Keys.Escape))
{
Exit();
}
foreach (var button in gameButtons)
{
button.Update(gameTime);
}
foreach (var indicator in gameIndicators)
{
//Get the signal, switch, derail, route, whatever that determines the state of the indicator.
object refObject = indicator.GetReferenceObject();
indicator.Update(gameTime, refObject);
}
foreach (var indicator in crossingIndicators)
{
Crossing refCrossing = indicator.GetReferenceCrossing();
string target = indicator.GetTarget();
indicator.Update(gameTime, refCrossing, target);
}
foreach (var crossing in crossings)
{
crossing.Update(gameTime);
}
/*foreach (var route in interlocking.allRoutes) {
* if (route.isLocked) {
* //Update to check for lowered barriers etc.
* }
* }*/
// TODO: Add your update logic here
base.Update(gameTime);
}
protected virtual bool MakeDetectionOnPath(Vector2 position)
{
int result = 0;
//float biggerSize=size.x>size.y?size.x:size.y;
float xx, yy;
int num = Path.Length;
Vector2 myoffset = pos;
float rot = 0;
CrossResultRec CrossResult;
//vertwxhelpertouch
Vector2 p11, p12, p21, p22;
p11.x = position.x;
p11.y = position.y;
p12.x = position.x;
p12.y = position.y + GlobalOptions.Vsizey * 30;
xx = Path[num - 1].x * scale * ExtraTouchScale * GlobalOptions.scaleFactory;
yy = Path[num - 1].y * scale * ExtraTouchScale * GlobalOptions.scaleFactory;
p21.x = myoffset.x + (xx * Mathf.Cos(rot) + yy * Mathf.Sin(rot));
p21.y = myoffset.y + (-xx * Mathf.Sin(rot) + yy * Mathf.Cos(rot));
for (int i = 0; i < num; i++)
{
xx = Path[i].x * scale * ExtraTouchScale * GlobalOptions.scaleFactory;
yy = Path[i].y * scale * ExtraTouchScale * GlobalOptions.scaleFactory;
p22.x = myoffset.x + (xx * Mathf.Cos(rot) + yy * Mathf.Sin(rot));
p22.y = myoffset.y + (-xx * Mathf.Sin(rot) + yy * Mathf.Cos(rot));
CrossResult = Crossing.GetCrossing(p11, p12, p21, p22);
if (CrossResult.type == enumCrossType.ctInBounds || CrossResult.type == enumCrossType.ctOnBounds)
{
result++;
}
p21.x = p22.x;
p21.y = p22.y;
}
return((result & 1) != 0);
}
public List <Waypoint> GetWayPoints()
{
Straight _straight = straight.GetComponent <Straight>();
Crossing _crossing = crossing.GetComponent <Crossing>();
CrossingT _crossingT = crossingT.GetComponent <CrossingT>();
Turn _turn = turn.GetComponent <Turn>();
switch (roadType)
{
case TYPE.Straight:
return(new List <Waypoint>
{
_straight.topIn, _straight.topOut, null, null, _straight.bottomIn, _straight.bottomOut, null, null
});
case TYPE.Turn:
return(new List <Waypoint>
{
_turn.topIn, _turn.topOut, null, null, null, null, _turn.leftIn, _turn.leftOut
});
case TYPE.CrossingT:
return(new List <Waypoint>
{
_crossingT.topIn, _crossingT.topOut, null, null,
_crossingT.bottomIn, _crossingT.bottomOut, _crossingT.leftIn, _crossingT.leftOut
});
case TYPE.Crossing:
return(new List <Waypoint>
{
_crossing.topIn, _crossing.topOut, _crossing.rightIn, _crossing.rightOut,
_crossing.bottomIn, _crossing.bottomOut, _crossing.leftIn, _crossing.leftOut
});
}
return(new List <Waypoint>());
}
private Simulation simulation; //needed to stop the simulation timer
#endregion Fields
#region Constructors
public TrafficLight(Crossing crossing, int greenLight, int feederID, Simulation simulation)
{
this.simulation = simulation;
this.feederID = feederID;
this.GreenLight = greenLight;
this.crossing = crossing;
greenLightTimer = new System.Timers.Timer();
yellowLightTimer = new System.Timers.Timer();
yellowLightTimer.Interval = (this.GreenLight * 100);
yellowLightTimer.Elapsed += yellowLightTimer_Elapsed;
greenLightTimer.Interval = (this.GreenLight*1000);
greenLightTimer.Elapsed += greenLightTimer_Elapsed;
switch (this.feederID)
{
case 1:
redPOint = new Point(71,96);
greenPOint = new Point(65, 96);
break;
case 2:
redPOint = new Point(96, 71);
greenPOint = new Point(96, 65);
break;
case 3:
redPOint = new Point(123, 96);
greenPOint = new Point(128, 96);
break;
case 4:
redPOint = new Point(96, 123);
greenPOint = new Point(96, 128);
break;
}
}
public void Update(GameTime gametime, Crossing referenceCrossing, string target)
{
switch (target)
{
case "down": {
indicatorState = referenceCrossing.barriersDown;
break;
}
case "up": {
indicatorState = referenceCrossing.barriersUp;
break;
}
case "signal": {
indicatorState = referenceCrossing.signalTowardRoad;
break;
}
default: {
break;
}
}
}
private void MainLoop(CancellationToken cancelTok)
{
int i = 1;
int db = INTERVAL / ANIM_INTERVAL;
while (true)
{
if (cancelTok.IsCancellationRequested)
{
inProgress = false;
Console.WriteLine("cancel requested");
break;
}
stopwatch.Stop();
long millisElapsed = stopwatch.ElapsedMilliseconds;
stopwatch.Restart();
double seconds = TimeScale * millisElapsed / 1000.0;
updateRangersPositions(seconds);
updateInterlopersPositions(seconds);
updateInterlopersVisibility();
Dictionary <Ranger, List <Interloper> > dictCaught = getInterlopersWithinRangersRange();
lock (rangerLayer.DataLock)
{
foreach (Ranger ranger in dictCaught.Keys)
{
rangerLayer.ShowFineAnimation(ranger);
ranger.Route = null;
}
}
List <Interloper> caught = dictCaught.Values.SelectMany(x => x).Distinct().ToList();
lock (interloperLayer.DataLock)
{
foreach (Interloper interloper in caught)
{
viewModel.Stats.NrCaught++;
interloperLayer.RemoveElement(interloper);
}
foreach (Interloper finished in getFinishedInterlopers())
{
viewModel.Stats.NrEscaped++;
interloperLayer.RemoveElement(finished);
}
}
lock (rangerLayer.DataLock)
{
foreach (Ranger finished in getFinishedRangers())
{
finished.Route = null;
}
}
ISet <Sensor> alarms = getAlarms();
foreach (Sensor alarm in alarms)
{
sensorLayer.RaiseAlarm(alarm);
}
// XXXXXXXXXXXXXXXXXXX POLICY DEPENDENT
foreach (Sensor alarm in alarms)
{
Crossing destination = getRandomCrossing(alarm);
if (viewModel.Policy == PursuitPolicy.NEAREST)
{
List <Ranger> freeRangers = getFreeRangers();
Ranger ranger = rangerLayer.GetNearestTo(destination.EsriPosition);
if (ranger != null)
{
viewModel.LeadMobileToCrossing(ranger, destination);
}
}
}
if (i % db == 0)
{
lock (interloperLayer.DataLock)
{
interloperLayer.Elements.ForEach(x => x.UpdateDbPosition());
}
lock (rangerLayer.DataLock)
{
rangerLayer.Elements.ForEach(x => x.UpdateDbPosition());
}
i = 0;
}
i++;
Thread.Sleep(ANIM_INTERVAL);
}
}
public void AddCrossing(Crossing c)
{
Crossing = c;
}
public virtual void AddDetailes(int feederID, Crossing crossing, int rPercentage, int lPercentage, int sPercentage, int carQuantity, int pedTimer)
{
}
