Libgdx Game

samedi 14 juillet 2012

Tutoriel Libgdx :Se rapprocher encore plus de libgdx #3

developpement avec libgdx sous android

  ---> Introduction

  ---> Cycle de vie d’une application

  ---> Les Classes de démarrage d’application

  ---> L’accès aux différents modules de Libgdx 

  ---> Conclusion


Introduction

Comme on a déjà vu dans le précédant tutoriel, libgdx  permet de cibler plusieurs plateformes tels que les systèmes d’exploitation, Android ou le navigateur avec un unique code source. On a aussi mentionné que pour chaque plateforme il y a un backends qui représente un étage de sortie d’une application,  et qui permet de produire le résultat du code source implémenté dans la partie logique (voir les différentes parties de développement avec Libgdx ici)

Libgdx prend actuellement en charge 4 backends:
  • LWJGL : Fonctionne sur Windows, Linux et Mac OS X,
  • JOGL :    Il vise également Windows, Linux et Mac OS X.
Remarque:
Actuellement LWJGL est le plus préféré, car il est plus stable, surtout quand il s'agit de développer une application en plein écran.
  • Android : Permet le développement sous Android  (Le but de ce tutoriel)
  • HTML5 : On ne va pas s’intéressé sur le développement sous cette plateforme.

Libgdx est composé de 5 modules

Application : Pour exécuter l'application et s'informer sur les événements produits au niveau des applications, telles que le redimensionnement de la fenêtre. C’est aussi le module qui permet d’effectuer des fonctions de  journalisation (le Logging).
File : c’est le module qui permet de lire, écrire, même copier, déplacer et supprimer des fichiers.
Input : C’est le module qui nous permet de détecter les entrées de l’utilisateur tels que les évènements souris (sous desktop)/tactile (sous Android) et même l'accéléromètre.
Audio : C’est le module qui permet de lire des effets sonores et de la musique en streaming et qui permet un accès direct au périphérique audio du diapositif, et permet même de créer des effets sonores.
Graphiques : Comporte tout ce qui concerne la manipulation et le réglage du mode vidéo et graphisme.


Le cycle de vie d’une application :

Libgdx définie un cycle de vie d’une application qui possède plusieurs états comme : créé (ouverte), suspendu, reprit, détruite (fermée).

On implémentant  ApplicationListener on doit obligatoirement définir les méthodes qui doivent être appelées à chaque fois qu’un évènement changeant l’état de l’application se produit.

package my.works.jeu;
import com.badlogic.gdx.ApplicationListener;
public class Jeu implements ApplicationListener {
            @Override
            public void create() {
            }
            @Override
            public void dispose() {
            }
            @Override
            public void pause() {
            }
            @Override
            public void render() {
            }
            @Override
            public void resize(int arg0, int arg1) {
            }
            @Override
            public void resume() {
            }
}

Ou on peut hériter de la classe abstraite ApplicationAdapter qui elle-même implémente ApplicationListener et on aura pas à définir obligatoirement toutes les méthodes.

package my.works.jeu;
import com.badlogic.gdx.ApplicationListener;
public class Jeu extends ApplicationAdapter {
            public void create() {
            }
            public void pause() {
            }
            public void render() {
            }
}

Ce code source correspond à la partie Logique de développement(voir les parties de développement ici), c’est là que la totalité du code source de notre jeu/app est située.

Les méthodes seront appelées comme suite :

Create ()                                                                                                                                 :
Cette méthode est appelée une fois l'application est créée.
resize(int width, int height)                                                                                                      :
Cette méthode est appelée à chaque fois que l'écran du jeu (qui n’est pas en état de pause) est redimensionné. Elle est aussi toujours appelée juste après la création (donc, juste après la méthode create() ). Les paramètres sont la nouvelle largeur(en pixels) et la nouvelle hauteur(en pixels) de l'écran redimensionnée.
render ()                                                                                                                                 :
Méthode appelée en boucle. Elle est appelée à chaque fois qu’un  rendu doit être effectué. 
La totalité de la logique du jeu est construite dans cette méthode, elle est considérée comme étant le corps de la boucle principale.
pause ()                                                                                                                                 :
Sur Android, cette méthode est appelée lorsque le bouton Home est pressé ou un appel entrant est reçu. 
Sur le desktop, cette méthode est appelée juste avant la méthode dispose(), donc juste avant de quitter l'application.
Pause() est un bon endroit pour enregistrer l'état du jeu.
resume ()                                                                                                                               :
Cette méthode est appelée uniquement sur Android, lorsque l'application reprend d'un état de pause.
dispose ()                                                                                                                               :
cette méthode est Appelée lorsque l'application est détruite. Elle est précédée par un appel à la méthode pause().

Le schéma suivant illustre le cycle de vie d’une application implémentée en Libgdx:
ce schéma est pris du site officiel de libgdx voir ici

Les classes de démarrage d’application

On va prendre l’exemple du tutoriel précédant il y avait ces deux classes :
Classe de démarrage de l’application sous Android : La classe main
Classe de démarrage de l’application sous desktop : La classe LanceurDesktop

Main
public class main extends AndroidApplication {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initialize(new Jeu(), false);
  }
}

LanceurDesktop
package my.works.jeu;
import com.badlogic.gdx.backends.jogl.JoglApplication;
public class LanceurDesktop {
            public static void main(String[] args) {
                                new JoglApplication (new Jeu(),"titre du jeu",480,320,false);
    }
}

Les deux classes se situent dans deux projet différents
Les deux classes font appel à la classe Jeu qui contient le code source de notre jeu/app

L’accès aux différents modules de Libgdx :

Les modules de Libgdx décrit précédemment peuvent être accéder via des champs statiques de la classe Gdx, cela permet un accès facile aux modules de libgdx par exemple :
Pour accéder au module audio on utilise Gdx.audio
Pour le module File on utilise Gdx.file
Pour le module d’application c’est à travers Gdx.app
Exemple de code source :
AudioDevice audioDevice =  GDx.audio.newAudioDevice (44100,faux);


Conclusion
A ce niveau de connaissances acquisent à travers ce tutoriel et ceux qui le précède, on pourra s’intéresser au code source. Si vous avez des remarques ou des questions n’hésitez pas à les poster en commentaire. Merci pour votre lecture.

2 commentaires: