internal void AddMessages(ISessionResult list)
{
foreach (var msg in list.Messages)
{
AddMessage(msg);
}
}
internal ConstraintContext(ISessionContext sessionContext, string category, ConstraintKind kind)
{
DebugContract.Requires(sessionContext);
DebugContract.RequiresNotEmpty(category);
this._sessionContext = sessionContext;
this._messages = _sessionContext.Result;
this._category = category;
this.ConstraintKind = kind;
}
ISessionResult IExecutionResultInternal.Merge(ISessionResult other)
{
DebugContract.Requires(other);
_messages.AddRange(other.Messages);
var messageList = other as ExecutionResult;
if (messageList != null)
{
_silentMode |= messageList._silentMode;
}
return(messageList);
}
void IDataErrorNotifier.NotifyDataErrors(ISessionResult result)
{
var set = BeginDataErrorNotifications();
foreach (var msg in result.Messages)
{
if (msg.MessageType != MessageType.Info && msg.PropertyName != null && msg.Element != null && msg.Element.Id == _id)
{
AddDataError(set, msg);
}
}
EndDataErrorNotification(set);
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Send all validations message raises during the session.
/// </summary>
/// <param name="session">
/// .
/// </param>
/// <param name="result">
/// The result.
/// </param>
///-------------------------------------------------------------------------------------------------
public void NotifyMessages(ISessionInformation session, ISessionResult result)
{
Contract.Requires(session, "session");
Contract.Requires(result, "result");
_messageOccurs.OnNext(result);
if (session.IsReadOnly)
{
return;
}
foreach (var mel in PrepareNotificationList(session).Values)
{
var den = mel as IDataErrorNotifier;
if (den != null)
{
den.NotifyDataErrors(result);
}
}
}
public void Update(ISessionResult session, ISimulation sim)
{
// Completely rebuild the queue
// TODO: Add laps to the queue as they come in, making sure not to add duplicates
// Or: only update when new information available (new laps)
//Queue.Clear();
_buckets = new Dictionary <Weights, Queue <double> >();
var leader = session.LiveLeader;
var raceSession = sim.Session.GetLatestRace();
var qualSession = sim.Session.GetQualification();
if (leader != null && raceSession != null)
{
// Get last LapsToAverage laps of top 5
var top5 = raceSession.Results.OrderBy(r => r.Position).Take(5);
foreach (var result in top5)
{
// Make sure we only take into account the leading class
if (result.Entity.Car.Class.Id != leader.Car.Class.Id)
{
continue;
}
// Get the valid laps, most recent first
var laps = result.Laps.Where(l => l.Time > 1).OrderByDescending(l => l.Number).ToArray();
// Debug.WriteLine(
// $" > Found {laps?.Length} laps for car P{result.Position}, #{result.Entity.Car.Number} {result.Entity.CurrentDriver.ShortName}");
if (laps.Length > 0)
{
var isLeader = result.Position == 1;
// Add as many laps as possible until LapsToAverage is reached
// Laps receive the appropriate weight
foreach (var lap in laps)
{
Weights weight;
if (lap.WasUnderCaution)
{
weight = Weights.CautionLap;
}
else
{
if (lap.WasOnPitRoad)
{
weight = isLeader ? Weights.LeaderPittedLap : Weights.NonLeaderPittedLap;
}
else
{
if (lap.Number <= 1)
{
weight = isLeader ? Weights.LeaderOpeningLap : Weights.NonLeaderOpeningLap;
}
else
{
weight = isLeader
? Weights.LeaderRaceLapsExceptOpeningLap
: Weights.NonLeaderRaceLapsExceptOpeningLap;
}
}
}
EnqueueLap(lap, weight);
// Stop if we have enough laps for a good average
if (HasEnoughLaps())
{
return;
}
}
}
// Stop if we have enough laps for a good average
if (HasEnoughLaps())
{
return;
}
}
}
// Best qual laps
if (qualSession?.Results?.Count > 0)
{
var qualResults = qualSession.Results.OrderBy(r => r.Position);
foreach (var result in qualResults)
{
if (result.FastestLapTime > 1)
{
EnqueueLap(result.FastestLapTime, Weights.QualLap);
}
}
}
}
