Discussion :

[LittleWhite]

Bonjour à tous,

J'ai l'intention, pendant ce weekend de faire une reprise d'un jeu auquel je jouais sur Atari ST : Atomix.

Petite vidéo :

(Je vous conseille d'aller directement à la quatrième minute, où l'on peut voir le jeu).

Pour cela, je vais utiliser la dernière version de ma surcouche de bibliothèque 2D : NEngine

J'ai réalisé récemment un CMakeList (fichier de description de projet pour CMake) pour directement récupérer le code sur le SVN de NEngine et compiler la bibliothèque (je l'avais fait pour OpenAWars).

Donc, je vais partir sur ce principe pour avec NEngine puis faire mon jeu from scratch.

Bon weekend

[LittleWhite]

Pour intégrer NEngine dans son projet, c'est plutôt simple.

cmake_minimum_required(VERSION 2.8)

include(ExternalProject)
ExternalProject_Add(
NEngine_lib
SVN_REPOSITORY https://openawars.googlecode.com/svn/branches/NEngine
CMAKE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_BINARY_DIR}/
INSTALL_DIR ./
)

project(Atomix)

À la fin du fichier CMakeLists.txt, il est nécessaire d'ajouter :

add_dependencies(Atomix NEngine_lib)

sinon, CMake essayera de compiler Atomix avant NEngine (ce qui est génant, car les fichier include et lib ne sont pas encore présent pour Atomix).
(Note : j'ai perdu une heure, ne connaissant pas ce problème).

Voilà, j'ai une belle fenêtre noire qui s'ouvre et se ferme \ o /

[LittleWhite]

Pour l'occasion, j'ai sorti mon émulateur AtariST (hatari) pour relancer Atomix et ainsi analyser les éléments qui composent ce jeu afin de programmer.

J'adore la musique de l'écran titre et je regrette qu'il n'y ai pas de musique dans le jeu.

On passe rapidement l'écran titre car, il n'est constitué que d'un scroller (en haut) et d'une image fixe. De plus, c'est un élément que je programmerai surement à la fin (pas très important, le jeu prend bien plus de temps à faire).

Nous arrivons sur l'écran principale dans le jeu.

La partie interface utilisateur se situe à gauche. On y voit le nom du joeuur en cours (bon, il n'y avait pas le choix), le score, le niveau actuel, le temps (car chaque niveau se fini dans un temps imparti) et la molécule à reproduire dans le tableau.

Le but du jeu est de faire glisser les éléments (les atomes) afin de reconstituer la molécule demandée. Pourquoi je dis "glisser" ? Simplement, car une fois un atome sélectionné, vous pouvez le faire aller dans la direction voulue, mais il ne s'arrêtera que lorsqu'il touchera le mur au bout de sa course. Vous ne pouvez bien sur, pas changer sa direction pendant son glissement. Et c'est là que le jeu devient un puzzle.
(Notez que ce type de jeu est souvent reproduit en tant que mini-jeu (simple et court), notamment dans Pokemon ou Zelda).

Une fois la molécule reconstituée, vous passez au niveau suivant et ainsi de suite. Si le temps est écoulé, vous perdez.

Simple

Il existe un écran de pause, mais il cache l'écran de jeu (pour empêcher de réfléchir sans le décompte du temps ? )

Pour les points, cela semble environ 500 points par atome et deux fois le temps. Mais c'est vraiment du détail.

La difficulté croit au fur et à mesure des niveau.

Décomposons maintenant le jeu et ces éléments.

Nous avons un fond d'écran (je ne sais plus s'il change dans les prochains niveaux). Le joueur joue dans une surface rectangulaire qui d'après cette version : (http://ledger.sdf.org/atomix/) possède une taille limitée et ne nécessite pas de défilement (scrolling). Cela était assez important à déterminer car le code aurait un peu plus complexe avec un défilement en plus.
Nous avons des murs, des atomes et des espaces vide.
Un curseur est contrôlé par le joueur et permet de sélectionner l'atome à déplacer. Une fois l'atome sélectionnée, les touches fléchées permettent de déplacer cet atome.

Donc, nous avons :

• des niveaux (une façon de stocker les plateaux) ;
• Un plateau (Board) ;
• des tuiles (vide ou pleine) ;
• des atomes (de différents types avec différentes connexions possibles) ;
• un curseur (avec deux états). Lorsqu'il est en mode sélection de cellule, il est ovale et animé.

Actuellement, je me demande encore comment implémenter les différents types d'atomes et leurs connexions. Je vais donc d'abord faire en sorte de récupérer des sprites et d'afficher un plateau de tuiles. Ensuite, je verrai pour le chargement de ce plateau à partir d'un fichier.

J'ai du pain sur la planche

[LittleWhite]

Après une assez longue section de codage de l'architecture du programme et de mise en place des bases, j'arrive à charger un niveau correctement (du moins, pour la partie tuiles.

Voilà ce que cela donne :



Maintenant que l'architecture se stabilise, les évolutions seront de plus en plus visuelles et plus rapides à mettre en place.

[LittleWhite]

Voici une nouvelle version avec l'arrivée des atomes.
Cela signifie que j'ai extraie les sprites dont j'avais besoin, mais aussi, que j'ai trouvé une idée pour coder le type des atomes et surtout les connexions avec les autres (une chose que je ne savais pas faire hier soir).

Il y a quelques astuces. Chaque atome est identifié avec deux variables : le type (oxygène, hydrogène, ...) et sa connexion.
Le type est évidemment un int, rien de plus classique. Par contre, la connexion est encodé dans un int, certes, mais ce sont les bits à l'intérieur de celui-ci que je vérifie. En effet, mon sprite est le suivant :

et un atome peut avoir plusieurs connexions à la fois. Du coup, suivant les bits à un dans mon identifiant de connexion, j'affiche les différentes connexions présent dans ma feuille de sprite.

Voici le code d'affiche :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
for (unsigned int i = 0 ; i < 12 ; i++ )
{
    int connectionID = powl(2,i);
    if ( (connectionID & m_connectionType) == connectionID )
    {
        Rect connectionSpriteSource(IVec2(SPRITE_WIDTH*i,0),
                                   USize2(SPRITE_WIDTH,SPRITE_HEIGHT));
 
        bResult &= renderer.drawSurface(screenPosition,m_pConnectionSprite,connectionSpriteSource);
    }
}

Le résultat est le suivant :



Je charge le niveau à partir d'un fichier. Le format est le suivant (tout n'est pas encore implémenté) :

Nom du fichier à utiliser pour le fond
Nom du thème des tuiles à utiliser
Largeur du niveau
Hauteur du niveau
Tableau des tuiles du niveau
Nombre d'atomes
Liste des atomes suivant le format : ID_Atom ID_Connexion PositionX PositionY
Nom de la molécule
Largeur de la molécule
Hauteur de la molécule
Tableau des ID de la molécules. Les ID de la molécules sont les ID d'un atom (donc son type et sa connexion)

Maintenant, je vais gérer le curseur

[LittleWhite]

Le curseur est maintenant en place. Il peut être déplacé et on peut aussi déplacer des atomes. Toutefois, le mouvement n'est pas fluide, il est brut. J'espère trouver comment faire un mouvement brut plus tard, mais autant que j'avance sur les parties les plus importantes du jeu.



L'implémentation du curseur a entrainé l'utilisation de méthode "update" pour mettre à jour l'état du jeu qui était jusqu'à présent inutilisé. Cela a deux reprises :

• pour l'animation du curseur en mode sélection (il bouge, même si vous ne pouvez pas le constater avec la capture) ;
• la récupération des évènements utilisateurs ;

À part cela, il n'y rien de bien compliqué dans la gestion du curseur.

Maintenant, je vais m'attaquer au schéma et à la condition de victoire (vu que l'on peut enfin gagner en déplaçant les atomes ).

