Votre navigateur est obsolète !

Pour une expériencenet et une sécurité optimale, mettez à jour votre navigateur. Mettre à jour maintenant

×

Hugues Stéphano TELOLAHY

Engineer in Software Development and IT

Hugues Stéphano TELOLAHY
37 years old
Driving License
Tangier (90040) Morocco
Professional Status
Nearing graduation
Looking for an internship
About Me
Independent and passionate about IT, android and games development, I am creative and adapt easily to new systems.
Resume created on DoYouBuzz
Tokana
29 déc. 2014
Tokana is an addictive one level solitary game on Android. Get in on Google Play




ZE'MO
07 déc. 2014
Zemo is a funny Android puzzle game with a great gameplay. Now Available on Google Play



Hanoi Origins
09 nov. 2014
A classic Hanoi Tower puzzle developed above AndEngine. Now available on PlayStore.


It contains 6 levels for each numbers of rings to move to the right tower. AndEngine is a quasi-complete and simple-use engine for Android. 
The game logic is based on two rules:
  • No disk may be placed on top of a smaller 
  • Game is over when all rings are put on the right stack




Run AndEngine on Android Studio
29 oct. 2014
AndEngine is a powerful game Engine on Android. After finding lots of people having trouble on configuring it, I want to share via this tutorial simple and quick way to setup your Android game platform.


The goal is to build and test all extensions available with AndEngine

  • Download AndEngine project and extensions from RealMayo repositories
  • Create an empty Android Studio project
  • For each extension, you have to create new module by importing existing project (see the figure below)
  • Build .so files from NDK by following these instructions
  • Move .so files in /libs folder on the root of each module

If you don't want to waste time following these steps, you just can download a working Android Studio project from here. Import it and Enjoy !!
Sprites sous Android
20 janv. 2012
Tutoriel Développement Jeux sur Android Part 2 : les sprites sous Android
Dans les jeux 2D, un sprite est un élément qui peut se déplacer, s’animer. Il possède théoriquement une certaine couleur de transparence ou bien carrément un canal alpha. En fait il existe bien différentes manières de faire une animation: soit en faisant défiler des séquences successives d’images comme dans les gifs animés, soit en faisant des transformations squelettiques sur un objet.

Dans ce tutoriel, nous allons remplacer notre image du premier tutoriel par un personnage qui est animée en fonction de sa direction.




Le corps du jeu (GameLoop)


Par rapport au premier tutoriel, on a juste pris en considération le sprite: création avec mario=new Sprite(...), la mis à jour avec mario.update() puis l'affichage avec mario.render(screen.canvas) 

package com.creativegames;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Paint;
import android.graphics.drawable.BitmapDrawable;
import android.view.MotionEvent;

public class GameLoop extends Thread {

 /** Variable booléenne pour arrêter le jeu */
 public boolean running;
 /** durée de la pause entre chaque frame (FPS=10) */
 private long sleepTime = 100;
 /** Ecran de jeu */
 public GameView screen;
 /** le dernier évenement enregistré */
 public MotionEvent lastEvent;
 /** Personnage animé */
 private Sprite mario;
 /** Valeur du FPS (nombre de frames par secondes) */
 private int fps;

 public void initGame(Context context) {
  // créer la vue du jeu
  this.screen = new GameView(context, this);
  Bitmap img = ((BitmapDrawable) context.getResources().getDrawable(
    R.drawable.bad1)).getBitmap();
  // créer un sprite en spécifiant la position et la vitesse puis l'écran
  mario = new Sprite(img, 0, 0, 2, 3, screen);
  running = true;
 }

 /**
  * Ici on va faire en sorte que lorsqu'on clique sur l'écran, le sprite va
  * se rendre à la position cliquée
  * */
 public void processEvents() {
  if (lastEvent != null && lastEvent.getAction() == MotionEvent.ACTION_DOWN) {
   int xTouch = (int)lastEvent.getX();
   int yTouch = (int)lastEvent.getY();
   mario.moveTo(xTouch, yTouch);
  }
  lastEvent = null;
 }

 /**
  * Mise à jour des composants du jeu Ici nous déplaçon le personnage avec la
  * vitesse vx S'il sort de l'écran, on le fait changer de direction
  * */
 public void update() {
  mario.update();
 }

