Projet NSI - Reversi en Python, par où commencer ?

Salut 19BlueMonkey92,

je ne sais pas quoi faire en premier, le plateau ? La validité d'un pion ? Une classe joueur ?

Moi de commencerai par le site de la Fédération Française d'Othello :

• https://www.ffothello.org/othello/regles-du-jeu/
• une site pour jouer et comprendre le déroulement du jeu (https://www.toupty.com/jeu-en-ligne-othello-reversi.html#gsc.tab=0 par exemple)

Une fois que tu connais cela, tu es capable de décrire le comportement du jeu en français. Commence à coder ces comportements un par un.

Pour la stratégie, tu peux commencer par une stratégie très nulle : l'ordinateur passe en revue toutes les cases et s'il peut jouer un coup en posant un pion sur cette case, il le fait sur la première case qu'il rencontre. Ou il recense toutes les cases où il est possible de jouer un coup et il en joue une au hasard.

Pour la stratégie, tu peux donc faire très simple et avoir un jeu fonctionnel de A à Z. Tu peux ensuite aussi faire bien mieux, voire très compliqué.

• https://www.ffothello.org/strategie/
• https://www.ffothello.org/strategie/repertoire-douvertures/
• https://www.ffothello.org/informatique/algorithmes/

Si tu arrives à implémenter Minimax, cela sera déjà bien sans doutes dans le cadre de ton exercice. Cette dernière page parle d'algorithmes bien plus avancés.

Je pense que je vais un peu m'entraîner à la POO en Python avant de passer à la partie pratique

Quelle drôle d'idée. On t'impose de faire de l'orienté objet ?

Fais comme tu veux.

Une bonne approche est de programmer ton jeu pour que son fonctionnement interne soit indépendant de l'affichage et de l'interface homme machine, pour que tu puisses commencer en faisant simple avec un programme console et que tu t'embarrasses d'une interface graphique si tu as le temps et la motivation (surtout si ce n'est pas obligatoire dans ton énoncé de le faire). Tu peux le faire en utilisant l'OO mais tu peux aussi faire sans.

Bonjour,

D'abord quel est ton niveau en programmation, qu'as tu déjà réalisé, et pareil avec Python ?

Premièrement il te faut arriver à comprendre et maitriser les règles du jeu lui-même. Donc entraine toi.

Intuitivement, on va devoir utiliser une bibliothèque graphique, pour dessiner un plateau et déplacer les pions. Si on te demande un affichage graphique ? Dans les codes fournis, des bibliothèques sont-elles mentionnées ? Y a-t-il des fonctions avec certaines actions mentionnées ?

On va avoir le joueur humain qui va placer un pion, il va falloir contrôler que son placement respecte les règles, puis réaliser le basculement des pions adverses.

L'autre joueur c'est le système. On peut commencer à écrire le programme en le faisant jouer sur le 1er emplacement possible pour lui. Puis dans un second temps, une fois que toute la dynamique du programme fonctionne, imaginer qu'il joue avec une stratégie, donc trouver pour lui le meilleur emplacement possible. Par exemple tester toutes les cases jouables et chercher celle qui fait basculer le plus de pions adverses.

Merci pour ta réponse

 >> D'abord quel est ton niveau en programmation, qu'as tu déjà réalisé, et pareil avec Python ?

Je dirais que je suis un peu au dessus du niveau débutant, un poil en dessous en Python (j'utilise surtout C++), en programmes déjà réalisés je pourrais te donner en Python un jeu du pendu (https://drive.google.com/file/d/15t7zC1MU3lyrznfWgTh6ZT0HnpoJBwTN/view?usp=sharing) que j'ai réalisé à la fin de l'année dernière en groupe sur environ 2 semaines, ou ce programme simulant un jeu de combat au tour par tour en C++ en 3 semaines seul (https://drive.google.com/drive/folders/1YOZGxf6UfwBUMKXgvoNUrbdxUizYY2i0?usp=drive_link). Ces jeux sont nettement plus simples étant donné qu'il n'y a pas de calculs de positions précises ou d'interfaces graphiques (pseudo ou non), et j'avais des bases pour partir comparé à ce nouveau projet que je dois faire seul sans bases pendant 3 mois.

>> Premièrement il te faut arriver à comprendre et maitriser les règles du jeu lui-même. Donc entraine toi.

C'est ce que je vais faire, je vais chercher des tutos sur YouTube, ça devrait être plus simple à trouver déjà.

>> Intuitivement, on va devoir utiliser une bibliothèque graphique, pour dessiner un échiquier et déplacer les pions. Dans les codes fournis, des bibliothèques sont-elles mentionnées ? Y a-t-il des fonctions avec certaines actions mentionnées ?

Dans les exemples de code, il y a wxPython qui était utilisée mais je n'ai pas compris quand elle était utilisée et à quoi elle servait, je pense que je vais me renseigner là dessus, idem pour les bibliothèques graphiques en Python, voilà l'un des codes proposés : pyReversi. (developpez.com).

>> On va avoir le joueur humain qui va placer un pion, il va falloir contrôler que son placement respecte les règles, puis réaliser le basculement des pions adverses.

L'autre joueur c'est le système. On peut commencer à écrire le programme en le faisant jouer sur le 1er emplacement possible pour lui. Puis dans un second temps, une fois que toute la dynamique du programme fonctionne, imaginer qu'il joue avec une stratégie, donc trouver pour lui le meilleur emplacement possible.

C'est là que je bloque, je ne sais pas quoi faire en premier, le plateau ? La validité d'un pion ? Une classe joueur ?

L'exemple que tu donnes a effectivement 16 ans, je ne sais pas si la bibliothèque wxPython est encore largement utilisée aujourd'hui, mais elle est toujours maintenue et mise à jour. Le code est en Python 2.

Il y a quelque chose qui m'échappe, quand on te demande de développer un jeu et que l'on te donne un exemple fonctionnel avec les sources. Comment faut-il le comprendre, comment se situer dans ce contexte ? Moi je prends les sources, peut être que je j'utilise une autre bibliothèque graphique plus récente et j'adapte le tout. Créativité faible ;-)

Quelles étapes pour le développement ? Chacun peut avoir son idée.

Je commencerais par dessiner le plateau, afficher les pions contenu dans un tableau (contenant 2 blancs, 2 noirs au centre au début), compter le nombre de pions de chaque joueur, rajouter un pion (peut être en saisie manuelle  position h/v, avant de le réaliser plus tard en utilisant un clic souris sur le plateau), vérifier s'il respecte les règles de placement, inverser les pions adverses suite à un nouveau pion.

C'est une démarche où visuellement le projet avance, qui permet d'avoir une première satisfaction quand la partie graphique est opérationnelle. Avant d'attaquer la partie pour moi la plus délicate, la mise en place de la stratégie de "l'ordinateur" pour gagner.

>> L'exemple que tu donnes a effectivement 16 ans, je ne sais pas si la bibliothèque wxPython est encore largement utilisée aujourd'hui, mais elle est toujours maintenue et mise à jour. Le code est en Python 2.

Ok donc c'est bien un peu daté (obsolète peut-être).

>> Il y a quelque chose qui m'échappe, quand on te demande de développer un jeu et que l'on te donne un exemple fonctionnel avec les sources. Comment faut-il le comprendre, comment se situer dans ce contexte ? Moi je prends les sources, peut être que je j'utilise une autre bibliothèque graphique plus récente et j'adapte le tout. Créativité faible ;-)

Autant mes 2 projets précédents j'ai réussi mais là, je bloque, j'ai essayé d'entrer le code avec une impression qu'il me manquait quelque chose, comme si le programme n'allait pas fonctionner à cause d'un potentiel manque d'instructions. De plus, pour cet exemple, je pense que j'aurais mieux fait de partir sans code pour me faire une première version, ce qui ne m'aurait embrouillé dans mon planning, puis aller checker d'autres codes. En bref je vais complètement me détacher de ce code qui au début me semblait être une sorte de T.P mais qui au final m'embrouille plus qu'autre chose. Je pense que je vais un peu m'entraîner à la POO en Python avant de passer à la partie pratique.

>> Quelles étapes pour le développement ? Chacun peut avoir son idée.

Je commencerais par dessiner le plateau, afficher les pions contenu dans un tableau (contenant 2 blancs, 2 noirs au centre au début), compter le nombre de pions de chaque joueur, rajouter un pion (peut être en saisie manuelle  position h/v, avant de le réaliser plus tard en utilisant un clic souris sur le plateau), vérifier s'il respecte les règles de placement, inverser les pions adverses suite à un nouveau pion.

Je pense que je vais opter sur la création d'un plateau (en pseudo-graphique/console par contre), où je peux juste placer des pions noirs ou blancs, le reste je me déciderais après. Chaque tour il est modifié et est affiché. Est-ce que cette première approche te semble correcte ?

>> C'est une démarche où visuellement le projet avance, qui permet d'avoir une première satisfaction quand la partie graphique est opérationnelle. Avant d'attaquer la partie pour moi la plus délicate, la mise en place de la stratégie de "l'ordinateur" pour gagner.

L'ordinateur passera à la fin quand le jeu sera fonctionnel déjà, je ne suis pas sûr d'utiliser une bibliothèque graphique pour le moment, mais déjà faut-il que j'apprenne à en utiliser une, pour qu'il y ait au moins un système de coordonnées, de plateau, et de classes interagissant avec la fenêtre.

Je pense que je te partagerai mes avancées ces prochains jours.

Bonjour,

Quelques éléments de réponses

Conseils de bases

• Comme le dit [Dal] la première chose à faire, c'est de comprendre les règles du jeu et peut-être de faire quelques parties.
• Othello est un jeu qui utilise une grille. Comme ça ne semble pas imposé par l'énoncé, tu peux sans doute te contenter de représenter le plateau de jeu par du texte (par exemple . pour une case vide, X pour un pion noir, O pour un pion blanc).
  • Il sera toujours temps de faire une interface graphique plus tard quand le moteur du jeu fonctionnera.
  • De nombreux modules python peuvent alors être considérés (tkinter, GTK, PyQT...). Toutefois, je te conseille vivement de ne pas te préoccuper de l'interface graphique dans un premier temps. Garde ça vraiment pour la fin.
• Pour stocker ton plateau, tu peux utiliser une liste de liste. À toi ensuite d'écrire les bonnes boucles pour réaliser toutes les primitives
  • Vérifier si une case est jouable
  • Jouer un coup sur une case jouable
  • Vérifier s'il y a un vainqueur (et le cas échéant, quel est-il)
• Commence simple. Ajoute petit à petit des fonctionnalités. Programme proprement (les paramètres de tes fonctions doivent être légitimes). Interdis-toi les variable globales.
• Teste ton programme régulièrement. Comme ça, ce qui pose problème vient très probablement de ce que tu viens de programmer.

Conseils avancés

Attention, les conseils qui suivent sont probablement trop avancés à ce stade, mais qui sait, il te restera peut-être du temps et de l'énergie pour les explorer. Alors à toutes fins utiles, voici quelques conseils supplémentaires...

• Si tu sais utiliser git (par exemple sur github), l'idéal serait de créer dès le début un dépôt et d'y publier petit ton travail. Si tu ne sais pas de quoi je parle, ignore cette remarque.
• On te demande de documenter ton code. Je te conseille de documenter ton code au fur et à mesure. En python on utilise des docstrings. Il existe principalement deux syntaxes :
  • la syntaxe numpy
  • la syntaxe google.
  • Je recommande la syntaxe google qui est plus concise (voir ce tutoriel). À terme, la documentation se génère avec un module python (en général sphinx).
  • Je ne pense pas que ton enseignant demande de générer la documentation, donc tu peux sans doute ignorer tout ce qui concerne sphinx dans un premier temps, mais je te recommande de prendre tôt les bonnes habitudes pour écrire des docstrings correctes.
• Je ne connais pas VSCode community. Personnellement je te conseillerais Pycharm. Mais si tu es à l'aise avec VSCode, continue avec VSCode.
• Dans tous les cas, je t'incite à installer flake8 et le lancer sur ton code pour vérifier le contrôler. Ça te permettra d'écrire "proprement" et de corriger des étourderies de code. Pour installer le module python flake8, tape simplement :

  pip install flake8
  flake8 src/  # Valider les fichiers .py dans le dossier src/

• Si tu as envie de packager ton travail dans un module python, il existe principalement deux écoles : setuptools et poetry (je recommande poetry). Encore une fois ça ne fait pas partie de tes consignes, donc tu peux parfaitement ignorer cette remarque.

  pip install poetry
  poetry init  # Créer un projet

  Généralement on met les sources dans le dossier src/ et les tests dans le dossiers tests/. Poetry crée un module à partir de tes sources sous la forme d'un paquet python ".whl" (appelé wheel) dans le dossier dist/. Une wheel installable avec pip.

  poetry lock            # Répercute les dépendances définies dans pyproject.toml dans poetry.lock
  poetry install         # Installe les dépendances définies dans poetry.lock
  poetry build           # Crée dist/*.whl
  pip install dist/*whl  # Installe le paquet python

• Vu que tu fais partie de la jeune génération, on t'a sans doute enseigné à programmer avec des tests, ce qui est plutôt une bonne habitude. En python, on utilise souvent pytest. Généralement, on crée un fichier de test par fichier ".py" dans les source.)

  pip install pytest
  pytest tests/  # Lance les tests stockés dans les fichiers tests/test_*.py

• Il existe des outils (comme cookie cutter ou package helper) qui permettent de générer un squelette de projet mettant en jeu tous les outils que je viens de mentionner. Personnellement je ne les utilise pas, mais c'est sans doute intéressant quand on débute.

Bonne chance