private LinkedComplexGap CreateComplexGapForDriver(int lapNumber, int positionIndex)
            {
                LapCrossing      currentLC = temp[lapNumber][positionIndex];
                LinkedComplexGap cg        = new LinkedComplexGap()
                {
                    CarIdx         = currentLC.CarIdx,
                    CrossedAt      = currentLC.CrossedAt,
                    LapIndex       = lapNumber,
                    Position       = positionIndex + 1,
                    IsPitted       = currentLC.IsPitted,
                    IsOffTrack     = currentLC.IsOffTrack,
                    IsBlackFlagged = currentLC.IsBlackFlagged,
                    IsTimeInvalid  = currentLC.IsTimeInvalid
                };

                if (positionIndex > 0)
                {
                    FillComplexGapGaps(cg);
                }
                else
                {
                    cg.ToFirst    = new Gap();
                    cg.ToPrevious = new Gap();
                }

                return(cg);
            }
示例#2
0
        public void Update(LapCrossing e)
        {
            Contract.Assert(w.CurrentSession != null);

            var sess  = w.CurrentSession;
            var stand = sess.Standings.TryGetByCarIdx(e.CarIdx);

            Contract.Assert(stand != null);

            Support.LapCrossingUpdater.Update(e, stand);
            if (sess is RaceSession)
            {
                RaceLapCrossings.Add(e);
            }
        }
        public static void Update(LapCrossing lc, Standing target)
        {
            Contract.Requires(lc.CarIdx == target.Driver.CarIdx, "CarIDx differs!");

            var previousLapCrossing = target.LastLapCrossing;

            // musi byt tady nahore pred tim, nez se prida dalsi kolo do kolekce kol
            // protoze se to podle toho tridi
            // taky jsem si to musel ulozit pro pozdejsi pouziti (tu puvodni hodnotu)
            target.LastLapCrossing = lc.CrossedAt;

            if (previousLapCrossing.HasValue)
            {
                double    diff = lc.CrossedAt - previousLapCrossing.Value;
                LapRecord lr   = new LapRecord(diff, lc.LapNum, lc.CrossedAt, (LapRecord.eFlag)lc.Flags);
                target.AddLap(lr);
            }
        }
            private LinkedComplexGap CalculateLapAndReturnFirst(int lapNumber)
            {
                LinkedComplexGap first;
                LinkedComplexGap current;

                SortAllLapCrossings();

                LapCrossing firstTime = temp[lapNumber][0];

                first = CreateComplexGapForDriver(lapNumber, 0);

                LinkedComplexGap previous = first;

                for (int i = 1; i < temp[lapNumber].Count; i++)
                {
                    current = CreateComplexGapForDriver(lapNumber, i);
                    LinkedComplexGap.LinkByPosition(previous, current);
                    previous = current;
                }

                return(first);
            }
        public void Fill(NonRaceSession session, LapCrossing te)
        {
            int carIdx = te.CarIdx;

            if (session.Weekend.Drivers.ContainsKey(carIdx) == false)
            {
                throw new ApplicationException("Failed to find driver with carIdx " + carIdx + " in registered drivers of weekend.");
            }
            Driver d = session.Weekend.Drivers[carIdx];

            NonRaceLap l = new NonRaceLap();

            l.Driver        = d;
            l.CrossedAtTime = Time.CreateFromSeconds(te.CrossedAt);
            if (l.CrossedAtTime.TotalMiliseconds < 0)
            {
                throw new ApplicationException("CrossedAt below zero.");
            }
            l.IsBlackFlagged = te.IsBlackFlagged;
            l.IsOffTrack     = te.IsOffTrack;
            l.IsPitted       = te.IsPitted;

            session.Laps.Add(l);
        }
示例#6
0
        /// <summary>
        /// Constantly checks if the game has provided new telemetry data. If it has, an event is fired.
        /// </summary>
        private void UpdateGauge()
        {
            bool loaded = NR2003Binding.Setup();

            OnAddressSpaceLoadedOrThrewError(loaded);

            if (NR2003Binding.WaitForSimToRun())
            {
                OnNR2003LoadedOrThrewError(true);

                TimeSpan    lap      = new TimeSpan(0, 0, 0, 0, 0);
                LapCrossing lapCache = new LapCrossing()
                {
                    carIdx    = new byte[] { 0, 0, 0, 0 },
                    lapNum    = new byte[] { 0, 0, 0, 0 },
                    flags     = new byte[] { 0, 0, 0, 0 },
                    crossedAt = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 },
                };
                GaugeData gaugeCache = new GaugeData();
                while (true)
                {
                    NR2003Binding.RequestData();
                    IntPtr gd = NR2003Binding.GetGaugeData();
                    if (gd != IntPtr.Zero)
                    {
                        GaugeData gauge = (GaugeData)Marshal.PtrToStructure(gd, typeof(GaugeData));
                        if (gauge != gaugeCache)
                        {
                            OnGaugeUpdate(new GaugeUpdatedEventArgs {
                                _gaugeData = gauge
                            });
                        }
                    }

                    IntPtr ptrlap = NR2003Binding.GetLapCrossing();
                    if (ptrlap != IntPtr.Zero)
                    {
                        LapCrossing _lap = (LapCrossing)Marshal.PtrToStructure(ptrlap, typeof(LapCrossing));
                        if (_lap != lapCache)
                        {
                            double   crossed      = BitConverter.ToDouble(_lap.crossedAt, 0);
                            int      seconds      = Convert.ToInt32(Math.Truncate(crossed));
                            int      milliseconds = Convert.ToInt32((crossed - seconds) * 1000);
                            TimeSpan crossedAt    = new TimeSpan(0, 0, 0, seconds, milliseconds);
                            int      carIdx       = BitConverter.ToInt32(_lap.carIdx, 0);
                            if (carIdx == 0 && crossedAt > lap)
                            {
                                OnLapTimeUpdate(new LapTimeUpdatedEventArgs {
                                    lapTime = string.Format("{0:0.000}", (crossedAt - lap).TotalSeconds)
                                });
                                lap      = crossedAt;
                                lapCache = _lap;
                            }
                            else if (carIdx == 0)
                            {
                                lap      = crossedAt;
                                lapCache = _lap;
                            }
                        }
                    }

                    //game only provides data at 36 hz
                    Thread.Sleep(20);
                }
            }
            else
            {
                OnNR2003LoadedOrThrewError(false);
            }
        }