GPIIPSA

Rapport projet
bataille navale
Poinsignon Elliot, Sauzeat Malo, 2PA1
0
RAPPORT PROJET BATAILLE NAVALE
Table des matières

Introduction ....................................................................................................................................................2
Organisation du grand projet..........................................................................................................................2
Journal de bord ...............................................................................................................................................3
Séance 1 ......................................................................................................................................................3
Séance 2 ......................................................................................................................................................6
Séance 3 ......................................................................................................................................................8
Séance 4 ....................................................................................................................................................11
Séance 5 : ..................................................................................................................................................13
Travail supplémentaire V4 ............................................................................................................................15
Travail supplémentaire V3 ............................................................................................................................17

Conclusion.....................................................................................................................................................22
Annexe ..........................................................................................................................................................22
Table des illustrations ...........................................................................................................................22
1
Poinsignon Elliot, Sauzeat Malo
Introduction
L’objectif de ce grand projet fut de réaliser une bataille navale sur python, pour cela il a été mis à notre
disposition une première ébauche de code, le but étant de faire évoluer notre programme au fur et à mesure
des séances et du travail personnel, pour obtenir en fin de projet une version V3 de notre programme
jouable sur tkinter et si faisable une version V4 jouable via réseau local.
Le but du jeu est donc de pouvoir dans un premier temps avoir une carte contenant des navires et de pouvoir
via des coordonnées les couler pour gagner la partie.
Organisation du grand projet
L’organisation pour la réalisation de ce grand projet a été définie de la manière suivante :

Notre groupe est composé de deux personne, Elliot POINSIGNON et Malo SAUZEAT, tous les membres de
l’équipe viennent de la classe 2PA.
Au cours de la première séance, notre binôme a donc commencé le codage de la première version V0. Nous
avons ainsi adopté une manière innovante de travailler en groupe et de coder. À l’inverse de
nombreux groupes et quelquefois précédentes où l’équipe s’est réuni dans le but de coder, cette fois-ci nous
avons réussi, au moyen du logiciel de codage, Visual Studio Code et de la bibliothèque Live Share, à coder
de manière simultanée sur le même code et ainsi de travailler plus vite sur les exercices.
Ainsi, le travail n’a pas été divisé entre chaque membre du groupe qui en faisait un morceau dans son coin
avant de tous mettre en commun, mais nous avons plutôt pu coder de manière simultanée, tantôt chacun
sur une définition, tantôt sur la même, dans le but de résoudre des erreurs ou encore des blocages.
Du fait de l’utilisation de Live share notre projet ne fut que plus aidé de par le partage en temps réel du
code.
Ainsi, le travail n’a pas été divisé entre chaque membre du groupe qui en faisait un morceau dans
son coin avant de tous mettre en commun, mais nous avons plutôt pu coder de manière simultanée, tantôt
chacun sur une définition, tantôt sur la même, dans le but de résoudre des erreurs ou encore des blocages.
2
Journal de bord
Séance 1
Pour la première séance les objectifs étaient donc de réaliser la version V0 du projet bataille navale. Il nous
a au départ été donné un code comportant des fonctions avec des noms prédéfini pour nous aider à
commencer.
Cette première esquisse prenait donc en compte plusieurs fonctions :
creerTerrain Permet de créer le terrain de jeu en fonction de la

hauteur de la largeur choisi par l’utilisateur.
initialiserTerrain Cela va appliquer au terrain des valeurs, en
l’occurrence la valeur à ajouter est le symbole
représentant l’eau.
afficherTerrain L’affichage terrain va permettre de rafraîchir le
terrain à chaque fois qu’un nouvel élément est
implémenté.
mettreBateaux Cela permet de positionner les bateaux sur des case
aléatoires.
dansIntervalle Permet de déterminer si les valeurs entrées sont bien
entre un intervalle défini.
caseValide Permet de déterminer si la case sélectionnée existe
dans le tableau.
demanderCaseTir Demande à l’utilisateur une case ou tirer.
tirer Prend la case entrée par l’utilisateur et va déterminer.
Jouer Lance le jeu.
La réalisation de ces fonctions a été assez rapide et nous a pris peu de temps en effet nous avons travaillés
sur différentes fonctions en même temps en effet nous utilisons tout deux « Visual studio code » qui
comporte une extension permettant d’être sur le même code en même temps, nous permettant de nous
corriger si besoin et d’avancer bien plus vite.
3
Figure 1: L'outil Live Share de VS Code permettant de travailler à plusieurs sur le même code.
Des fonctions supplémentaires ont été intégrées pour terminer la V0 :
verifVictoire Vérifie si le terrain contenant les bateaux contient