[LittleWhite]

Voilà, la condition de victoire est en place. Ce qui implique que j'ai mis à jour mon lecteur de niveau pour lire la partie du schéma du format de niveau, que j'ai récupéré les sprites (plus facile que pour les atomes) et que j'ai fait la condition de victoire.

Pour le schéma (en bas à gauche), il est affiché exactement de la même façon que pour les atomes (avec une partie atome et une partie connexion).

Pour la condition de victoire, je n'ai pas cherché très loin. C'est un parcours brut de la grille de jeu et pour chaque case j'essaie de voir si le schéma correspond aux atomes sur la grille (un peu comme si on placer une feuille de calque au dessus d'un schéma pour voir si cela correspond).

Les conditions pour invalider la correspondance sont :

• si on sort des dimensions du jeu (si la feuille de calque sort de la feuille originale ) ;
• si un atome est sur une case vide du schéma ;
• si un atome ne correspond pas au schéma (test du type de l'atome et de ses connexions).

Ce qui nous donne :

[LittleWhite]

J'avoue, les changements ne sont pas nombreux.

En fait, j'ai un peu réachitecturé mon code, car la classe Game (qui gère le jeu) faisait trop de chose à mon gout et était devenue un peu trop imposante. Du coup, j'ai délocalisé le chargement des sprites dans une autre classe (qui me permettra de charger facilement des ensemble de tuiles par niveau) et j'ai rajouté une classe Level afin de gérer un jeu avec plusieurs niveaux.

Du coup, lorsque l'on gagne, ça passe au niveau suivant :

[LittleWhite]

Pour finir cette journée, trouvant le jeu actuellement peu agréable à voir et à jouer, j'ai décidé d'intégrer les animations fluides, que précédemment, je n'avais pas trop d'idée pour les implémenter.

L'idée, c'est que chaque atome est le curseur possèdent une position (position sur la grille) et une position affinée. La position affinée correspond à la position réelle de l'objet sur l'écran.

Le rapport entre les deux est généralement :

positionAffinée = TAILLE_SPRITE * positionGrille;

Lorsqu'un objet doit se déplacer, il suffit de lui donner une destination, de changer son état pour le mettre "en mouvement" et la méthode de mis à jour mettra à jour la position affinée progressivement.
Une fois que la position affinée correspond à la position de destination, nous pouvons remettre à jour la position sur la grille afin que le reste du jeu prenne en compte le déplacement "logique" de l'objet. De plus, on enlèvera l'état en mouvement.

Il faut savoir que cet état "en mouvement" est aussi un indicateur pour le reste du jeu, car le joueur ne peut rien faire tant que le curseur se déplace.

[LittleWhite]

Maintenant que le gameplay est globalement intégré, je me suis penché sur l'interface et ce qui fait que le jeu n'est pas vide :



Les informations sur le fond et les tuiles sont maintenant chargés du fichier de niveau. J'ai rajouté le cadre du schéma et j'ai déplacé/recentré les différents éléments du jeu.

Il me reste à ajouter les écritures dans l'interface et la gestion du temps ainsi que du score. Pour cela, je vais reprendre ce que j'avais fait dans OpenAWars, notamment la classe Font.

[LittleWhite]

Voilà, l'interface est complète. Elle se met à jour et on peut même perdre .
Il me reste à intégrer d'autres niveau, faire des transitions (je me demande comment faire des transitions simples pour que ce soit propre à voir, sans pour autant trop casser mon code).

[Invité]

Bonsoir,
Bravo ! J'ai vraiment hâte de pouvoir tester ce jeu, et en attendant je te souhaite un bonne continuation .

Sorpia.

[LittleWhite]

Voilà, on y arrive. J'ai rajouté la musique.

J'ai un problème avec les effets sonores, qui ne veulent malheureuement pas se rejouer.
J'ai vu aussi un crash à la complétion d'un niveau, mais il n'est apparu qu'une unique fois et donc, je n'en connais pas l'origine (ça fait tache ).

Vous pouvez télécharger ici : http://alexandre-laurent.developpez....eux/Atomix.zip

Pour avoir le makefile (ou autre) (il faut SVN) :

cmake -G "Unix Makefiles"

Sous Windows, vous pouvez générer des projets Visual Studio ou Code::Blocks avec CMake :

cmake -G "CodeBlocks - MinGW Makefiles"

(Pour connaitre la liste tapez simplement cmake).

Ensuite, il suffit de compiler.

Le dossier data doit être avec l'exécutable.

À cause de la musique, j'ai fait une version plus légère : http://alexandre-laurent.developpez....omix_small.zip

La touche de jeu (pour sélectionner les atomes et passer l'écran titre est : 'A' ou 'Q' sur un clavier AZERTY).

Je vais rajouter les 14 niveaux que je connais du jeu de base, dans la prochaine heure :red:

Note : Le projet n'ayant été testé que sous Linux, je ne garantit rien. Je génèrerai un projet Windows (binaire) dans les prochains jours.

[LittleWhite]

Maintenant, le jeu possède sept niveaux.
J'apporterai les binaires Windows prochainement ainsi que les autres niveaux.

Je noterai qu'il manque le son (à cause du bogue dans le NEngine) et un éditeur.
Un gros nettoyage du code s'impose aussi et la documentation ().

Voici les liens (sept niveaux):

Version allegée : http://alexandre-laurent.developpez....omix_small.zip
Version avec musique : http://alexandre-laurent.developpez....eux/Atomix.zip

[yetimothee]

Salut,
je ne parviens pas à compiler (la version non-allégée) :

Linking CXX executable Atomix
/home/tim/Bureau/Atomix/./lib/libNEngine.so: undefined reference to `IMG_Init'
/home/tim/Bureau/Atomix/./lib/libNEngine.so: undefined reference to `IMG_Quit'
/home/tim/Bureau/Atomix/./lib/libNEngine.so: undefined reference to `IMG_Load'

J'ai peut-être fait un truc qui fallait pas ?

cmake -G "Unix Makefiles" (qui fonctionne)
make (qui donne l'erreur du dessus).

[LittleWhite]

Il faut installer SDL_Image-dev
Il est vrai que le cmake n'affiche pas de message pour ça, j'ai une modification pour améliorer la chose, en local

[yetimothee]

Ah oui maintenant ça compile (vraiment bien comme système avec Cmake, je crois que je vais apprendre ^^), mais ça me semble faire une boucle infinie juste après l'initialisation des inputs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
tim@Aristote:~/Bureau/Atomix$ ls
Atomix          CMakeFiles           CMakeLists.txt  include  Makefile            src
CMakeCache.txt  cmake_install.cmake  data            lib      NEngine_lib-prefix
tim@Aristote:~/Bureau/Atomix$ ./Atomix
Input Manager inited
^C

Ctrl+C ne permet pas de quitter, je suis obligé de faire un kill.

[LittleWhite]

Il y a maintenant 14 niveaux

Ceux qui auraient des freeze au démarrage (avec la ligne

Input Manager inited

) lancent le programme de la façon suivante :

SDL_AUDIODRIVER=esd ./Atomix

En effet, la SDL freeze lors de l'utilisation de PulseAudio. Merci à yetimothee pour ce retour.

Sinon, voici la nouvelle version :

Version allégée : http://alexandre-laurent.developpez....omix_small.zip
Version complète : http://alexandre-laurent.developpez....eux/Atomix.zip

EDIT : À l'aide de valgrind, le crash qui pouvait quelque fois survenir a été corrigé.

[LittleWhite]

Enfin ! Après quelques déboires avec CMake, j'ai réussi à compiler une version pour Windows (en utilisant MinGW).

Vous pouvez trouver la version binaire Windows light :
http://alexandre-laurent.developpez....ht_windows.zip
Et la version avec la musique :
http://alexandre-laurent.developpez....ix_windows.zip

Bon jeu