• Aucun résultat trouvé

Par où commencer ?

Dans le document Apprenez à programmer avec Ada (Page 131-136)

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.

Dans le document Apprenez à programmer avec Ada (Page 131-136)