encore des bateaux non touchés (contient encore
des strings « B »)
tirAuto Tir automatiquement au hasard, permet de tester
plus rapidement le programme.
Nous avons de même ajouté une partie base de données pour garder en mémoire les utilisateurs ayant joués
et leur score. Pour cela nous utilisons SQLite car nous ne prévoyons pas de faire une base de données
gourmande et nous savons déjà comment l’utiliser en combinaison avec python grâce au projet du premier
semestre.
Cette base se présente de la manière suivante : le nom de l’utilisateur, le pourcentage de réussite de ses
tirs, la date de la partie, le nombre de tirs effectué ainsi que le score qui se base sur diffèrent paramètre
mais principalement le pourcentage de réussite du tir.
4
Figure 2: Notre Base de données
Ci-dessus notre base de données comportant toutes les parties jouées avec les données de la partie.
En fin de jeu le programme affiche le joueur ayant le meilleur score.
Après avoir fait les fonctionnalités principales, nous les avons départagés en 4 fichiers python,
« ProgPrincBNavale.py », « combat.py », « terrain.py» et « save.py »
Fichier Fonctions Utilité

« ProgPrincBNavale.py » jouer C’est le programme principal, il
lance le jeu et gère les fonctions
des autres fichiers.
« terrain.py » creerTerrain, initialiserTerrain, Contient les fonctions de
afficherTerrain, mettreBateaux création du terrain, de mise en
place des bateaux, ainsi que
l’affichage.
« combat.py » dansIntervalle, Contient les fonctions de
caseValide, demanderCaseTir, tirer, gameplay du jeu.
verifVictoire, tirAuto
« save.py » save, best Contient les fonctions de
sauvegardes et de chargement
des meilleurs scores.
5
Séance 2
Pour la séance 2 nous nous sommes lancés dans la réalisation de la V1 et dans l’écriture de ce rapport.
La V1 apporte que de petit complément à la V0.
Pour réaliser la version 1 nous avons aux préalables décidés de changer notre terrain et nos bateaux pour
en faire deux classes :
Terrain : Servira à créer l’espace de jeu, ayant comme caractéristiques sa taille (10 le plus
souvent), et ses cases ainsi que ses cases contenant des bateaux :
Terrain
Attributs
size int() Taille du terrain (hauteur et largeur) public
cases dict() Dictionnaire qui contiendra le str de toutes les cases avec public
comme clé leur
Cases_bateaux List() Liste contenant toutes les cases où se trouve un bateau public
Méthodes
create_cases dict() Créer le dictionnaire cases privé
str str() Renvoie le terrain sous une forme affichable public
Navire
Attributs
taille int() Taille du navire étant de taille 1 pour la V1 public
Orientation int() 0 vertical, autre chose horizontal public
Cases_bateau list() Contiendra les coordonnées des cases composants le public
navire.
vie int() Nombre de cases bateaux encore non touchés public
Méthodes
Mettre_bateau Terrain() Place le navire sur le terrain public
verifCaseContigu bool() Vérifie qu’un bateau n’est pas contigu à un autre public
Ces classes nous permettent de mieux gérer et manipuler le terrain et les bateaux et cela a donc permit
d’intégrer bien plus facilement la contiguïté via notamment la fonction verifCaseContigu
6
Figure 4: Affichage avec contiguïté Figure 3: Affichage sans contiguïté
Nous obtenons donc un affichage sans contiguïté.
Nous avons également changé la commande tirer pour prendre en compte les deux terrains, celui sans
bateau d’affichage et celui avec bateaux. Le but est de tester si le tir à touché, avec le terrain bateaux, et
d’afficher le terrain sans les bateaux pour le joueur.
Nous avons mit en place un système de test qui affiche le terrain avec les bateaux si on décide de l’activer.
Mais pour prévenir de triche éventuelle, cela désactive la sauvegarde du score.
Une fois le V1 fini nous nous sommes directement attaqués à la V2 qui comprend l’ajout de différentes tailles
de bateau :
▪ Porte-avions : 5 cases
▪ Cuirassé : 4 cases
▪ Frégate : 3 cases
▪ Sous-marin : 3 cases
▪ Torpilleur : 2 cases
Pour cette version il a fallu ajouter une méthode pour vérifier à la fois la contiguïté de chaque case des
navires, mais aussi le fait que le navire ne dépasse pas du terrain. C’est fait via l’ajout de la méthode
« verifTaille » qui prendra comme argument la case d’origine du navire (x,y).
Chaque navire lorsqu’il va créer ses cases commence par sa case d’origine, il vérifie que sa case la plus
éloignée est bien toujours dans le terrain. On vérifiera ensuite la contiguïté de chaque case du navire.
Nous avons aussi rajouté la contiguïté diagonale des navires, pour ne pas que des morceaux de navire se
touche en diagonal, au début les bateaux lors de l’implémentation se faisait du plus petit au plus grand, il
arrivait qu’une fois arrivée au 5ème navire à placer il n’y a plus de place et donc le programme calculait dans
le vide des positions de navire impossible. Pour régler ce problème nous avons tout simplement fait notre
7
implémentation de navire du plus gros au plus petit, une fois le navire de taille 5 mis en place tous les autres
bateaux peuvent s’implémenter sans problème. Aucune configuration n’est impossible en commençant par
le plus gros navire. Ici, nous avons mis des navires de taille 1 à 5.
Figure 5: Affichage sans Navire Figure 6: Affichage avec Navire
Nous obtenons l’affichage ci-dessus.
Une fois cela fait nous avons donc commencé à commenter nos parties de code et à compléter le rapport,
pour la prochaine séance notre objectif est de commencer la version Tkinter.
Séance 3
Nous avons commencé l’interface graphique tkinter avec pour objectif d’avoir une première version
fonctionnelle à la fin de la séance.
App
Attribut
x Int Taille en x de la fenêtre Public
y int Taille en y de la fenêtre Public
Nb tir int Combien de tir ont été Public
effectué
Nb tir reussi int Combien de tir ont Public
réussi
Fenêtre Créé une première fenêtre comprenant notre grille
Exécute Permet de sélectionner la case que l’utilisateur veut
Feu Permet de tirer sur une case sélectionnée et va agir en fonction de s’il y avait
un bateau ou non, en coloriant la case en vert s’il y a un bateau ou en gris si
nous avons raté.
8
Notre interface est entièrement constituée de bouton, en effet pour avoir accès facilement a ces dernier
nous avons créé un dictionnaire de bouton, nous simplifiant grandement la vie.
Cela nous donne donc un graphique composé de 10 colonnes et de 10 lignes :
Chaque bouton est cliquable et devient rouge lorsque sélectionné, pour que l’utilisateur active le tir un
bouton ‘feu’ a été créé, c’est celui la qui va ensuite utiliser la fonction ‘tir’ créé précédemment pour voir si
9
l’on a fait mouche. Si oui le bouton devient vert et sinon il devient gris.
Figure 7: Première version fonctionnelle du Tkinter
Notre interface étant fonctionnelle il ne restera plus qu’à l’améliorer, pour cela nous devrons donc rendre
nos boutons déjà cliqués non-cliquable et ne permettre à l’utilisateur de sélectionner qu’un seul bouton et
non pas plusieurs. Puis une fois cela effectué permettre à l’utilisateur de savoir quand il a gagné.
Nous avons de plus commenter notre code et rempli notre partie word sur la séance 3.
10
Séance 4
Pour cette séance nous avons continué notre interface Tkinter, nous avons tout d’abord ajouter la
fonctionnalité pour ne pouvoir cliquer que sur un bouton à la fois.
En effet nos boutons était cliquable autant de fois que l’on voulait avant d’appuyer sur le bouton « feu »
nous nous retrouvions avec comme vu sur l’image de notre graphique séance 3 énormément de bouton
rouge.
Cela ne nous permettant pas de savoir quelle sera notre case sélectionnée. Pour cela à chaque fois que nous
cliquons sur un nouveau bouton le programme va parcourir le dictionnaire des boutons et trouver celui dont
la couleur du « background » est rouge et va la retransformer en bleu. Nous avons de plus rendu les boutons
sur lesquelles nous l’utilisateur avait déjà cliqué et confirmé le tir inutilisable en via l’application de la
fonction « tk.DISABLED». Pour que l’utilisateur ne clique pas sur le même bouton plusieurs fois.
Figure 8: Deuxième version de l'interface Tkinter
Nous avons aussi ajouté la fonction victoire qui informe le joueur qu’il a éliminé tous les bateaux.
Verif victoire Vérifie l’état des bateaux pour savoir si l’utilisateur

