LionEngine - The Web Site

Introduction

Le cycle de vie du moteur est très simple, similaire aux standards de jeux.

Étant donné que le LionEngine est une librairie (et non un programme), vous devrez créer vous même la première étape du cycle de vie: le Main

• En utilisant Java comme cible

  public final class MainJava
  {
      public static void main(String[] args)
      {
          // Here the program starts
      }
  }
  

• En utilisant Android comme cible

  public final class MainAndroid
          extends Activity
  {
      @Override
      protected void onPostCreate(Bundle savedInstanceState)
      {
          super.onPostCreate(savedInstanceState);
  
          // Here the program starts
      }
  }
  

Rien de nouveau jusqu'ici si vous avez assez de connaissance dans le domaine.

Cycle de vie

Une fois le point d'entré du langage compris, vous aimeriez certainement découvrir celui du moteur.

Voici l'arborescence complète du cycle de vie:

L'idée principale derrière cela est que le Loader peut être considéré comme un ordonnanceur de Sequence, où chacune des sections d'un jeu (introduction, menu, niveau...) représente une Sequence. Ainsi, lorsqu'une Sequence est terminée (fin d'une introduction, ou un niveau de jeu...), l'application (et également le moteur), n'est pas nécessairement terminé. Vous souhaiteriez par exemple poursuivre sur un autre niveau, ou simplement enchainer sur le menu après l'introduction.

L'application démarre avec la première Sequence que vous lui donnez, et continue sa vie jusqu'à sa terminaison (en arrêtant toute activité, ou en démarrant une nouvelle Sequence). Dans tous les cas, c'est le Loader qui contrôle ces étapes. La seule condition pour arrêter un programme est lorsque le Loader n'a plus aucune nouvelle Sequence à gérer. Dans ce cas là, le moteur sera clôturé, et l'application terminera (ainsi que la JVM associée).

Initialisation du moteur

L'initialisation du moteur doit être réalisée dans le main. C'est à ce moment là que vous aurez la possibilité de configurer le moteur selon vos besoins. Vous aurez à définir des éléments requis, tels que le nom du programme et sa version, le répertoire des ressources, la résolution d'affichage (plus un filtre optionnel), et enfin la première Sequence à lancer.

Engine.start("Name", Version.create(1, 0, 0), Verbose.CRITICAL, "resources");
final Resolution output = new Resolution(640, 480, 60);
final Config config = new Config(output, 32, false);
final Loader loader = new Loader(config);
loader.start(Scene.class);

L'initialisation est a peut près la même quelque soit la cible, Java & Android ...

Engine.start("Name", Version.create(1, 0, 0), Verbose.CRITICAL, this);

Contrôle des séquences

Une fois que le moteur a été initialisé et que le Loader a démarré la première Sequence, le programme tourne alors en roue libre. Il y a deux principales actions qui peuvent êtres réalisées pendant cette étape:

• La Sequence en cours démarre simplement une nouvelle Sequence, et termine à ce moment là. Le contrôle est donné à la nouvelle Sequence.
• La Sequence peut démarrer une nouvelle Sequence et la charger tout en étant actif, et lui passer le contrôle lors de sa terminaison.

Alors que le premier cas est simple à comprendre, le deuxième est un peu moins évidente.

Un bon exemple pour l'illustrer:

Le chargement de la prochaine Sequence est réalisé dans un thread séparé, qui permet de ne pas bloquer la Sequence actuelle. Ainsi il est possible de réduire significativement le temps global de chargement, tout du moins en apparence pour l'utilisateur, puisqu'il lui est possible d'interagir avec quelque chose pendant que le moteur charge la prochaine Sequence.

s.lionengine.Resolution;
import com.b3dgs.lionengine.core.Graphic;
import com.b3dgs.lionengine.core.Loader;
import com.b3dgs.lionengine.core.Sequence;

/**
 * SequenceLinkSimple implementation.
 * 
 * @author Pierre-Alexandre (contact@b3dgs.com)
 */
public class SequenceLinkSimple
        extends Sequence
{
    /** Count value. */
    private int count;

    /**
     * Constructor.
     * 
     * @param loader The loader reference.
     */
    public SequenceLinkSimple(Loader loader)
    {
        super(loader, new Resolution(320, 100, 32));
    }

    /*
     * Sequence
     */

    @Override
    protected void load()
    {
        count = 0;
    }

    @Override
    protected void update(double extrp)
    {
        count++;
        if (count > 2)
        {
            end(SequenceNext.class);
        }
    }

    @Override
    protected void render(Graphic g)
    {
        System.out.println("SimpleLink rendering number " + count);
    }
}

