Tutoriel: réagir au temps qui passe #

Animer le monde 2d #

Ouvrir AfficherPartie et compléter la tâche prochaineImagePartie comme suit

subTasks.task("prochaineImagePartie")

             .waitsFor(created(VuePartie.class))
             .waitsFor(created(DonneesVuePartie.class))

             // s'assurer d'avoir
             .waitsFor(clock().nextTick())

             .executes(inputs -> {


                DonneesVuePartie donneesVuePartie = inputs.get(created(DonneesVuePartie.class));
                VuePartie        vuePartie        = inputs.get(created(VuePartie.class));

                // s'assurer d'avoir
                Tick             tick             = inputs.get(clock().nextTick());


                // ajouter
                donneesVuePartie.reagirTempsQuiPasse(tick.elapsedTime());

                donneesVuePartie.afficherSur(vuePartie);

            });

Utiliser Ctrl+.Eclipse: Ctrl+1 pour créer la méthode DonneesVuePartie.reagirTempsQuiPasse

Dans DonneesVuePartie, compléter la méthode reagirTempsQuiPasse comme suit

public class DonneesVuePartie implements ViewData {

        // ...

        public void reagirTempsQuiPasse(double elapsedTime) {
            mondePong2d.onTimePasses(elapsedTime);
        }

    }

Faire bouger et rebondir la balle #

Ouvrir Balle2d et spécifier une vitesse pour la balle

public class Balle2d extends ObjetPong2d {

        // ...

        @Override
        public void initialize() {
            setTopLeftX(100);
            setTopLeftY(100);
            setWidth(10);
            setHeight(10);

            // ajouter
            setSpeedX(100 + Ntro.random().nextInt(100));
            setSpeedY(100 + Ntro.random().nextInt(100));
        }

        // ...

Dans Balle2d ajouter ce code pour donner un comportement à la balle

public class Balle2d extends ObjetPong2d {

        // ajouter
        private static final double EPSILON = 1;


        // ...

        // ajouter
        @Override
        public void onTimePasses(double secondsElapsed) {
            super.onTimePasses(secondsElapsed);

            if(balleFrappeMurGauche()) {

                balleRebondiSurMurGauche();

            }else if(balleFrappeMurDroit()) {

                balleRebondiSurMurDroit();

            }else if(balleFrappePlafond()) {

                balleRebondiSurPlafond();

            }else if(balleFrappePlancher()) {

                balleRebondiSurPlancher();
            }
        }

NOTES
- le super.onTimePasses correspond au comportement par défaut d’un objet 2d
- (c’est-à-dire se déplacer selon sa vitesse)

Utiliser Ctrl+.Eclipse: Ctrl+1 pour créer les méthodes suivantes
- balleFrappeMurGauche
- balleRebondiSurMurGauche
- balleFrappeMurDroit
- balleRebondiSurMurDroit
- balleFrappePlafond
- balleRebondiSurPlafond
- balleFrappePlancher
- balleRebondiSurPlancher

Compléter le code de Balle2d comme suit

public class Balle2d extends ObjetPong2d {

        // ajouter
        private static final double EPSILON = 1;

        // ...

        // implanter la méthode
        private boolean balleFrappePlancher() {
            return getTopLeftY() + getHeight() >= getWorld2d().getHeight();
        }

        // implanter la méthode
        private boolean balleFrappePlafond() {
            return getTopLeftY() <= 0;
        }

        // implanter la méthode
        private boolean balleFrappeMurDroit() {
            return getTopLeftX() + getWidth() >= getWorld2d().getWidth();
        }

        // implanter la méthode
        private boolean balleFrappeMurGauche() {
            return getTopLeftX() <= 0;
        }

        // implanter la méthode
        private void balleRebondiSurPlancher() {
            setTopLeftY(getWorld2d().getHeight() - this.getHeight() - EPSILON);
            setSpeedY(-getSpeedY());
        }


        // implanter la méthode
        private void balleRebondiSurPlafond() {
            setTopLeftY(0 + EPSILON);
            setSpeedY(-getSpeedY());
        }

        // implanter la méthode
        private void balleRebondiSurMurDroit() {
            setTopLeftX(getWorld2d().getWidth() - this.getWidth() - EPSILON);
            setSpeedX(-getSpeedX());
        }

        // implanter la méthode
        private void balleRebondiSurMurGauche() {
            setTopLeftX(0 + EPSILON);
            setSpeedX(-getSpeedX());
        }

NOTE: le EPSILON permet de s’assurer que la balle est distancée du mur
- (sinon elle peut rester «collée»)

Tester que ça fonctionne #

Exécuter AppPong pour vérifier que la balle rebondi sur les murs
```
$ sh gradlew pong
```

On peut aussi tester avec plusieurs balles en ajoutant ce code dans MondePong2d

public class MondePong2d extends World2dFx {

        // ...

        @Override
        protected void initialize() {

            // ...


            // ajouter
            for(int i = 0; i < 100; i++) {
                addObject2d(new Balle2d());
            }
        }

$ sh gradlew pong