Animation du ciel

Le ciel peut être animé simplement en le redessinant périodiquement, afin de rendre perceptible le mouvement apparent des objets célestes. Étant donné que ces objets ne se déplacent que lentement, il est également intéressant d'offrir la possibilité d'accélérer l'écoulement du temps, et l'écriture du code gérant cette accélération temporelle constitue la plus grosse partie de cette étape.

Deux techniques d'accélération du temps seront proposées dans ce projet, l'une continue et l'autre discrète, et elles font l'objet des deux sections suivantes.

Avant de mettre en œuvre cette étape, il convient de corriger quelques erreurs dans les étapes 1 à 6, qui sont décrites ci-dessous.

L'interface TimeAccelerator du paquetage ….gui, publique, représente un « accélérateur de temps », c'est-à-dire une fonction permettant de calculer le temps simulé —  et généralement accéléré — en fonction du temps réel.

Cette interface est une interface fonctionnelle, et peut donc être annotée au moyen de @FunctionalInterface.

L'unique méthode abstraite de cette interface, nommée p.ex. adjust, prend en arguments :

• le temps simulé initial \(T_0\), représenté par une valeur de type ZonedDateTime,
• le temps réel écoulé depuis le début de l'animation — soit la valeur de l'expression \((t - t_0)\) plus haut — représenté par une valeur de type long exprimée en nanosecondes (!).

Au moyen de ces arguments, elle calcule le temps simulé \(T\) et le retourne sous la forme d'une nouvelle instance de ZonedDateTime.

Le temps réel écoulé est exprimé en nanosecondes car c'est la représentation utilisée par JavaFX, comme nous le verrons plus bas.

En plus de la méthode abstraite décrite ci-dessus, l'interface TimeAccelerator offre deux méthodes statiques, permettant chacune de créer l'un des deux types d'accélérateurs décrits dans l'introduction :

• continuous retourne un accélérateur continu en fonction du facteur d'accélération \(\alpha\) (entier),
• discrete retourne un accélérateur discret en fonction de la fréquence d'avancement \(\nu\) (entière) et du pas \(S\).

Ces deux méthodes se définissent très simplement et élégamment au moyen de lambdas, et le pas d'un accélérateur discret est très naturellement représenté par une instance de la classe Duration de la bibliothèque Java.

Le type énuméré NamedTimeAccelerator du paquetage ….gui, publique, représente un accélérateur de temps nommé, c'est-à-dire une paire (nom, accélérateur).

Les membres de ce type sont les accélérateurs qui seront disponibles à l'utilisateur du programme une fois celui-ci terminé, et les noms seront ceux affichés à l'écran.

La table ci-dessous présente les noms et caractéristiques des six membres disponibles. Notez que le nom donné dans la première colonne est celui qui sera visible à l'écran, et il est stocké dans un attribut de type String du membre, tandis que le nom donné dans la dernière colonne est celui que nous vous suggérons d'utiliser pour nommer le membre de l'énumération Java.

Le type énuméré NamedTimeAccelerator offre trois méthodes, qui sont :

• getName, qui retourne le nom de la paire,
• getAccelerator, qui retourne l'accélérateur de la paire,
• toString, qui redéfinit la méthode de Object afin qu'elle retourne le nom de la paire, tout comme getName.

Notez qu'il est très important que le nom des deux méthodes d'accès commence par get car cette convention de nommage est utilisée par JavaFX. En nommant ces méthodes d'accès autrement — par exemple sans le get initial, comme nous l'avons fait jusqu'à présent —, vous rendriez le type énuméré NamedTimeAccelerator inutilisable dans une interface JavaFX.

La classe DateTimeBean du paquetage ….gui, publique et finale, est un bean JavaFX contenant l'instant d'observation, c-à-d le triplet (date, heure, fuseau horaire) d'observation. Il s'agit d'une classe très simple possédant les propriétés JavaFX suivantes :

• date, la date d'observation, de type LocalDate,
• time, l'heure d'observation, de type LocalTime,
• zone, le fuseau horaire d'observation, de type ZoneId.

Toutes ces propriétés ont une valeur initiale égale à null. Attention, cela ne signifie pas que les propriétés elles-mêmes sont nulles, mais que leur contenu l'est.

Comme expliqué à la §4.3 des notes de cours sur JavaFX, à chacune de ces propriétés correspondent trois méthodes dans la classe DateTimeBean :

1. une méthode donnant accès à la propriété elle-même,
2. une méthode donnant accès au contenu de la propriété,
3. une méthode permettant de modifier le contenu de la propriété.

Par exemple, pour la propriété date, ces méthodes sont, dans l'ordre :

1. ObjectProperty<LocalDate> dateProperty(),
2. LocalDate getDate(), et
3. void setDate(LocalDate date).

En plus des méthodes liées aux propriétés, la classe DateTimeBean en fournit deux qui permettent d'obtenir ou de modifier l'instant d'observation sous la forme d'une valeur de type ZonedDateTime. Ces méthodes pourraient être :

1. getZonedDateTime, qui retourne l'instant d'observation sous la forme d'une valeur de type ZonedDateTime,
2. setZonedDateTime, qui modifie l'instant d'observation pour qu'il soit égal à la valeur de type ZonedDateTime qu'on lui passe en argument.