s.lionengine.Resolution;
import com.b3dgs.lionengine.core.Graphic;
import com.b3dgs.lionengine.core.Loader;
import com.b3dgs.lionengine.core.Sequence;

/**
 * SequenceNext implementation.
 * 
 * @author Pierre-Alexandre (contact@b3dgs.com)
 */
public class SequenceNext
        extends Sequence
{
    /**
     * Constructor.
     * 
     * @param loader The loader reference.
     */
    public SequenceNext(Loader loader)
    {
        super(loader, new Resolution(320, 100, 32));
    }

    /*
     * Sequence
     */

    @Override
    protected void load()
    {
        System.out.println("SequenceNext loaded !");
    }

    @Override
    protected void update(double extrp)
    {
        end();
    }

    @Override
    protected void render(Graphic g)
    {
        System.out.println("I am Next !");
    }
}

s.lionengine.Config;
import com.b3dgs.lionengine.Resolution;
import com.b3dgs.lionengine.Version;
import com.b3dgs.lionengine.core.Engine;
import com.b3dgs.lionengine.core.Loader;
import com.b3dgs.lionengine.core.Verbose;

/**
 * Program starts here.
 * 
 * @author Pierre-Alexandre (contact@b3dgs.com)
 */
public final class AppSequenceLinkSimple
{
    /**
     * Main function called by the jvm.
     * 
     * @param args The arguments.
     */
    public static void main(String[] args)
    {
        Engine.start("AppSequenceLinkSimple", Version.create(1, 0, 0), Verbose.CRITICAL, "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(SequenceLinkSimple.class);
    }
}

La SequenceLinkSimple terminera lorsque count > 2, et démarrera la prochaine Sequence appelée SequenceNext. Quand la SequenceNext est démarrée, le programme s'arrêtera simplement (comme appelé).

s.lionengine.Resolution;
import com.b3dgs.lionengine.core.Graphic;
import com.b3dgs.lionengine.core.Loader;
import com.b3dgs.lionengine.core.Sequence;

/**
 * SequenceLinkComplex implementation.
 * 
 * @author Pierre-Alexandre (contact@b3dgs.com)
 */
public class SequenceLinkComplex
        extends Sequence
{
    /** Count value. */
    private int count;

    /**
     * Constructor.
     * 
     * @param loader The loader reference.
     */
    public SequenceLinkComplex(Loader loader)
    {
        super(loader, new Resolution(320, 100, 32));
    }

    /*
     * Sequence
     */

    @Override
    protected void load()
    {
        count = 0;
    }

    @Override
    protected void update(double extrp)
    {
        count++;
        if (count == 1)
        {
            start(false, SequenceNext.class);
        }
        if (count > 2)
        {
            end();
        }
    }

    @Override
    protected void render(Graphic g)
    {
        System.out.println("ComplexLink rendering number " + count);
    }
}

s.lionengine.Resolution;
import com.b3dgs.lionengine.core.Graphic;
import com.b3dgs.lionengine.core.Loader;
import com.b3dgs.lionengine.core.Sequence;

/**
 * SequenceNext implementation.
 * 
 * @author Pierre-Alexandre (contact@b3dgs.com)
 */
public class SequenceNext
        extends Sequence
{
    /**
     * Constructor.
     * 
     * @param loader The loader reference.
     */
    public SequenceNext(Loader loader)
    {
        super(loader, new Resolution(320, 100, 32));
    }

    /*
     * Sequence
     */

    @Override
    protected void load()
    {
        System.out.println("SequenceNext loaded !");
    }

    @Override
    protected void update(double extrp)
    {
        end();
    }

    @Override
    protected void render(Graphic g)
    {
        System.out.println("I am Next !");
    }
}

s.lionengine.Config;
import com.b3dgs.lionengine.Resolution;
import com.b3dgs.lionengine.Version;
import com.b3dgs.lionengine.core.Engine;
import com.b3dgs.lionengine.core.Loader;
import com.b3dgs.lionengine.core.Verbose;

/**
 * Program starts here.
 * 
 * @author Pierre-Alexandre (contact@b3dgs.com)
 */
public final class AppSequenceLinkComplex
{
    /**
     * Main function called by the jvm.
     * 
     * @param args The arguments.
     */
    public static void main(String[] args)
    {
        Engine.start("AppSequenceLinkComplex", Version.create(1, 0, 0), Verbose.CRITICAL, "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(SequenceLinkComplex.class);
    }
}

La SequenceLinkComplex démarrera la prochaine Sequence appelée SequenceNext, mais continuera également sa vie jusqu'à count > 2, et terminera alors. Lorsque la SequenceLinkComplex sera terminée, la SequenceNext entrera immédiatement dans sa routine (update & render).

Lire la suite: Outils de base