 /** Dessiner les composant du jeu sur le buffer de l'écran */
 public void render() {
  Paint paint = new Paint();
  // effacer l'écran avec la couleur verte
  paint.setColor(0xFF008000);
  this.screen.canvas.drawPaint(paint);
  // dessiner le sprite
  this.mario.render(screen.canvas);
  // ecrire le fps
  paint.setColor(0xFFFFFFFF);
  this.screen.canvas.drawText("FPS : " + fps, 10, 10, paint);
  // appliquer le buffer à l'écran
  this.screen.invalidate();
 }

 @Override
 public void run() {
  long startTime;
  long elapsedTime; // durée de (update()+render())
  long sleepCorrected; // sleeptime corrigé
  while (this.running) {
   startTime = System.currentTimeMillis();
   this.processEvents();
   this.update();
   this.render();
   elapsedTime = System.currentTimeMillis() - startTime;
   sleepCorrected = sleepTime - elapsedTime;
   // si jamais sleepCorrected<0 alors faire une pause de 1 ms
   if (sleepCorrected < 0) {
    sleepCorrected = 1;
   }
   try {
    Thread.sleep(sleepCorrected > 0 ? sleepCorrected : 1);
   } catch (InterruptedException e) {
   }
   // calculer le FSP
   fps = (int) (1000/(System.currentTimeMillis() - startTime));
  }
 }
}





La gestion des animations

Notre sprite est une image qui contient 4 animations avec 3 frames chacunes.

Alors, quand on observe notre image, on a les correspondances lignes-animation suivantes  (ligne3=up, ligne1=left, ligne0=down, ligne2=right)

Maitenant si la vitesse en x est supérieure en valeur absolue à la vitesse en y, on considèrera que le personnage se déplace soit à gauche ou à droite. Dans le cas contraire, on considèrera qu’il se déplace soit vers le haut ou vers le bas.
Nous avons donc besoin d’une fonction qui retourne l’animation à utiliser en fonction des paramètres de vitesse (xSpeed, ySpeed).
         private int getAnimationRow() {
  // animation: 3 back, 1 left, 0 front, 2 right
  if (Math.abs(xSpeed) > Math.abs(ySpeed)) {
   if (xSpeed > 0)
    return 2; //right
   else
    return 1; //left
  } else {
   if(ySpeed>0) 
    return 0; //down
   else
    return 3; //up
  }
 }



Maintenant  pour sélectionner un morceau d’image et l’afficher, on utilise la fonction.

drawBitmap(Bitmap bitmap, Rect src, RectF dst, Paint paint) de la classe Canvas.



        public void render(Canvas canvas) {
  int srcX = currentFrame * width;
  int srcY = getAnimationRow() * height;
  Rect src = new Rect(srcX, srcY, srcX + width, srcY + height);
  Rect dst = new Rect(x, y, x + width, y + height);
  canvas.drawBitmap(image, src, dst, null);
 }
Enfin le code source intégral de la classe Sprite
 
package com.creativegames;

import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Rect;


public class Sprite {

 private static final int BMP_ROWS = 4;
 private static final int BMP_COLUMNS = 3;

 private GameView gameView;
 private Bitmap image;
 private int x;
 private int y;
 private int xSpeed;
 private int ySpeed;
 /** numéro de la frame courante */
 private int currentFrame;
 /** dimension du sprite */
 private int width;
 private int height;

 public Sprite(Bitmap bmp, int x, int y, int vx, int vy, GameView gameView) {
  this.width = bmp.getWidth() / BMP_COLUMNS;
  this.height = bmp.getHeight() / BMP_ROWS;
  this.gameView = gameView;
  this.image = bmp;
  this.x = x;
  this.y = y;
  this.xSpeed = vx;
  this.ySpeed = vy;
 }

 public void update() {
  if (x >= gameView.getWidth() - width - xSpeed || x + xSpeed <= 0) {
   xSpeed = -xSpeed;
  }
  x = x + xSpeed;
  if (y >= gameView.getHeight() - height - ySpeed || y + ySpeed <= 0) {
   ySpeed = -ySpeed;
  }
  y = y + ySpeed;
  currentFrame = (currentFrame + 1) % BMP_COLUMNS;
 }
 
