LibGDX

Libgdx est un environnement spécialement dédié au développement de jeux. Sa spécificité est la portabilité des jeux qui sont développés sur une plateforme indépendante de l’OS et permettant ainsi un fonctionnement sur windows/linux/ios/web et Android.

  1. Installation :

Allez à l’adresse https://libgdx.badlogicgames.com/download.html pour télécharger gdx-setup.jar puis cliquer sur le fichier pour créer un projet.

You are asked to provide the following parameters:

  • Name: the name of the application, lower-case with minuses is usually a good idea, e.g. mygame
  • Package: the Java package under which your code will live, e.g. com.badlogic.mygame
  • Game Class: the name of the main game java class of your app, e.g. MyGame
  • Destination: Folder where your app will be created
  • Android SDK: the location of your android sdk. With Android Studio, to find out where it is, start Android Studio and click « Configure »-> »SDK Manager ». By default it is in /Users/username/Library/Android/sdk or in D:\Profile\<<User_Name>>\AppData\Local\Android\Sdk

puis sous Studio : File->Open->build.gradle ou Import project(Eclipse Adt, Gradle, etc…)

http://tuto-libgdx.blogspot.fr/2013/08/installation.html?m=1

https://github.com/libgdx/libgdx/wiki/Project-Setup-Gradle

Pour lancer le jeux sur un PC, sous STUDIO, cliquez dans la fenêtre « Android » à la gauche de la flêche run, Edit configuration, « + », choisir graddle, nommer « Desktop » et tapez dans tasks : desktop:run

desktop

Ou, plus simplement, une fois le projet importé, ouvrir une fenêtre terminal et tapez : gradlew desktop:run

2) Principes :

Le programme LIBGDX est autonome. Il s’appuie sur 6 modules :

Pour s’exécuter, le programme doit être appelé par une « starterclass »

Cette classe appelle soit la classe ApplicationListener ou sa déclinaison restreinte : ApplicationAdapter

Comme le programme LIBGDX est événementiel, il n’y a pas de boucle. Toutefois les actions répétitives sont à placer dans la fonction ApplicationListener.render()

Le cycle de vie d’une application est le suivant :

70efff32-dd28-11e3-9fc4-1eb57143aee6

cf. https://github.com/libgdx/libgdx/wiki/The-life-cycle

http://bitiotic.com/blog/2013/05/23/libgdx-and-android-application-lifecycle/

3) Premiers pas :

Après l’installation, le setup crée une classe publique du nom de votre jeux et de type ApplicationAdapter cette classe affiche uniquement une image en bas de l’écran.

Les images doivent avoir comme dimension en hauteur et en largeur un multiple de 2 :  2,4,8,16,32,64,128,256,512,1024,2048, etc… pixels

Les coordonnées (0,0) placent l’objet en bas à gauche.

https://ubuverse.com/beginning-android-game-development-with-libgdx/

Pour un jeux en 2D il est utile d’employer une camera ortho. Toutes les coordonnées des objets du jeux seront calculées en fonction de cette caméra rendant l’affichage indépendant de la définition du téléphone.  Si nous définissons une caméra avec une vue d’une portée de 100×100, et si nous plaçons un objet aux coordonnées de (X=50Y=50) cd point sera au centre de la vue quelque soit la résolution de l’écran 100×100 ou1920×1080.

Définir un objet camera après la déclaration de la class ApplicationAdapter

OrthographicCamera camera;

Dans la fonction create

// Create a camera with orthographic projection  
camera = new OrthographicCamera();  
// Set the viewport to fit the screen resolution and center camera at the center of the screen
camera.setToOrtho(false);

Maintenant que nous avons créé la caméra il faut placer le SpriteBatch dans la vue de la caméra. Ceci est fait dans la fonction render

// Show the SpriteBatch where to render stuff  
batch.setProjectionMatrix(camera.combined);

L’exemple de jeux décrit dans le tutoriel Ubuverse est ici

4) Pour aller plus loin :

Les tuiles !

Gamestate

a) Création des écrans du jeux :

Un jeux est composé de plusieurs écrans qui peuvent être :

  • LoadingScreen – initial screen to show loading screen.
  • MenuScreen – a menu screen our second screen to show.
  • MainScreen – the screen which shows the game play.
  • PreferencesScreen – shows the preferences and allows them to be changed.
  • EndScreen – show the end game credits etc.

Ces écrans vont être gérés par la classe principale de votre jeux (créée lors du SETUP). Supprimez tout le code de cette classe et étendez la classe de votre  jeux en type « game » : extends Game. Cette classe sera l’orchestrator  du jeux…

