énoncé - imagine

Introduction à la Programmation
G1: monasse(at) imagine.enpc.fr
G2: nicolas.audebert(at) onera.fr
G3: alexandre.boulch(at) onera.fr
G4: antoine.recanati(at) inria.fr
G5: bourkia(at) imagine.enpc.fr
G6: fadhela.kerdjoudj(at) u-pem.fr
TP #8 Figure 1 Jeu de Tron.
1
Tron
Dans ce TP, nous allons programmer le jeu TRON. Il s'agit d'un jeu à 2 joueurs, dans lequel chaque
joueur pilote un mobile qui se déplace à vitesse constante et laisse derrière lui une trace infranchissable. Le
premier joueur qui percute sa propre trace ou celle de son adversaire a perdu. Ce TP est assez ambitieux
et s'approche d'un mini-projet. Il nous occupera plusieurs séances.
1.1
Serpent
Nous allons procéder en deux temps. D'abord programmer un jeu de Serpent à un joueur. Le programme serpent.exe vous donne une idée du résultat recherché. Dans ce jeu, le joueur pilote un Serpent
qui s'allonge petit à petit (d'un élément tous les x tours, avec la convention que la longueur totale est
bornée à nmax éléments). Il s'agit de ne pas se rentrer dedans ni de percuter les murs.
La solution de départ comporte deux chiers, utils.h et utils.cpp, qui contiennent une structure
point (qu'il faudra éventuellement étoer de méthodes utiles) et une fonction destinée à récupérer les
touches clavier pour l'interaction avec les joueurs.
Il s'agit ici de concevoir un objet Serpent doté des méthodes adéquates, plus une fonction jeu_1p
exploitant les capacités du Serpent pour reproduire le comportement désiré. On pourra dans un premier
temps ne pas gérer les collisions (avec le bord et avec lui-même), et ne les rajouter que dans un second
temps. Votre travail se décompose en 6 étapes :
1. (sur papier) Dénir l'interface de la classe Serpent (c'est-à-dire lister toutes les fonctionnalités
nécessaires).
2. (sur papier) Rééchir à l'implémentation de la classe Serpent : comment stocker les données ?
comment programmer les diérentes méthodes ? (lire en préliminaire les remarques du paragraphe
suivant).
3. Dans un chier serpent.h, écrire la déclaration de votre classe Serpent : ses membres, ses méthodes,
ce qui est public, ce qui ne l'est pas.
4. Soumettre le résultat de vos réexions à votre enseignant pour valider avec lui les choix retenus.
1
5. Implémenter la classe Serpent (c'est-à-dire programmer les méthodes que vous avez déclarées).
6. Programmer la fonction jeu_1p utilisant un Serpent.
Remarque : Dans le chier utils.h sont dénis :
1. 4 entiers gauche, bas, haut, droite de telle manière que :
(a) la fonction x → (x + 1)%4 transforme gauche en bas, bas en droite, droite en haut et haut en
gauche ; cette fonction correspond donc à un quart de tour dans le sens trigonométrique.
(b) la fonction x → (x − 1)%4 transforme gauche en haut, haut en droite, droite en bas et bas
en gauche ; cette fonction correspond donc à un quart de tour dans le sens des aiguilles d'une
montre.
2. un tableau de 4 points dir de telle manière que, moyennant la dénition d'une fonction permettant
de faire la somme de deux points, la fonction p → p + dir[d] renvoie :
(a) pour d=gauche le point correspondant au décalage de p de 1 vers la gauche.
(b) pour d=haut le point correspondant au décalage de p de 1 vers la haut.
(c) pour d=droite le point correspondant au décalage de p de 1 vers la droite.
(d) pour d=bas le point correspondant au décalage de p de 1 vers la bas.
1.2
Tron
A partir du jeu de Serpent réalisé précédemment, nous allons facilement pouvoir implémenter le jeu
Tron. Le programme tron.exe vous donne une idée du résultat recherché. Le principe de ce jeu est que
chaque joueur pilote une moto qui laisse derrière elle une trace infranchissable. Le but est de survivre
plus longtemps que le joueur adverse.
1. Passage à deux joueurs.
A partir de la fonction jeu_1p, créer une fonction jeu_2p implémentant un jeu de serpent à 2
joueurs. On utilisera pour ce joueur les touches S, X, D et F. La fonction Clavier() renverra donc
les entiers int ( 'S'), int ( 'X'), int ( 'D') et int ( 'F'). Remarque : on ne gèrera qu'une touche par
tour, soit un seul appel à la fonction Clavier() par tour.
2. Ultimes réglages
(a) Gérer la collision entre les deux serpents.
(b) Le principe de Tron est que la trace des mobiles reste. Pour implémenter cela, il sut d'allonger
nos serpents à chaque tour.
1.3
Graphismes
Petit bonus pour les rapides : nous allons voir comment gérer des graphismes un peu plus sympas que
les rectangles uniformes que nous avons utilisés jusqu'ici. L'objectif est de remplacer le carré de tête par
une image que l'on déplace à chaque tour.
Nous allons utiliser pour cela les NativeBitmap d'Imagine++, qui sont des images à achage rapide.
Pour charger une image dans une NativeBitmap on procède ainsi :
// E n t i e r s p a s s é s par r é f é r e n c e l o r s du chargement de l ' image pour
// qu ' y s o i e n t s t o c k é e s l a l a r g e u r e t l a hauteur de l ' image
i n t w, h ;
// Chargement de l ' image
byte ∗ rgb ;
l o a d C o l o r I m a g e ( " n o m _ f i c h i e r . bmp" , rgb , w, h ) ;
// D é c l a r a t i o n de l a NativeBitmap
NativeBitmap ma_native_bitmap (w, h ) ;
// On p l a c e l ' image dans l a NativeBitmap
ma_native_bitmap . s e t C o l o r I m a g e ( 0 , 0 , rgb , w, h ) ;
L'achage d'une NativeBitmap à l'écran se fait alors avec la méthode :
v o i d putNativeBitmap ( i n t x , i n t y , NativeBitmap nb )
1. Remplacer dans le serpent l'achage de la tête par l'achage d'une image. On pourra utiliser les
images moto_blue.bmp et moto_red.bmp fournies.
2. Utiliser l'image explosion.bmp lors de la mort d'un des joueurs.
2