 private int getAnimationRow() {
  // animation: 3 back, 1 left, 0 front, 2 right
  if (Math.abs(xSpeed) > Math.abs(ySpeed)) {
   if (xSpeed > 0)
    return 2; //right
   else
    return 1; //left
  } else {
   if(ySpeed>0) 
    return 0; //down
   else
    return 3; //up
  }
 }

 public void render(Canvas canvas) {
  int srcX = currentFrame * width;
  int srcY = getAnimationRow() * height;
  Rect src = new Rect(srcX, srcY, srcX + width, srcY + height);
  Rect dst = new Rect(x, y, x + width, y + height);
  canvas.drawBitmap(image, src, dst, null);
 }

 /** déterminer la vitesse vers le point cliqué */
 public void moveTo(int x2, int y2) {
  int dx = x2-this.x;
  int dy = y2-this.y;
  double r = Math.sqrt(dx*dx+dy*dy);
  xSpeed = (int) (3*dx/r);
  ySpeed = (int) (3*dy/r);
 }

}
Inconvénients de cette méthode !
Le problème survient ici c’est que le sprite est toujours animé à la cadence du FPS. C’est-à-dire si on augmente le FPS (nombre de frames par seondes), on vera le personnage se déplacer plus vite. Il faut chercher à isoler la rapidité des sprites avec la boucle du jeu.
Ce que l’on peut faire c’est de fournir à chaque update le temps écoulé depuis le dernier frame, par exemple GameLoop.update(long elapsedTime).
Ainsi on a la possibilité par exemple de dire au sprite de changer de direction après exactement 3 secondes.

Téléchargements

Boucle de jeu sous Android
20 janv. 2012
Tutoriel Développement Jeux sur Android Part 1 : boucle de jeu 
On entend souvent parler de la boucle de jeu. Il s’agit en fait d’une boucle quasi-infinie au cours de laquelle s’effectuent généralement trois tâches essentielles:
  • Traitement des entrées (input)
  • Mis à jour (update)
  • Affichage (render)
Un jeu basique est  composé d’une seule boucle, c’est la boucle d’affichage. Mais on peut également trouver d’autres boucles comme la lecture des fichiers audio ou des flux réseaux par exemple. Ainsi on dit d’un jeu est composé de plusieurs moteurs : moteur graphique, moteur audio, etc. Voir Utilité d'un moteur de jeu

Dans cette première partie de tutoriel consacré au développement de jeux sur Android, mon objectif est de vous montrer comment réaliser une animation simple en respectant l’architecture d’un jeu.  Vous allez voir qu’au fil du temps, cette architecture facilite beaucoup la réalisation de n’importe quelle application interactive sur Android.


Si vous êtes débutant en Android et que vous aurez des doutes sur les notions de bases (Activité, View), référez-vous à ce site.

Nous aurons besoin de deux classes seulement, en plus le point d’entrée qui est l’Activité:
Le composant GameView

Nous allons définir une vue spécifique pour notre activité en héritant de la classe SurfaceView. Cette dernière nous donne accès à son buffer (mémoire tampon pour dessiner nos objets) et aussi à des événements du type MotionEvent (toucher l’écran).
package com.creativegames;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Bitmap.Config;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceHolder.Callback;
import android.view.SurfaceView;

public class GameView extends SurfaceView implements Callback{
 
 public int width; //largeur de l'écran
 public int height; //hauteur de l'écran 
 public Canvas canvas; //outil pour dessiner sur l'écran
 private Bitmap buffer; // pixel buffer 
 private SurfaceHolder holder;
 private GameLoop game; //pointeur vers la boucle de jeu
 
 public GameView(Context context, GameLoop game) {
  super(context);
  this.holder = getHolder();
  this.holder.addCallback(this);
  this.game = game;
 }
 
 /** Rafraichir l'écran*/
 @Override
 public void invalidate() {
  if (holder != null) {
   Canvas c = holder.lockCanvas();
   if (c != null) {
    c.drawBitmap(buffer, 0, 0, null);
    holder.unlockCanvasAndPost(c);
   }
  }
 }
 
