private DriverInfo CreateDriverInfo(AllPacketsComposition rawData, string driverName, int driverIndex)
        {
            var        rawDriverData    = rawData.PacketParticipantsData.MParticipants[driverIndex];
            var        rawDriverLapInfo = rawData.PacketLapData.MLapData[driverIndex];
            var        rawCarMotionData = rawData.PacketMotionData.MCarMotionData[driverIndex];
            DriverInfo driverInfo       = new DriverInfo
            {
                DriverName      = driverName,
                CompletedLaps   = rawDriverLapInfo.MCurrentLapNum - 1,
                CarName         = string.Empty,
                InPits          = rawDriverLapInfo.MPitStatus != 0 || rawDriverLapInfo.MDriverStatus == 0,
                IsPlayer        = driverIndex == rawData.PacketCarTelemetryData.MHeader.MPlayerCarIndex,
                Position        = rawDriverLapInfo.MCarPosition,
                PositionInClass = rawDriverLapInfo.MCarPosition,
                Speed           = Velocity.FromKph(rawData.PacketCarTelemetryData.MCarTelemetryData[driverIndex].MSpeed),
                LapDistance     = rawDriverLapInfo.MLapDistance >= 0 ? rawDriverLapInfo.MLapDistance : rawData.PacketSessionData.MTrackLength + rawDriverLapInfo.MLapDistance,
                TotalDistance   = rawDriverLapInfo.MTotalDistance
            };

            driverInfo.CarName         = TranslationTable.GetCarName(rawDriverData.MTeamId);
            driverInfo.CarClassName    = TranslationTable.GetClass(rawData.PacketSessionData.MFormula);
            driverInfo.CarClassId      = driverInfo.CarClassName;
            driverInfo.FinishStatus    = rawData.AdditionalData.RetiredDrivers[driverIndex] ? DriverFinishStatus.Dnf : TranslateFinishStatus(rawDriverLapInfo.MResultStatus);
            driverInfo.WorldPosition   = new Point3D(Distance.FromMeters(rawCarMotionData.MWorldPositionX), Distance.FromMeters(rawCarMotionData.MWorldPositionY), Distance.FromMeters(rawCarMotionData.MWorldPositionZ));
            driverInfo.CurrentLapValid = rawDriverLapInfo.MCurrentLapInvalid == 0 && rawDriverLapInfo.MDriverStatus != 2 && rawDriverLapInfo.MDriverStatus != 3;

            ComputeDistanceToPlayer(_lastPlayer, driverInfo);
            FillTimingInfo(driverInfo, rawDriverLapInfo, driverIndex);
            return(driverInfo);
        }
