Bataille navale

Le kit est découpé comme un projet : le réseau d’un côté, la boucle de jeu de l’autre, et vos décisions isolées dans trois fichiers. Ce découpage vous permettra de changer d’interface ou de stratégie sans rien casser ailleurs.

Le premier quart d’heure

Terminalcd battleship-kit
python -m venv .venv
.venv\Scripts\activate            # sous Windows
source .venv/bin/activate         # sous macOS et Linux
pip install -r requirements.txt

python main.py --serveur $SERVEUR --nom "Les Corsaires"

Le client s’inscrit, trouve une partie, envoie sa flotte, puis s’arrête sur NotImplementedError: jalon 1 : tir aleatoire sans repetition. C’est le point de départ prévu. À partir de là, ce sont les tests qui vous guident.

arborescencebattleship-kit/
    main.py               assemble les morceaux
    banc.py               mesure une strategie hors ligne
    requirements.txt
    battleship/
        api.py            les appels au serveur
        game.py           la boucle d'une partie
        fleet.py          le placement des navires
        strategy.py       le choix du tir
        display.py        l'affichage
    tests/
        test_fleet.py     ce qu'exige le serveur
        test_strategy.py  ce qu'exige une strategie

Les tests comme liste de courses

Terminalpytest -q

Cinq tests passent déjà : ils portent sur la flotte fournie et montrent ce qu’un placement valide veut dire. Les autres échouent, et chacun décrit une contrainte que le serveur appliquera pendant la partie. Les faire passer un par un vaut mieux que découvrir une règle en plein tournoi. Ils tournent sans serveur, donc aussi souvent que vous voulez. Au jalon 2, vous en ajouterez deux à vous, sur votre propre stratégie : lire une spécification est une chose, en écrire une en est une autre.

Chaque binôme crée un dépôt GitHub dès le lundi, y pousse le kit tel quel, puis y travaille toute la semaine. Il n’y a pas d’autre rendu : le code, les diapositives du prosit retour et celles de la soutenance sont lus sur le dépôt, dans l’état où il se trouve à chaque échéance.

arborescencevotre-depot/
    README.md             les deux noms, et comment lancer le client
    .gitignore            fourni, il écarte .venv et les caches
    main.py
    requirements.txt
    battleship/           votre code
    tests/                ceux du kit, plus les vôtres au jalon 2
    slides/
        prosit.pdf        avant le prosit retour du mardi
        soutenance.pdf    avant la soutenance du vendredi

Les premières commandes

Terminal# dans le dossier du kit, une fois le dépôt créé sur github.com
git init
git add .
git commit -m "Kit de depart"
git branch -M main
git remote add origin https://github.com/VOTRE_COMPTE/VOTRE_DEPOT.git
git push -u origin main

# puis, tout au long de la semaine, à chaque étape qui tient debout
git add .
git commit -m "Tir aleatoire sans repetition"
git push

Le second membre clone le dépôt et pousse de la même manière. Public ou privé, à vous de voir : s’il est privé, invitez l’enseignant comme collaborateur.

Un seul prosit retour, mardi en fin de journée : le jalon 1 doit être bouclé pour cette échéance-là. Le jalon 2 se construit ensuite en autonomie, du mercredi au vendredi matin, et c’est la soutenance qui le vérifie. Le check du mercredi après-midi n’est pas une évaluation : on regarde ensemble où vous en êtes, et c’est le moment de dire ce qui coince pendant qu’il reste deux jours. Trois jours et demi de développement effectif en tout, le lundi matin et le jeudi après-midi appartenant à d’autres activités.

D’abord jouer, ensuite bien jouer. Le premier jalon produit une partie complète contre un bot, avec une interface pour la suivre. Le second remplace le hasard par une stratégie, au tir comme au placement.

Le prosit retour

Il n’y en a qu’un, mardi en fin de journée, et il porte sur le jalon 1 : le jalon 2 se présente à la soutenance. Dix minutes devant le groupe, diapositives projetées, puis les questions. L’objectif n’est pas de montrer que tout fonctionne, mais d’expliquer où vous en êtes et pourquoi. Une difficulté rencontrée et analysée vaut mieux qu’une démonstration lisse dont personne ne comprend le fonctionnement.

Six diapositives, dans cet ordre, plus deux annexes au maximum. Pas de code sur les diapositives, sauf trois lignes quand elles portent le propos : le code se montre à l’écran, pas en image.

Le serveur n’envoie pas d’images, il envoie des faits. Afficher la partie consiste à traduire l’état reçu à chaque tour en une représentation lisible. Voici ce dont vous disposez :

