Chaque joueur dispose d'une grille quadrillée horizontalement de 1 à 10 et verticalement de A à J. Les joueurs placent leur bateaux comme ils le souhaitent sur leur propre grille, en se cachant de leur adversaire.

Ensuite les joueurs font un tir chacun leur tour.

Quand vient son tour, un joueur annonce où il tire. Par exemple B7. L'adversaire réponde À l'eau si le tir n'a rien touché ou bien Touché quand le tir a touché un bateau et si toutes les cases du bateau ont été touchées, l'adversaire doit même annoncer Coulé.

Le premier à couler la flotte de son adversaire à gagné.

Bien que la grille soit une grille à 2 dimensions, on va procéder un peu différemment. On choisit de numéroter chaque case selon son ordre sa position dans l'ordre de lecture.

Ainsi la case F5 correspond au numéro 54.

Il faudra donc prévoir une fonction…

def adresse_to_index(adresse:str) -> int:
    """
    adresse: chaine comme "F5"
    renvoie le numéro de la case. Pour "F5" le numéro est 54
    """

On décide qu'une case vide contiendra 0. La grille entièrement vide sera donc :

grille_vide = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

À la bataille navale, chaque joueur dispose des navires suivants :

• 1 porte-avions : 5 cases,
• 1 croiseur : 4 cases,
• 2 contre-torpilleurs : 3 cases
• 1 torpilleur : 2 cases

Le nom des navires n'a pas d'importance. On décide d'allouer à chaque bateau un numéro pour les identifier. 1 pour le porte-avions, 2 pour le croiseur, 3 et 4 pour les contre-torpilleurs et 5 pour le torpilleur.

Voici une grille de jeu possible :

grille = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          0, 0, 0, 2, 2, 2, 2, 0, 0, 0,
          0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
          0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
          0, 0, 5, 5, 0, 0, 0, 0, 1, 0,
          0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
          0, 0, 0, 0, 0, 4, 0, 0, 1, 0,
          0, 0, 0, 0, 0, 4, 0, 0, 0, 0,
          0, 3, 3, 3, 0, 4, 0, 0, 0, 0,
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Par exemple ici, le croiseur est au indices 13 à 16, c'est à dire aux positions B4 à B7.

On veut une fonction lire(grille:list, adresse:str) → int qui pour une grille de jeu et une adresse – par exemple "B4" – renvoie le contenu de la case.

Avec la grille précédente, il faut que lire(grille, "B4") renvoie 2.

On veut une fonction ecrire(grille:list, adresse:str, valeur:int) permettant d'écrire la valeur indiquée à la position demandée dans la grille.

Par exemple, si avec la grille précédente, on exécute ecrire(grille, "B5", 0), la grille devient :

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 2, 0, 2, 2, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
 0, 0, 5, 5, 0, 0, 0, 0, 1, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
 0, 0, 0, 0, 0, 4, 0, 0, 1, 0,
 0, 0, 0, 0, 0, 4, 0, 0, 0, 0,
 0, 3, 3, 3, 0, 4, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

On a besoin d'une fonction coulé(grille:list, navire:int) → bool

• grille est la grille de jeu
• navire est le numéro de navire, par exemple 1 pour le porte-avions
• la fonction renvoie True si ce navire est coulé, c'est à dire si l'entier identifiant le navire n'est plus présent dans la grille.

Quand on tire sur une flotte, on veut savoir si on a touché et éventuellement si on a coulé.

Il faut donc une fonction tir(flotte:list, adresse:str) → (bool,bool),

• on précise en entrée la flotte de l'adversaire et la case ciblée,
• la fonction doit renvoyer deux booléens. Le premier indique si un navire est touché et le second indique si un navire est coulé. Par exemple, le retour True, False indique que c'est « touché » mais pas « coulé ».
• en cas de « touché », la flotte est modifiée en remplaçant la position par 0.

Par exemple, avec la grille précédente :

touché, coulé = tir(grille, "B6")
# touché est True
# coulé est False
# la grille devient :
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 2, 2, 0, 2, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
 0, 0, 5, 5, 0, 0, 0, 0, 1, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
 0, 0, 0, 0, 0, 4, 0, 0, 1, 0,
 0, 0, 0, 0, 0, 4, 0, 0, 0, 0,
 0, 3, 3, 3, 0, 4, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

On veut une fonction vide(grille:list) → bool qui renvoie True quand la grille est vide.

Dans le but de pouvoir jouer avec la machine on voudrait pouvoir remplir une grille aléatoirement.

C'est un problème difficile. Dans un premier temps vous pouvez vous contenter d'imposer une grille fixe à la machine. Dans un deuxième temps, vous pouvez fournir à la machine une quantité raisonnable de grille prédéfinies et lui faire choisir aléatoirement parmi ces grilles. Et puis si vous avez une bonne idée, vous pouvez lui faire placer aléatoirement ses navires.

Ces fonctions étant définies, vous avez les ingrédients pour lancer le jeu. À vous de les assembler !

Vous pouvez créer une version de jeu simplifiée ou l'humain est le seul à tirer :

• au démarrage du jeu, la machine initialise sa propre grille,
• l'ordinateur ne tire pas,
• à chaque tour, le joueur est invité à entrer une adresse de tir,
• la machine essaie cette adresse sur sa grille et répond au joueur : manqué, touché ou coulé.
• Le joueur recommence jusqu'à avoir coulé la flotte de la machine ou bien on peut décider d'un nombre maximal de coups autorisés.