Puis créez les classes des écrans en implements Screen :

import com.badlogic.gdx.Screen;

public class LoadingScreen implements Screen {
private "votre_classe_de_jeux" parent; // a field to store our orchestrator
// our constructor with a  argument
public EndScreen("votre_classe_de_jeux" rGame){
    parent = rGame;     // setting the argument to our field.
}
@Override 
public void show() 
{ // TODO Auto-generated method stub }
 @Override 
public void render(float delta) 
{ // TODO Auto-generated method stub } 
@Override public void resize(int width, int height) 
{ // TODO Auto-generated method stub } 
@Override public void pause() 
{ // TODO Auto-generated method stub } 
@Override public void resume() 
{ // TODO Auto-generated method stub } 
@Override public void hide() 
{ // TODO Auto-generated method stub } 
@Override public void dispose() 
{ // TODO Auto-generated method stub } 
}

Copiez ce code pour toutes les classes et placez le code suivant dans la classe orchestrator :

 public class "votre_classe_de_jeux" extends Game {  
   private LoadingScreen loadingScreen;  
   private PreferencesScreen preferencesScreen;  
   private MenuScreen menuScreen;  
   private MainScreen mainScreen;  
   private EndScreen endScreen;  
   public final static int MENU = 0;  
   public final static int PREFERENCES = 1;  
   public final static int APPLICATION = 2;  
   public final static int ENDGAME = 3;  
   @Override  
   public void create () {  
     loadingScreen = new LoadingScreen();  
     setScreen(loadingScreen);  
   }  
   public void changeScreen(int screen){  
     switch(screen){  
       case MENU:  
         if(menuScreen == null) menuScreen = new MenuScreen();  
         this.setScreen(menuScreen);  
         break;  
       case PREFERENCES:  
         if(preferencesScreen == null) preferencesScreen = new PreferencesScreen();  
         this.setScreen(preferencesScreen);  
         break;  
       case APPLICATION:  
         if(mainScreen == null) mainScreen = new MainScreen();  
         this.setScreen(mainScreen);  
         break;  
       case ENDGAME:  
         if(endScreen == null) endScreen = new EndScreen();  
         this.setScreen(endScreen);  
         break;  
     }  
   }  
 }  

4) Animations :

Exemple : dessiner 4 images de 256 pixels par 256 pixels. Puis regrouper les 4 images dans une image de 512 par 512 pixels.

FrameGroup

L’animation se fera grâce à l’instruction

batch.draw((TextureRegion) anim.getKeyFrame(elapsedTime,true),0,0);

Une fois l’image décodée par

img = new Texture("FrameGroup.png");
//-- Split l'image dans un tableau consituée de n images de 256x256 pixels
TextureRegion[][] tmpFrames = TextureRegion.split(img, 256, 256);
//-- Définition de l'animation contituée de 4 images
animFrames = new TextureRegion[4];
//-- Boucle pour extraire les images
int index = 0;
for (int i = 0; i < 2; i++) { // Lignes
    for (int j = 0; j < 2; j++) { // Colonnes
        animFrames[index++] = tmpFrames[i][j];
    }
}
//-- Définition de la vitesse d'animation
anim=new Animation(1f/2f,animFrames);

Le code source de la première partie du tuto youtube est ici

 

http://tutoriel-libgdx-android.blogspot.fr/2012/12/faire-une-animation-avec-libgdx-9.htmlhttp://tutoriel-libgdx-android.blogspot.fr/2012/12/faire-une-animation-avec-libgdx-9.html

https://www.gamedevelopment.blog/full-libgdx-game-tutorial-project-setup/

Tutorial :

http://www.creationjeuxjava.fr/tutorials/view/creez-votre-jeu-video-avec-libgdx

http://williammora.com/a-running-game-with-libgdx-part-1/

https://classroom.udacity.com/courses/ud405

https://github.com/udacity/ud405https://github.com/udacity/ud405

Animations :

http://gamedevelopment.tutsplus.com/tutorials/make-a-splash-with-dynamic-2d-water-effects–gamedev-236

Exemple de jeux :

http://www.kilobolt.com/zombie-bird-tutorial-flappy-bird-remake.html

https://github.com/libgdx/libgdx/wiki/A-simple-game

Références :

https://libgdx.badlogicgames.com/download.html

https://github.com/libgdx/libgdx/wiki/The-application-framework

A lire :

Tuto : 

Démos :

Publicités
Articles récents
Commentaires récents
fatima sur Bienvenue !
AdminDroid sur Bienvenue !
fatima sur Bienvenue !
Archives
Catégories
%d blogueurs aiment cette page :