II - Introduction a

Java Arcade 2D Engine
Documentation II
Introduction à Jade
Tous droits réservés ( 2003 ) – A.PAUTROT
Table des matières
Affichage et animation............................................................................................................................3
Affichage.................................................................................................................................3
Animation................................................................................................................................4
Règles du jeu, comportements des sprites et interactivité......................................................................5
Règles de jeu...........................................................................................................................5
Comportements.......................................................................................................................5
Interactivité.............................................................................................................................5
Boucle de jeu et boucle principale..........................................................................................5
Chargement de jeu.................................................................................................................................6
Affichage et animation
Affichage
Afin d’expliquer le fonctionnement de l’affichage dans Jade, prenons l’exemple de l’écran de
jeu suivant:
Fond d’écran
Score
Elément de décor
Bonus
Piège
Personnage
Echelle
Plate-forme
Sol
Dans cet écran de jeu, l’affichage se constitue en plusieurs étapes :
l’affichage d’un fond d’écran (le fond semi-uni mauve)
l’affichage d’un décor (le sol, les murs, les plates-formes, l’échelle)
l’affichage des sprites du jeu (les bornes clignotantes rouges/vertes, les bonus, les
pièges et les personnages)
l’affichage du score.
L’ordre d’affichage est important et permet par exemple aux personnages d’être dessinés
devant les éléments du décor.
L’affichage est décomposé dans cet exemple en trois parties différentes : un fond d’écran
mauve, un décor et un layer de sprites. Un layer de sprites est une surface sur laquelle les
sprites du jeu s’affichent.
Notez que l’affichage d’un jeu ne repose pas sur une architecture figée et que Jade ne
s’occupe pas de faire cet affichage ; c’est au programmeur de faire l’affichage dont il a
besoin. Il est possible de créer n’importe quel type d’affichage en utilisant les composants
fournis par Jade. L’affichage se repose principalement sur deux composants : les décors de
fond et les layers de sprites. Vous pouvez combiner et utiliser autant de ces composants que
voulu pour faire votre affichage.
Le décor de fond de l’exemple ci-dessus est un décor de fond composite constitué de deux
fonds différents : un fond mauve (une image répétée horizontalement et verticalement sur tout
l’écran) et un décor affiché par-dessus, composé de morceaux d’images (appelé carte
d’images). Jade prévoit les fonctions et les outils permettant de créer ce genre de fond
d’écran. (voir le chapitre « Fonds d’écran » du document « Document III – Guide de
programmation » et la documentation des outils du SDK).
L’affichage des sprites est effectué par le layer de sprite. Le layer de sprite anime
graphiquement les sprites (il produit par exemple l’animation des personnages qui marchent)
et affiche ceux-ci. (voir le chapitre « Les layers de sprites » du document « Document III –
Guide de programmation »).
L’affichage du score est fait grâce à une police bitmap utilisée sur la surface graphique de
l’écran d’affichage (voir la section « Affichage utilisateur » du chapitre « L’affichage » du
document « Document III – Guide de programmation »).
Animation
L’animation du jeu est une boucle, exécutée à intervalle fixe. La boucle est appelée boucle de
jeu et est responsable d’appliquer les règles de jeu, de déplacer les sprites et de faire
l’affichage (voir le chapitre « Les scènes » du document « Document III – Guide de
programmation »).
Cette boucle est exécutée par le moteur d’animation. Celui-ci s’occupe de mesurer le temps
écoulé entre chaque appel pour synchroniser la vitesse d’exécution et s’occupe aussi de copier
le contenu de l’affichage du jeu dans un double buffer (voir la section « Double buffer » du
chapitre « L’affichage » du document « Document III – Guide de programmation »).
L’animation des sprites est la responsabilité du layer de sprite. Le layer s’occupe d’afficher les
sprites qu’il contient, mais aussi d’en faire l’animation. Dans notre exemple, c’est lui qui fait
marcher les personnages et clignoter les bornes rouges/vertes. Par contre il ne s’occupe pas du
déplacement des sprites, qui est à la charge du développeur (voir le chapitre « Les layers de
sprites » du document « Document III – Guide de programmation »).
Les animations de sprites sont des ressources que Jade permet de créer grâce à ses outils (voir
la documentation des outils du SDK).
Règles du jeu, comportements des sprites et interactivité
Règles de jeu
Les règles du jeu définissent la manière dont le jeu réagit face à tout événement. Ces règles
vont du calcul d’un score à la sortie du jeu lorsque le joueur a perdu toutes ses vies.
Comportements
Les comportements définissent la réaction des sprites. En général, on applique le même
comportement générique à tous les sprites d’une même famille. Ainsi, on peut faire marcher
tous les personnages à l’écran grâce au même comportement, faire rebondir toutes les balles
d’un casse-brique, etc. (voir la section « Enumération des sprites d’une famille » du chapitre
« Les familles » du document « Document III – Guide de programmation »).
Interactivité
L'interactivité est essentielle dans un jeu. Pour cela, un jeu dispose du clavier et de la souris.
Certains sprites du jeu répondent en fonction de l'utilisateur: en général, un seul sprite (un
personnage par exemple) répond aux commandes de l’utilisateur, d’autres sprites étant créés
selon les actions de l’utilisateur, comme par exemple des tirs (voir les chapitres « Le clavier »
et « La souris » du document « Document III – Guide de programmation »).
Boucle de jeu et boucle principale
Les règles du jeu, les comportements des sprites et l’interactivité sont situés dans une boucle
de jeu et sont exécutés avant chaque affichage de l’écran de jeu. Cette fonction est présente
pour chaque scène du jeu, dont c’est le rôle de la définir (voir le chapitre « Les scènes » du
document « Document III – Guide de programmation »).
Un jeu se compose d’une boucle principale qui s’occupe de l’agencement et du lancement des
scènes. C’est dans cette boucle que seront testé le nombre de vies restantes, le niveau à
charger, etc. afin de lancer les scènes appropriées. Chaque scène est une boucle imbriquée
dans la boucle principale, qui gère l’animation et l’interactivité d’un écran et interagit avec la
boucle principale en changeant par exemple le nombre de vies lorsque l’énergie du joueur
tombe à zéro et en stoppant la scène pour en sortir.
Chargement de jeu
Le chargement d’un jeu est un processus incontournable. Il est possible d’effectuer un
chargement très simple des jeux comme de faire un chargement plus complet mettant en scène
un pré-chargement des classes du jeu, l’affichage de pourcentage de progression et de divers
messages de chargement.
Jade fourni trois classes différentes permettant de contenir un jeu, trois modes de
fonctionnement différents : sous forme d’applet, sous forme d’application fenêtrée et sous
forme d’application plein écran.
Chacun de ces containeurs de jeu utilise un chargeur de jeu, afin de faire le chargement et le
lancement d’un jeu. Un seul chargeur de jeu doit être défini pour chaque jeu, quel que soit son
mode de fonctionnement, rendant possible son exécution sous les trois formes citées cidessus, sans aucun changement. Les containeurs pré-chargent toujours les classes du moteur
avant de donner la main au chargeur de jeu (voir le chapitre « Chargement et exécution » du
document « Document III – Guide de programmation »).
Jade fourni une interface graphique de chargement afin d’afficher les pourcentages et
messages de progression du chargement. Il est aussi possible de refaire sa propre interface de
chargement, afin de la personnaliser graphiquement (voir la section « Interface de
chargement » du chapitre « Chargement et exécution » du document « Document III – Guide
de programmation »).