 /**callback lorsque l'écran est touché
  * on stocke l'événement pour être ensuite traité dans la boucle de jeu*/
 @Override
 public boolean onTouchEvent(MotionEvent event) {
  this.game.lastEvent = event;
  return true;
 }

 /** callback lorsque la surface est chargée, 
  * donc démarrer la boucle de jeu*/
 public void surfaceChanged(SurfaceHolder holder, int format, 
   int width, int height) {
  this.width = width;
  this.height = height;
  this.buffer = Bitmap.createBitmap(width, height, Config.ARGB_8888);
  this.canvas = new Canvas(buffer);
  this.game.start();
 }

 public void surfaceCreated(SurfaceHolder holder) {
 }

 public void surfaceDestroyed(SurfaceHolder holder) {
 }
}


La classe GameLoop

Comme la boucle de jeu doit tourner indépendamment de la boucle d’affichage principale de l’activité, il faut lancer GameLoop comme un thread. Elle sera démarrée dès que la vue (GameView) sera prête.



package com.creativegames;

import com.creativegame.R;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Paint;
import android.graphics.drawable.BitmapDrawable;
import android.view.MotionEvent;

public class GameLoop extends Thread {

 /** Variable booléenne pour arrêter le jeu */
 public boolean running;

 /**
  * durée de la pause entre chaque frame 
         * du jeu pour frame per second FPS=10
  * on a sleepTime=100
  */
 private long sleepTime = 100;

 /** Ecran de jeu */
 public GameView screen;
 
 /** le dernier évenement enregistré sur l'écran*/
 public MotionEvent lastEvent; 

 /** Position de l'image que nous dessions sur l'écran */
 private int x, y;
 /** vitesse de l'image : nombre de pixel parcouru à chaque boucle de jeu */
 private int vx;
 /** image que nous allons dessiner */
 private Bitmap img;
 /** contexte de l'application */
 private Context context;
 /** activer ou désactiver l'animation*/
 private boolean animate;

 public void initGame(Context context) {
  this.context = context;
  img = ((BitmapDrawable) context.getResources().getDrawable(
    R.drawable.ic_launcher)).getBitmap();
  x = 0;
  y = 10;
  vx = 2; 
  animate = true;
  running = true;
  this.screen = new GameView(context, this);
 }

 /** la boucle de jeu */
 @Override
 public void run() {
  while (this.running) {
   this.processEvents();
   this.update();
   this.render();
   try {
    Thread.sleep(sleepTime);
   } catch (InterruptedException e) {
   }
  }
 }

 /** Dessiner les composant du jeu sur le buffer de l'écran*/
 public void render() {
  Paint paint = new Paint();
  paint.setColor(0xFF000000);
                //effacer l'écran avec la couleur noire
  this.screen.canvas.drawPaint(paint);
  this.screen.canvas.drawBitmap(img, x, y, null);
  this.screen.invalidate();
 }

 /** Mise à jour des composants du jeu
  *  Ici nous déplaçon le personnage avec la vitesse vx
  *  S'il sort de l'écran, on le fait changer de direction
  *  */
 public void update() {
  if(this.animate==false) return;
  int oldX = x;
  x = x + vx;
  if (x < 0 || x > screen.width - img.getWidth()) {
   x = oldX;
   vx = -vx;
  }
 }
 
 /** Ici on va faire en sorte que lorsqu'on clique sur l'écran,
  * L'animation s'arrête/redémarre
  * */
 public void processEvents() {
  if (lastEvent != null && 
                   lastEvent.getAction() == MotionEvent.ACTION_DOWN) {
   this.animate = ! this.animate;   
  }
  lastEvent = null;
 }
}


Le programme principal

Dans le point d’entrée de l’application qui est l’activité, il nous reste à instancier un objet GameLoop et affecter sa gameView à l’activité.

N’oubliez pas d’arrêter proprement la boucle de jeu lorsque l’application est fermée (onDestroy()).


package com.creativegames;

import android.app.Activity;
import android.os.Bundle;

public class Main extends Activity {
 
 private GameLoop game;
 
