Ejemplo n.º 1
0
        public void NonFinDepart()
        {
            if (ParamCommuns.Instance.Etat != ParamCommuns.EtatEnum.EnCourse)
            {
                if (this.Evenements == null)
                {
                    this.Evenements = new ObservableCollection <EvenementPatineur>();
                }

                EvenementPatineur ep = new EvenementPatineur();
                ep.Evenement      = "NFDTOUR";
                ep.HeureEvenement = DateTime.Now;
                ep.TempsElapse    = new TimeSpan(23, 59, 59);
                ep.NbTour         = 0;
                this.Evenements.Add(ep);
                //MessageBox.Show("La course doit être en cours afin d'enregistrer un temps");
                return;
            }

            if (!this.Termine)
            {
                EvenementPatineur ep = new EvenementPatineur();
                ep.Evenement      = "TOUR";
                ep.HeureEvenement = DateTime.Now;
                ep.TempsElapse    = new TimeSpan(23, 59, 59);
                ep.NbTour         = 0;
                this.Evenements.Add(ep);
                this.DernierTemps = ep.DernierTemps();
                this.FinCourse(ep.HeureEvenement, ep.TempsElapse);
            }
        }
Ejemplo n.º 2
0
        private void FinCourse(DateTime heure, TimeSpan chrono)
        {
            EvenementPatineur epf = new EvenementPatineur();

            epf.HeureEvenement = heure;
            epf.Evenement      = "FIN";
            epf.TempsElapse    = chrono;
            this.Evenements.Add(epf);
            this.Termine = true;

            if (this.CourseTerminee != null)
            {
                this.CourseTerminee(this, new EventArgs());
            }
        }
Ejemplo n.º 3
0
        public void Reprise(DateTime dt)
        {
            this.Termine = false;
            EvenementPatineur ep = new EvenementPatineur();

            ep.HeureEvenement = dt;
            ep.TempsElapse    = dt - dt;
            ep.Evenement      = "REPRISE";
            ep.NbTour         = this.NbTourCourse;
            this.Evenements.Add(ep);
            this._HeureDepart = dt;
            NotifierChangementPropriete("HeureDepart");
            this.DernierTour  = string.Empty;
            this.DernierTemps = string.Empty;

            NotifierWeb();
        }
Ejemplo n.º 4
0
        public void Fin(DateTime dt)
        {
            EvenementPatineur ep = new EvenementPatineur();

            ep.HeureEvenement = dt;

            var k = this.Evenements.Where(z => z.Evenement == "DEPART");

            if (k != null && k.Count() > 0)
            {
                DateTime dep = k.Last().HeureEvenement;
                ep.TempsElapse = dt - dep;
            }
            else
            {
                ep.TempsElapse = new TimeSpan(0);
            }
            ep.Evenement = "FIN";
            this.Evenements.Add(ep);
        }
Ejemplo n.º 5
0
        public void Tour(DateTime temps)
        {
            if (ParamCommuns.Instance.Etat != ParamCommuns.EtatEnum.EnCourse)
            {
                if (this.Evenements == null)
                {
                    this.Evenements = new ObservableCollection <EvenementPatineur>();
                }

                EvenementPatineur ep = new EvenementPatineur();
                ep.Evenement      = "NTOUR";
                ep.HeureEvenement = DateTime.Now;
                ep.TempsElapse    = new TimeSpan(23, 59, 59);
                ep.NbTour         = 0;
                this.Evenements.Add(ep);
                //MessageBox.Show("La course doit être en cours afin d'enregistrer un temps");
                return;
            }

            if (this.Evenements == null || this.Evenements.Count == 0)
            {
                if (this.Evenements == null)
                {
                    this.Evenements = new ObservableCollection <EvenementPatineur>();
                }

                EvenementPatineur ep = new EvenementPatineur();
                ep.Evenement      = "NTOUR";
                ep.HeureEvenement = DateTime.Now;
                ep.TempsElapse    = new TimeSpan(23, 59, 59);
                ep.NbTour         = 0;
                this.Evenements.Add(ep);
                //MessageBox.Show("La course doit être en cours afin d'enregistrer un temps");
                return;
            }

            EvenementPatineur eve = this.Evenements.Where(z => z.Evenement == "DEPART").Last();

            if (eve != null)
            {
                DateTime dep = eve.HeureEvenement;
                int      pos = this.Evenements.IndexOf(eve);
                List <EvenementPatineur> lep = new List <EvenementPatineur>();
                for (int i = pos; i < this.Evenements.Count(); i++)
                {
                    if (this.Evenements[i].Evenement == "TOUR" || this.Evenements[i].Evenement == "DEPART")
                    {
                        lep.Add(this.Evenements[i]);
                    }
                }
                //DateTime preced = null;
                bool decrementTour = true;
                bool finCourse     = false;
                bool tourComplet   = false;

                EvenementPatineur ep = new EvenementPatineur();
                if (lep.Count > 0)
                {
                    decrementTour = false;
                    int trMin = lep.Min(z => z.NbTour);
                    EvenementPatineur preced   = lep.Where(z => z.NbTour == trMin).First();
                    DateTime          trPreced = preced.HeureEvenement;
                    TimeSpan          ts       = temps - trPreced;
                    if (ts.TotalSeconds > 5)
                    {
                        decrementTour = true;
                    }

                    if (decrementTour)
                    {
                        ep.NbTour        = preced.NbTour - 1;
                        this.DernierTour = ep.DernierTour(ts);

                        tourComplet = true;

                        if (ep.NbTour == 0)
                        {
                            // Enregistrer la fin de la course pour ce patineur.
                            finCourse = true;
                        }
                    }
                    else
                    {
                        ep.NbTour = preced.NbTour;
                    }
                }
                else
                {
                    ep.NbTour   = this.NbTourCourse - 1;
                    tourComplet = true;
                }

                if (ep.NbTour != 0 && this.Termine)
                {
                    // On inscrit pas de temps si le patineur a terminé sa course
                    // EXCEPTION du double tour zéro!
                    return;
                }

                ep.HeureEvenement  = temps;
                ep.TempsElapse     = temps - dep;
                this.DernierTemps  = ep.DernierTemps();
                ep.Evenement       = "TOUR";
                this.NbTour        = ep.NbTour;
                this.NbTourAffiche = ep.NbTour - 1;
                this.Evenements.Add(ep);

                if (tourComplet && this.TourComplete != null)
                {
                    this.TourComplete(this, new EventArgs());
                }

                this.NotifierWeb();

                if (finCourse)
                {
                    this.FinCourse(ep.HeureEvenement, ep.HeureEvenement - dep);
                }
            }
        }