private void AddPlayerCarInfo(AssettoCorsaShared data, SimulatorDataSet simData)
{
CarInfo playerCar = simData.PlayerInfo.CarInfo;
playerCar.CarDamageInformation.Bodywork.MediumDamageThreshold = 0.02;
playerCar.CarDamageInformation.Bodywork.HeavyDamageThreshold = 0.2;
playerCar.CarDamageInformation.Bodywork.Damage = data.AcsPhysics.carDamage.Max() / 100.0;
playerCar.SpeedLimiterEngaged = simData.PlayerInfo.InPits;
FillDrsData(data, playerCar);
FillBoostData(data, playerCar);
}
public void Observe(SimulatorDataSet dataSet)
{
if (!ShouldObserve(dataSet))
{
_lastDataSet = dataSet;
return;
}
CheckAndAdvanceState(dataSet);
_lastDataSet = dataSet;
}
public void UpdateTelemetry(SimulatorDataSet dataSet)
{
if (IsPurged)
{
throw new InvalidOperationException("Cannot update Telemetry on a purged TelemetryInfo");
}
PortionTimes.UpdateLapPortions();
if (!dataSet.PlayerInfo.InPits)
{
TimedTelemetrySnapshots.AddNextSnapshot(LapInfo.CurrentlyValidProgressTime, dataSet.PlayerInfo, dataSet.SessionInfo.WeatherInfo, dataSet.InputInfo, dataSet.SimulatorSourceInfo);
}
}
public void Observe(SimulatorDataSet dataSet)
{
/*if (!ShouldObserve(dataSet))
* {
* _lastDataSet = dataSet;
* return;
* }
*
* CheckAndAdvanceState(dataSet);
*
*
* _lastDataSet = dataSet;*/
}
public TimeSpan GetTimeRemaining(SimulatorDataSet dataSet)
{
if (dataSet.SessionInfo.SessionLengthType == SessionLengthType.Time || dataSet.SessionInfo.SessionLengthType == SessionLengthType.TimeWitchExtraLap)
{
return(TimeSpan.FromSeconds(dataSet.SessionInfo.SessionTimeRemaining));
}
else
{
return(_paceProvider.LeadersPace != null
? TimeSpan.FromSeconds(GetLeaderLapsToGo(dataSet) *_paceProvider.LeadersPace.Value.TotalSeconds)
: TimeSpan.Zero);
}
}
private void AddPlayerCarInfo(PCars2SharedMemory data, SimulatorDataSet simData)
{
CarInfo playerCar = simData.PlayerInfo.CarInfo;
playerCar.CarDamageInformation.Bodywork.Damage = data.mAeroDamage;
playerCar.CarDamageInformation.Engine.Damage = data.mEngineDamage;
playerCar.CarDamageInformation.Suspension.Damage = data.mSuspensionDamage.Max();
playerCar.EngineTorque = Torque.FromNm(data.mEngineTorque);
playerCar.EnginePower = Power.FromKw(data.mEngineTorque * playerCar.EngineRpm / 9549);
/*playerCar.SpeedLimiterEngaged = (data.mCarFlags & (int)CarFlags.CarSpeedLimiter) == (int)CarFlags.CarSpeedLimiter;*/
FillBoostData(data, playerCar);
}
private void RecalculateTimeRemaining(SimulatorDataSet dataSet)
{
if (dataSet.SessionInfo.SessionLengthType == SessionLengthType.Time || dataSet.SessionInfo.SessionLengthType == SessionLengthType.TimeWithExtraLap)
{
_timeRemaining = TimeSpan.FromSeconds(dataSet.SessionInfo.SessionTimeRemaining);
}
else
{
_timeRemaining = _paceProvider.LeadersPace != null
? TimeSpan.FromSeconds(GetLeaderLapsToGo(dataSet) *_paceProvider.LeadersPace.Value.TotalSeconds)
: TimeSpan.Zero;
}
}
private void CheckAndAdvanceStartRestartTimeout(SimulatorDataSet dataSet)
{
if (dataSet.LeaderInfo.TotalDistance < 400 && dataSet.SessionInfo.SessionTime > _restartTimeoutEnd)
{
_startState = StartState.Countdown;
dataSet.SessionInfo.SessionType = SessionType.Na;
}
if (dataSet.LeaderInfo.CompletedLaps > 1)
{
_startState = StartState.StartCompleted;
}
}
private void CheckAndAdvanceStarted(SimulatorDataSet dataSet)
{
if (dataSet.PlayerInfo != null && dataSet.PlayerInfo.InPits)
{
_startState = StartState.Countdown;
dataSet.SessionInfo.SessionType = SessionType.Na;
}
if (dataSet.LeaderInfo.TotalDistance > 500)
{
_startState = StartState.StartCompleted;
}
}
internal void AddDriversData(SimulatorDataSet data, Rf2FullData rfData)
{
if (rfData.scoring.mScoringInfo.mNumVehicles < 1)
{
return;
}
data.DriversInfo = new DriverInfo[rfData.scoring.mScoringInfo.mNumVehicles];
DriverInfo playersInfo = null;
for (int i = 0; i < rfData.scoring.mScoringInfo.mNumVehicles; i++)
{
rF2VehicleScoring rF2VehicleScoring = rfData.scoring.mVehicles[i];
DriverInfo driverInfo = CreateDriverInfo(rfData, rF2VehicleScoring);
if (driverInfo.IsPlayer)
{
playersInfo = driverInfo;
driverInfo.CurrentLapValid = true;
_lastPlayerId = rF2VehicleScoring.mID;
}
else
{
driverInfo.CurrentLapValid = true;
}
data.DriversInfo[i] = driverInfo;
if (driverInfo.Position == 1)
{
data.SessionInfo.LeaderCurrentLap = driverInfo.CompletedLaps + 1;
data.LeaderInfo = driverInfo;
}
AddLappingInformation(data, rfData, driverInfo);
FillTimingInfo(driverInfo, rF2VehicleScoring, rfData);
if (driverInfo.FinishStatus == DriverFinishStatus.Finished && !driverInfo.IsPlayer && driverInfo.Position > _lastPlayer.Position)
{
driverInfo.CompletedLaps--;
driverInfo.FinishStatus = DriverFinishStatus.None;
}
}
CheckValidityByPlayer(playersInfo);
_lastPlayer = playersInfo;
if (playersInfo != null)
{
data.PlayerInfo = playersInfo;
}
FillGapInformation(data.DriversInfo);
}
private void RaiseDataLoadedEvent(SimulatorDataSet data)
{
try
{
DataEventArgs args = new DataEventArgs(data);
_oldDataSet = data;
DataLoaded?.Invoke(this, args);
}
catch (Exception)
{
LogSimulatorDataSet(_oldDataSet);
throw;
}
}
public LapInfo(SimulatorDataSet dataSet, int lapNumber, DriverTiming driver, bool firstLap, LapInfo previousLapInfo)
{
Driver = driver;
LapStart = dataSet.SessionInfo.SessionTime;
LapProgressTimeBySim = TimeSpan.Zero;
LapProgressTimeByTiming = TimeSpan.Zero;
LapNumber = lapNumber;
Valid = true;
FirstLap = firstLap;
PitLap = false;
PreviousLap = previousLapInfo;
CompletedDistance = double.NaN;
LapTelemetryInfo = new LapTelemetryInfo(driver.DriverInfo, dataSet, this);
}
public LapInfo(SimulatorDataSet dataSet, int lapNumber, DriverTiming driver, bool firstLap, LapInfo previousLapInfo)
{
Driver = driver;
LapStart = dataSet.SessionInfo.SessionTime;
LapProgressTimeBySim = TimeSpan.Zero;
LapProgressTimeByTiming = TimeSpan.Zero;
LapNumber = lapNumber;
Valid = true;
FirstLap = firstLap;
PitLap = false;
PreviousLap = previousLapInfo;
CompletedDistance = double.NaN;
LapTelemetryInfo = new LapTelemetryInfo(driver.DriverInfo, dataSet, this, TimeSpan.FromMilliseconds(Driver.Session.TimingDataViewModel.DisplaySettingsViewModel.TelemetrySettingsViewModel.LoggingInterval), dataSet.SimulatorSourceInfo);
}
private void CheckAndAdvanceStartSequence(SimulatorDataSet dataSet)
{
if (dataSet.PlayerInfo != null && dataSet.PlayerInfo.InPits)
{
_startState = StartState.Countdown;
dataSet.SessionInfo.SessionType = SessionType.Na;
}
if (dataSet.LeaderInfo.Speed > Velocity.FromKph(2))
{
_startState = StartState.Started;
dataSet.SessionInfo.SessionType = SessionType.Na;
}
}
public override bool DoDataLoaded(SimulatorDataSet simulatorDataSet)
{
if (simulatorDataSet.SessionInfo.SessionType == SessionType.Race && !_timeoutStopwatch.IsRunning)
{
_timeoutStopwatch.Start();
return(false);
}
if (simulatorDataSet.SessionInfo.SessionType == SessionType.Race && !_sessionCompleted && _timeoutStopwatch.ElapsedMilliseconds < 5000)
{
return(false);
}
return(base.DoDataLoaded(simulatorDataSet));
}
public DatagramPayload CreateHearthBeatDatagramPayload()
{
SimulatorDataSet dataSet = new SimulatorDataSet("Remote")
{
InputInfo = { BrakePedalPosition = _random.NextDouble(), ClutchPedalPosition = _random.NextDouble(), ThrottlePedalPosition = _random.NextDouble() },
SessionInfo = new SessionInfo(),
DriversInfo = new DriverInfo[0],
PlayerInfo = new DriverInfo(),
LeaderInfo = new DriverInfo(),
SimulatorSourceInfo = new SimulatorSourceInfo(),
};
return(CreatePayload(dataSet, DatagramPayloadKind.HearthBeat));
}
internal void AddDriversData(SimulatorDataSet data, RfShared rfData)
{
if (rfData.NumVehicles < 1)
{
return;
}
data.DriversInfo = new DriverInfo[rfData.NumVehicles];
DriverInfo playersInfo = null;
for (int i = 0; i < rfData.NumVehicles; i++)
{
RfVehicleInfo rfVehicleInfo = rfData.Vehicle[i];
DriverInfo driverInfo = CreateDriverInfo(rfData, rfVehicleInfo);
if (driverInfo.IsPlayer)
{
playersInfo = driverInfo;
driverInfo.CurrentLapValid = true;
}
else
{
driverInfo.CurrentLapValid = true;
}
data.DriversInfo[i] = driverInfo;
if (driverInfo.Position == 1)
{
data.SessionInfo.LeaderCurrentLap = driverInfo.CompletedLaps + 1;
data.LeaderInfo = driverInfo;
}
if (rfVehicleInfo.Control == 2)
{
data.SessionInfo.IsMultiplayer = true;
}
AddLappingInformation(data, rfData, driverInfo);
FillTimingInfo(driverInfo, rfVehicleInfo, rfData);
}
CheckValidityByPlayer(playersInfo);
_lastPlayer = playersInfo;
if (playersInfo != null)
{
data.PlayerInfo = playersInfo;
}
FillGapInformation(data.DriversInfo);
}
public SimulatorDataSet CreateSimulatorDataSet(PCars2SharedMemory pcarsData, TimeSpan sessionTime)
{
SimulatorDataSet simData = new SimulatorDataSet("PCars 2");
simData.SimulatorSourceInfo.HasLapTimeInformation = true;
simData.SimulatorSourceInfo.OutLapIsValid = true;
simData.SimulatorSourceInfo.InvalidateLapBySector = true;
simData.SimulatorSourceInfo.SectorTimingSupport = DataInputSupport.Full;
simData.SimulatorSourceInfo.TelemetryInfo.ContainsSuspensionTravel = true;
simData.SimulatorSourceInfo.TelemetryInfo.ContainsSuspensionVelocity = true;
FillSessionInfo(pcarsData, simData, sessionTime);
AddDriversData(simData, pcarsData);
FillPlayerCarInfo(pcarsData, simData);
// PEDAL INFO
AddPedalInfo(pcarsData, simData);
// WaterSystemInfo
AddWaterSystemInfo(pcarsData, simData);
// OilSystemInfo
AddOilSystemInfo(pcarsData, simData);
// Brakes Info
AddBrakesInfo(pcarsData, simData);
// Tyre Pressure Info
AddTyresAndFuelInfo(pcarsData, simData);
//Add Additional Player Car Info
AddPlayerCarInfo(pcarsData, simData);
// Acceleration
AddAcceleration(pcarsData, simData);
if (simData.PlayerInfo?.FinishStatus == DriverFinishStatus.Dns && simData.SessionInfo.SessionType == SessionType.Race)
{
simData.SessionInfo.SessionPhase = SessionPhase.Countdown;
}
PopulateClassPositions(simData);
AddActiveFlags(pcarsData, simData);
_pCars2TyreProperties.FillWheelIdealQuantities(simData);
return(simData);
}
public SimulatorDataSet CreateSimulatorDataSet(Rf2FullData rfData)
{
SimulatorDataSet simData = new SimulatorDataSet("Rfactor 2");
simData.SimulatorSourceInfo.HasLapTimeInformation = true;
simData.SimulatorSourceInfo.SimNotReportingEndOfOutLapCorrectly = true;
simData.SimulatorSourceInfo.SectorTimingSupport = DataInputSupport.FULL;
FillSessionInfo(rfData, simData);
AddDriversData(simData, rfData);
if (_lastPlayerId == -1)
{
return(simData);
}
try
{
rF2VehicleTelemetry playerF2VehicleTelemetry =
rfData.telemetry.mVehicles.First(x => x.mID == _lastPlayerId);
FillPlayersGear(playerF2VehicleTelemetry, simData);
// PEDAL INFO
AddPedalInfo(playerF2VehicleTelemetry, simData);
// WaterSystemInfo
AddWaterSystemInfo(playerF2VehicleTelemetry, simData);
// OilSystemInfo
AddOilSystemInfo(playerF2VehicleTelemetry, simData);
// Brakes Info
AddBrakesInfo(playerF2VehicleTelemetry, simData);
// Tyre Pressure Info
AddTyresAndFuelInfo(simData, playerF2VehicleTelemetry);
// Acceleration
AddAcceleration(simData, playerF2VehicleTelemetry);
currentlyIgnoredPackage = 0;
}
catch (ArgumentException)
{
}
return(simData);
}
private void UpdateCurrentLap(SimulatorDataSet dataSet)
{
CurrentLap.Tick(dataSet, DriverInfo);
CurrentLap.InvalidBySim = !DriverInfo.CurrentLapValid;
LapPercentage = (DriverInfo.LapDistance / dataSet.SessionInfo.TrackInfo.LayoutLength.InMeters) * 100;
if (CurrentLap.Valid && SessionType.Race != dataSet.SessionInfo.SessionType && InPits && _lapsInfo.Count >= 1)
{
CurrentLap.InvalidateLap(LapInvalidationReasonKind.DriverInPits);
}
if (CurrentLap.Valid && !DriverInfo.CurrentLapValid && _lapsInfo.Count > 0 && (LastLap == null || !LastLap.IsPending))
{
CurrentLap.InvalidateLap(LapInvalidationReasonKind.InvalidatedBySim);
}
}
private void InitializeDrivers(ChampionshipDto championship, SimulatorDataSet dataSet)
{
int position = 0;
List <DriverInfo> eligibleDrivers = dataSet.DriversInfo.Where(x => x.CarClassId == dataSet.PlayerInfo.CarClassId).ToList();
championship.ClassName = dataSet.PlayerInfo.CarClassName;
championship.TotalDrivers = eligibleDrivers.Count;
championship.Drivers = eligibleDrivers.Select(x => new DriverDto()
{
LastUsedName = x.DriverName,
IsPlayer = x.IsPlayer,
Position = ++position,
LastCarName = x.CarName,
}).ToList();
}
private void CheckAndAdvanceStartRestartTimeout(SimulatorDataSet dataSet)
{
if (dataSet.LeaderInfo.TotalDistance < 400 && dataSet.SessionInfo.SessionTime > _restartTimeoutEnd)
{
_startState = StartState.Countdown;
Logger.Info("Leader completed less than 400m - moving to countdown");
dataSet.SessionInfo.SessionType = SessionType.Na;
}
if (dataSet.LeaderInfo.CompletedLaps > 1)
{
Logger.Info("Leader completed whole lap - moving to start completed");
_startState = StartState.StartCompleted;
}
}
private void CheckAndAdvanceStarted(SimulatorDataSet dataSet)
{
if (dataSet.PlayerInfo != null && dataSet.PlayerInfo.InPits)
{
Logger.Info("Player in pits - moving to start sequence");
_startState = StartState.Countdown;
dataSet.SessionInfo.SessionType = SessionType.Na;
}
if (dataSet.LeaderInfo.TotalDistance > 500)
{
Logger.Info("Leader moved more than 500m - moving to start completed");
_startState = StartState.StartCompleted;
}
}
private SimulatorDataSet CreateSimulatorDataSet(DatagramPayload datagramPayload)
{
SimulatorDataSet newSet = new SimulatorDataSet(datagramPayload.Source)
{
DriversInfo = datagramPayload.DriversInfo,
InputInfo = datagramPayload.InputInfo,
LeaderInfo = datagramPayload.LeaderInfo,
PlayerInfo = datagramPayload.PlayerInfo,
SessionInfo = datagramPayload.SessionInfo,
SimulatorSourceInfo = datagramPayload.SimulatorSourceInfo,
};
FillMissingInformation(newSet);
return(newSet);
}
private void CalculateLapsUntilHeavyWear(WheelInfo wheelInfo, SimulatorDataSet simulatorDataSet)
{
TimeSpan?playersPace = _paceProvider.PlayersPace;
if (_wearPerMinute == 0 || !playersPace.HasValue || playersPace.Value == TimeSpan.Zero)
{
LapsUntilHeavyWear = 0;
return;
}
double wearLeft = (wheelInfo.TyreWear.HeavyWearLimit - wheelInfo.TyreWear.ActualWear);
double minutesLeft = wearLeft / _wearPerMinute;
LapsUntilHeavyWear = (int)Math.Floor(minutesLeft / playersPace.Value.TotalMinutes);
}
public override bool DoDataLoaded(SimulatorDataSet simulatorDataSet)
{
if (_stateDuration.ElapsedMilliseconds > 7000 && !IsStateInitialized)
{
_stateDuration.Stop();
if (!simulatorDataSet.SimulatorSourceInfo.NAStateBetweenSessions)
{
Logger.Info("Idle state for 7seconds - clearing race and qualification context");
SharedContext.QualificationContext = null;
SharedContext.RaceContext = null;
}
IsStateInitialized = true;
}
return(simulatorDataSet.SessionInfo.SessionType != SessionType && base.DoDataLoaded(simulatorDataSet));
}
public void Reset()
{
CreateAndAddSessionFuelConsumptionInfo();
_nextMinuteConsumptionUpdate = TimeSpan.Zero;
_lastTickFuelStatus = null;
_lastMinuteFuelStatus = null;
_lastLapFuelStatus = null;
_lastLapNumber = -1;
_totalFuelConsumption = new FuelConsumptionInfo();
ActPerMinute = Volume.FromLiters(0);
ActPerLap = Volume.FromLiters(0);
TotalPerMinute = Volume.FromLiters(0);
TotalPerLap = Volume.FromLiters(0);
_lastDataSet = null;
}
private void ApplyGapToPlayer(SimulatorDataSet simulatorDataSet)
{
foreach (DriverInfo driverInfo in simulatorDataSet.DriversInfo)
{
if (driverInfo.IsPlayer)
{
continue;
}
if (_computedGapToPlayer.TryGetValue(driverInfo.DriverName, out TimeSpan gap))
{
driverInfo.Timing.GapToPlayer = gap;
}
}
}
private void RaiseSessionStartedEvent(SimulatorDataSet data)
{
DataEventArgs args = new DataEventArgs(data);
Logger.Info("New Session starting");
if (_oldDataSet != null)
{
Logger.Info("Old set:");
LogSimulatorDataSet(_oldDataSet);
}
_oldDataSet = data;
Logger.Info("New set:");
LogSimulatorDataSet(_oldDataSet);
SessionStarted?.Invoke(this, args);
}
public void Visit(SimulatorDataSet simulatorDataSet)
{
if (simulatorDataSet.SessionInfo.SessionType != SessionType.Race || simulatorDataSet.SimulatorSourceInfo.GapInformationProvided != GapInformationKind.TimeToSurroundingDrivers)
{
return;
}
if (_updateStopwatch.Elapsed > _informationValiditySpan)
{
ComputeGapToPlayer(simulatorDataSet);
_updateStopwatch.Restart();
}
ApplyGapToPlayer(simulatorDataSet);
simulatorDataSet.SimulatorSourceInfo.GapInformationProvided = GapInformationKind.Both;
}