 /** A la création de l'activité
  * 1. on initialise le jeu et affecter la vue à l'activité
  * */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        game = new GameLoop();
        game.initGame(this);       
        setContentView(game.screen);
    }
    
    /** Lorsque l'application s'arrête, 
   il faut arrêter proprement la boucle de jeu*/
    @Override
    protected void onDestroy() {
     game.running = false;
     super.onDestroy();
    }
}
Voici me résultat de l'exécution du code: une image qui se déplace en va et vient dans l'écran, cadencé par le sleepTime. Au clic, l'animation s'arrête/redémarre.
Faiblesses de cette méthode

La fait de fixer le sleepTime suppose que la frame du jeu s’exécute pendant 0 ms. Ce qui n’est pratiquement  pas le cas. En effet si nous ajoutons beaucoup de traitements dans GameLoop.update(), le FPS va varier et notre jeu deviendra moins performant. La solution consiste donc à  ajuster le sleepTime à chaque frame.

Proposition de solution.


@Override
 public void run() {
  long startTime;
  long elapsedTime; // durée de (update()+render())
  long sleepCorrected; // sleeptime corrigé
  while (this.running) {
   startTime = System.currentTimeMillis();
   this.processEvents();
   this.update();
   this.render();
   elapsedTime = System.currentTimeMillis() - startTime;
   sleepCorrected = sleepTime - elapsedTime;
   // si jamais sleepCorrected<0 alors faire une pause de 1 ms
   if (sleepCorrected < 0) {
    sleepCorrected = 1;
   }
   try {
    Thread.sleep(sleepCorrected > 0 ? sleepCorrected : 1);
   } catch (InterruptedException e) {
   }
   // calculer le FSP
   fps = (int) (1000/(System.currentTimeMillis() - startTime));
  }
 }



Si vous avez des remarques ou erreurs à corriger ne manquez pas de m’informer via un commentaire.



Droid contamination
17 janv. 2012
Il s'agit de mon premier jeu Android. Le but est d'accumuler 40 points en tuant les zombies qui contaminent la ville. Aussi vous devez protéger les personnes non contaminées car en perdant une, vous perdez un point et ainsi en arrivant à 0, vous perdez la partie.  Petite indication: les zombies ont des cornes tandis que les personnes normales ont des ailes.

Fonctionalités
  • gestion de collision
  • gestion des sprites
  • gestion des effets audio

Développement
J'ai essayé de rendre le code source suffisamment modulaire en respectant l'architecture de base d'un jeu.
Une brève description des classes:
  • Sprite : gère l'affichage et le mouvement d'un acteur
  • TempSprite : gère une image temporaire qui affiche la mort d'un acteur
  • GameView: vue où est affichée le terrain de jeu avec les acteurs et le score
  • Game : classe principale qui effectue les 3 fonctions de base d'un jeu (traitement des événements d'entrée, mis à jour, affichage)
  • GameLoader : class qui gère la boucle de jeu et fixe le FPS
Outils
Android SDK 1.5
Edition des sprites: http://www.famitsu.com/freegame/tool/chibi/index2.html
Edition des effets sonores : Video converter premier

Téléchargements


Safe driver
16 janv. 2012
Il s'agit d'un utilitaire nous aidant à conduite plus prudemment.
Fonctionnalités: 
- avtertir un excès de vitesse
- lire mes SMS


Paramétrages
Vous pouvez modifier
- la langue (français - anglais)
- le nom d'utilisateur
- la vitesse maximale

Plateforme android 2.3


Téléchargements
Escape from OpenGL
03 déc. 2011
En voici un jeu de labyrinthe 3D bien avec un code bien documenté. L'objectif comme le nom du jeu l'indique c'est de s'échapper du labyrinthe pendant un temps limité à l'aide d'une vue radar. La sortie du labyrinthe est indiquée par un point vert sur la carte.
Techniquement les librairies utilisées sont OpenGL/Glut pour le moteur 3D, Irrklang pour le moteur audio. Les modèles 3D ont été créés avec l'outil Google Sketchup.

