Tout cela a été possible grâce à la librairie jMonkeyEngine (JME). Non seulement cette librairie est très complète et bien documentée, mais elle bénéficie d’une communauté réactive et bienveillante (c’est en tout cas ce que j’ai ressenti à mon égard).
Plus qu’une librairie, c’est en fait un moteur de jeu complet (graphisme 3D, son, interface utilisateur, réseau…).

Vous l’aurez compris, si vous avez un projet de jeu ou d’application 3D en java alors je vous recommande chaudement jMonkeyEngine. La lecture des tutoriels (y compris en vidéo) peut paraître fastidieuse, mais c’est indispensable à mon avis pour comprendre le fonctionnement de ce moteur.

Quelle est l’architecture du moteur du jeu ?

Le moteur utilise une architecture client/serveur. Le client sert à l’affichage et à la saisie des commandes du joueur et le serveur est utilisé pour centraliser le calcul des positions des différents joueurs.

Quels sont les messages échangés ?

Les messages de service comme les connexions, le démarrage de la course… sont envoyés par TCP pour assurer que les messages arrivent à bon port. Chaque client envoie régulièrement les commandes effectuées par le joueur sous la forme d’un message UDP plus rapide mais moins fiable. Le serveur envoie régulièrement aussi les positions de tous les bateaux à tous les clients, ceci sous la forme d’un message UDP également.

Gestion des temps de transferts entre le serveur les les clients

Pour que l’affichage ne soit pas trop saccadé, le client calcule les déplacements de tous les bateaux entre deux messages du serveur. A chaque message reçu du serveur, le client met à jour la position du bateau correspondant et continue la simulation locale.

Analyse du code

Le client et le serveur partage tout le code de la simulation, mais le serveur n’a pas d’affichage.

Le serveur

Exemple de parcours :

La vidéo du parcours complet :

Pour les courageux ou les inconscients… les sources sont disponibles sur GitHub.
Par contre le code est vraiment moche, il faut encore beaucoup de remise en forme et de restructuration.
Le point d’entrée est la classe… Main.java.

Ma première idée est de déformer une grille en fonction du terrain :

La déformation est proportionnelle à l’altitude.

Pas terrible, certaines parties se chevauchent, cela ne va pas être évident d’en tirer quelque chose.

Une autre idée a consisté à ne déformer la grille que perpendiculairement au vent :

Voila, ce n’est pas parfait, mais c’est beaucoup plus près de ce que je voulais obtenir comme effet.

En faisant tourner la carte (ou le vent) on obtient ces différentes déviations :

J’ai mis quelques jours pour obtenir un effet qui me parait acceptable, maintenant il faut en déduire la direction et la force du vent.

Le départ et l’arrivée sont matérialisés par une ligne entre deux bouées. La ligne s’efface lorsque la le départ ou l’arrivée sont franchis.

Pour l’instant il n’y a pas de top départ ni de chronométrage.

Voici le parcours actuel (à rendre plus ludique rapidement).

Pour l’instant l’architecture consiste à créer une classe contenant les données pour chaque objet. Par exemple pour la classe Boat nous avons la classe associée BoatData qui est sérialisée en XML par XStream.

Je ne sais pas si, à terme, la solution sera pérenne (évolution des classes data et support des anciennes versions de fichier XML).

Le wrapper pour XStream ressemble à ça :

package com.sailboatsim.utils;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import com.thoughtworks.xstream.XStream;

public class Conf {
    @SuppressWarnings("unchecked")
    public T load(String pSection, String pFile) {
        XStream xStream = new XStream();
        FileInputStream fis;
        try {
            fis = new FileInputStream(Utils.getFilePath(pSection, pFile));
        } catch (Exception e) {
            // Default values
            return null;
        }
        return (T) xStream.fromXML(fis);
    }

    public void save(T pObj, String pSection, String pFile) {
        XStream xStream = new XStream();
        try {
            FileOutputStream fos = new FileOutputStream(Utils.getFilePath(pSection, pFile));
            xStream.toXML(pObj, fos);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }
}

pour sauver un fichier, par exemple depuis BoatData la sauvegarde est appelée avec :

new Conf().save(this, "Boat", boatName);

et la lecture avec création d’un object BoatData :

new Conf().load("Boat", boatName);

Cette image donne le décor de la vidéo ci-dessous.

La caméra a été modifiée pour suivre le bateau en vue de derrière.

Les polaires de vitesse on été améliorées, je peux directement importer une polaire depuis le site http://www.ffvoile.net/ffv/web/pratique/habitable/ORC_IMS/certificats.asp pour l’instant la polaire utilisée dans la vidéo est celle d’un First 36.7 Racing de 2001.

Prochaine étape, gérer un parcours.

Du vent relatif (force et direction) on déduit la vitesse du bateau en utilisant une fonction dont la courbe est traditionnellement représentée sous la forme d’une polaire.

Note :

En fait traditionnellement  les polaires sont données en fonction de la vitesse et de l’angle « absolu » du vent par rapport au bateau et non en fonction du vent relatif.

Le vent relatif (celui indiqué par la girouette en au du mat) sera indiqué au joueur (vitesse et direction) le vent absolu est utilisé par le programme pour calculer la vitesse du bateau.

Pour la suite, comme la gestion du déplacement du bateau fonctionne, il faudra ajouter :

P.S. J’ai essayé de packager le programme pour webstart et pour application Mac, échec à chaque fois.

Les tutoriels sont vraiment très bien faits, on sent bien que JMonkeyEngine est fait pour développer des jeux, tout est axé là-dessus.

J’ai chargé le modèle de bateau dans JME3 :

bon ce n’est qu’un début.

A suivre…

C’est donc en Java que va être codé le jeu. Il y a du pour et du contre, mais comme j’ai déjà fait un jeu en C, je peux essayer le Java.

L’idée est de diriger le bateau en vue de haut un peut à la manière de Micro Machines, ou plus récemment BangBangRacing.

Le look est du genre cartoon.