Programmation Orientée Jeux

Nous allons dans un premier temps préparer le terrain, en créant un nouveau projet, et en préparant l'architecture globale.

1) Création d'un nouveau projet

Pour bien démarrer un projet, il faut avant tout préparer correctement le terrain. Il est nécessaire d'avoir une idée de ce dont on aura besoin pour réaliser le prototype.

• Choisissez votre IDE préféré (Eclipse, Netbeans, ...) et installez (si ce n'est pas déjà fait) le JDK 7.
• Télécharger le LionEngine et créez un nouveau projet Java sous votre IDE.
• Copiez le contenu de l'archive dans un dossier de votre projet (/lib par exemple).
• Liez le LionEngine à votre projet (exemple sous Eclipse):
• • Cliquez droit sur votre projet, cliquez sur Properties, onglet Java Build Path, onglet Libraries
  • Assurez-vous d'avoir au moins le JDK7 (sinon cliquez sur Add Library..., JRE System Library), Add JARs...
  • Pointez sur le fichier LionEngine_Core_x.y.z.jar (où x.y.z représente la version, par exemple 6.0.0)
  • Mario étant un jeu de plateforme, vous aurez également besoin des modules LionEngine_Game_x.y.z.jar et LionEngine_Game_Platform_x.y.z.jar
  • Toujours dans cet onglet, cliquez sur la flêche à gauche du JAR qui vient d'être ajoutée (LionEngine_Module_x.y.z.jar, où Module est le module du moteur)
  • Cliquez sur Javadoc location, sur Edit, puis sur Javadoc in archive, Archive Path, et pointez le fichier LionEngine_Module_x.y.z_doc.zip
  • Cliquez sur OK. Votre projet est maintenant configuré avec un JDK (au moins 7) et le LionEngine en librairie !
• La base des packages se trouve dans com.b3dgs.lionengine
• Créez votre première classe, que vous pourrez nommer AppMario, et ajoutez-y le code suivant (qui doit être compilable):

/**
 * Program starts here.
 *
 * @author Pierre-Alexandre (contact@b3dgs.com)
 */
public final class AppMario
{
    /** Application name. */
    public static final String NAME = "Mario";
    /** Application version. */
    public static final Version VERSION = Version.create(1, 0, 0);
    /** Resources directory. */
    private static final String RESOURCES = Media.getPath("resources", "mario", "a");

    /**
     * Main function.
     *
     * @param args The arguments.
     */
    public static void main(String[] args)
    {
        Engine.start(AppMario.NAME, AppMario.VERSION, AppMario.RESOURCES);
        final Resolution output = new Resolution(640, 480, 60);
        final Config config = new Config(output, 16, true);
        final Loader loader = new Loader(config);
        loader.start(new Scene(loader));
    }

    /**
     * Private constructor.
     */
    private AppMario()
    {
        throw new RuntimeException();
    }
}

Ce simple code permet de préparer l'environnement graphique, en spécifiant la configuration de notre programme. Cela est très utile dans le cas ou vous souhaiteriez agrandir la fenêtre de jeu (par exemple en 640*480). Le moteur pourra alors redimensionner automatiquement le contenu. Il est également possible d'ajouter des filtres.

2) Une fenêtre vide

Maintenant, nous pouvons préparer le squelette de jeu, là où il sera possible de charger, de mettre à jour, et d'afficher les ressources. Il suffit de créer une nouvelle classe, que nous nommerons Scene, et qui héritera de la classe Sequence. Selon les automatismes de votre IDE, vous devriez vous retrouver avec ceci:

/**
 * Game loop designed to handle our little world.
 *
 * @author Pierre-Alexandre (contact@b3dgs.com)
 */
final class Scene
        extends Sequence
{
    /** Native resolution. */
    private static final Resolution NATIVE = new Resolution(320, 240, 60);

    /**
     * Constructor.
     *
     * @param loader The loader reference.
     */
    Scene(Loader loader)
    {
        super(loader, Scene.NATIVE);
    }

    /*
     * Sequence
     */

    @Override
    protected void load()
    {
        // Load
    }

    @Override
    protected void update(double extrp)
    {
        if (keyboard.isPressedOnce(Key.ESCAPE))
        {
            end();
        }
    }

    @Override
    protected void render(Graphic g)
    {
        // render
    }
}

La séquence sera démarée par le moteur grâce au code que nous avons ajouté précédement, et plus précisement la dernière partie:

loader.start(new Scene(loader));

Vous devriez avoir une fenêtre vide sur fond noir.

Lire la suite: Jeu de Plateforme - Gestion du niveau