Téléchargements
Importer un modèle 3D avec GLM
12 juin 2011
Dans le développement 3D on se doit d’avoir un moyen simple pour créer des modèles. Actuellement l’application Google Sketchup est une solution gratuite vous permettant de créer rapidement des modèles 3D. Mais il est aussi important de pouvoir charger votre modèle dans un programme OpenGL sans se préoccuper de la forme de chaque objet et des caractéristiques matérielles.
J’ai passé des jours et des nuits à Googler sur Internet pour des éclaircissements sur l’utilisation de GLM mais rien ne répondait complètement à tous les problèmes de compilation.
Dans ce tutoriel, je vais vous montrer la démarche à suivre pour charger votre modèle créé sur Sketchup dans OpenGL en utilisant VC++ Visual Studio 2010.

GLM est une bibliothèque qui a été fourni dans le dossier des exemples de la distribution source de GLUT. Fondamentalement, il lit un modèle OBJ et sait comment le dessiner sur l'écran exactement comme elle est vue dans 3D Studio Max, ou Sketchup. Il est actuellement à la version 0.3.1.

Pour pouvoir naviguer dans le modèle, j’ai ajouté une structure camera qui va paramétrer la fonction glLookAt à chaque mouvement de la souris.

Ainsi nous manipulons la position de la caméra avec les touches Z, S, Q, D puis sa direction avec le mouvement de la souris tout en gardant le curseur au centre de la fenêtre.

Utilité d'un moteur de jeu
20 févr. 2011
Pour être efficace en développement de jeu, on doit se concentrer sur un aspect à la fois. D’où la naissance de divers moteurs de jeux qui encapsulent plusieurs traitement et laisse le développeur se concentrer uniquement sur la logique du jeu ou sur l’interface graphique. 

Les moteurs de jeu les plus connus sont Ogre, Irrlicht, Panda3D, Blender, Cafu engine, LWJGL, JMonkeyEngine, Crystal Space. Mais la plupart ne sont que des moteurs graphiques.

Description d'un moteur de jeu 
Un moteur de jeu est un ensemble de composants logiciels qui effectuent des calculs de géométrie et de physique utilisés dans les jeux vidéo. L'ensemble forme un simulateur en temps réel souple qui reproduit les caractéristiques des mondes imaginaires dans lesquels se déroulent les jeux. Le but visé par un moteur de jeu est de permettre à une équipe de développement de se concentrer sur le contenu et le déroulement du jeu plutôt que la résolution de problèmes informatiques.
Le moteur de jeu produit donc les technologies bas niveau pour 
-        L’interface graphique
-        Le moteur physique
-        L’audio
-        Le Scripting
-        Les animations
-        L’intelligence artificielle
-        Le réseau
Le moteur de jeu simplifie la procédure de développement et doit être adapté à plusieurs plateformes.

Pourquoi utiliser un moteur de jeu ?
L'utilisation d'un moteur peut être particulièrement utile si par exemple vous désirez développer vous-même certains aspects de votre jeu, mais ne souhaitez pas galérer dans les domaines que vous ne maîtrisez pas.
-        Moins de temps de développement
-        Moins de test de débogage
-        Plusieurs fonctionnalités directement disponibles
-        Concentration sur le design du jeu
Pourquoi ne pas utiliser un moteur de jeu ?
-        Aucun contrôle de l’implémentation des fonctionnalités
-        Addition difficile de fonctionnalités qui ne sont pas personnalisables
-        Dépendance d’autres librairies


L'architecture
Finalement l’architecture d’un jeu contiendra de plusieurs modules plus ou moins indépendants. L’objectif étant de rendre possibles l’exécution des différents modules en parallèle sans que cela n’entraine des effets de bords dans les autres modules.



Jeux de dames 2
12 févr. 2011
Voici un jeu de dames créé avec la bibliothèque Swing en Java.

L'algorithme utilisée pour la stratégie est bien évidemment Mini-max améliorée avec Apha-bêta.
L'intérête du jeu résite dans sa capacité à prévoir jusqu'au huits prochains coups de l'adversaire et qui devient par la suite la raison d'avoir sept niveaux de difficultés.
En termes de rapidité la fonction d'évaluation a été intégrée dans la classe Coeur afin de ne pas réévaluer à chaque situation à partir de zéro.
Téléchargements
Ce qu'il faut pour développer des jeux vidéos
17 déc. 2010
Voilà, je m'intéresse au plus haut point au développement des jeux vidéos. Actuellment je suis développeur de logiciels Web et BD.

