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.
- 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.
Sous Linux : java -jar gdx-setup.jar
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\<>\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
Ou, plus simplement, une fois le projet importé, ouvrir une fenêtre terminal et tapez : gradlew desktop:run
Pour debugger l’application Desktop, suivre le tuto ici (Clic droit sur la Class DesktopLauncher – Run ou Debug en précisant la localisation du fichier Assets dans Working Directory et Use Class Of Module Desktop)
Et ajouter dans le log des balises pour les traces : https://github.com/libgdx/libgdx/wiki/Logging
Pour un lancement HTML :
cd C:/ProjectDirectoryPath/RootProjectDirectory
gradlew html:superDev
Si il est impossible de relancer le site :
- trouver ce qui tourne sur le port no (exemple 8080)netstat -ano | findstr 8080TCP 0.0.0.0:8080 LISTENING 6772
- Tuer le processus en utilisant son PIDtaskkill /F /pid 6772
Déploiement sur un serveur Apache :
Se placer dans le répertoire de l’application puis taper
gradlew.bat html:dist Le résultat sera dans html/build/dist
transférer l’enssemble sur un serveur et
sudo chmod -R 755 /repertoire du jeux
Références : https://github.com/libgdx/libgdx/wiki/Deploying-your-application
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 :
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 va créer 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=50, Y=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 :
a) La classe GAME :
Cette classe permet d’implémenter toutes les méthodes nécessaires et de déléguer le fonctionnement du jeux à des écrans ‘Screen’. Il suffit de changer le type de class par défaut par ‘Game’
public abstract class Game implements ApplicationListener {
protected Screen screen;
@Override
public void dispose () {
if (screen != null) screen.hide();
}
@Override
public void pause () {
if (screen != null) screen.pause();
}
@Override
public void resume () {
if (screen != null) screen.resume();
}
@Override
public void render () {
if (screen != null) screen.render(Gdx.graphics.getDeltaTime());
}
@Override
public void resize (int width, int height) {
if (screen != null) screen.resize(width, height);
}
public void setScreen (Screen screen) {if (this.screen != null) this.screen.hide();
this.screen = screen;
if (this.screen != null) {
this.screen.show();
this.screen.resize(Gdx.graphics.getWidth(), Gdx.graphics.
getHeight());
}
}
public Screen getScreen () {
return screen;
}
}
Cette classe déléguera le fonctionnement à des classes Screen :
public interface Screen {
public void show ();
public void render (float delta);
public void resize (int width, int height);
public void pause ();
public void resume ();
public void hide ();
public void dispose ();
}
Donc pour créer le jeux, il faudra implémenter notre classe en se basant sur la classe Game et en paramétrant la logique du jeux dans les Screens (principalement dans les méthodes show() et render().
b) 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.
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 :
Exemple de jeux :
http://www.kilobolt.com/zombie-bird-tutorial-flappy-bird-remake.html
https://github.com/libgdx/libgdx/wiki/A-simple-game
https://expertise.jetruby.com/creating-android-game-from-scratch-with-libgdx-box2d-45c381d84268
https://www.instructables.com/id/How-to-Make-an-Android-Game-Snake/
Références :
https://libgdx.badlogicgames.com/download.html
https://github.com/libgdx/libgdx/wiki/The-application-framework
A lire :
Tuto :
- http://www.gamefromscratch.com/page/LibGDX-Tutorial-series.aspx
- http://www.kilobolt.com/day-3-understanding-the-libgdx-framework.html
- http://theinvader360.blogspot.fr/2013/05/street-race-swipe-libgdx-scene2d.html
- http://vladimirslav.com/tutorials/
- https://classroom.udacity.com/courses/ud405
- https://www.gamedevelopment.blog/full-libgdx-game-tutorial-loading-screen/
- https://www.youtube.com/channel/UCuCkU88bBJN4whZDZhzdBMQ/videos
Démos :
Astuces :
Couleur du fond
Gdx.gl.glClearColor(Color.BLACK.r, Color.BLACK.g, Color.BLACK.b,
Color.BLACK.a);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
xxxx
xx
AndroLogiciels 