Nous en sommes au troisième TP, il serait bon que vous commenciez à établir vous-même votre approche du problème. Je ne vais donc pas détailler énormément cette partie. Voici comment j'aborderais ce TP (en entrecoupant chaque étape de divers tests pour trouver d'éventuels bogues) :
Création des types nécessaires pour faire un serpent.
Réalisation des procédures d'affichage de l'aire de jeu et du serpent.
Réalisation des procédures de déplacement et d'agrandissement du serpent + actualisation éventuelle des procédures d'affichage.
Réalisation des procédures permettant au Joueur de piloter le Serpent au clavier.
Mise en place des règles : interdiction de sortir de l'espace de jeu, de mordre le corps du serpent, d'effectuer des demi-tours.
Réalisation des procédures générant l'item à avaler (appelé Anneau dans mon code) et actualisation des règles : «si le serpent mange l'anneau alors il grandit», «un anneau ne peut apparaître directement sur le serpent».
Éventuels débogages et ajouts de fonctionnalités.
Voilà pour le plan de bataille. Il est succinct mais devrait vous fournir des objectifs partiels facilement atteignables. Je me répète mais n'hésitez pas à effectuer des tests réguliers et approfondis pour être sûr de ne pas avoir créé de bogues. Par exemple, ce n'est pas parce que votre serpent avance correctement vers le haut, qu'il avancera correctement vers la droite ou après avoir effectué un ou deux virages. Et en cas de difficultés persistantes, n'hésitez pas à poser des questions.
Une solution possible
Le fichier principal : Secret (cliquez pour afficher)
Code : Ada
with nt_console ; use nt_console ; with Snake_Variables ; use Snake_Variables ; with Snake_Programs ; use Snake_Programs ; with Snake_Screen ; use Snake_Screen ;
procedure Snake is Serpent : T_Serpent ; begin
Set_Cursor(false) ; print_ecran(snake) ; print_ecran(ready) ; print_ecran(start) ; Clear_screen(Couleur_Ecran) ; print_plateau ;
Init_Serpent(Serpent) ; Print_Serpent(Serpent) ; Game(Serpent) ; end Snake ;
Partie 3 : Ada, les types composites 131/312
Le package contenant quelques types et surtout les variables nécessaires au programme : subtype Intervalle_Alea is natural range 1..Longueur*Hauteur ; HDecalage : Natural :=
Le package contenant la plupart des programmes servant au jeu : Secret (cliquez pour afficher) procedure print_plateau is
begin procedure print_score is begin
set_foreground(green) ; set_background(Couleur_Ecran) ; goto_XY(0,0) ;
put("SCORE = ") ; put(Score,4) ; set_foreground(Couleur_Texte) ; set_background(Couleur_Fond) ; end print_score ;
CREATION SERPENT
procedure Init_Serpent(Serpent : in out T_Serpent) is begin
Serpent.curseur := First(Serpent.corps) ; --placement du curseur sur la tête du serpent
Serpent.direction := (0,-1) ; --direction vers le haut
end Init_Serpent ;
procedure move(Serpent : in out T_Serpent) is coord: T_coord ;
procedure grow(Serpent : in out T_Serpent) is coord: T_coord ;
begin
coord.x := First_Element(Serpent.corps).x + Serpent.direction.x ;
coord.y := First_Element(Serpent.corps).y + Serpent.direction.y ;
Prepend(Serpent.corps,coord) ; --on ajoute une nouvelle tête
Serpent.curseur := First(Serpent.corps) ;
print_serpent(serpent) ; --on affiche le nouveau corps
end grow ;
function est_sorti(Serpent : T_Serpent) return boolean is tete : T_Coord ;
function est_mordu(Serpent : T_Serpent) return boolean is tete : T_Coord ;
Serpent2 : T_Serpent := Serpent ; begin
tete := First_Element(Serpent2.corps) ;
Partie 3 : Ada, les types composites 132/312
Delete_first(Serpent2.corps) ;
function a_mange(Serpent : T_Serpent ; Anneau : T_Coord) return boolean is procedure print_tete(Serpent : in T_Serpent) is begin
procedure print_corps(nb : natural) is begin
procedure print_serpent(Serpent : in out T_Serpent) is begin
Set_Foreground(Couleur_Texte) ; for i in 1..length(Serpent.corps) loop
Goto_XY(Element(serpent.curseur).x + HDecalage-1, Element(serpent.curseur).y + VDecalage-1) ;
Serpent.curseur := First(Serpent.corps) ; end print_serpent ;
procedure efface_queue(Serpent : in out T_Serpent) is begin
Serpent.curseur := Last(Serpent.corps) ; Goto_XY(Element(serpent.curseur).x + HDecalage-1, Element(serpent.curseur).y + VDecalage-1) ; put(' ') ;
Serpent.curseur := First(Serpent.corps) ; end efface_queue ;
GESTION DES ANNEAUX
function generer(germe : generator ; Serpent : T_Serpent) return T_Coord IS
procedure print_anneau(anneau : T_Coord) is begin
set_foreground(Couleur_Anneau) ;
Goto_XY(anneau.x+Hdecalage-1,anneau.y+Vdecalage-1) ; put(character'val(15)) ;
set_foreground(Couleur_Texte) ; end print_anneau ;
PROGRAMME DE JEU procedure Erreur(Message : in String) is begin
Goto_XY(HDecalage+5,VDecalage+Hauteur+2) ; set_background(Couleur_Ecran) ; set_foreground(light_Red) ; Put(Message) ; delay 1.0 ; end Erreur ;
procedure un_tour(Serpent : in out T_Serpent) is choix_effectue : boolean := false ;
procedure game(Serpent : in out T_Serpent) is germe : generator ;
Partie 3 : Ada, les types composites 133/312
end loop ;
with ada.Containers.Doubly_Linked_Lists ; use ada.Containers ; package Snake_Programs is
Type T_Serpent is record corps : List ; Curseur : Cursor ; direction : T_Coord ; end record ;
procedure print_plateau ; procedure print_score ;
procedure Init_Serpent(Serpent : in out T_Serpent) ; procedure move(Serpent : in out T_Serpent) ; procedure grow(Serpent : in out T_Serpent) ; function est_sorti(Serpent : T_Serpent) return boolean ; function est_mordu(Serpent : T_Serpent) return boolean ; procedure print_tete(Serpent : in T_Serpent) ; procedure print_corps(nb : natural) ;
procedure print_serpent(Serpent : in out T_Serpent) ; procedure efface_queue(Serpent : in out T_Serpent) ; function generer(germe : generator ; Serpent : T_Serpent) return T_Coord ;
procedure print_anneau(anneau : T_Coord) ; procedure Erreur(Message : in String) ; procedure un_tour(Serpent : in out T_Serpent) ; procedure game(Serpent : in out T_Serpent) ; end Snake_Programs ;
Enfin, le package servant à l'affichage de mes écrans de titre : Secret (cliquez pour afficher)
Code : Ada
with ada.text_IO ; use ada.Text_IO ; with NT_Console ; use NT_Console ; With Snake_Variables ; use Snake_Variables ; package body Snake_screen is
procedure print_line(line : string) is begin
procedure print_fichier(name : string) is F : file_type ;
begin
open(F,In_File,name) ; clear_screen(couleur_ecran) ; set_background(Couleur_Ecran) ;
while not end_of_file(f) and not end_of_page(f) loop print_line(get_line(f) ) ;
end loop ; close(f) ; end print_fichier;
procedure print_ecran(Ecran : T_Ecran) is begin
type T_Ecran is(START,READY,SNAKE) ; procedure print_line(line : string) ; procedure print_fichier(name : string) ; procedure print_ecran(Ecran : T_Ecran) ; end Snake_Screen ;
Pour finir, je vous transmets également les fichiers .pic (en fait des fichiers textes) servant de support à ces fameux écrans titres (je suis preneur pour tout écran titre pouvant remplacer celui qui ressemble vaguement à un serpent ):
Secret (cliquez pour afficher)
Partie 3 : Ada, les types composites 134/312
GG YGG GGGG YYGGGGGG YYGGGGGG YYGGGGG YYYG
Code : Texte .
#### ##### # #### # # ###
# # # # # # # # # # # # # # # # # # # # # #### ### # # # # # # # # # ##### # # # # # # # # # # # # # # ##### # # #### # #
Code : Texte .
### ##### # #### ##### # # # # # # # # # # # # # # # # # # # # # # # ### # # # #### # # # # # # ##### # # # # # # # # # # # # # # ### # # # # # # # # #
Pistes d'amélioration :
Proposer différent niveaux de difficulté : en faisant varier la vitesse, la taille de l'aire de jeu…
Ajouter des adversaires ou des obstacles.
Proposant l'enregistrement des meilleurs scores.
Proposer des bonus comme des anneaux comptant le double de points ou permettant de réduire votre taille.
Nous avons aborder dans ce chapitre la plupart des notions qui nous manquaient en découvrant des types plus complexes comme les tableaux, les pointeurs, les types abstraits de données… Vous avez dors et déjà fait un large tour des possibilités et savez désormais programmer en Ada ! Enfin, en Ada83. Mais la science de l'informatique évolue sans cesse et la programmation n'échappe pas à cette règle. La norme Ada95 a fait entré le langage Ada dans la catégorie des langages orientés objets, renforcé par la norme Ada2005. Découvrir cette fameuse POO (Programmation Orientée Objet) sera l'objectif principal de la partie IV.
Et quand est-ce que l'on fera des programmes en Ada plus jolis que ces vilaines consoles ?
Ce sera le rôle de la cinquième partie que d'aborder ces notions au travers de GTK, une librairie qui nous permettra de créer de jolies fenêtres avec de jolis boutons et tout et tout ! Les plus curieux (ou pressés) pourront s'y rendre directement, car il vous sera dors et déjà possible d'obtenir des résultats. Toutefois, pour des applications plus poussées et pour une meilleure compréhension, il sera nécessaire de lire la partie IV, la bibliothèque Gtk étant construite sur le mode « orienté objet ».
Partie 3 : Ada, les types composites 135/312
Partie 4 : Ada : Notions avancées et Programmation Orientée Objet
Nous avons abordé dans la partie précédente des notions essentielles de programmation, mais nous n'avons pas encore découvert la Programmation Orientée Objet. Cette partie n'a pas pour but de révolutionner votre façon de coder mais plutôt d'y apporter des améliorations. Créer des packages plus génériques, gérer des erreurs qui pourraient survenir, gérer de manière plus dynamique vos allocations/désallocation de mémoire…
Comme précédemment, elle comportera un fil conducteur autour duquel viendront se greffer des chapitres un peu plus hors sujet (ou plutôt hors thème). Mon fil conducteur ne sera plus les tableaux ou les pointeurs, mais les packages et la Programmation Orientée Objet.
Eh ! Y'a erreur ! On a déjà vu les packages dans la partie III, non ?!
Je le sais bien, mais il nous reste beaucoup à dire sur les packages. Nous allons aborder ce que l'on appelle les classes et les méthodes. Que les néophytes se rassurent, tout ira bien et nous prendrons plus de temps qu'il n'en faut pour comprendre ce que cela signifie. Et que les aficionados de la programmation orientée objet calment leurs ardeurs : Ada gère les notions de classes d'une manière particulière, très différente des C++, Java et autres Python.