Le langage C++

J'avais commencé à developper des jeux en 2006 avec le langage Pascal.
Après je me suis orienté vers le langage Visual Bascic qui est un outil impressionnant mais souvent consomme plus de ressources qu'il faut.
Finalement j'ai développé des jeux avec le langage C et C++ ceux ci ont apporté un nouveau souffle avec l'utilisation de la bibliothèque SDL.
C++ est excelent, rien à dire si ce n'est que c'est un des langages les plus compliqués et que le débuguage est parfois difficile. C'est le plus rapide des langages avec lesquels j'ai eu à faire.
Java est un langage orienté objet pur et très rigoureux avec des éditeurs comme Eclipse. Mais la machine virtuelle est très lente à se charger. Il est nettement plus lente que C.
La bibliothèque SDL peut être utilisée sous Java avec la technique de Binding.

L'algorithmique

En fait, pour développer des jeux il faut de grosses bases en algorithmique mais aussi en Mathématiques car l'intérêt d'un jeu vidéo c'est que l'on réinvente parfois la roue.
C'est pas comme une application de gestion où l'on crée des forms avec zones de texte et pushbuttons et un SGBD derrière comme Oracle ou SQL-Server et que l'on obtienne la somme des factures par SQL (SELECT SUM (MONTANT) from Clients).
Non un jeu vidéo c'est plus que cela: il faut implémenter les règles du jeu manuellement, un éditeur de niveau et modeleur est parfois nécessaire.

Mario Sokoban
10 déc. 2010

La librairie SDL a été développée initialement sur le langage C++. Mais elle a aussi été adapté par certains programmeurs de Java afin de faire ce qu'on appelle le Binding. Ce jeu est un premier essai de la librairie SDL C++ pour le Mario sokoban.
Téléchargements
Gondor III
31 oct. 2010
Un duel de cartes à deux joueurs réalisé avec Java et la librairie SDL.

Le jeu en elle-même a quelque chose de mystérieux. en effet l’environnement du jeu provoque assez la peur. Il a été joué au fil des années avec des cartes dessinées à la main. En juin 2008, j’ai élaboré la première version du jeu fabriqué avec Visual Basic 5. Les images étaient totalement prises du jeu Warcraft III. La dernière version sur VB est Gondor 3.4. J’avais trouvé comment insérer des gifs animés dans mon programme mais cela était fragile et ne suffisait pas car je devais capturer plusieurs images. Elles prenaient beaucoup d’espace et donc lourdes à manipuler. Le plus grand problème c’est que je ne pouvais pas synchroniser les images des personnages avec leurs voix !
Aujourd’hui, Gondor est un super jeu vidéo 2D avec des animations synchronisées et jouable en réseau grâce à la librairie SDLJava.

Téléchargements
Echecs
17 oct. 2009
Une première utilisation de SDL C++
Le jeu d'échec est sans doute l'un des grands classiques jeux de stratégie. Cette dernière s'articuler autour de l'algorithme MiniMax.
Téléchargements
Snake
21 mai 2008
Un jeu que l'on retrouve dans les premiers téléphones portables, implémenter ici avec VB juste pour apprécier le graphisme de Visual Basic.
Téléchargements
SuperWar Evolution
14 avr. 2008
Un jeu de Tank réalisé avec les animation de Mario Bros sur Visual Basic
Téléchargements
SPWar
30 janv. 2008
J'ai commencé à développer un jeu  de Tank avec Turbo C++. Il comporte un certain nombre de niveaux. L'objectif est d'éliminer les énemis et d'obtenir la clé qui ouvre une porte permettant de passer au niveau suivant.
Téléchargements
Labyrinthe
24 déc. 2007
Un jeu de labyrinthe développé avec Turbo C++
Téléchargements
Dames
24 nov. 2007
Un jeu de dames réalisé avec Turbo C++
Téléchargements
SuperWar Origins
20 déc. 2006
Un jeu de Tank sur Visual Basic 6
Téléchargements
IntelArt
12 avr. 2006
Ceci mon premier jeu d'échecs réalisé sur Turbo Pascal, intégralement en mode texte.

Téléchargements