Ces méthodes s'expriment trivialement en termes de celles travaillant sur le contenu des propriétés date, time et zone.

Il faut bien comprendre que DateTimeBean contient exactement les mêmes composantes qu'une instance de ZonedDateTime, à savoir une date, une heure et un fuseau horaire. La différence entre ces deux classes est que, dans DateTimeBean, ces composantes sont des propriétés JavaFX observables — et donc pas immuables. On peut donc voir DateTimeBean comme une version modifiable et observable de ZonedDateTime.

La classe TimeAnimator du paquetage ….gui, publique et finale, représente un « animateur de temps ». Son but est de modifier périodiquement, via un accélérateur de temps, l'instant d'observation stocké dans une instance de DateTimeBean, dans le but d'animer ainsi (indirectement) le ciel. L'instance de DateTimeBean dont le temps d'observation doit être modifié de la sorte est passée en argument au constructeur de TimeAnimator, tandis que l'accélérateur lui est transmis par la propriété accelerator décrite plus bas.

La classe TimeAnimator hérite de la classe AnimationTimer de JavaFX. AnimationTimer est une classe (abstraite) très simple, représentant un minuteur d'animation dont le but est de faire évoluer une (ou plusieurs) animation(s) d'une application JavaFX. Pour ce faire, dès qu'un minuteur est démarré au moyen de sa méthode start, sa méthode handle est automatiquement appelée environ 60 fois par secondes afin de faire progresser l'animation. Pour arrêter le minuteur, il suffit d'appeler sa méthode stop.

La méthode handle reçoit en argument une valeur représentant le nombre de nanosecondes écoulées depuis un instant de départ non spécifié. Comme l'origine de ce temps en nanosecondes n'est pas spécifiée, sa valeur absolue n'a pas vraiment de signification, mais il est par contre possible d'utiliser la différence des valeurs passées à des appels successifs à handle pour mesurer le temps écoulé. Il est même assez simple de mesurer le temps écoulé depuis le début d'une animation, en s'assurant que lorsque la méthode handle est appelée pour la première fois après le démarrage du minuteur, elle stocke le nombre de nanosecondes qui lui est passé dans un attribut du minuteur.

En plus de la définition de la méthode handle, la classe TimeAnimator possède les deux propriétés suivantes :

• accelerator, qui contient l'accélérateur de temps, de type TimeAccelerator, valant initialement null,
• running, qui contient l'état de l'animateur, de type bool — vrai si l'animation est en train de s'exécuter, c-à-d si le temps simulé est périodiquement mis à jour, faux sinon.

La propriété running doit bien entendu être accessible en lecture seulement, donc impossible à modifier depuis l'extérieur.

Pour tester vos classes, vous pouvez vous inspirer du petit programme ci-dessous, une application JavaFX qui utilise un animateur de temps pour afficher la manière dont le temps simulé évolue lorsqu'on accélère le temps réel d'un facteur 3000.

public final class UseTimeAnimator extends Application {
  public static void main(String[] args) { launch(args); }

  @Override
  public void start(Stage primaryStage) {
    ZonedDateTime simulatedStart =
      ZonedDateTime.parse("2020-06-01T23:55:00+01:00");
    TimeAccelerator accelerator =
      NamedTimeAccelerator.TIMES_3000.getAccelerator();

    DateTimeBean dateTimeB = new DateTimeBean();
    dateTimeB.setZonedDateTime(simulatedStart);

    TimeAnimator timeAnimator = new TimeAnimator(dateTimeB);
    timeAnimator.setAccelerator(accelerator);

    dateTimeB.dateProperty().addListener((p, o, n) -> {
	System.out.printf(" Nouvelle date : %s%n", n);
	Platform.exit();
      });
    dateTimeB.timeProperty().addListener((p, o, n) -> {
	System.out.printf("Nouvelle heure : %s%n", n);
      });
    timeAnimator.start();
  }
}

En l'exécutant vous devriez voir des lignes similaires à celles ci-dessous s'afficher sur votre console :

Nouvelle heure : 23:55:46.073088
Nouvelle heure : 23:56:36.153303
Nouvelle heure : 23:57:26.100501
Nouvelle heure : 23:58:16.676541
Nouvelle heure : 23:59:09.397014
Nouvelle heure : 23:59:56.754609
 Nouvelle date : 2020-06-02
Nouvelle heure : 00:00:46.465743

Notez que les valeurs exactes changent d'une exécution à l'autre. Toutefois, les heures successives devraient être séparées les unes des autres d'environ 50 secondes, car le temps simulé s'écoule 3000 fois plus vite que le temps réel, et JavaFX fait avancer les animations à 60 images par secondes environ. On a donc :

\[ 3000 \times \frac{1}{60}\,\mathrm{s} = 50\,\mathrm{s} \]

Suivant la manière dont vous avez écrit votre classe DateTimeBean, il est également possible que les deux dernières lignes soient inversées, ce qui ne pose aucun problème.

Notez que si vous remplacez l'accélérateur continu utilisé ci-dessus par un accélérateur discret, alors la durée séparant les couples date/heure successifs devrait être exactement égale au pas de l'accélérateur.