a gagné.
Victoire Si l’utilisateur a gagné alors il ouvre une nouvelle
fenêtre, permettant d’informer l’utilisateur de sa
victoire.
11
Figure 9: Victoire V3
Notre version tkinter étant pleinement fonctionnelle nous avons décidé de commencer à le rendre plus jolie,
car pour l’instant il reste très austère. Nous sommes donc parties à la recherche d’image pour le fond et les
boutons sur internet.
Figure 10: Menu V3
12
Voici donc notre page d’accueil du programme nous avons bien entendu décider d’opter pour une image
de destroyer et de prendre des boutons dans le thème de la bataille naval.
Nous avons utilisé des Canvas pour implémenter notre background pour ce qui est des boutons, les
boutons classiques de tkinter n’étant pas adapté à l’utilisation d’image, nous avons créé un Canvas
cliquable qui réagit comme des boutons.
Séance 5 :
Pout ce début séance nous avons continué de travailler sur notre interface d’accueil.
Puisque nous ne sommes plus sur la même version que le v2 changer notre code pour obtenir le score et
le mettre sous sql en effet notre « save » n’était affecter que sur la V2 il a fallu la rajouter pour le tkinter et
créer une fenêtre les affichant ; pour des raisons de simplicité de lecture nous avons juste affiché les 3
premiers joueurs
Cela se présente comme ceci :
Figure 11: Score Board V3
Ensuite nous avons commencé la partie réseaux en essayant donc de s’envoyer des messages sur le même
réseau.
Nous avons reçu pour pouvoir débuter des codes de la part de notre professeur encadrant M Quetin, il
s’agissait donc de 2 codes un qui est un serveur et un autre un client. Le serveur peut recevoir les
messages du client et lui répondre, il faut obligatoirement ouvrir le serveur pour que le client puisse
envoyer des messages.
13
Figure 12 code client
Figure 13 code serveur
Une fois le serveur ouvert le client peut envoyer des messages au serveur qui peut ensuite répondre. Pour
mettre fin à la discussion il faut que l’un des deux envoies une message ‘fin’, les sockets se fermeront donc
fermant la liaison entre le serveur et le client.
Cela se présente comme ceci, l’un envoie un message en premier et l’autre le reçoit et peux ensuite
répliquer.
14
Figure 14: Première utilisation du réseau
Une fois avoir pris nos marques avec le réseau nous avons décidé de revoir intégralement nos anciennes
versions pour tout d’abord vérifier si elles fonctionnaient bien, ce qui était le cas mais aussi voir s’il ne
manquait pas des commentaires à rajouter, nous avons aussi travaillé sur notre rapport pour le
compléter et lui donner une meilleure forme.
Par la suite nous nous sommes attaqués à la version V4 et à l’amélioration de notre version V3.
Travail supplémentaire V4
Nous avons donc par la suite séparé le travail en 2 un continuant sur la version réseaux, pendant
que l’autre upgradait la partie V3.
Pour la partie réseau la liaison se fait donc en réseau local, le défi après cela est donc d’appliquer une
liaison entre 2 machines en réseau local.
Le problème majeur est de savoir qui des 2 joueurs est l’hôte en effet il faut qu’une machine soit le serveur
partie et l’autre le client, pour cela nous avons opté pour un système user, l’utilisateur va rentrer le type
de « user » qu’il est, 1 ou 2, il ne faut pas que les 2 joueurs prennent le même sinon il n’y aura pas de
connexion. La sélection du user se fait dans le PowerShell et non pas dans l’interface graphique.
15
Figure 15 demande de user
Il y a donc dans notre code une partie de connexion qui s’appliquera en fonction de l’user sélectionner.
Une fois les user rentrés les machines vont donc se connecter entre eux. Puis les interfaces vont se lancer,
l’utilisateur va pouvoir sélectionner une case de tir, une fois fait l’ordinateur attend de recevoir le message
adverse, les messages envoyés au départ son très simple il s’agit simplement des coordonnées de tir. Le
programme peut continuer avec ces valeurs reçues, car il sait donc s’il a été touché ou non, le problème
dans cette situation est qu’on sait si on a été touché mais on ne sait pas si nous avons touché un
adversaire. Il faut donc envoyer un autre message pour dire si le tir reçu par la machine est raté ou touché.
Cela va nous donner les PowerShell suivants :
Figure 16: Discussion réseau des commandes de tirs
On peut donc voir les cases qui sont envoyées à l’ordinateur à travers le réseau ainsi que l’information si
on a touché ou coulé. Cela va se répercuter sur notre programme d’affichage qui va nous donner le
graphique suivant :
16
Figure 17: Interface Tkinter Réseau
On peut donc apercevoir que nos bateaux sont sur le côté droit et notre interface d’attaque sur le côté
gauche. Ce qui est appliqué dans notre interface d’attaque se répercute sur l’interface des bateaux de
l’ennemie.
Pour ensuite déterminer qui a gagné à chaque session de tir l’ordinateur va regarder s’il a perdu, temps que
tout va bien il envoie à l’ordinateur ennemi un message ‘ok’, mais lorsqu’il a perdu il va envoyer comme
message ‘fin’ si l’ordinateur reçoit donc un message ‘fin’ il ouvre une fenêtre informative expliquant que
l’utilisateur a gagné ou perdu en fonction de qui a envoyé le message de ‘fin’ les sockets sont ensuite fermées
et le programme se ferme.
Figure 18 message perdant Figure 19 message gagnant
Une fois appuyé sur ‘ok’ les fenêtres se ferment. Pour cette version de bataille navale, nous avons décidé
d’enlever la partie sauvegarde sql pour le moment pour se concentrer juste sur la partie en elle-même.
Avec plus de temps nous pourrions créer une base de données répertoriant les parties jouées et contre
qui.
Nous avions donc fini cette version de la bataille navale et la version V3.5 aussi dont voici les explications :
Travail supplémentaire V3
17
Nous n’étions pas satisfaits du rendu graphique du premier tkinter. Pour remédier à ce problème nous
avons mis en place une version 3.5, avec une interface de jeu bien plus belle.
Il y a plusieurs changements majeurs, le premier vient des classes Bouton et LabelCanavas qui dans la V3
héritaient de la classe Canvas de tkinter. Cela permettait de bien séparer chaque bouton et chaque zone
de clique mais posait des problèmes de transparence et de mise en place. Faire une interface plus complexe
avec ces Classes étaient impossible.
C’est pourquoi ces classes ont été réécrites et placées dans un fichier à part nommé « ConstructCanvas ».
Maintenant elles n’héritent plus de la classe Canvas, elles vont créer leur image et texte directement sur
un canvas mère, qui sera dans notre cas le canvas global sur lequel tous les éléments sont placés.
Cette méthode permet maintenant de prendre en compte la transparence ainsi que de mieux gérer la taille
des différents éléments. Via notamment l’utilisation de la bibliothèque PIL permettant de changer la taille
des images pour toujours avoir la taille demandée par le programme.
Un problème apparaît ici pour les boutons, en effet dans la version précédente, chaque bouton étant un
canvas à part entière, chacun pouvait avoir son événement relié au clic droit de la souris. Ce n’est plus le
cas dans la nouvelle version, il n’y a qu’un seul canvas, donc qu’un seul événement de la clique. Ce dernier
est relié au dernier bouton créé, il n’y a donc que lui qui fonctionne.
Pour résoudre ce problème, nous avons mis en place une variable de classe « dict_hit_box » qui sera un
dictionnaire ayant pour clé le bouton et comme valeur une liste contenant la hit box du bouton, les
coordonnées entre lesquelles le bouton sera cliqué.
Cela permet à l’événement de la clique du dernier bouton créer de tester les autres boutons déjà créés et
de si c’est un autre bouton qui est touché, de lancer la procédure de clique de ce bouton en particulier.
Figure 21: Bouton en V3.5 Figure 20: Bouton en V3
Tous ces changements permettent d’obtenir des boutons plus jolis, car acceptant la transparence comme
vous pouvez le voir sur la comparaison ci-dessus.
Une fois ces outils en place, nous avons pu commencer la nouvelle version du Jeu. Nous avons abandonné
l’idée des boutons constituant la grille, car trop complexe à rendre esthétique. Au lieu de cela nous utilisons
l’événement du clic droit de la souris (comme sur les boutons) pour analyser si le curseur de l’utilisateur
est dans une case ou non.
Pour cela nous créons une classe Case qui contiendra toutes les caractéristiques de ces dernières
(coordonnées sur la grille, coordonnées sur le canvas, taille). L’utilisation d’un dictionnaire de case ayant
18
comme clé ses coordonnées sur la grille permettent de rapidement tester si le clic de l’utilisateur se trouve
dans une des cases ou non.
Cette nouvelle méthode de détection permet de mettre n’importe quelle texture en fond du champ de
bataille, c’est pourquoi nous avons opté pour une texture d’eau.
Ce champ de bataille fait toujours 700px sur 700px, donc les cases font 70px sur 70px. Il faut maintenant
mettre en place les textures des navires ainsi que des explosions.
Les textures des navires sont obtenues via le découpage d’image vu de haut de navires, elles sont ensuite
mises à la bonne échelle (70px de large) et découpées en autant de partis que le navire contient de case (5
pour le Porte-Avions, 4 pour le Cuirassé, …). Ce découpage n’était pas forcément nécessaire car le navire
n’est affiché qu’une fois toutes ses cases touchées, mais cela permet de s’assurer que le navire rentre bien
parfaitement dans ses cases. Des textures d’explosion de feu et d’eau sont également ajoutées lorsque l’on
touche un bateau ou la mer.
Tout cela permet donc facilement à l’utilisateur de savoir si son tir touche, coule ou rate.
Un ajout de sound design, via l’utilisation de la bibliothèque Pygame, permet également d’amplifier le
phénomène via l’utilisation de différents sons lorsqu’un boulet touche l’eau ou un navire.
Figure 22: Interface du Jeu
Une fois l’interface de Jeu créer, il faut encore créer l’habillage de ce dernier. Cela se fait via l’insertion
d’images de cadran de sous-marin ainsi que de l’utilisation de LabelCavas pour afficher les informations
19
importantes, comme le nombre de tirs, le pourcentage de précision, ainsi que le score. Enfin l’ajout d’un
bouton pour retourner au Menu permet de quitter le Jeu.
Figure 23: Interface Complète
Le Score est calculé ainsi : +1 si on touche une case d’eau, +10 si on touche un bateau, +100 si on coule un
navire. Ce score est ensuite multiplié par le pourcentage (Pouvant donc au maximum multiplié le score par
100). Le score maximum étant donc de 182000 pts et le minimum de 32351 pts.
Une fois que l’utilisateur à détruit tous les navires, un message lui indiquant la victoire apparaît, son score
est sauvegardé dans la base de données et il peut retourner au menu via le bouton en bas à droite.
Cette version 3.5 voit également la suppression de la bibliothèque combat, car la détection et la gestion du
tir se font directement dans le même fichier que le tkinter.
20
Figure 24: Victoire V3.5
Pour améliorer encore l’expérience utilisateur ainsi que l’immersion dans le jeu nous avons inclus des
musiques dans le jeu via la bibliothèque Pygame.
21
Conclusion
Ce projet a été très instructif à bien des égards. La construction de code via l’ajout de complexité
au fur et à mesure et via différentes versions a permis d’avancer pas à pas, sans pour autant avoir affaire à
de très complexes problématiques à chaque fois. Petit à petit nous sommes arrivés à des codes plus
complexes et ambitieux. Cela a également était permis via un travail d’équipe remarquable, via notamment
l’utilisation de l’extension live share de visual studio code, qui a permis de très rapidement finir la V0, V1,
et V2. À partir de la V3, nous nous sommes divisé le travail, l’un d’entre nous ayant codé l’interface du jeu,
l’autre le menu. Ce projet nous a permis de confirmer nos acquis et connaissances sur les bases de données,
et les classes python qui nous a été très utile pour résoudre de nombreuses problématiques tel que la
contiguïté. De plus nous avons pu avoir un avant-goût de la programmation réseau, qui bien que complexe,
est extrêmement intéressante et amusante à mettre en place surtout dans le cadre d’un jeu tel que la
bataille navale.
Pour aboutir encore plus ce projet nous pourrions par la suite appliquer les graphismes de la version 3.5 à
la version 4. Puis appliquer notre sauvegarde de données en créant une table plus complète pour regrouper
toutes les informations des 2 joueurs. Puis après peut-être travailler sur l’ouverture d’un serveur en ligne
pour jouer sur des réseaux différents et non pas qu’en local.
Annexe
Table des illustrations

