Algorithmique et Programmation — Projets 2004

Algorithmique et Programmation
—
Projets 2004
—
G1: keriven(at)certis.enpc.fr
G3: gmellier(at)melix.org
G5: pierre(at)senellart.com
G2: juan(at)certis.enpc.fr
G4: pierre.maurel(at)ens.fr
G6: adde(at)certis.enpc.fr
F IG . 1 – Tetris 3D.
1 Tetris 3D
1. Modèle : Block Out (Fig. 1) :
– Page WEB : http://www.blockout.de/
– Programme : http://www.blockout.de/download/blockout.exe
2. A faire :
– Imiter le programme le mieux possible en mode "out of control".
3. A faire éventuellement :
– Gestion des scores.
4. Techniquement :
– Utiliser les instructions 3D de la WinLib dans une fenêtre à caméra fixe.
2 Retouche d’images
1. Modèle : si vous ne connaissez pas Photoshop, un clone gratuit : Gimp (Fig. 2) :
– Page WEB : http://www.gimp.org
– Progamme : http://gimp-win.sourceforge.net/stable.html
2. A faire au minimum :
– Une classe image couleur raisonnable.
– Deux types de fonctionnalités :
– Un algorithme appliqué automatiquement à toute l’image (négatif ou flou).
– Une retouche interactive de type pinceau.
3. A faire ensuite :
– D’autres algorithmes (netteté, déformations, contours, débruitage, etc.) : demandez à ceux de vos enseignants spécialistes d’images.
– D’autres types de retouches : clone par exemple (utile pour truquer des images)
1
F IG . 2 – Retouche d’images
– Une notion de sélection pour limiter l’effet de la retouche (rectangle par exemple).
4. A ne pas faire :
– Ne pas considérer le côté "vectoriel" de Gimp. Seul le côté "Bitmap" (i.e. pixels) nous intéresse.
– Ne pas gérer les calques.
5. Techniquement :
– Utiliser la WinLib.
– Ne pas faire de menus, etc. Utiliser le clavier. Ou mieux : dessiner des boutons très simples dans un
coin de la fenêtre.
– Ne pas tout afficher tout le temps.
3 Séquenceur
Le but de ce projet est de produire une version allégée d’un séquenceur MIDI.
1. A faire au minimum
Ce logiciel prendra en entrée un fichier MIDI (en gros, une partition) et devra pouvoir jouer ce fichier
en temps réel à partir d’échantillons (’samples’) fournis. Ce logiciel possédera également une interface
graphique.
– Le séquenceur devra être capable de charger un fichier midi en mémoire. Une fois ce fichier chargé, le
séquenceur devra être capable de lancer et d’arrêter la reproduction du morceau au travers de l’interface graphique.
– Le séquenceur comportera un nombre maximal de piste à déterminer. Pour chaque piste, l’interface
devra présenter un certain nombre de contrôles, notamment : le niveau de la piste, sa balance et sa
réverbération.
– Le séquenceur devra pouvoir reproduire n’importe quel fichier MIDI, quitte à ne pas jouer certaines
pistes ou à les jouer avec l’instrument le plus proche disponible dans le séquenceur.
– L’interface graphique sera programmée à l’aide de la Winlib.
– Il n’est pas demandé d’implémenter toutes les possibilités de la norme MIDI (Pitch Bend, Control
Change, Bank Select, par exemple ne seront pas implémentés).
2. Pour commencer
La production d’un tel logiciel requiert notamment deux étapes difficiles et fastidieuses pour un débutant. Il s’agit de :
– L’étape de lecture et d’interprétation du fichier MIDI.
– L’interfacage avec le système pour pouvoir effectuer une sortie sonore
Ces deux étapes ont donc été programmées et une démonstration en est faite dans la solution de départ.
Finalement restent à faire pour ce projet :
– Charger les fichiers WAV des samples.
– Synthétiser le son.
3. Quelques liens en vrac...
– http ://www.harmony-central.com/MIDI/Doc/tutorial.html
http ://www.sonicspot.com/guide/wavefiles.html
2
F IG . 3 – Asteroids
4 Asteroids
1. Modèle : un des tous premiers "jeux de café", bien avant PacMan : Asteroids (Fig. 3) :
– Page WEB : http://www.programurl.com/asteroids-extreme.htm
– Progamme : http://www.chunkypig.com/games/download/asteroids_extreme.exe
– Touches : les flèches, la barre d’espace, mais aussi Shift.
2. A faire au minimum :
– Gérer l’inertie.
– Un tir à la fois.
– Des astéroïdes que ne se coupent pas en deux.
3. A faire éventuellement :
– Des astéroïdes qui se divisent.
– Des tirs multiples.
– L’hyper-espace (touche Shift )
– La soucoupe volante.
– Gestion des scores.
4. Techniquement :
– Utiliser la WinLib : penser au paramètre XOR des tracés de ligne.
5 Calcul formel
Le but de ce projet est de produire un petit calculateur symbolique, version extrêmement réduite de logiciels connus tels que Maple, Mathematica ou Maxima, capable d’exécuter quelques traitements élémentaires
tels que : dériver, développer ou réduire une expression.
1. A faire au minimum
Le programme devra s’exécuter sur une console texte. Cette dernière servira d’interface avec l’utilisateur
qui y entrera des lignes de commande. Chaque ligne de commande sera suivie d’un écho indiquant la
réaction du calculateur. Il n’est pas demandé de faire un affichage graphique des expressions mathématiques. Parmi les fonctionnalités à implémenter on peut citer :
– Le calculateur doit pouvoir comprendre n’importe quelle expression contenant les opérateurs et fonctions usuelles (+,-,*,,,̂cos,sin,tan,arccos,arcsin,arctan,exp,log,cosh,sinh,tanh,arccosh,arcsinh,arctanh,(,),...).
– Le calculateur doit être capable de mémoriser des variables contenant des expressions. Ces variables
doivent pouvoir être réutilisées pour entrer d’autres expressions. Le calculateur doit, en outre, diposer
d’une commandes who pour lister l’enesemble des variables mémorisées et d’une commande kill pour
effacer une variable donnée.
– Le calculateur doit être capable de developper une expression, i.e. faire usage des règles de ditributivité.
– Le calculateur doit être capable de dériver une expression par rapport à une variable.
– Le calculateur doit être capable de simplifier une expression ; au moins suffisamment pour rendre
lisible le résultat d’une dérivation.
2. Pour commencer
La production d’un tel logiciel requiert deux étapes assez différentes.
– L’étape de ’parsing’ qui consiste à partir d’une expression entrée au clavier à en vérifier la syntaxe et
dresser l’arbre correspondant.
– L’étape de calul symbolique à proprement parler.
3
Afin d’alléger la charge de travail, la première étape est déjà implémentée dans le projet de départ. Ce dernier contient une démonstration de ’parsing’ d’une expression entrée au clavier. Il est possible d’étendre
assez facilement la syntaxe et la grammaire du langage utilisé en modifiant les fichier ’.y’ et ’.lm’. Pour
davantage de détails se renseigner auprès de son professeur.
3. Quelques liens en vrac...
– google : Computer Algebra Systems
– http ://stommel.tamu.edu/ baum/graphics-math.html
http ://planetmath.org/encyclopedia/ComputerAlgebraSystems.html
http ://www.math.wpi.edu/IQP/BVCalcHist/calc5.html
http ://www.sai.msu.su/sal/A/1/index.shtml
– Computer Algebra - Symbolic and Algebraic Computation, B. Buchberger, G.E. Collins, R. Loos (eds.)
Computing (Archiv for Informatics and Numerical Computation), Supplement Nr. 4 (1st ed.), Springer
Verlag Wien, (2nd edition : Springer-Verlag Wien-New York, 1982, 1983 ; Reprinted : World Publishing
Coorporation, Beijing, 1988 ; Russian translation : translated by V.P. Gerdt, D.Yu.Grigoryev, V.A. Rostovtsev, S.Yu. Slavyanov, Mir Publishing Company, Moscow, 1986) ISSN 0344-8029, ISBN 3-211-816844, ISBN 0-387-81684-4, ISBN 3-211-81776-X, ISBN 0-387-81776-X, ISBN 7-5062-0253-0, BBK 22.14+22.16
6 Calcul scientifique
Le but de ce projet est de produire un petit calculateur matriciel, version extrêmement réduite de logiciels
connus tels que Matlab, SciLab ou Octave, capable d’exécuter des traitements élémentaires sur des matrices
tels que : charger, écrire des matrices, calculer des expressions à partir de ces matrices...
1. A faire au minimum
Le programme devra s’exécuter sur une console texte. Cette dernière servira d’interface avec l’utilisateur
qui y entrera des lignes de commande. Chaque ligne de commande sera suivie ou non d’un écho indiquant la réaction du calculateur (le ’ ;’ finale interdisant l’écho). Parmi les fonctionnalités à implémenter
on peut citer :
– Le calculateur doit pouvoir charger et écrire sur le disque (fonctions ’load’ et ’save’) des matrices (au
format texte). Ces matrices sont ainsi stockées dans des variables. De même le calculateur doit mettre
à la disposition de l’utilisateur une syntaxe permettant d’entrer au clavier une matrice.
– Le calculateur doit disposer d’une commandes who pour lister l’ensemble des variables mémorisées
ainsi que leurs caractéristiques et d’une commande kill pour effacer une variable donnée.
– Le calculateur doit pouvoir comprendre n’importe quelle expression contenant les opérateurs et fonctions usuelles (+,-,*,,,̂cos,sin,tan,arccos,arcsin,arctan,exp,log,cosh,sinh,tanh,arccosh,arcsinh,arctanh,(,),...)
appliqués à des variables et calculer l’expression résultante.
2. Pour commencer La production d’un tel logiciel requiert deux étapes assez différentes.
– L’étape de ’parsing’ qui consiste à partir d’une expression entrée au clavier, à en vérifier la syntaxe et
à dresser l’arbre correspondant.
– L’étape de calcul à proprement parler, qui une fois l’arbe de l’expression dressé est obtenue aisément.
La première étape représente donc la part la plus importante du travail, elle peut elle même se décomposer en deux sous-étapes :
(a) ’tokenize’ : Cette étapes consiste à découper la chaîne de caractères entrée en une successions
morceaux (’token’) ayant un sens pour le langage considéré. Par exemple (mat1 + 2 ∗ −mat2)
donne { ( , mat1 , + , 2 , ∗ , − , mat2 , ) }
(b) ’parse’ : qui est l’étape de parsing à proprement parler. Cette étape consiste, à partir de la sortie
du ’tokenizer’, à dresser l’arbre de l’expression, étant données les règles de grammaire du langage
considéré.
Il existe des logiciels capables de générer des code de tokenizer et de parser (lex, flex, bison, yacc...)
mais ces logiciels sont assez compliqués pour des débutant et les sources qu’ils produisent ne sont pas
d’une grande aide pour essayer de les imiter.
3. Quelques liens en vrac...
– http ://epaperpress.com/oper/index.html http ://www.ibiblio.org/obp/thinkCSpy/chap20.htm
– Et bien entendu : google
7 Jeu en réseau
Ce projet s’adresse à un public averti et consiste à faire un mini doom-like en 3D + réseau.
1. Modèle : WOLFENSTEIN 3D : premier jeu en 3D d’ID Software, grand nom de la scène du jeux vidéo en
ce moment.
– Page WEB : http://www.idsoftware.com/games/wolfenstein/wolf3d/
4
– Progamme : http://www.jeuxgratis.com/download_43.php
– Touches : les flèches, la barre d’espace, la souris ...
2. A faire au minimum :
– Réaliser un serveur capable de synchroniser les déplacements et des tirs des joueurs dans l’arène (ou
carte de jeu).
– Un client ’Joueur’ qui permet à un utilisateur humain de se déplacer dans l’arène et de tirer sur les
autres joueurs.
– Le client affiche l’arène en 3D avec un modèle de déplacement à la première personne avec la WinLib.
3. Quelques étapes :
– Construire un ’langage’ de communication entre le serveur et les clients.
– Se limiter à un seul tir par joueur.
4. A faire éventuellement :
– Un client ’Ordinateur’ qui permet à un personnage non-joueur de se déplacer dans l’arène et de tirer
sur les autres joueurs avec une certaine forme d’intelligence.
– Des tirs multiples.
– Des Portes ?
– Gestion des scores.
– Gestion d’un système de points de vie.
– Bonus de vie, etc...
5. Pour les fans :
– Migration du jeu vers une deuxième version plus proche d’un PACMAN 3D réseau.
6. Techniquement :
– Utiliser la WinLib pour la 3D. (cf poly)
– Utiliser la couche d’abstraction réseau fournie pour le serveur et le client (Héritage C++ pour le serveur).
– Le client affiche et gère le clavier ou la souris.
– Le serveur gère l’arène entière ainsi que les règles du jeu.
8 Editeur de sons
Le but de ce projet est de produire un petit logiciel capable de traiter en temps réel du son. Fonctionnellement, ce logiciel se présentera comme un enchaînement de petits modules spécialisés et paramétrisables.
1. A faire au minimum
Le programme devra pouvoir charger en mémoire un fichier son (sous forme de fichier wav) puis le faire
passer à travers un pipeline de modules modifiant le son à chaque étapes et enfin reproduire le son ainsi
modifié. Le programme devra présenter un interface graphique simple codée grâce à la Winlib. Parmi les
fonctionnalités à implémenter, on peut citer :
– un module Volume/Balance
– un module Equalizer
– Un module Delay/Reverb
– Un module Compresseur/Expandeur
2. Pour Commencer
La production d’un tel logiciel recouvre .
– La programmation de l’interface graphique
– La programmation du traitement du son
Afin de pouvoir se consacrer exclusivement à ces deux taches un programme de départ est fourni. Ce
programme prend en charge la restitution d’un son synthétisée au travers d’une interface graphique
élémentaire.
Il conviendra avant de la coder, de convenir de l’aspect de l’interface graphique avec son professeur.
3. Quelques liens en vrac...
– google : sound Signal Processing, chorus, reverb, equalizer ....
– http ://www.harmony-central.com/Effects/effects-explained.html
http ://www.lnt.de/lms/lecture/digsounds/index.php ?lang=eng
http ://sonicflow.sourceforge.net/sounds/
http ://www.harmony-central.com/Computer/Programming/
http ://sonicflow.sourceforge.net/resources.html
9 Ray tracing
1. Modèle : un programme d’images de synthèse gratuit : Pov Ray (Fig. 4) :
5
F IG . 4 – Ray tracing
– Page WEB : http://www.povray.org/
– Progamme : http://www.povray.org/ftp/pub/povray/Official/Windows/povwin36.exe
2. A faire au minimum :
– Comprendre le principe du Ray Tracing (lancé de rayons ). (Recherche WEB).
– Commencer par un programme simple, sans fichier de description, pour lequel les objets sont des
sphères, sans traiter les reflets.
– Rajouter un affichage progressif : ne pas calculer les pixels ligne par ligne mais par grilles de plus en
plus fines, en les affichant au fur et à mesure.
– Rajouter les reflets.
– Rajouter d’autres objets analytiques (cubes, cylindres, etc.).
– Construire de nouveaux objets par intersection, union et différence d’objets de base.
3. A faire éventuellement :
– Lire un fichier de description des objets.
– Rajouter les transparences.
– Gérer des objets de type maillage (ex. : R2D2 dans C:\Program Files\WinLib5\Test\Test\surprise.3d
– Optimiser le calcul d’intersections avec une notion de boites.
F IG . 5 – Cyber-pinball
10 Flipper
1. Modèle : un petit flipper :
– premier exemple : le flipper de windows (démarrer → programmes → Jeux → Pinball)
– un autre progamme (Fig. 5) : ftp://ftp.moraff.com/permanent-link/cyberpinball.exe
2. A faire au minimum :
– une balle soumise à un champ de pesanteur uniforme dirigé vers le bas
6
– deux "flips" que l’utilisateur peut actionner pour frapper la balle
– des obstacles sur lesquels la balle rebondit
3. A faire éventuellement :
– des obstacles plus interactifs (bumpers, etc ...)
– gestion du score
– des multi-balles
– faites parler votre imagination ...
F IG . 6 – Morphing
11 Morphing
On se donne deux images A et B. On souhaite passer de manière "continue" de l’une à l’autre. On cherche
donc à définir une suite d’image C(t) telle que C(0) = A et C(1) = B. Supposons que l’on dispose de deux
fonctions :
ft : C(t) → A
gt : C(t) → B
qui, à chaque pixel P de C(t), associent un pixel ft (P ) de A et un pixel gt (P ) de B, alors on peut définir
l’intensité du pixel P de C(t) par
P = (1 − t) ft (P ) + t gt (P ).
La difficulté est donc de trouver les fonctions ft et gt qui associent des points qui semblent se correspondre.
Pour cela, on va demander à l’utilisateur d’indiquer une grille sur chaque image initiale A et B (Fig. 6).
Ces grilles vont guider la transformation. Soit (ai,j )1≤i,j≤n les points constituant la grille sur A, et (bi,j )1≤i,j≤n
pour celle sur B. On a donc ai,j qui "correspond"’ à bi,j pour tout (i, j).
Soit t ∈ [0, 1], on veut remplir l’image C(t), c’est-à-dire définir une fonction φC qui à chaque pixel de C(t)
associe une valeur (une intensité, une couleur). On commence par définir une grille sur C(t) par :
ci,j = (1 − t) ai,j + t bi,j , 1 ≤ i, j ≤ n
Soit P un point de C(t), on veut définir φC (t).
– si P = ci,j , φC (P ) = (1 − t) φA (ai,j ) + t φB (bi,j )
– si P n’est pas sur la grille, on cherche dans quelle "case" de la grille il est, puis on cherche à quel point de
la case correspondante sur A on va l’associer (Fig. 7) et on fait de même pour B.
12 Cubebuster
CubeBuster est un jeu mêlant rapidité et réflexion. Différents versions peuvent être essayées aux adresses
suivantes :
– http://www.miniclip.com/cubebuster.htm
– http://www.shockwave.com/bin/content/shockwave.jsp?id=collapse
12.1 Règles
Dans un tableau bidimensionnel sont empilés des cubes de couleurs différentes. La difficulté du jeu augmente avec le nombre de couleurs différentes, le niveau le plus facile commençant avec 3 couleurs.
7
F IG . 7 – correspondance entre deux quadrilatères
F IG . 8 – Exemple de niveau
8
12.1.1 Disparition de cubes
Le joueur peut cliquer sur les cubes à l’aide de la souris. LorsquŠil clique sur un cube possédant au moins
deux voisins de la même couleur que lui, tous les cubes voisins de cette couleur disparaissent. Si n cubes disparaissent, le joueur marque n*(n-2) points. Tous les cubes situés au dessus des cubes qui ont disparu tombent
pour s’empiler sur ceux du dessous. Une fois que tous les cubes sont descendus, si il reste des colonnes médianes vides, les colonnes de gauche se décalent vers la droite pour les combler. Si le joueur clique sur un cube
ne possédant moins de deux voisins de même couleur, il perd 10 points.
12.1.2 Apparition de cubes
A intervalle régulier, une nouvelle ligne de cubes est insérée par le bas, l’ensemble des cubes présents dans
le tableau étant décalé d’un cran vers le haut. Si ce décalage conduit un ou plusieurs cubes à sortir du tableau
par le haut, le joueur a perdu. La couleur des différents cubes insérés est choisie de manière aléatoire. Plus le
jeu avance, plus on augmente la difficulté en réduisant l’intervalle de temps entre deux insertions.
12.1.3 Déroulement du jeu
Deux déroulements de jeu peuvent être choisis :
– un jeu continu, au cours duquel la difficulté (fréquence d’insertion de nouvelles lignes, nombre de couleurs différentes, ...) augmente progressivement.
– un jeu par tableaux : un tableau dure le temps d’insérer n lignes et se fait avec un nombre de couleurs
constantes. La fréquence d’insertion des lignes peut soit être constante au cours du tableau soit augmenter à l’intérieur d’une plage donnée. Au fil des tableaux, le nombre de lignes, le nombre de couleurs et la
fréquence d’insertion augmentent.
12.1.4 Bonus
Dans un second temps, il est possible d’insérer des bonus, sous la forme de petites bombes prenant la place
de cubes. On pourra gérer deux types de bombes :
– des bombes de couleur : lorsque que le joueur clique sur une de ces bombes, tous les cubes de cette
couleur disparaissent. Les cubes restants tombent et se réempilent. Le joueur ne marque aucun point.
– des bombes blanches : lorsque que le joueur clique sur une de ces bombes, tous les cubes situés à moins
d’une distance donnée de la bombe disparaissent. Les cubes restants tombent et se réempilent. Le joueur
ne marque aucun point.
La fréquence d’insertion de ces bonus constitue alors une manière supplémentaire de faire varier la difficulté du jeu.
12.2 Programmation
12.2.1 Données et fonctionnalités
Commencer par définir les données nécessaires, et la manière de les stocker. Puis lister l’ensemble des
fonctions nécessaires, et les implémenter.
La principale difficulté algorithmique réside dans la fonction de comptage du nombre de cubes voisins de
même couleur. Avant de la programmer, décrivez sur papier (en français et non en C++) l’algorithme que vous
comptez implémenter et soumettez le à votre professeur.
12.2.2 Tests
Afin de tester et débugger votre programme, il pourra être intéressant de prévoir de quoi afficher simultanément plusieurs états successifs du jeu (avant et après un clic notamment).
La Winlib autorise l’ouverture de plusieurs fenêtres. Une fenêtre peut être stockée dans une variable de
type Window :
– Window win1 = OpenWindow(w,h) ;
– Window win2 = OpenWindow(w,h) ;
La commande UseWindow permet de spécifier quelle fenêtre utiliser pour les prochaines opérations de
dessin :
– UseWindow(win1) ;
– FillRect(x1,y1,w1,h1,Blue) ;
– UseWindow(win2) ;
– FillRect(x2,y2,w2,h2,Red) ;
9
12.3 Extensions possibles
Différentes possibilités d’extensions, à choisir en fonction du temps restant.
12.3.1 JawBreaker
Principe A partir des éléments programmés pour réaliser CubeBuster, il est assez rapide de programmer un
jeu proche mais jouant davantage sur la réflexion que sur la rapidité : JawBreaker.
L’objectif du joueur est de marquer le maximum de points. Au départ le tableau est entièrement rempli de
cubes. Il n’y a pas d’insertion de lignes au cours de la partie. Le joueur peut faire disparaître les ensembles
de deux ou plus cubes voisins de même couleur (au lieu de trois ou plus pour CubeBuster). Il marque alors
n*(n-1) points, et ne perd pas de points s’il clique sur un cube isolé. La partie se termine lorsque le joueur ne
peut plus faire disparaître aucun cube.
Au démarrage, le joueur aura accès à un écran lui permettant de choisir entre le mode CubeBuster ou le
mode JawBreaker.
Programmation Programmer ce jeu en créant une nouvelle fonction jeu différente de celle du CubeBuster,
mais en réutilisant les autres fonctions, si nécessaire en leur passant de nouveaux paramètres leur permettant
d’adapter leur comportement suivant le type de jeu (CubeBuster ou JawBreaker) en cours.
Avant de modifier les fonctions du CubeBuster pour leur permettre de gérer également un JawBreaker,
pensez à réaliser une sauvegarde de votre projet au cas où ...
12.3.2 Gestion des hi-scores
Stocker les meilleurs scores dans un fichier texte.
12.3.3 Jeu à 2 joueurs
Il s’agira de dédoubler le jeu sur un même ordinateur. On pourra par exemple retenir comme principe
d’interaction entre les deux joueurs qu’un ń gros coup ż d’un joueur insère des lignes supplémentaires chez
l’adversaire.
L’impossibilité de brancher deux souris sur un même ordinateur conduira à remplacer la souris par le
clavier ...
12.3.4 Jeu en réseau
Plutôt que de jouer à plusieurs sur un même ordinateur, chaque joueur pourra jouer sur son propre ordinateur (ce qui résout par ailleurs le problème de la souris Ě). On pourra pour gérer les échanges par le réseau
se baser sur les éléments fournis pour le projet Mini-Doom.
13 Stack Attack
13.1 Règles
Dans un entrepôt, des grues laissent tomber des caisses de couleur. Le travail du manutentionnaire de
l’entrepôt consiste à garder celui-ci rangé. Pour ce faire, il doit regrouper les caisses de même couleur.
13.1.1 Jeu standard
Déplacement du manutentionnaire Le manutentionnaire peut se déplacer dans les quatre directions tant
qu’une caisse ne le bloque pas. Il est capable de sauter de la hauteur d’une caisse, et donc de monter sur une
caisse qui lui fait face.
Apparition des caisses Les grues lâchent les caisses depuis le plafond de manière aléatoire. Il existe 5 couleurs de caisses : noires, rouges, vertes, bleues, jaunes. Une fois lâchées, les caisses tombent verticalement à
vitesse constante jusqu’à ce qu’elles rencontrent un obstacle, sol ou autre caisse. A chaque apparition d’une
nouvelle caisse, le joueur marque 1 point.
Fin de partie Si une caisse tombe sur la tête du manutentionnaire, celui-ci meurt et la partie se termine.
Si une caisse apparaît à un endroit où se trouve déjà une autre caisse, la partie se termine.
10
F IG . 9 – Stack Attack
Déplacement des caisses Les caisses noires sont inamovibles. Seules les caisses de couleur peuvent être
déplacées. La seule manière pour le manutentionnaire de déplacer une caisse est de la pousser. Le manutentionnaire ne peut pousser une caisse que si :
– l’espace situé immédiatement derrière la caisse est libre
– rien n’est posé sur la caisse
– elle n’est pas noire
Au cours d’un saut, le manutentionnaire peut pousser une caisse sous les mêmes conditions.
Disparition des caisses Lorsque le manutentionnaire regroupe trois ou plus caisses de même couleur, cellesci disparaissent. Des caisses sont considérées comme regroupées lorsqu’elles sont en contact par une face (le
contact par une arête uniquement ne compte pas).
Lorsqu’il effectue un regroupement, le joueur gagne :
– 3 points pour 3 caisses
– 8 points pour 4 caisses
– 20 points pour 5 caisses
– 48 points pour 6 caisses
Le manutentionnaire peut également faire disparaître des caisses en remplissant une rangée complète à
l’intérieur de l’entrepôt. Toutes les caisses de la rangée disparaissent alors, quelle que soit leur couleur, mais le
joueur ne marque aucun point.
13.1.2 Bonus
Dans un second temps, il est possible d’insérer des bonus. Il s’agit d’éléments lâchés par les grues comme
des caisses, et qui peuvent être ramassés par le manutentionnaire. Lorsque le manutentionnaire ramasse un
bonus, il décide du moment de son utilisation. Il ne peut ramasser qu’un bonus à la fois.
Différents types de bonus :
– un aimant : lorsque le manutentionnaire l’utilise face à une caisse, il lui permet de tirer la caisse vers lui
(sous réserve que l’espace derrière lui soit libre). L’aimant permet de tirer une caisse ou un autre bonus,
même si d’autres éléments sont posés dessus.
– un chronomètre : lorsque le manutentionnaire l’utilise, l’apparition de nouvelles caisses s’interrompt
pendant un court laps de temps
– un marteau : lorsque le manutentionnaire l’utilise face à une caisse, celle-ci disparaît, sauf si il s’agit d’une
caisse noire. Le marteau permet aussi de faire disparaître un bonus.
– une bombe de couleur : lorsque le manutentionnaire l’utilise, toutes les caisses de cette couleur présentes
dans l’entrepôt disparaissent.
– une bombe noire : lorsque le manutentionnaire l’utilise, tous les éléments situés au contact du manutentionnaire (par une face, une arête ou un coin) disparaissent, y compris les caisses noires.
– une plume : lorsque le manutentionnaire l’utilise, elle lui permet de sauter deux fois plus haut pendant
un court laps de temps
– un poids : lorsque le manutentionnaire l’utilise, il lui permet de pousser deux caisses l’une derrière l’autre
pendant un court laps de temps
11
13.2 Programmation
13.2.1 Phasage
Commencer par programmer le jeu sans bonus : apparition des caisses, déplacements et suppression des
caisses. Dans un second temps, une fois que le jeu avec les caisses marche, ajouter progressivement la gestion
des différents bonus.
13.2.2 Données et fonctionnalités
Commencer par définir les données nécessaires, et la manière de les stocker. Puis lister l’ensemble des
fonctions nécessaires, et les implémenter.
La principale difficulté algorithmique réside dans la fonction de comptage du nombre de caisses voisines
de même couleur. Avant de la programmer, décrivez sur papier (en français et non en C++) l’algorithme que
vous comptez implémenter et soumettez le à votre professeur.
13.2.3 3D
Une annexe du poly du cours présente les différentes fonctionnalités 3D de la Winlib. Les fonctions indispensables ici sont :
– le constructeur Mesh : :Mesh permettant de créer un maillage (un Mesh) à partir d’une liste de points
(des Vect) et d’une liste de triangles (des Triangle) précisant parmi ces points quels sont ceux à relier
– la fonction Mesh : :SetColor permettant de fixer ou modifier la couleur d’un maillage
– la fonction Mesh : :Move permettant de déplacer un maillage
– la fonction SetCamera permettant de spécifier de placer le point d’observation de la scène
– éventuellement la fonction Mesh : :SetGeometry permettant de modifier un maillage après sa création
13.2.4 Tests
Afin de simplifier les tests au cours de la programmation, il pourra être intéressant de programmer un
affichage 2D de l’état de l’entrepôt, en le décomposant en couches.
Cela devrait permettre de distinguer les problèmes de gestion du jeu de ceux de gestion de l’affichage en
3D.
13.3 Extensions possibles
Différentes possibilités d’extensions, à choisir en fonction du temps restant.
13.3.1 Gestion des hi-scores
Stocker les meilleurs scores dans un fichier texte.
13.3.2 Jeu à 2 joueurs
Il s’agira de dédoubler le jeu sur un même ordinateur. On pourra par exemple retenir comme principe
d’interaction entre les deux joueurs qu’un ń gros coup ż d’un joueur insère des caisses supplémentaires chez
l’adversaire.
13.3.3 Jeu en réseau
Plutôt que de jouer à plusieurs sur un même ordinateur, chaque joueur pourra jouer sur son propre ordinateur. On pourra pour gérer les échanges par le réseau se baser sur les éléments fournis pour le projet
Mini-Doom.
14 Pathological
14.1 Objectif
Il s’agit de reproduire le jeu Pathological. Le jeu est téléchargeable à l’adresse suivante :
http://pathological.sourceforge.net
Pathological est un jeu mêlant réflexion et rapidité. Il s’agit de diriger des billes de couleur dans des tuyaux
reliant des roues à réceptacles. L’objectif de chaque niveau est de "valider" toutes les roues en remplissant
chacune avec des billes de même couleur.
12
F IG . 10 – Exemple de niveau
14.2 Règles
La page suivante présente le détail des règles du jeu :
http://pathological.sourceforge.net/howtoplay.php
14.3 Programmation
14.3.1 Données et fonctionnalités
Commencer par définir les données nécessaires, et la manière de les stocker. Bien réfléchir au découpage en
objets, et aux fonctionnalités nécessaires. En discuter avec votre enseignant avant de commencer à programmer.
14.3.2 Phasage
Programmer le jeu par étapes : dans un premier temps les tuyaux puis le lanceur, dans un second temps les
roues. Il sera ensuite possible de rajouter un par un les différents éléments spéciaux : filtres, colorateurs, sens
uniques, switchs ...
Il faudra également implémenter un module permettant de charger différents tableaux à partir d’un fichier
texte. Le plus simple consistera à utiliser le format défini dans le fichier ń all-boards ż du jeu téléchargeable, ce
qui permettra de récupérer tous les tableaux existants.
15 Compression
15.1 Objectif
Il s’agit ici d’implémenter différents algorithmes de compression. Dans un premier temps, vous implémenterez un algorithme simple de type Run Length Encoding. Dans un second temps, vous implémenterez
l’agorithme de Huffman (1950s).
15.2 Run Length Encoding
15.2.1 Principe
Le principe consiste à détecter une donnée ayant un nombre d’apparitions consécutives qui dépasse un
seuil fixe. Puis à remplacer cette séquence par deux informations : un chiffre indiquant le nombre de répétitions et l’information à répéter. Aussi, cette méthode remplace une séquence par une autre beaucoup plus
courte moyennant le respect du seuil (souvent fixé à 4). Elle nécessite la présence de répétitions relativement
fréquentes dans l’information source à compresser.
Exemple :
13
– Information à compresser : vrillette
– Information compressée : vri2le2te
L’exemple précédent révèle cependant deux problèmes : d’une part il n’y a pas de compression puisque
le codage prend autant de place que l’information source ; d’autre part il est nécessaire pour le décodage de
pouvoir distinguer les zones codées des zones intactes.
15.2.2 Elaboration de l’algorithme
Afin que la méthode permette une compression effective et ne risque pas d’augmenter la taille des données
de base, il ne faut encoder que lorsque le facteur de répétition est supérieur à 3.
Il faut aussi distinguer la séquence de remplacement de l’information non compressée, c’est-à-dire faire
ressortir du texte compressé les information compactées. Pour cela, on utilise un caractère spécial. Il indique
que la séquence des 2 caractères suivants est le résultat d’une compression. C’est la raison pour laquelle on fixe
le seuil de répétition à 4. Toute séquence d’au moins 4 caractères répétitifs sera compressée en 3 caractères. On
commence donc à gagner de la place.
Cette méthode présente peu d’avantages pour la compression de fichier texte. Par contre, sur une image,
on rencontre régulièrement une succession de données de même valeur, des pixels de même couleur.
Exemple : le caractère # repésente le caractère spécifique.
– Source : 18 18 18 18 18 167 167 167 167 167 167 167 32 9 9 9 9 9 9 203 203 203 203
– Compression : # 5 18 # 7 167 32 # 6 9 # 4 203
Telle quelle, la méthode présente encore deux défauts. Tout d’abord le caractère spécial (Cs) introduisant la
répétition doit être un caractère unique dans tout le fichier source. S’il apparaît en tant que donnée, à la phase
de compression, il sera pris comme tel. Par contre, lors de la décompression, ce caractère sera détecté comme le
caractère spécial, et le décompresseur lui fera remplir son rôle, entraînant des erreurs. Dans un second temps,
on remarque la limite du compteur de répétitions. Dans notre exemple, le compteur était stocké sur un octet,
d’où un comptage limite de 255 répétitions.
15.2.3 Travail demandé
Concevoir un programme capable de comprimer un fichier en Run Length Encoding, puis un second programme capable de décomprimer ces fichiers. Après avoir vérifié que le gain obtenu en traitant un fichier
texte était faible, spécialiser le programme dans la compression d’images, en niveaux de gris dans un premier
temps, puis en couleur dans un second temps.
15.3 Compression de Huffman
15.3.1 Principe
Considérons la suite de caratères : AABACDAABBABADABAACA. On a ici un alphabet de 4 caractères : A,
B, C, D. La méthode la plus simple pour représenter cette suite de caractères consiste à coder chaque caractère
sur 2 bits. On peut ainsi par exemple poser : A=00,B=01, C=10, D=11. La séquence précédente devient alors :
0000010010110000010100010011000100001000. La séquence initiale comportait 20 caractères, il nous a fallu 40
bits pour la représenter.
Considérons une autre manière de coder notre alphabet. Soit A=0, B=10, C=110, D=111. La séquence devient : 001001101110010100100111010001100. Il n’y a plus besoin que de 33 bits pour stocker la séquence. En
utilisant un codage plus court pour le caractère le plus fréquent, on réduit la taille nécessaire pour stocker la
séquence. Sur des séquences plus longues, le gain s’accroît.
15.3.2 Algorithme
Le codage de Huffman, qui date des années 50, repose sur une analyse statistique préalable des données
à comprimer. A l’issue de cette analyse, un arbre est construit qui permet d’attribuer à chaque symbole un
code dont le nombre de bits est inversement proportionnel à la probabilité d’apparition du symbole. Ainsi, les
symboles les plus fréquents se voient affecter des codes plus courts, et les codes les plus longs sont attribués
aux symboles rares. En outre, ces codes sont séparables, c’est-à-dire qu’un code donné ne peut pas être le préfixe d’un autre code. Bien sûr, pour permettre au décodeur de reconnaître les symboles, il est nécessaire de lui
transmettre le dictionnaire obtenu après la phase d’analyse statistique des données.
Nous allons illustrer l’algorithme de construction de l’arbre de Huffman sur un exemple. Soit à coder le
message : "EXEMPLE DE CODAGE DE HUFFMAN".
14
L’algorithme commence par calculer la probabilité de chaque symbole : (E,6/28), (X,1/28), (M,2/28), (P,1/28),
(L,1/28), (espace,4/28), (D,3/28), (C,1/28), (O,1/28), (A,2/28), (G,1/28), (H,1/28), (U,1/28), (F,2/28), (N,1/28).
A chaque étape, les deux symboles de plus petite probabilité sont regroupés en un nouveau symbole ayant
pour probabilité la somme des deux probabilités. Le processus est itéré jusqu’à obtenir un unique symbole de
probabilité 1 (cf figure 11).
F IG . 11 – Exemple de construction de l’arbre de Huffman. Les bits de codages sont en gras (et en rouge), pour
les probabilités, on n’a pas fait figurer le dénominateur (28)
Le code de chaque symbole est ensuite obtenu en suivant le chemin depuis la racine de l’arbre de Huffman
jusqu’à la feuille contenant le symbole. Un bit est ajouté à chaque embranchement : 0 si le chemin emprunte
la branche supérieure, 1 si c’est la branche inférieure. Ainsi, le code du symbole le plus fréquent (E : 00) est de
longueur 2, tandis qu’un symbole rare (H : 11101) est codé sur 5 bits.
15.3.3 Travail demandé
Concevoir un programme capable de comprimer un fichier en utilisant l’algorithme de Huffman, puis
un second programme capable de décomprimer ces fichiers. Il est à noter que lors de la décompression, il est
nécessaire de connaître le codage qui a été utilisé à la compression. Il est donc nécessaire lors de la compression
d’inclure ce codage dans le fichier comprimé.
F IG . 12 – Jeu de dames
16 Jeu de dames
1. Modèle : Dam (Fig. 12) :
– Page WEB : http://www.xs4all.nl/~hjetten/dameng.html
– Programme : http://www.xs4all.nl/~hjetten/dam227.exe
15
2. Règles du jeu : http://membres.lycos.fr/nic55/dames/regles.htm
3. A faire :
– Affichage et mouvement des pièces (pions et dames) sur l’échiquier
– Autoriser uniquement les coups valides suivant les règles du jeu
– Jeu à deux joueurs
– Jeu contre l’ordinateur, ce dernier utilisant un Minimax
(cf http://cermics.enpc.fr/~keriven/Info/Projets/2003/alphabeta.pdf)
– Fonction d’évaluation pour le minimax : nombre de pièces (une dame valant 2 pions)
4. A faire éventuellement :
– Utiliser un algorithme αβ plutôt que Minimax (cf document cité plus haut)
– Raffiner la fonction d’évaluation
16