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
    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 des prosits 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-1.pdf      avant le prosit retour du mercredi
        prosit-2.pdf      avant le prosit retour du jeudi
        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.

Deux jours et demi de développement effectif, prosits compris. C’est court : le jalon 1 doit être bouclé mardi soir, sans quoi le jalon 2 ne tiendra pas.

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

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

   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.

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

2. Chasse et achèvement

   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.

   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

   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 ?

4. La carte de probabilités

   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é.

   Comment recalculer cette carte à chaque tir sans y passer trois secondes ?

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 ? Essayez, comparez, et venez défendre votre réponse.

La soutenance reprend le format des prosits 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.
• 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.