#!/usr/bin/python3 # -*- coding: utf-8 -*- """ TP AP1 Licence SESI 1ère année Univ. Lille 1 bataille_navale.py Module pour le jeu de bataille navale. Pour une description générale du jeu voir http://fr.wikipedia.org/wiki/Bataille_navale_%28jeu%29 """ __author__ = 'BEAUSSART Jean-loup & PREUD\'HOMME Geoffrey' __date_creation__ = 'Mon, 16 Feb 2015 19:22:32 +0100' ############################################### # Modules utilisés ############################################### # Pour la disposition aléatoire des navires from random import randint # Pour le fichier des scores from datetime import datetime ############################################### # Constantes nommées utilisées ############################################### # les deux dispositions possibles pour un navire # sur le plateau : # - H : horizontale # - V : verticale DISPOSITIONS = "HV" # codes réponses d'analyse de tirs RATE = 0 TOUCHE = 1 COULE = 2 # nom du fichier contenant les scores réalisés FICHIER_RESULT = 'bataille_navale_scores.txt' ############################################### # Procédure principale du jeu ############################################### def jouer(nom, descr): """ str, str -> () procédure de jeu complet de bataille navale, le nom du joueur est donné par le paramètre nom, et le jeu est décrit dans le fichier descr. CU : le fichier jeu doit exister et être conforme à un fichier de description. """ jeu = cree_jeu(descr) print(jeu) decrire_le_jeu(jeu) nbre_tirs = 0 while not tous_coules(jeu): tir = lire_un_tir(nom) nbre_tirs += 1 nav, res = analyse_un_tir(jeu, tir) if res == RATE: print("raté.") elif res == TOUCHE: print(nav + " touché.") else: print(nav + " coulé.") sauver_result(nom, descr, nbre_tirs) print("Terminé en {0} tirs".format(nbre_tirs)) ############################################### # Opérations sur les fichiers ############################################### def lire_donnees(num_descr): """ str -> tuple renvoie un triplet dont les deux premières composantes sont et la troisième une liste de couples (nature, taille) où nature est une chaîne de caractères décrivant la nature du navire et taille un entier désignant le nombre de cases occupées par ce navire. Toutes ces données sont lues dans un fichier nommé 'jeu'+num_descr+'.txt'. CU : le fichier 'jeu'+num_descr+'.txt' doit exister et être au bon format, ie un fichier texte contenant : larg : haut nature1 : taille1 nature2 : taille2 ... """ # with s'occupe de fermer automatiquement le fichier ouvert, c'est un gestionnaire de contexte. # Il ferme le fichier à la fin du bloc, si une exception est levée ou si on rencontre un # break/return, autrement dit, quoi qu'il arrive with open('jeu%s.txt' % num_descr, 'r') as fichier: dimensions = fichier.readline().split(':') largeur, hauteur = int(dimensions[0].strip()), int(dimensions[1].strip()) navires = list() for ligne in fichier: couple = ligne.split(':') navires.append((couple[0].strip(), int(couple[1].strip()))) return (largeur, hauteur, navires) # Tests # print(lire_donnees('1')) # print(lire_donnees('2')) # print(lire_donnees('3')) # Fichier personnalisé # Sauvegarde du bilan # >>> datetime.today() # datetime.datetime(2015, 2, 16, 19, 6, 17, 207811) # On obtient la date et l'heure sous forme d'objet datetime # >>> str(datetime.today()) # '2015-02-16 19:07:31.624846' # On obtient la date et l'heure au format AAAA-MM-JJ HH:MM:SS.UUUUUU def sauver_result(nom, jeu, nbre): """ str, str, int -> NoneType ajoute une ligne dans le fichier FICHIER_RESULT contenant le nom, le numéro du jeu joué et le nombre de tirs effectués dans la partie. CU : aucune """ with open(FICHIER_RESULT, 'a') as fichierScores: fichierScores.write(':'.join([nom, str(jeu), str(nbre), str(datetime.today())]) + '\n') # sauver_result('Pisitrate', 2, 125) # sauver_result('Aristide', 52, 12) # sauver_result('Caligula', 1112, 12356) # sauver_result('Périclès', 12, 1458) ############################################### # Procédures de construction du jeu ###############################################< def cree_jeu(descr): """ str -> dict renvoie un nouveau jeu de bataille navale construit à partir des données lues dans le fichier descr. Le jeu est représenté par un dictionnaire à quatre clés : - 'plateau' pour représenter le plateau de jeu (l'espace maritime) avec ses navires - 'nb_cases_occupees' dont la valeur associée est le nombre de cases du plateau occupées par les navires - 'touches' dictionnaire contenant deux champs : * l'un nomme 'nb_touches' contenant un entier * l'autre nomme 'etats_navires' qui contient un dictionnaire donnant pour chaque navire le nombre de tirs qu'ils peuvent encore recevoir avant d'être coulés - 'coups_joues' ensemble des coups joués depuis le début de la partie. CU : le fichier doit contenir une description correcte du jeu (cf lire_donnees) """ donnees = lire_donnees(descr) nb_cases_occupees = 0 etats_navires = dict() for n in donnees[2]: etats_navires[n[0]] = n[1] nb_cases_occupees += n[1] return {'plateau': cree_plateau(*donnees), 'nb_cases_occupees' : nb_cases_occupees, \ 'touches': {'nb_touches': 0, 'etats_navires': etats_navires}, 'coups_joues': set()} # Tests # print(cree_jeu('1')) # print(cree_jeu('2')) # print(cree_jeu('3')) def cree_plateau(l, h, l_nav): """ int, int, list -> dict renvoie un plateau de largeur l et de hauteur h occupé par les navires de l_nav. La disposition est aléatoire. CU : les dimensions doivent permettre le placement de tous les navires """ esp = {'larg': l, 'haut': h} for nav in l_nav: placer(esp, nav) return esp def cases_du_navire(nav, pos, disp): """ tuple, tuple, str -> list fournit une liste des cases occupées par un navire nav aux coordonnées pos dans la disposition disp CU : disp = 'H' ou 'V' """ assert(disp in DISPOSITIONS), 'disp = \'H\' ou \'V\'' cases = list() if disp == 'H': for i in range(pos[0], pos[0]+nav[1]): cases.append((i, pos[1])) elif disp == 'V': for i in range(pos[1], pos[1]+nav[1]): cases.append((pos[0], i)) return cases def est_placable(esp, nav, pos, disp): """ dict, tuple, tuple, str -> bool indique si le navire nav aux coordonnées pos peut être posé dans la disposition disp dans l'espace maritime esp CU : disp = 'H' ou 'V' """ assert(disp in DISPOSITIONS), 'disp = \'H\' ou \'V\'' for c in cases_du_navire(nav, pos, disp): if c[0] > esp['larg'] or c[0] <= 0 or c[1] <= 0 or c[1] > esp['haut'] or c in esp: return False return True # Tests # espTest = {'larg': 4, 'haut': 3, (1, 2): 'grand', (2, 2): 'grand', (4, 1): 'petit'} # print(est_placable(espTest, ('Poutre', 3), (1, 1), 'H')) # True # print(est_placable(espTest, ('Buche', 3), (1, 1), 'V')) # False # print(est_placable(espTest, ('Règle', 3), (3, 1), 'V')) # True # print(est_placable(espTest, ('Antenne', 3), (3, 2), 'V')) # False def placer(esp, nav): """ dict, tuple -> NoneType place le navire nav dans l'espace maritime esp. Choix de l'emplacement aléatoire. CU : il doit rester de la place """ while True: pos = (randint(0, esp['larg']-1), randint(0, esp['haut']-1)) disp = DISPOSITIONS[randint(0, 1)] if est_placable(esp, nav, pos, disp): for c in cases_du_navire(nav, pos, disp): esp[c] = nav[0] return # Tests # espTest2 = {'larg': 4, 'haut': 3} # placer(espTest2, ('grand', 2)) # placer(espTest2, ('petit', 1)) # print(espTest2) # Aléatoire ############################################### # Procédures de déroulement du jeu ############################################### def decrire_le_jeu(jeu): """ dict -> () imprime une description du jeu. CU : aucune """ print('Dimensions du plateau de jeu :') print('- largeur : %d' % jeu['plateau']['larg']) print('- hauteur : %d' % jeu['plateau']['haut']) print('Navires :') etats = jeu['touches']['etats_navires'] for navire in etats: print('- %s : %d case%s' % (navire, etats[navire], 's' * (etats[navire] >= 2))) print( 'À vous de jouer en répondant à l\'invite ?- par deux nombres séparés par une virgule.') def lire_un_tir(nom): """ str -> tuple renvoie un couple d'entiers lus sur l'entrée standard CU : l'entrée doit être de la forme xxx,yyy avec xxx et yyy une représentation décimale de deux nombres entiers """ while True: try: entree = input('%s - ' % nom) dec = entree.split(',') x, y = int(dec[0]), int(dec[1]) assert x > 0 and y > 0 return (x, y) except KeyboardInterrupt: sys.exit(0) except IndexError: print('Merci de saisir deux composantes séparées par une virgule') except ValueError: print('Merci de saisir des composantes entières') except AssertionError: print('Merci de saisir des composantes strictement positives') def analyse_un_tir(jeu, tir): """ dict, tuple -> str,int renvoie - ("",RATE) si tir raté - (nav,TOUCHE) si nav touché - (nav,COULE) si nav coulé et modifie l'état du jeu en conséquence. CU : aucune """ if tir in jeu['coups_joues']: return ('', RATE) elif tir in jeu['plateau']: jeu['coups_joues'].add(tir) nav = jeu['plateau'][tir] jeu['touches']['nb_touches'] += 1 jeu['touches']['etats_navires'][nav] += -1 if jeu['touches']['etats_navires'][nav] > 0: return (nav, TOUCHE) else: return (nav, COULE) else: jeu["coups_joues"].add(tir) return ('', RATE) # Tests # test = {'nb_cases_occupees': 3, 'plateau': {'haut': 3, (2, 3): 'grand', 'larg': 4, (2, 1): \ # 'petit', (2, 2): 'grand'}, 'coups_joues': set((1, 2)), 'touches': {'etats_navires': {'grand': 2, \ # 'petit': 1}, 'nb_touches': 0}} # print(analyse_un_tir(test, (1, 1)) == ('', RATE)) # print(analyse_un_tir(test, (1, 2)) == ('', RATE)) # print(analyse_un_tir(test, (2, 2)) == ('grand', TOUCHE)) # print(analyse_un_tir(test, (2, 1)) == ('petit', COULE)) def tous_coules(jeu): """ dict -> bool renvoie True si tous les navires du plateau de jeu ont été coulés et False dans le cas contraire. CU : aucune """ return jeu['touches']['nb_touches'] >= jeu['nb_cases_occupees'] ############################################### # Pour une utilisation du module depuis un terminal ############################################### if __name__ == '__main__': import sys if len(sys.argv) != 3: jouer('Jean Bart', '1') else: jouer(sys.argv[1], sys.argv[2])