Quatre paliers, du plus simple au plus ambitieux. Les deux premiers sont attendus, les autres sont là pour ceux qui veulent aller plus loin.

1. Le hasard sans répétition 97 coups

   Une case au hasard, jamais deux fois la même, sinon le serveur refuse le tir et vous perdez votre tour. C’est ce que fait votre client au jalon 1, et c’est le niveau du bot Facile.

   Dans quelle structure gardez-vous les cases déjà jouées ?

2. Chasse et achèvement 69 coups

   Tant que rien n’est touché, vous cherchez. Dès qu’un tir répond HIT, le navire continue forcément dans une des quatre cases voisines : vous les explorez avant de repartir ailleurs. Et si deux touches s’alignent, vous connaissez sa direction. C’est le niveau du bot Chasseur, votre adversaire de référence : il applique cette idée sans rien de plus.

   Comment tenez-vous la liste des cases à explorer ? Et qu’en faites-vous quand le serveur répond SUNK, alors qu’elle peut contenir des touches d’un autre navire ?

3. Le damier 54 coups

   Le plus petit navire occupe deux cases collées. Il ne peut donc pas se cacher entre les cases d’un damier bien espacé, ce qui vous dispense d’en viser la moitié tant qu’il n’est pas coulé.

   Quel espacement choisissez-vous, et quand cesse-t-il d’être valable ?

   C’est le niveau du bot Moyen. Une chasse sans damier ne lui prend qu’un duel sur quatre : tant que vous n’avez pas ce palier, ne vous étonnez pas de perdre contre lui.

4. La carte de probabilités 49 coups

   Pour chaque case libre, comptez dans combien de positions possibles des navires encore à flot elle apparaît, puis visez le maximum. C’est ce que fait le bot Difficile : du dénombrement, contraint par ce que vous avez déjà observé.

   Le comptage lui-même est rapide, moins d’une milliseconde par tour. La vraie difficulté est ailleurs : quand un navire coule, lesquelles de vos touches lui appartenaient ?

Le banc d’essai

Une partie contre le serveur dure plusieurs minutes ; cinquante parties au banc tiennent en une seconde. C’est ce qui vous permet de comparer deux idées au lieu d’en défendre une au feeling. Il applique les mêmes règles que le serveur, refus des tirs répétés compris, mais ne simule ni le réseau ni le chronomètre : un client qui passe au banc doit encore tourner en ligne.

Terminalpython banc.py                      # votre tir, 50 parties
python banc.py --flotte             # votre placement, vu d'en face
python banc.py --parties 200        # quand l'ecart est trop petit pour conclure

Et votre propre placement

Au jalon 2, vous remplacez la flotte au hasard du kit par la vôtre. On pense surtout au tir, mais la moitié du sort se joue en posant les navires. Ils ont le droit de se toucher : est-ce imprudent face à un adversaire qui explore les cases voisines d’une touche, ou est-ce au contraire ce qui l’égare ? Les bords protègent-ils vraiment ? Et garder le même placement quand on affronte trois fois la même équipe, est-ce tenable ? banc.py --flotte fait attaquer votre flotte et celle du kit par le même adversaire : la question se tranche en dix secondes, et une réponse mesurée vaut mieux qu’une réponse plausible.

Le client se lance toujours de la même manière, seules les options changent. Elles sont lues en haut de main.py : ce fichier vous appartient, rien ne vous empêche d’en ajouter.

Trois lancements typiques

Terminal# premiers pas : un bot qui tire au hasard
python main.py --serveur $SERVEUR --nom "Les Corsaires"

# mesurer une strategie : dix parties contre le damier
python main.py --serveur $SERVEUR --nom "Les Corsaires" --niveau moyen --parties 10

# affronter une autre equipe : les deux binomes lancent ceci
python main.py --serveur $SERVEUR --nom "Les Corsaires" --file

# le jour du tournoi : rester disponible, et ne pas couper
python main.py --serveur $SERVEUR --nom "Les Corsaires" --tournoi --parties 60

Avec --file, le client entre dans la file publique et attend : votre nom apparaît sous « en attente d’un adversaire » au tableau de bord, et la partie démarre dès qu’une autre équipe s’y présente. Tant que personne n’attend en face, le client tourne sans rien afficher, et c’est normal : prévenez la salle, ou convenez d’une heure avec le binôme que vous visez.