Figure 1: L'outil Live Share de VS Code permettant de travailler à plusieurs sur le même code. ..................4
Figure 2: Notre Base de données ....................................................................................................................5
Figure 3: Affichage sans contiguïté .................................................................................................................7
Figure 4: Affichage avec contiguïté................................................................................................................7
Figure 5: Affichage sans Navire .......................................................................................................................8
Figure 6: Affichage avec Navire ......................................................................................................................8
Figure 7: Première version fonctionnelle du Tkinter ....................................................................................10
Figure 8: Deuxième version de l'interface Tkinter ........................................................................................11
Figure 9: Victoire V3......................................................................................................................................12
Figure 10: Menu V3.......................................................................................................................................12
Figure 11: Score Board V3.............................................................................................................................13
Figure 12 code client .....................................................................................................................................14
Figure 13 code serveur .................................................................................................................................14
Figure 14: Première utilisation du réseau.....................................................................................................15
Figure 15 demande de user ..........................................................................................................................16
Figure 16: Discussion réseau des commandes de tirs ..................................................................................16
Figure 17: Interface Tkinter Réseau ..............................................................................................................17
22
Figure 18 message perdant...........................................................................................................................17

Figure 19 message gagnant ..........................................................................................................................17
Figure 20: Bouton en V3 ...............................................................................................................................18
Figure 21: Bouton en V3.5 ............................................................................................................................18
Figure 22: Interface du Jeu ...........................................................................................................................19
Figure 23: Interface Complète ......................................................................................................................20
Figure 24: Victoire V3.5.................................................................................................................................21
23

