Besoin d'aide sur un petit programme java [Résolu/Fermé]

import java.util.Scanner;

class Cycliste {
    private static Scanner clavier = new Scanner(System.in);
    public static void main(String[] args) {

        double t = 0.0;    // temps, en min.
        double d = 0.0;    // distance, en km
        double v = 30.0;   // vitesse, en km/h
        double acc = 0.0;  // accélération, en km/h/min
        double p = 175.0;  // puissance, en W

        /******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
        
        double m = 0.0;         // masse, en Kg
        double vWind = 0.0;     // vitesse du vent, en km/h
        double dp = 0.0;        // distance du parcours
        double d1 = 0.0;        // distance du col, en km
        double p1 = 0;        // pente de la montée en %
        double p2 = 0;        // pente de la descente en %
        double DV = v - vWind;  // différence de vitesse entre le cycliste et le vent
        double DT = 1.0/60;     // definition de temps de la simulation
        double P_MIN = 10.0;    // puissance minimale du cycliste
        boolean crete = false;  // marqueur de crète
        
        // Définition des variables par l'interface opérateur.
        do {
         System.out.print("masse du cycliste (entre 40 et 180 ) ? ");
         m = clavier.nextDouble();
  } while ((m < 40) || (m > 180));
        
        do {
         System.out.print("vent (entre -20 et +20 km/h) ? ");
         vWind = clavier.nextDouble();
  } while ((vWind < -20) || (vWind > 20));
        
        do {
         System.out.print("distance du parcours (<= 200 km) ? ");
         dp = clavier.nextDouble();
  } while ((dp < 11) || (dp > 200));
        
        do {
         System.out.print("distance au sommet du col (<= "+(dp - 10)+" km) ? ");
         d1 = clavier.nextDouble();
  } while (d1 > (dp - 10) || (d1 <= 0));
        
        do {
         System.out.print("pente moyenne jusqu'au sommet (<= 20 %) ? ");
         p1 = clavier.nextDouble();
  } while ((p1 <= 0) || (p1 > 20));
        
        do {
         System.out.print("pente moyenne après le sommet (<= 20 %) ? ");
         p2 = clavier.nextDouble();
  } while ((p2 <= 0) || (p2 > 20));
        
        // Simulation du mouvement
        while (d < dp) 
        {
         // Affichage des informations courantes
         double roundedTime = Math.round(t);
            if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) 
            {
                System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                                  t, d, v, acc, p);
            }
            
            // Mise a jour du temps, du vent relatif et de la fatigue
            t += DT;                                             // mise a jour du temps
            DV = v - vWind;                               // détermination du vent relatif
            
            if ((d < d1)&&(p > P_MIN))                           // détermination de la fatigue si montée ou descente
            {
             p -= (DT / 2);                                   // en Montée
            }
            else
            {
             p = P_MIN;                                       // en descente
            }
            
            // Calcul de l'accélération
            if (d < d1)                                          // détermination si montée ou descente
            {
             acc = -2118.96 * Math.sin(Math.atan(p1/100.0));    // accélération en montée
   }
            else
            {
             acc = -2118.96 * Math.sin(Math.atan(-p2/100.0));   // accélération en descente
            }
            
            acc -= (5.0 * DV * Math.abs(DV) / m);                  // on applique le ralentissement du vent
            
            if ((v > 0) && (p > 0)) 
            {
    acc += 776.6 * (p / (v * m));
   }
            
            if (Math.abs(acc) < 1e-5)                            // nullifier la valeur de l'accélération si elle est très faible
            {
             acc = 0.0;
   }
            
            v += (acc * DT);                                     // appliquer l'accélération à la vitesse
            
            if (v < 3)                                           // on définit l'abbandon
            {
             System.out.println("## Bernard abandonne, il n'en peut plus");
             System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                        t, d, v, acc, p);
             return;
   }
            
            d += (v * (DT / 60.0));                                // mise a jour de la distance
            
            if ((crete == false) && (d >= d1)) 
            {
    crete = true;
    System.out.format("## Bernard a atteint le sommet en %.0f min.\n", t);
   }
  }

        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/

        System.out.println("## Bernard est arrivé");
        System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
                          t, d, v, acc, p);
    }
}