Exemple #2
0
 public DataSetCompositor(Action <AllPacketsComposition> sessionStartedHandler, Action <AllPacketsComposition> newDataHandler)
 {
     _sessionStartedHandler = sessionStartedHandler;
     _newDataHandler        = newDataHandler;
     AllPacketsComposition  = new AllPacketsComposition();
     _resetWhenData         = true;
 }
        internal SimulatorDataSet ConvertData(AllPacketsComposition data)
        {
            SimulatorDataSet simData = new SimulatorDataSet(ConnectorName)
            {
                SimulatorSourceInfo =
                {
                    HasLapTimeInformation  = true,
                    SectorTimingSupport    = DataInputSupport.Full,
                    AIInstantFinish        = true,
                    GapInformationProvided = GapInformationKind.None,
                    SimNotReportingEndOfOutLapCorrectly = true,
                    HasRewindFunctionality = true,
                    OverrideBestLap        = true,
                    TelemetryInfo          =
                    {
                        ContainsOptimalTemperatures     = true
                    }
                }
            };

            FillSessionInfo(data, simData);
            AddDriversData(ref data, simData);

            var rawTelemetryData = data.PacketCarTelemetryData.MCarTelemetryData[_playerDataIndex];
            var rawCarStatusInfo = data.PacketCarStatusData.MCarStatusData[_playerDataIndex];
            var rawCarMotionData = data.PacketMotionData.MCarMotionData[_playerDataIndex];

            FillPlayerCarInfo(ref rawTelemetryData, simData);

            // PEDAL INFO
            AddPedalInfo(ref rawTelemetryData, simData);

            // Add Engine Temperatures
            AddEngineTemperatures(ref rawTelemetryData, simData);

            // Brakes Info
            AddBrakesInfo(ref rawTelemetryData, simData);

            // Tyre Pressure Info
            AddTyresInfo(ref rawTelemetryData, ref rawCarStatusInfo, ref data.PacketMotionData, simData);

            // Acceleration
            AddAcceleration(ref rawCarMotionData, simData);

            //Add Additional Player Car Info
            AddPlayerCarInfo(ref rawCarStatusInfo, ref rawTelemetryData, simData);

            //Add Flags Info
            AddFlags(ref data.PacketSessionData, simData);

            simData.SessionInfo.IsMultiClass = simData.DriversInfo != null && simData.DriversInfo.Any(x => x != null && x.Position != x.PositionInClass);

            return(simData);
        }
 private void OnSessionStarted(AllPacketsComposition rawData)
 {
     try
     {
         var convertedData = _f12019DataConvertor.ConvertData(rawData);
         _lastSessionType = convertedData.SessionInfo.SessionType;
         _lastSessionTime = convertedData.SessionInfo.SessionTime;
         RaiseSessionStartedEvent(convertedData);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
     }
 }
        private void AddDriversData(ref AllPacketsComposition rawData, SimulatorDataSet data)
        {
            int numOfCars = data.SessionInfo.SessionType == SessionType.Race ? 20 : rawData.PacketParticipantsData.MNumActiveCars;

            List <DriverInfo> driverInfos = new List <DriverInfo>(20);
            DriverInfo        playersInfo = null;

            for (int i = 0; i < numOfCars; i++)
            {
                var    rawDriverData = rawData.PacketParticipantsData.MParticipants[i];
                string driverName    = rawDriverData.MName.FromArray();
                if (string.IsNullOrWhiteSpace(driverName))
                {
                    continue;
                }
                DriverInfo driverInfo = CreateDriverInfo(rawData, driverName, i);
                if (driverInfo.IsPlayer)
                {
                    playersInfo = driverInfo;
                }

                AddWheelInfo(driverInfo, rawData.PacketCarStatusData.MCarStatusData[i]);
                driverInfos.Add(driverInfo);
                if (driverInfo.Position == 1)
                {
                    data.SessionInfo.LeaderCurrentLap = driverInfo.CompletedLaps + 1;
                    data.LeaderInfo = driverInfo;
                }

                AddLappingInformation(data, driverInfo);
            }

            if (playersInfo != null)
            {
                data.PlayerInfo = playersInfo;
                _lastPlayer     = playersInfo;
            }

            data.DriversInfo = driverInfos.ToArray();
        }
        private void OnDataLoaded(AllPacketsComposition rawData)
        {
            try
            {
                var convertedData = _f12019DataConvertor.ConvertData(rawData);
                if (_lastSessionType != convertedData.SessionInfo.SessionType && _lastSessionTime - convertedData.SessionInfo.SessionTime > TimeSpan.FromSeconds(5))
                {
                    RaiseSessionStartedEvent(convertedData);
                }
                else
                {
                    RaiseDataLoadedEvent(convertedData);
                }

                _lastSessionType = convertedData.SessionInfo.SessionType;
                _lastSessionTime = convertedData.SessionInfo.SessionTime;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }
        }
        private void FillSessionInfo(AllPacketsComposition data, SimulatorDataSet simData)
        {
            // Timing
            simData.SessionInfo.SessionTime = TimeSpan.FromSeconds(data.PacketCarTelemetryData.MHeader.MSessionTime);
            _layoutLength    = data.PacketSessionData.MTrackLength;
            _playerDataIndex = data.PacketSessionData.MHeader.MPlayerCarIndex;
            simData.SessionInfo.TrackInfo.LayoutLength = Distance.FromMeters(_layoutLength);
            simData.SessionInfo.IsActive = true;
            simData.SessionInfo.WeatherInfo.AirTemperature   = Temperature.FromCelsius(data.PacketSessionData.MAirTemperature);
            simData.SessionInfo.WeatherInfo.TrackTemperature = Temperature.FromCelsius(data.PacketSessionData.MTrackTemperature);
            if (data.PacketSessionData.MWeather == 3)
            {
                simData.SessionInfo.WeatherInfo.RainIntensity = 30;
            }
            else if (data.PacketSessionData.MWeather == 4)
            {
                simData.SessionInfo.WeatherInfo.RainIntensity = 60;
            }
            else if (data.PacketSessionData.MWeather == 5)
            {
                simData.SessionInfo.WeatherInfo.RainIntensity = 100;
            }


            switch ((SessionKind)data.PacketSessionData.MSessionType)
            {
            case SessionKind.TimeTrial:
            case SessionKind.Practice1:
            case SessionKind.Practice2:
            case SessionKind.Practice3:
            case SessionKind.ShortPractice:
                simData.SessionInfo.SessionType = SessionType.Practice;
                break;

            case SessionKind.Qualification1:
            case SessionKind.Qualification2:
            case SessionKind.Qualification3:
            case SessionKind.ShortQualification:
            case SessionKind.OnlineQualification:
                simData.SessionInfo.SessionType = SessionType.Qualification;
                break;

            case SessionKind.Race:
            case SessionKind.Race2:
                simData.SessionInfo.SessionType = SessionType.Race;
                break;

            default:
                simData.SessionInfo.SessionType = SessionType.Na;
                break;
            }

            simData.SessionInfo.SessionPhase = SessionPhase.Green;

            simData.SessionInfo.TrackInfo.TrackName       = TranslationTable.GetTrackName(data.PacketSessionData.MTrackId);
            simData.SessionInfo.TrackInfo.TrackLayoutName = string.Empty;

            if (data.PacketSessionData.MTotalLaps > 2 && simData.SessionInfo.SessionType == SessionType.Race)
            {
                simData.SessionInfo.SessionLengthType = SessionLengthType.Laps;
                simData.SessionInfo.TotalNumberOfLaps = data.PacketSessionData.MTotalLaps;
            }
            else
            {
                simData.SessionInfo.SessionLengthType    = SessionLengthType.Time;
                simData.SessionInfo.SessionTimeRemaining = data.PacketSessionData.MSessionTimeLeft;
            }
        }