GPIIPSA

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

GPIIPSA

Transféré par

Droits d'auteur :

Formats disponibles

Rapport projet

Table des matières

Travail supplémentaire V3 ............................................................................................................................17

Organisation du grand projet

L’organisation pour la réalisation de ce grand projet a été définie de la manière suivante :

Cette première esquisse prenait donc en compte plusieurs fonctions :

creerTerrain Permet de créer le terrain de jeu en fonction de la

tirer Prend la case entrée par l’utilisateur et va déterminer.

Jouer Lance le jeu.

Des fonctions supplémentaires ont été intégrées pour terminer la V0 :

verifVictoire Vérifie si le terrain contenant les bateaux contient

Figure 2: Notre Base de données

En fin de jeu le programme affiche le joueur ayant le meilleur score.

Fichier Fonctions Utilité

La V1 apporte que de petit complément à la V0.

Figure 4: Affichage avec contiguïté Figure 3: Affichage sans contiguïté

Nous obtenons donc un affichage sans contiguïté.

Figure 5: Affichage sans Navire Figure 6: Affichage avec Navire

Nous obtenons l’affichage ci-dessus.

Cela nous donne donc un graphique composé de 10 colonnes et de 10 lignes :

Figure 7: Première version fonctionnelle du Tkinter

Figure 8: Deuxième version de l'interface Tkinter

Verif victoire Vérifie l’état des bateaux pour savoir si l’utilisateur

Figure 10: Menu V3

Cela se présente comme ceci :

Figure 11: Score Board V3

Figure 12 code client

Figure 13 code serveur

Figure 14: Première utilisation du réseau

Figure 15 demande de user

Cela va nous donner les PowerShell suivants :

Figure 16: Discussion réseau des commandes de tirs

Figure 17: Interface Tkinter Réseau

Figure 18 message perdant Figure 19 message gagnant

Figure 21: Bouton en V3.5 Figure 20: Bouton en V3

Figure 22: Interface du Jeu

Figure 23: Interface Complète

Figure 24: Victoire V3.5

Table des illustrations

Figure 18 message perdant...........................................................................................................................17

Vous aimerez peut-être aussi