--tournoi ne demande rien au serveur : il attend. Pendant un tournoi, c’est l’arbitre qui cree les rencontres, et votre client n’a qu’a etre la quand la sienne arrive. Vous apparaissez donc « en ligne » sans apparaitre dans la file. Dimensionnez --parties largement : une manche dont la flotte n’arrive pas dans les quatre-vingt-dix secondes est perdue, et un client arrete en cours de route abandonne toutes ses rencontres restantes.

La soutenance reprend le format du prosit retour, en plus complet : une dizaine de diapositives, une démonstration en direct, puis les questions sur le code.

Les repères

Le déroulé d’une partie

Les corps de requête et de réponse

envoyé{
  "name": "Les Corsaires"
}

reçu{
  "token": "kJ8...",
  "player_id": "3f9a1c02",
  "name": "Les Corsaires",
  "message": "..."
}

envoyé{
  "ships": [
    { "ship": "porte_avions",      "x": 0, "y": 0, "orientation": "H" },
    { "ship": "croiseur",          "x": 4, "y": 3, "orientation": "V" },
    { "ship": "contre_torpilleur", "x": 7, "y": 1, "orientation": "V" },
    { "ship": "sous_marin",        "x": 2, "y": 6, "orientation": "H" },
    { "ship": "torpilleur",        "x": 9, "y": 8, "orientation": "V" }
  ]
}

reçu{
  "status": "playing",
  "opponent": "Les Flibustiers",
  "your_turn": true,
  "seconds_left": 24.3,
  "turn_number": 17,
  "your_shots":      [ { "x": 4, "y": 2, "result": "HIT",  "ship": "croiseur" } ],
  "shots_received":  [ { "x": 0, "y": 0, "result": "MISS" } ],
  "your_fleet":      [ { "ship": "croiseur", "name": "Croiseur",
                         "size": 4, "hits": 1, "sunk": false } ],
  "opponent_ships_remaining": 4,
  "winner": null,
  "finished": false
}

envoyé{ "x": 4, "y": 2 }

reçu{
  "result": "SUNK",
  "ship": "croiseur",
  "ship_name": "Croiseur",
  "ship_size": 4,
  "your_turn": false,
  "remaining_ships": 3,
  "finished": false,
  "winner": null
}

Quand le serveur refuse

Une erreur arrive toujours sous la forme { "error": "..." }, avec un code HTTP. Le kit la transforme en message lisible : affichez-le.

Essayer à la main

Facultatif, mais instructif : jouer un tour depuis le terminal montre exactement ce qui circule, et aide beaucoup le jour où le code ne fait pas ce que vous croyez. Sous Windows, écrivez curl.exe, car curl est un alias vers autre chose dans PowerShell.

Terminal# les réglages de la partie
curl $SERVEUR/api/config

# inscription, on note le jeton renvoyé
curl -X POST $SERVEUR/api/register \
     -H "Content-Type: application/json" \
     -d '{"name": "Les Corsaires"}'

# un entraînement contre le bot Facile
curl -X POST $SERVEUR/api/sparring \
     -H "Content-Type: application/json" \
     -H "X-Token: MON_JETON" \
     -d '{"level": "facile"}'

# le match en cours, puis son état
curl $SERVEUR/api/match/current -H "X-Token: MON_JETON"
curl $SERVEUR/api/match/MON_MATCH/state -H "X-Token: MON_JETON"

# un tir en E3, soit x=4 et y=2
curl -X POST $SERVEUR/api/match/MON_MATCH/fire \
     -H "Content-Type: application/json" \
     -H "X-Token: MON_JETON" \
     -d '{"x": 4, "y": 2}'

• Tirer sans regarder à qui est la main. Le serveur répond 409 et le chronomètre continue de tourner. Lisez your_turn avant chaque tir.
• Intervertir x et y. Les tirs visent le symétrique de la cible. Si les résultats n’ont pas de sens, vérifiez cela en premier.
• Laisser filer le chronomètre de placement et perdre la partie avant le premier tir.
• Avaler les erreurs. Un except silencieux transforme un détail en soirée de recherche. Affichez le message du serveur.
• Coder les règles en dur. Taille de grille, flotte et chronomètres viennent de /api/config : ils peuvent changer le jour du tournoi.
• Conclure sur cinq parties. Une stratégie qui gagne trois fois de suite peut être moins bonne que celle d’à côté : sur dix parties, le hasard décide encore. Le banc en joue deux cents pour rien.
• Pousser tout d’un coup le vendredi matin. Le dépôt est lu à chaque échéance et son historique aussi : un commit par étape, à deux noms, vaut mieux qu’un seul gros commit final.