Vous venez de débuter Minecraft et vous commencez à comprendre que creuser sous ses pieds, dans ce jeu, est peut être une mauvaise idée. Nous allons non pas vous présenter un tutoriel sur comment jouer à Minecraft mais bien un tutoriel qui va vous permettre de sublimer et d’améliorer votre expérience de jeux grâce à l’installation d’optifine avec des shaders et des textures packs.
Quel est l’intérêt et qu’est ce que c’est ?
Comme nous l’avons déjà dis, cela va permettre d’améliorer votre expérience de jeu en sublimant les graphismes. Si vous êtes ici c’est que l’univers de Minecraft vous intéresse. En tant que joueur de Minecraft depuis maintenant de nombreuses années, je fais moi même l’usage de packs de textures et de shaders dans mes aventures ou encore même pour combattre contre d’autres joueurs en ligne (appelé « PvP »), c’est pourquoi je vais vous conseiller des packs de textures et des shaders et vous montrer comment se passe l’installation de ces derniers.
Les shaders sont des programmes qui modifient les pixels qui s’affichent, ce qui va donner un meilleur rendu du jeu. Comme moi, l’apparence des textures (blocs, objets, créatures et autres) peut vous lasser, on installe donc un pack de texture qui va venir changer ces apparences.
Aperçu des shaders :
Voici un exemple de ce que donne l’application des quelques étapes qui suivent pour installer des shaders :
Sans shaders VS Avec Shaders
Passons maintenant à l’installation.
Installation Optifine
a) Prérequis
On choisis ici la version 1.8.9 pour le tutoriel, le processus reste le même pour une autre version mais il faudra télécharger les logiciels suivants pour la version souhaitée.
Tout d’abord, pour le bon déroulement de l’installation, il y a certains prérequis :
Avoir télécharger Java si ce n’est pas fait : pour cela cliquez ici.
b) Installation
Vous avez maintenant tous les outils pour installer Optifine. Passons donc à son installation :
Rendez vous sur ce lien pour télécharger Optifine 1.8.9.
Après l’avoir télécharger, vous pouvez le lancer et vous arrivez sur cette fenêtre :
Vous devez tous simplement cliquez sur « Install ».
Shaders
Vous possédez maintenant Optifine qui est enfaite nécéssaire pour l’installation de shaders. Maintenant il va falloir choisir des shaders parmi des centaines qui se trouvent sur le net, c’est pour cela que je vais vous faire 3 suggestions qui sont, à mon sens, des très bons shaders.
a) Suggestions de shaders
BSL Shaders : shaders avec de l’eau peu mouvementée accompagnée d’un léger brouillard assez sympathique. Ce pack a aussi une très beau couché de soleil ce qui donne une bonne ambiance.
Sans shaders VS Avec BSL shaders
Complementary shaders : shaders lumineux, assez simples mais qui restent néanmoins très beaux. Si vous ne savez pas quoi choisir, ces shaders sont une bonne option ils conviennent généralement à la plupart des gens.
Sans shaders VS Avec complementary shaders
Sildur’s Vibrant : d’après moi les plus beaux shaders de Minecraft. C’est une pack qui fait sa force grâce à son couché de soleil compétitif et de très beaux reflets sur l’eau. L’apparence de nuit est aussi très sympathique.
Sans shaders VS Avec BSL shaders
b) Installation des shaders
Vous avez sûrement choisi des shaders parmi les suggestions ci-dessus, passons maintenant à l’installation de ces derniers pour qu’ils soient fonctionnels en jeu. Pour cela on prendra comme exemple les shaders Sildur’s Vibrant.
Tout d’abord, après avoir installé les shaders de votre choix, il va falloir saisir le raccourci Windows+R puis écrire « %appdata% ».
Vous arrivez normalement sur des dossier. Il vous faudra juste cliquer sur le premier dossier nommé « .minecraft » puis le dossier « shaderpacks » : .minecraft > shaderpacks
Vous n’avez plus qu’à glisser le pack dans ce dossier et à lancer Minecraft. 😁
Packs de texures
Concentrons nous maintenant sur les packs de textures. En effet, tout bon joueur minecraft possède des pack de textures que ce soit pour de la survie ou encore pour du PvP (=combat contre d’autres joueurs en ligne).
Si vous êtes arrivé sur ce tutoriel c’est que vous n’avez surement pas de pack de texture et/ou vous cherchez la manière pour les installer. Je vais donc vous proposer quelques packs de textures pour la survie et pour le PvP et par la suite vous montrer le déroulement de l’installation.
a) Suggestions de packs de textures
Voici donc 3 packs de textures que je vous suggère :
Faithful : pack très similaire au pack de texture de base de Minecraft mais qui améliore les graphismes. Un très bon choix pour ne pas se retrouver dépayser surtout si vous vous axez sur la survie, je vous le conseille donc fortement.
Amaranth : ce pack s’axe principalement sur le PvP. Il offre un style épuré et des graphiques sympathiques. J’utilise personnellement ce pack depuis maintenant quelques temps et il passe très bien.
Red Killua x32 Revamp : pack qui s’axe principalement sur le PvP mais peut aussi convenir pour la survie si ce style vous plaît. En revanche, les graphiques sont assez simples, ce qui explique ce côté épuré qu’on peut voir sur les blocs.
b) Installation des packs de textures
Contrairement au shaders, vous n’avez pas besoin d’Optifine pour avoir des pack de textures, ce qui vous laisse plus de liberté pour essayer les packs proposés !
Passons maintenant à l’installation :
Après avoir téléchargé l’un des packs, il faut saisir le même raccourci que pour les shaders : Windows+R et écrire « %appdata ». Aller dans .minecraft > ressourcepacks et glisser votre pack dans ce dossier.
Mise en place en jeu
Vous possédez maintenant tous les packs de textures et shaders installés, peut-être avez vous envie de les essayer, lancez donc votre jeu !
Je vais vous montrer comment les avoir en jeu directement, c’est enfaite assez simple :
Commençons par les packs de textures.
Etape 1 : accéder aux options comme l’affiche le screen ci-dessous.
Etape 2 : aller dans les packs de ressources.
Etape 3 : transférer le pack souhaité dans la colonne « Packs de ressources sélectionnés ».
La colonne a gauche « Packs de ressources disponibles » correspond enfaite au dossier « ressourcepacks », même si ils sont là, pour en utiliser un il faut simplement cliquer sur la flèche comme on le voit dans le screen ci-dessous.
Pour les shaders, rendez-vous dans encore une fois dans les options puis dans la section « Options graphiques ».
Etape 1 :
Etape 2 : aller dans la section « Shader… »
Etape 3 : vous pouvez enfin voir les packs que vous avez téléchargés. Pour appliquer un des shaders, vous avez tout simplement à cliquer dessus, il se chargera (ce qui peut bugger parfois) et vous en avez terminé.
Conclusion
Voila, maintenant vous savez comment installer des shaders et des packs de texures. N’hésitez pas à en tester pleins pour trouver le style qui vous convient dans l’optique d’améliorer votre expérience de jeu !
2048 est un jeu de puzzle en ligne ou sur appareil mobile qui consiste à glisser des tuiles numériques sur une grille afin de les fusionner et de créer une tuile de plus grande valeur. Le but du jeu est de créer une tuile de la valeur de 2048 en faisant des mouvements de glissement sur la grille.
La grille de jeu est divisée en cases de 4 lignes et 4 colonnes, pour un total de 16 cases.
Au début du jeu, deux tuiles numériques apparaissent sur la grille, chacune ayant une valeur de 2 ou 4.
Pour jouer, vous devez utiliser les touches de direction ou glisser votre doigt sur l’écran (si vous jouez sur un appareil mobile) pour déplacer toutes les tuiles sur la grille dans la direction choisie. Toutes les tuiles se déplaceront aussi loin que possible dans la direction choisie avant de s’arrêter.
Lorsqu’une tuile rencontre une autre tuile de même valeur, elles fusionnent pour former une tuile de valeur doublée. Par exemple, si vous faites glisser une tuile de valeur 4 vers une tuile de valeur 4, elles fusionneront pour former une tuile de valeur 8.
Après chaque mouvement, une nouvelle tuile apparaîtra sur la grille, généralement avec une valeur de 2. Cependant, il y a également une chance de 1 sur 10 que la tuile apparaisse avec une valeur de 4.
Le jeu se termine lorsqu’il n’y a plus de place sur la grille pour de nouvelles tuiles, ou lorsque vous créez une tuile de valeur 2048. Si vous arrivez à créer une tuile de valeur 2048, vous avez gagné ! Si la grille est pleine et que vous n’avez pas créé de tuile de valeur 2048, vous avez perdu.
Bien commencer
Au début le jeu est facile mais il faut tout de même faire attention à ne pas se faire prendre au piège. Le cadre est de 4×4 cases et il est nécessaire de bien utiliser l’espace.
Les tuiles doivent être ramenées dans un coin du cadre de façon à ce que celle qui a la plus grande valeur se retrouve dans le coin. La tuile ayant la deuxième plus grande valeur est à côté et ainsi de suite.
Tant que la plus grande case est inférieure à 128, le jeu est plutôt facile. Après, le jeu se complexifie et devient plus intéressant.
D’après la vidéo, nous pouvons noter qu’il faut éviter de libérer le coin bas-gauche. D’autres tuiles peuvent y apparaître, rendant le mouvement risqué, notamment quand il n’y a pas beaucoup de cases libres. Cependant jusqu’ici une erreur peut se rattraper facilement parce que nous sommes encore dans les « petits » nombres : il y a toujours moyen de s’en sortir. Lorsque la partie commence, nous pouvons alternativement appuyer sur les touches bas et gauche tant que possible sans trop réfléchir, cela jusqu’à 128.
La suite
Ici nous avons une ligne : notre base. Cette configuration permet que, quand un deuxième 16 est formé au dessus du premier, un effet avalanche est créé.
Le choix de la direction
Choix 1 : Cela créé une avalanche mais, après l’avalanche, sur la ligne du bas, il n’y aura plus que le 512 ainsi qu’éventuellement un 2 ou un 4, ce qui n’est pas idéal bien que pas catastrophique.
Choix 2 : Ce choix permet de conserver la série du bas, et en revenant, créer une avalanche, ce qui nous donne le 512 suivi du 32.
Choix 3 : Ce choix est similaire au choix 2. En appliquant le mouvement nous obtenons 16 et 64 sur les deux premières cases de la deuxième ligne. Si un chiffre apparaît sur les cases vides de la deuxième ligne, déplacer vers la droite est suffisant, sinon il faut essayer par soi-même pour pouvoir après créer son effet d’avalanche.
Astuce
Dans cette astuce, notre but est d’avoir un 64 au dessus du 64 pour former un 128 qui va produire une avalanche pour obtenir un 1024. Nous remarquons qu’au dessus du 64 il y a un 16 et qu’à gauche de ce dernier un 32. Or 32 > 16, il est donc nécessaire de transformer le 16 en 32. Pour cela, nous formons un 16 au dessus du 16. Nous pouvons pour cela utiliser le même principe que nous avons vu précédemment pour la ligne du bas. Après cette étape nous pouvons les assembler et obtenir le 64. Ensuite vient l’avalanche vers le 1024.
Gagner est « facile »
Gagner nécessite de parvenir à avoir une tuile de valeur 2048, ce qui, si vous avez suivi mon tutoriel, ne devrait pas poser de soucis.
Si 2048 vous suffit c’est fini. Sinon vous pouvez juste appuyer sur continuer et la partie ne s’arrêtera pas, à moins que la grille soit bloquée. Après 2048, le jeu devient « difficile », il faut s’accrocher, d’autant plus qu’il devient long.
Conseil
Nous pouvons nous trouver bloqué en ne pouvant faire aucun autre mouvement que ‘haut’, à ce moment-là nous sommes obligés de faire ce mouvement là : nous n’avons pas le choix. Il nous reste à espérer que la tuile qui va apparaître ne soit pas au niveau du coin et qu’elle soit le plus à droite possible. Néanmoins il arrive parfois que ce mouvement nous sauve.
Il faut donc tout faire pour éviter de se retrouver dans ce type de situation quitte à faire des mouvements qui peuvent sembler inutiles.
Une astuce pratique (sous-tableau)
Dans la situation ci-contre, la ligne du bas est verrouillée à cause des lignes du dessus et du 2 sur la ligne du bas… Mais heureusement, il existe une astuce pour palier la situation.
Nous pouvons procéder en sous-tableau : Le 2 de la ligne du bas est à la 3ème case, regardons si les nombres autour du 2048 peuvent nous arranger : c’est le cas. En effet, nous avons un carré composé des nombres 2048, 512, 128, 64 classés dans l’ordre décroissant, ce qui va permettre de réduire ce carré si nous réussissons à créer un 512 au dessus du 512 et que le jeu ne soit pas perturbé durant cette opération. Cela ne fonctionne pas à tous les coups, mais peut s’avérer très utile. (Personnellement je n’ai pas réussi à me sortir de cette situation.)
Une dernière astuce ?
Dans le cas où une case apparaît dans le coin bas-gauche à cause du fait que la plus grande case a bougé, il peut être nécessaire de s’occuper d’abord de cette case pour la faire arriver à la même valeur que la plus grande valeur et\ou de faire l’astuce du sous-tableau expliqué brièvement ci-dessus.
Conclusion
Dans ce tutoriel j’ai donné quelques astuces sur le jeu 2048. Ce sont uniquement des astuces que j’ai trouvées moi-même par la pratique, donc elles comportent forcément des imperfections. J’espère toutefois que ce tutoriel vous aura plu et que celui-ci vous sera utile.
La vidéo complète d’une partie pendant laquelle je parviens à créer les nombres 4096, 2048, 1024, 512 et 128 et sur laquelle vous pourrez observer un certain nombre des astuces expliquées dans ce tutoriel est disponible en cliquant sur le lien suivant : 2048 PB (4096+2048+1024+512+128).
Étudiant en spécialité NSI en Terminale en 2022-2023.
Insanity: Doing the same thing over and over again and expecting different results. Albert Einstein
Factors Game est à l’origine un jeu indépendant jouable en ligne, donc directement depuis un site web. Ceci dit, les Numworks ne peuvent pas encore se connecter à internet… Mais pas de panique, nous nous sommes occupés de l’adaptation du jeu sur calculatrice ! On est sacrément sympa nous… Arriveras tu à atteindre le niveau 404 ?
Développement
02/04 🧐 Bon, maintenant que t’as fini ton nyan_cat, résolu deux de mes énigmes, corrigé les bugs sur laboHelp, aidé au développement de pixChoice. Ça te dit de faire un jeu sur la calculatrice ? 🤓 Pourquoi pas !
🧐 On va afficher les nombres dans des tuiles de 42 pixels par 42 pixels
(2 jours plus tard)
🤓 J’ai fini le système de mouvement, et le système de génération aléatoire de la grille. Il y a juste le front qui est à revoir…
🧐 Bon, pas très UX les déplacements du haut vers le bas comme sur le jeu original avec la résolution de l’écran des calculatrices. On va les faire de gauche à droite du coup, tu dois réadapter le système de mouvement. 🤓 … D’accord
avantaprès
Parallèlement le codage des nombres a été intégré, il est d’Eric Schrafstetter, il est explicité sur cette vidéo.
Ce codage, celui du jeu 2048, dont nous avons amélioré le rendu a été réutilisé pour écrire F A C T O R S en haut à gauche de l’écran !
Petit récap’, mouvements OK, grille OK, maintenant il faut faire le système de calcul entre le curseur et les cases de la grille (vous savez, les divisons, les additions, tout ça tout ça. Ça se fait pas par magie malheureusement).
Aussitôt commencé, aussitôt terminé ! Moi qui redoutait cette phase du développement, ça avait été plus facile que prévu. Plus qu’à faire le système de détection de fin du niveau. Fastoche ! Si le curseur est égal à 1, ou que le curseur est positionné dans la dernière colonne, niveau terminé ! Et on relance la génération de la grille sans oublier d’incrémenter le niveau et calculer la moyenne.
Voilà. En quelques jours, le jeu est théoriquement jouable.
🤓 Plus que le menu, et le système de sauvegarde. Mais le jeu est jouable ! 🧐 Ok, pour le menu, on va faire ça, ça, mais il faut ça s’il y a ça, ça ça doit donc s’activer et du coup réactiver ça si ça a été désactivé seulement si ça avait été activé et puis… 🤓 Et si on faisait un cahier des charges ? 😅 🧐 Je m’en occupe.
🤓 Le menu est terminé, il faut sauvegarder le score de chaque niveau ? 🧐 Oui, on va utiliser un dictionnaire. 🤓 Larousse ou Le Petit Robert ?
Menu
🧐Le dictionnaire sert à rien, on aurait pu faire ça avec un tableau, mais laissons le dictionnaire ! 😂
🤓 Bon, je taffe sur une transition entre les niveaux, car les coups de sleep(3), ça va 2 secondes… (3 !)
🧐 Parfait !
Et voilà, en une bonne semaine, le jeu est terminé, il manque plus que le système de sauvegarde, enfin c’est ce que je pensais…
🧐 Bon, ton code est illisible on ne comprend rien. Tu me redéveloppes toute la fonction principale en respectant ces contraintes :
Le moins de if imbriqués possibles
Chaque if doit donner lieu à 2,3 traitements maximum
61 lignes pour une fonction c’est trop
Tout abus de booléen est à éviter
🤓 Mais ça nécessite de redévelopper quasiment toutes les fonctions. Donc tout le jeu… 🧐 Oui mais sinon on comprend rien. 🤓 Oui mais le jeu marche. 🧐 Oui mais on comprend rien. 🤓 J’ai compris…
Vous vous comprenez hein rassurez moi. À moins que j’ai un problème.
def factors(): # Ceci est l'ancien code incompréhensible !
global cursor, pos, level_current, retry
gui()
menu()
level_in_progress, in_menu, re_menu, last_key, end, go, input_await = False, False, False, None, False, False, False
while not keydown(5):
if not level_in_progress:
if not in_menu:
menu(0)
start_level(1)
cursor, pos, end, input_await = level_current, [51 + 44 * 1, 13 + 44 * 1], False, False
aff(level_current, pos[0] + 44 // 2 + center(level_current)[0],
pos[1] + 44 // 2 + center(level_current)[1], black_color)
level_in_progress = True
if not re_menu and in_menu:
menu(1)
start_level(0)
re_menu = True
if keydown(1) and pos[1] >= 51 and last_key != 1:
if not in_menu:
move(0, -1)
if in_menu and level_current != level_max:
level_current += 1
re_menu = False
last_key = 1
if keydown(2) and pos[1] <= 51 + 44 * 2 and last_key != 2:
if not in_menu:
move(0, 1)
if in_menu and level_current != 1:
level_current -= 1
re_menu = False
last_key = 2
if keydown(3) and last_key != 3:
if not in_menu:
move(1, 0)
if in_menu:
level_in_progress, in_menu, re_menu = False, False, False
if input_await:
go = True
fill_rect(pos[0] + 42, pos[1] + 42, 0 - 220, 0 - 176, (255, 255, 255))
last_key = 3
if keydown(0) and last_key != 0:
if pos[0] != 51 + 44 or input_await:
level_in_progress = False
retry = True
if input_await:
fill_rect(pos[0] + 42, pos[1] + 42, 0 - 176, 0 - 176, (255, 255, 255))
if not in_menu and pos[0] == 51 + 44:
level_in_progress, in_menu = False, True
last_key = 0
if not (keydown(0) or keydown(1) or keydown(2) or keydown(3)):
last_key = None
if not (pos[0] != 51 + 44 * 5 and (cursor != 1 or pos[0] == 51 + 44)):
end = True
if end:
if not input_await:
level_transition(cursor)
input_await = True
if go:
next_level()
level_in_progress, retry, input_await, go = False, False, False, False
Finalement, presque tout le jeu a donc été redéveloppé pour améliorer la lisibilité des fonctions python. Vous pouvez donc désormais comprendre le code ! Sauf le système de sauvegarde, ça vous vous débrouillez ! 🤫
🧐 Oui enfin le système de sauvegarde est codé pour être incompréhensible, c’est une fonctionnalité pour éviter qu’un joueur lambda ne génère trop facilement une clé de sauvegarde.
🤓 À noter, le code a été compressé pour passer de 10.2 ko à 8.42 ko, et désormais il ne respecte plus PEP 8 – Style Guide for Python Code (En – Fr)
Fonctionnement
La plupart des différents événements sont lancés grâce à la liste pos[x, y]. Cette liste correspond aux coordonnées x, et y du curseur :
La position par défaut du curseur est donc [0, 1] ! Oui, l’axe vertical est inversé. 🙄
Ainsi, si pos vaut [-1, y], on lance le menu, si pos[4, 0], on termine le niveau, etc. L’affichage sur l’écran est géré par la fonction d_p(), qui va convertir pos en coordonnées réelles (celles de l’écran), car évidemment, les coordonnées de pos sont virtuelles ! Le (0 ; 0) de l’écran lui se situe tout en haut à gauche !
Fonctionnalités délaissées
Beaucoup de fonctionnalités ont été retirés pour réduire au plus la taille du fichier ainsi que la mémoire utilisée ou pour d’autres raisons. Un histogramme dynamique avec le score des 20 derniers niveaux a été par exemple testé mais abandonné, le système de chargement d’une sauvegarde sur la couche graphique est lui aussi retiré, remplacé par une fonctionnalité équivalente mais exploitant le console python.
Un jeu qui mettra vos méninges au défi ! Sur Factors, vous ne devez pas réfléchir à comment vous allez pouvoir faire pour augmenter cette foutue moyenne générale, mais au contraire comment la baisser !
Règles du jeu
Avec une variante des règles de base de la division, Factors est un jeu de mathématiques amusant conçu pour être facile à comprendre, mais qui met de plus en plus à l’épreuve vos compétences mentales en mathématiques à mesure que vous progressez dans les niveaux. Déplacez votre numéro vers la droite à travers la grille des numéros pour vous rapprocher le plus possible de 1. Mais attention, si la division de vos nombres ne forment pas un nombre entier, ils s’additionnent ! Votre objectif est de maintenir votre moyenne globale aussi basse que possible !
Ce jeu est une adaptation du jeu original Factors Game.
Fonctionnalités
Support des couleurs des systèmes d’exploitations Epsilon et Omega
Réinitialisation des mouvements pendant un niveau
Menu de sélection du niveau
Stockage du meilleur score de chaque niveau
Sauvegarde de sa progression
Et bien plus…
Captures d’écran du jeu
Commandes
△ et ▽
▷
◁
OK
Ans
Naviguer
Accéder / Calculer
Réinitialiser / Menu
Sauvegarder / Charger
Quitter le programme
Pour aller plus loin
Si vous souhaitez en savoir davantage sur le fonctionnement du jeu, vous pouvez lire l’article de présentation : Factors Game en python sur NumWorks
Télécharger
Nous vous proposons 2 liens distincts, le premier est le lien vers la source du créateur de l’application, le deuxième est un lien alternatif en cas de problème. Seul le premier lien garanti de disposer de la dernière version de l’application.
2048 est un jeu vidéo de type puzzle conçu en mars 2014 par le développeur indépendant italien Gabriele Cirulli et publié en ligne sous licence libre. La version présenté ici est le portage du jeu, réalisé par Eric Schrafstetter et légèrement modifiée par nos soins pour un rendu sublimé sur la NumWorks.
Portage du jeu, en python, sur NumWorks
Eric Schrafstetter est le premier a voir porté ce jeu sur la calculatrice NumWorks, ce jeu nécessite une version Epsilon 13 ou supérieur installé sur la calculatrice. En effet, la version 13 de l’OS de cette calculatrice à permis le développement de jeux car il était désormais possible de récupérer les touches du clavier saisies.
Publié le premier avril 2020, la première version de ce programme a été suivie par une version améliorée proposée le 30 juillet 2021. Nous avons découvert ce jeu fin décembre 2021, et avons décidé de l’améliorer afin de proposer une expérience joueur améliorée.
La version 2 de Eric Schrafstetter
La version modifié par nos soins
Modifications réalisées par nos soins
La grille a été centrée et la bordure épaisse réduite, on conserve l’effet « ombre » sans écraser la grille.
Le score a été déplacé, il est moins visible pendant la partie, l’interface présente une symétrie visuelle et la modification du score n’attire pas l’œil.
Les micros-lags ont été supprimés. Dans la version d’origine, la grille était entièrement effacée puis reconstruite ce qui générait un affichage haché avec un effet de rafraichissement pas agréable. Le jeu est du coup plus fluide, plus agréable à utiliser.
Une détection de la fin de partie a été implémentée, si la grille est remplie et que 4 touches sont pressées sans que rien ne se passe, on signale au joueur que la partie est terminée.
Une vidéo de présentation du codage
Si le codage de ce jeu vous intéresse, la vidéo de son auteur est incontournable. 😍
Commandes
Le jeu se joue simplement avec les touches fléchées de la calculatrice.
Télécharger
Des liens vers les version 1 et 2 du jeu, celle de Eric Schrafstetter sont au début de cet article. Nous vous proposons de tester la version modifiée par nos soins :
Enseignant de mathématiques et de spécialité NSI, Lycée Louis Pasteur d’Avignon.
Aime compter jusqu’à 666 mais s’arrête souvent à 42.
Auteur du livre Découvrir la calculatrice NumWorks.
Vous êtes seul et ne savez pas quoi faire? Nous vous proposons un jeux du pendu: affrontez l’ordinateur!
Notre projet consiste à créer un programme en python sur un jeux traditionnel d’école: le jeux du pendu.
Introduction
L’ordinateur va choisir un mot parmi une liste prédéfinie et inconnue de vous, joueur. Vous devez alors essayer de retrouver le mot en proposant différentes lettres. Vous avez le droit a 8 erreurs, et pas une de plus. Une fois toutes les tentatives épuisées, le bonhomme est pendu: vous avez perdu! Mais si vous trouvez le mot avant d’avoir épuisé toutes vos chances, alors c’est gagné!!
Lorsque vous avez trouvé la bonne lettre, un message s’affiche pour vous informer que votre proposition est juste. Le mot qui était vide se complète alors par la bonne lettre. Ainsi il sera plus facile de deviner quel est le mot.
Le code en entier
from random import randint,choice
def initialisation():
liste_mots=["chocolat", "tentacule", "dictionnaire", "magnifique", "saucisson", "xylophone", "serveur", "houx", "clavier"]
choix = choice(liste_mots)
myst = ""
for i in choix:
myst += "_"
return (choix,myst)
def verification(lettre,mot):
if lettre in mot:
return True
else:
return False
def mot_complet(mot):
if "_" not in mot:
return True
else:
return False
def complete_mot(lettre,mot,myst):
for i in range(len(mot)):
if mot[i] == lettre
temp = list(myst)
temp[i] = lettre
myst = "".join(temp)
return myst
def dessin_pendu(n):
dessin = ""
if n == 1:
dessin = "\n" * 7 + " =============="
elif n == 2:
dessin = "\n" + " ||/\n" + " ||\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 3:
dessin = "==============\n" + " ||/\n" + " ||\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 4:
dessin = "============Δ=\n" + " ||/ |\n" + " ||\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 5:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 6:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " || /|\ \n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 7:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " || /|\ \n" + " || |\n" + " ||\n" + " /||\n" + " =============="
elif n == 8:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " || /|\ \n" + " || |\n" + " || / \ \n" + " /||\n" + " =============="
return dessin
def jeu():
tentatives = 8
mot_choisi,mot_cache = initialisation()
while (tentatives > 0) and (not mot_complet(mot_cache)):
print("\nNombre de tentatives restantes :\t", tentatives, "\n")
print(" ".join(mot_cache),"\n\n")
lettre_choisie = input("Choisir une lettre (en minuscule) :\t")
if verification(lettre_choisie,mot_choisi):
mot_cache = complete_mot(lettre_choisie, mot_choisi, mot_cache)
print("\nLa lettre se trouve bien dans le mot\n")
else:
tentatives -= 1
print("\nLa lettre ne se trouve pas dans le mot...\n\n", dessin_pendu(8 - tentatives),"\n\n")
if tentatives == 0:
print(" ".join(mot_cache))
print("\nLe mot était :\n")
print(" ".join(mot_choisi))
print("\nVous avez malheureusement échoué ... \n")
if "_" not in mot_cache:
print(" ".join(mot_cache),"\n\n")
print("\nBravo, vous avez gagné !\n")
input("\nVeuillez taper sur la touche Entrer pour recommencer\n\n")
menu()
def menu():
print("\n-----------BIENVENUE SUR LE JEU DU PENDU-----------\n")
print("-------------------BONNE CHANCE--------------------\n\n")
print("C'EST PARTI! \n")
jeu()
menu()
Nous avons choisi la bibliothèque random pour avoir accès à choice qui nous permet donc d’avoir un programme capable de faire un choix de manière complètement aléatoire.
Les appels aux différentes fonctions
Le programme ci dessus se résume en une ligne;
menu()
Celle ci sert à faire appel à la fonction menu, qui elle même va faire appel à d’autres fonctions. Ainsi le programme peut s’exécuter. Par exemple, on remarque que la fonction menu fait appel à la fonction jeu, qui elle même, fait appel à d’autres fonctions (à voir dans le code ci-dessous)
def menu():
#cette fonction présente le jeu
jeu() #renvoie à la fonction "jeu"
def jeu():
#cette fonction est le squelette du programme. elle permet de relier les nombreuses fonctions de manière a pouvoir jouer
mot_choisi,mot_cache = initialisation() #renvoie à la fonction initialisation
while (tentatives > 0) and (not mot_complet(mot_cache)): #tant que le nb de tentatives est > 0 et que --> renvoie à la fonction mot complet --> alors...
"""
etc...
"""
Les grandes lignes
Pour pouvoir jouer au jeu du pendu, nous avons besoin d’avoir une liste de mots prédéfinie dans laquelle, un mot au hasard, va être choisi. Le mot, qui aura été sélectionné, apparaitra sous forme de tirets (le nombre de tirets correspondant au nombre de lettres dans le mot).
def initialisation():
liste_mots=["chocolat", "tentacule", "dictionnaire", "magnifique", "saucisson", "xylophone", "serveur", "houx", "clavier"]
choix = choice(liste_mots)
myst = ""
for i in choix:
myst += "_"
return (choix,myst)
Une fois le mot apparu sous la forme de tirets, il faut que lorsqu’une lettre est découverte par le joueur, elle prenne la place du tiret auquel elle correspond (complete_mot). Pour cela, le mot va être transformé en une liste et pourra donc être parcouru par le programme. Mais tout d’abord il faut vérifier que la lettre se trouve bien dans le mot (verification).
def verification(lettre,mot):
if lettre in mot:
return True
else:
return False
def complete_mot(lettre,mot,myst):
for i in range(len(mot)):
if mot[i] == lettre
temp = list(myst) # Transforme le mot en une liste temp
temp[i] = lettre # Remplace le tiret underscore par la lettre
myst = "".join(temp) # Re-combine les éléments de temp pour en faire à nouveau un mot
return myst # Renvoi le mot caché, complété avec la (ou les) lettre(s)
Dans ce jeu, nous avons fait le choix de représenter un bonhomme pendu, comme dans le jeu classique d’école. Pour cela, nous avons programmé une fonction permettant d’afficher une partie du dessin du pendu, au fur et à mesure que le nombre de chances diminue, . Au début il n’y a donc pas de dessin; dessin = "" . Plus le pendu apparait, plus les chances de trouver le bon mot diminuent.
Pour terminer, nous avons donc crée une fonction qui, comme dit plus haut, structure notre programme. Elle lie toutes les autres fonctions. Le nombre de tentatives y est rentré, et le programme se lance.
Tant que le nombre de tentatives est supérieur à 0 et que le mot n’est pas complet, le script s’exécute. Si la lettre choisie par le joueur est dans le mot, alors le (ou les dans certains cas) tiret correspondant à la lettre sera remplacé par celle-ci. Sinon, le nombre de tentatives diminue de 1 et le dessin du pendu correspondant au nombre de tentatives apparait.
Pour gagné, il suffit donc de vérifier s’il reste ou non des tirets dans le mot (mot_complet). Lorsqu’il n’y en a plus et que tentative>0, alors c’est gagné. Et lorsque le nombre de tentative = 0, alors le mot apparait en entier, c’est perdu.
def jeu():
tentatives = 8
mot_choisi,mot_cache = initialisation()
while (tentatives > 0) and (not mot_complet(mot_cache)):
print("\nNombre de tentatives restantes :\t", tentatives, "\n")
print(" ".join(mot_cache),"\n\n") # Pour un affichage montrant bien le nombre de lettres à trouver en séparant chaque tiret underscore
lettre_choisie = input("Choisir une lettre (en minuscule) :\t")
if verification(lettre_choisie,mot_choisi):
mot_cache = complete_mot(lettre_choisie, mot_choisi, mot_cache)
print("\nLa lettre se trouve bien dans le mot\n")
else:
tentatives -= 1
print("\nLa lettre ne se trouve pas dans le mot...\n\n", dessin_pendu(8 - tentatives),"\n\n")
if tentatives == 0:
print(" ".join(mot_cache))
print("\nLe mot était :\n")
print(" ".join(mot_choisi))
print("\nVous avez malheureusement échoué ... \n")
if "_" not in mot_cache:
print(" ".join(mot_cache),"\n\n")
print("\nBravo, vous avez gagné !\n")
input("\nVeuillez taper sur la touche Entrer pour recommencer\n\n")
menu()
def mot_complet(mot):
if "_" not in mot:
return True
else:
return False
Une fois la partie finie, il ne reste plus qu’à cliquer sur la touche Entrer et le programme nous renvoie au menu de base. Une nouvelle partie peut commencer.
A vous de jouer
Si contre, vous trouverez le lien pour télécharger le programme et faire des parties dignes de ce nom. Quelques explications ont été rajoutées dans ce code pour, si vous le souhaitez, réussir à comprendre plus en détail comment il fonctionne.
Comment ça on peut coder des IA qui apprennent en Python en 1ère ? C’est pas censé être un truc ultra pointu ? Eh bien en fait c’est relativement facile à faire pour des jeux aux règles simples comme l’Hexapawn.
Un Hexapawn, quésaco
Il s’agit d’un jeu d’échec miniature, qui se joue sur un plateau de jeu constitué de 9 cases (3×3), et dans lequel chaque joueur possède 3 pions – d’où le nom: hexa, six et pawn, pion en anglais.
Les règles du jeu sont simples: les pions se déplacent comme des pions d’échec:
Ils ne se déplacent que d’une case à la fois et uniquement vers l’avant
Ils ne peuvent manger qu’en diagonale, là aussi dans un rayon d’une case
Le but est de réussir à amener l’un de ses pions de l’autre côté du plateau ou d’éliminer la totalité des pions adverses.
Dans le cas ou aucun pion ne peut plus bouger, il y a égalité
Ce projet a été inspiré par une vidéo de Vsauce2, une chaîne présentant divers jeux ayant lien avec les mathématiques ou la logique.
Particularités du jeu
Comme les règles de l’Hexapawn sont très simples, il suffit simplement d’empêcher l’ordi de refaire des mouvements qui l’ont amené à perdre afin de le faire s’améliorer au fur et a mesure qu’il joue.
La principale difficulté dans la réalisation de ce projet a été de devoir prendre en compte toutes les possibilités de jeu, ce qui rend au final le script assez long.
En bonus, on s’est dit que ce serait sympa d’ajouter un menu afin de personnaliser les couleurs de l’interface
Commencer le projet : les Libraries nécessaires
Ce jeu a été entièrement codé en Python, et en Python, la première chose à faire lorsqu’on commence quelque chose est d’importer les Libraries (programmes externes) nécessaires pour sa réalisation.
#les différentes libraries nécessaires
from tkinter import *
import tkinter as tk
from functools import partial
from random import *
import webbrowser
Les différentes libraries que nous avons choisi d’utiliser sont les suivantes :
tkinter (abrégé de ToolKit Interface) qui permet de créer une interface graphique,
la fonction partial de la library functools, qui va nous être utile lors de la création des différents boutons,
random, qui va permettre d’ajouter de l’aléatoire dans certaines actions,
webbrowser, qui va permettre d’ouvrir des pages web.
Maintenant que l’on a importé tous les modules nécessaires, on va pouvoir commencer à coder le projet en lui-même.
Configuration de la fenêtre
Comme l’on utilise tkinter afin de pouvoir donner une interface graphique à notre jeu, on va commencer par configurer notre fenêtre (taille, titre, couleur de fond etc…)
couleur = "#424242"
#mise en place de la fenêtre
window = Tk()
window.title("♟ Hexapawn ♟")
window.geometry("1080x720")
window.config(bg=couleur)
Ici on a donc une fenêtre de couleur grise, dont le titre est « ♟ Hexapawn ♟ » et dont la taille est de 1080 x 720 pixels
Création des variables
Une fois la fenêtre créée, on configure les variables qui seront utilisées par le script (le nombre de points de chacun, l’état des cases -vides au début-, les différentes variables à afficher…)
Tkinter ne peut pas afficher des variables classiques dans les fenêtres, c’est pourquoi il est nécessaire de créer des variables spéciales que l’on déclare comme ceci :
Comme la majorité de ces variables tkinter sont associées à des variables classiques, nous avons décidé d’ajouter « _display » à la fin de leur nom pour pouvoir plus facilement les différencier.
Par exemple, la variable a1 sera associée à la variable tkinter a1_display qui sera actualisée dans le script à chaque fois que a1 change de valeur
Configuration des boites
Maintenant on crée les différentes boites. Elles permettront d’afficher les différents éléments qu’elles contiennent quand elles seront appelées (la boite menu, règle etc…) ou de ne plus les afficher lorsqu’elles seront oubliées.
Afin d’avoir une interface claire, il est important d’ajouter des éléments textuels: titre, règles du jeu etc.
Dans tkinter, les éléments textuels sont nommés labels. On les déclare comme ceci:
#mise en place des différents éléments textuels
titre = Label(boite_titre, text =
'''
.----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .-----------------.
| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |
| | ____ ____ | || | _________ | || | ____ ____ | || | __ | || | ______ | || | __ | || | _____ _____ | || | ____ _____ | |
| | |_ || _| | || | |_ ___ | | || | |_ _||_ _| | || | / \ | || | |_ __ \ | || | / \ | || ||_ _||_ _|| || ||_ \|_ _| | |
| | | |__| | | || | | |_ \_| | || | \ \ / / | || | / /\ \ | || | | |__) | | || | / /\ \ | || | | | /\ | | | || | | \ | | | |
| | | __ | | || | | _| _ | || | > `' < | || | / ____ \ | || | | ___/ | || | / ____ \ | || | | |/ \| | | || | | |\ \| | | |
| | _| | | |_ | || | _| |___/ | | || | _/ /'`\ \_ | || | _/ / \ \_ | || | _| |_ | || | _/ / \ \_ | || | | /\ | | || | _| |_\ |_ | |
| | |____||____| | || | |_________| | || | |____||____| | || ||____| |____|| || | |_____| | || ||____| |____|| || | |__/ \__| | || ||_____|\____| | |
| | | || | | || | | || | | || | | || | | || | | || | | |
| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |
'----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
''', font=("consolas",7), bg = couleur, fg = couleur_texte)
sep = Label(boite_titre, text = "."*200, font=("consolas",7), bg = couleur, fg = couleur_texte)
regles_label = Label(boite_regles, text =
'''
Regles du jeu:
Vous possédez 3 pions, qui peuvent se déplacer comme des pions aux échecs:
-ils ne peuvent que se déplacer vers l'avant
-ils ne peuvent se déplacer que d'une case à la fois
-ils ne peuvent "manger" un pion adverse qu'en diagonale
2 conditions de victoire possibles:
-l'adversaire ne possède plus aucun pion
-vous parvenez à amener un pion à l'autre bout du plateau
Pour déplacer un pion, cliquez sur lui puis sur la case vers laquelle vous
voulez qu'il aille.
Lorsque vous avez joué, cliquez sur le bouton sous l'échéquier
'''
, font=("consolas",15), bg = couleur, fg = couleur_texte)
resultat_Label = Label(boite_resultat, text = "", font=("consolas",15), bg = couleur, fg = couleur_texte)
scores = Label(boite_resultat, text = "%s à %s" %(score_joueur_display.get(),score_ordi_display.get()), font=("consolas",15), bg = couleur, fg = couleur_texte)
retour_selection = Label(boite_couleurs, text = "", font=("consolas",10), bg = couleur, fg = couleur_texte)
contour1 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour2 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour3 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour4 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour5 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour6 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
Pour le titre, nous avons décidé de l’écrire en ASCII à l’aide de ce générateur
Chaque Label possède plusieurs attributs: la boîte dans lequel il va apparaître, le texte qu’il contient, la police et la taille d’écriture, la couleur de fond et enfin la couleur de l’écriture.
Comme vous pouvez le constater, certains de ces Labels font appel à des variables tkinter qui nous avons précédemment définies comme celui-ci par exemple:
scores = Label(boite_resultat, text = "%s à %s" %(score_joueur_display.get(),score_ordi_display.get()), font=("consolas",15), bg = couleur, fg = couleur_texte)
Pour appeler ces variables, il suffit d’écrire leur nom suivi de .get()
Maintenant que l’on a défini les éléments texte, on va pouvoir s’attaquer aux différentes fonctions du script.
Premières fonctions: fonctions de navigation
Comme l’on a décidé d’utiliser une ineterface graphique pour ce projet, la plupart des fonctions seront appelées à l’aide de boutons.
#commande permettant d'afficher les règles du jeu
def command_regles():
boite_menu.pack_forget()
boite_regles.pack(pady = 25)
Cette fonction par exemple permettra d’afficher les règles du jeu. Il suffit d’ajouter .pack() à la fin du nom d’une boite pour la faire apparaître, et .pack_forget() pour la faire disparaître.
Ainsi, lorsque cette fonction sera appelée, les éléments de la boite_menu disparaîtront pour laisser place à ceux de la boite_regles
Cette fonction sera associée à un bouton de la manière suivante :
b_regles = Button(boite_menu, text = "Règles du jeu", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_regles)
On créé un nouvel élément nommé b_regles: un bouton (Button) à qui on donne différents attributs: une boite, un texte, une police et une taille, une couleur de fond, une couleur de texte, et surtout une fonction (l’attribut command) qui sera appelée en cas de clic.
Lorsque l’on cliquera sur ce bouton, la fonction command_regles sera exécutée, ce qui aura pour effet d’afficher les règles du jeu.
On procède de même avec les autres fonctions qui vont nous permettre de naviguer dans notre fenêtre :
#commande pour retourner au menu depuis les règles
def command_retour_regles():
boite_menu.pack(pady = 25)
boite_regles.pack_forget()
#commande pour afficher le menu de personnalisation des couleurs
def command_personnaliser():
boite_menu.pack_forget()
boite_couleurs.pack(pady = 25)
boite_couleurs2.pack()
#commande pour retourner au menu principal depuis celui de personnalisation des couleurs
def command_retour_personnaliser():
boite_menu.pack(pady = 25)
boite_couleurs.pack_forget()
boite_couleurs2.pack_forget()
Ainsi qu’avec leurs boutons respectifs
b_retour_regles = Button(boite_regles, text = "Retour", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_retour_regles)
b_personnaliser = Button(boite_menu, text = "Personnaliser", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_personnaliser)
b_retour_personnaliser = Button(boite_couleurs2, text = "Retour", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_retour_personnaliser)
Personnalisation des couleurs
Grâce au menu de personnalisation des couleurs, les utilisateurs du script pourront choisir les couleurs qui leur plait ainsi créant des mélanges uniques.
Ce menu est constitué de plusieurs boutons :
b_couleur1 = Button(boite_couleurs2, text = "Changer la couleur principale ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,0))
b_couleur2 = Button(boite_couleurs2, text = "Changer la couleur secondaire ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,1))
b_couleur3 = Button(boite_couleurs2, text = "Changer la couleur de selection", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,2))
b_couleur_joueur = Button(boite_couleurs2, text = " Changer la couleur du joueur ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,3))
b_couleur_ordi = Button(boite_couleurs2, text = " Changer la couleur de l'ordi ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,4))
b_personnaliser = Button(boite_menu, text = "Personnaliser", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_personnaliser)
couleur_entry = Entry(boite_couleurs, text = "#", textvariable=valeur, font=("Helvetica",15) , bg="white", fg="black")
b_ok = Button(boite_couleurs, text = "Cliquez pour appliquer", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = rien)
C’est ici que la fonction partial que nous avons importée va nous être utile: en effet, tous les boutons de ce menu vont exécuter la même fonction, mais avec un paramètre différent, ce qui nous permet de n’écrire qu’une seule fonction au lieu de 5 différentes.
Lorsque le bouton « Cliquez pour appliquer » est cliqué la fonction appliquer est exécutée avec un paramètre différent en fonction du bouton sélectionné auparavant.
La fonction change la couleur demandée puis rafraîchit tous les éléments différents afin que le changement de couleur apparaisse.
Il est à noter que le script ne comprend que certains noms de couleur en anglais ou les couleurs données en hexadécimal
Ce menu comporte aussi un bouton permettant d’ouvrir une page web avec un panneau pour sélectionner la couleur de son choix et avoir son code en hexadécimal :
b_trouver_hex = Button(boite_couleurs2, text = " Trouver des couleurs ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = pick_hex)
L’ouverture de la page depuis le script est faite grâce a la Library webbrowser
Elle permet de mettre en place le plateau de jeu en faisant apparaître les boites boite_jeu et boite_ordi et en faisant disparaître les autres.
Ensuite les pions sont placés sur le plateau et le compteur de tours, et ceux des pions sont mis à leurs valurs initiales
Enfin, le script teste les cases à partir desquelles l’on peut bouger nos pions à l’aide de la fonction tester_cases_selectionnables().
Les possibilités de déplacement
La fonction « tester_cases_selectionnables() » teste les cases sur lesquels se trouve les pions du joueur et permet au joueur de cliquer le bouton si jamais un de ses pions y est présent.
Ensuite, selon la case sélectionnée le script étudie les mouvements possibles et modifie les commandes éxécutées en cas de clic sur la case en conséquence :
def selected(case):
global a1, a2, a3, b1, b2, b3, c1, c2, c3
global tour
if tour == 0 :
if case == "c1":
b_b1.config(command = partial(jouer_vers,"c1","b1"))
b_b2.config( command = rien)
b_b3.config(command = rien)
b_c1.config(fg=couleur_selection)
b_c2.config(fg=couleur_joueur)
b_c3.config(fg=couleur_joueur)
b_b2.config(command = rien)
b_b3.config(command = rien)
elif case == "c2":
b_b2.config(command = partial(jouer_vers,"c2","b2"))
b_c2.config(fg=couleur_selection)
b_c1.config(fg=couleur_joueur)
b_c3.config(fg=couleur_joueur)
b_b1.config(command = rien)
b_b3.config(command = rien)
#et ainsi de suite avec les autres cases
elif tour >= 2:
if case == "c1":
reset_commandes()
tester_cases_selectionnables()
b_c1.config(fg=couleur_selection)
if b1 == " ":
b_b1.config(command = partial(jouer_vers,"c1","b1"))
if b2 == "♟":
b_b2.config(command = partial(jouer_vers,"c1","b2"))
elif case == "c2":
reset_commandes()
tester_cases_selectionnables()
b_c2.config(fg=couleur_selection)
if b2 == " ":
b_b2.config(command = partial(jouer_vers,"c2","b2"))
if b1 == "♟":
b_b1.config(command = partial(jouer_vers,"c2","b1"))
if b3 == "♟":
b_b3.config(command = partial(jouer_vers,"c2","b3"))
#etc...
Après avoir choisi le pion qu’il souhaitait déplacer, le joueur va cliquer sur la case vers laquelle il veut que le pion se déplace.
La fonction jouer_vers va alors être exécutée avec en paramètres la case de départ et la case d’arrivée du pion.
La fonction va rendre vide la case de départ du pion et va mettre un pion blanc dans la case d’arrivée
def jouer_vers(case1, case2):
global tour, jeu
global a1, a2, a3, b1, b2, b3, c1, c2, c3
global pions_ordi, ordi_gagne
if tour / 2 == tour // 2 and not ordi_gagne:
if case1 == "c1":
c1 = " "
c1_display.set(c1)
b_c1.config(text = c1_display.get())
elif case1 == "c2":
c2 = " "
c2_display.set(c2)
b_c2.config(text = c2_display.get())
#etc...
if case2 == "b1":
if b1 == "♟":
pions_ordi -= 1
b1 = "♙"
b1_display.set(b1)
b_b1.config(text = b1_display.get(), fg = couleur_joueur)
jeu += case2
elif case2 == "b2":
if b2 == "♟":
pions_ordi -= 1
b2 = "♙"
b2_display.set(b2)
b_b2.config(text = b2_display.get(), fg = couleur_joueur)
jeu += case2
#etc...
Si le joueur a réussi à amener l’un de ses pions de l’autre côté, il gagne un point et le résultat de la partie est affiché avec les scores.
Les mouvements possible de l’ordinateur sont étudiés par la fonction « ordi() ».
#début de la fonction ordi()
def ordi():
global tour
global a1, a2, a3, b1, b2, b3, c1, c2, c3
global pions_joueur, points_joueur, ordi_gagne, points_ordi, pions_ordi, joueur_gagne, pions_bloques, resultat, egalite, coups_gagnants, coups_perdants, jeu, couleur_ordi
Elle étudie tout d’abord si il y a un vainqueur ou une égalité ( grâce à la fonction « tester_tie() » expliquée un peu plus plus loin ) .
if pions_ordi == 0:
joueur_gagne = True
if pions_joueur == 0:
ordi_gagne = True
tester_tie()
if pions_bloques == pions_ordi:
egalite = Tr
Si il n’y a pas de vainqueur ou d’égalité et que c’est au tour de l’ordi de jouer, le script analyse les mouvements possibles de l’ordinateur. si il s’aperçoit qu’un mouvement l’a amené à perdre dans une configuration similaire, il ne l’inclura pas dans la liste des mouvements possibles.
Si, au contraire un des mouvements l’a fait gagner précédemment, il le mettra dans une liste spéciale
elif tour/2 != tour//2 and not joueur_gagne and not ordi_gagne :
mvt_possibles = []
mvt_gagnants = []
if a1 == "♟":
if b1 == " " and jeu + "a1b1" not in coups_perdants :
mvt_possibles.append("a1b1")
if jeu + "a1b1" in coups_gagnants:
mvt_gagnants.append("a1b1")
if b2 == "♙" and jeu + "a1b2" not in coups_perdants:
mvt_possibles.append("a1b2")
if jeu + "a1b2" in coups_gagnants:
mvt_gagnants.append("a1b2")
if a2 == "♟":
if b1 == "♙" and jeu + "a2b1" not in coups_perdants :
mvt_possibles.append("a2b1")
if jeu + "a2b1" in coups_gagnants:
mvt_gagnants.append("a2b1")
if b2 == " " and jeu + "a2b2" not in coups_perdants:
mvt_possibles.append("a2b2")
if jeu + "a2b2" in coups_gagnants:
mvt_gagnants.append("a2b2")
if b3 == "♙" and jeu + "a2b3" not in coups_perdants:
mvt_possibles.append("a2b3")
if jeu + "a2b3" in coups_gagnants:
mvt_gagnants.append("a2b3")
#et ainsi de suite avec toutes les cases...
Ensuite, la fonction teste si des mouvements possibles peuvent amener l’ordi à gagner à coup sûr. Si c’est le cas, un mouvement aléatoire est pioché parmi la liste mvt_gagnants.
Sinon, l’ordi choisit un mouvement aléatoire parmi les mouvements possibles.
Le coup joué est ensuite ajouté à la variable jeu.
Si le mouvement amène l’ordi à prendre un pion, le nombre de pions du joueur est décrémenté de 1
Si l’ordi a amené l’un de ses pions de l’autre côté, la variable ordi_gagne devient « vraie » (True)
jeu += mvt_ordi
Si l’ordi a gagné, c’est à dire si ordi_gagne est True, son score est incrémenté, la variable « jeu » est ajouté à la liste des coups gagnants et le score ainsi que le résultat de la partie sont affichés
Si le joueur avait déjà gagné au début du tour (l’ordi n’a donc pas joué) ou s’il y a égalité le score est incrémenté en conséquence et l’issue de la partie est affichée
Si aucune de ces conditions n’est vérifiées, c’est au tour du joueur de jouer.
Plisieurs conditions peuvent mettre fin à la partie
Le joueur ou l’ordi amène l’un de ses pions de l’autre côté du plateau
le joueur ou l’ordi ne possèdent plus de pions
Tous les pions sont bloqués
Les deux premières conditions sont facilement vérifiables et sont déjà testées directement dans les fonctions ordi() et jouer_vers()
On teste donc s’il y a égalité à l’aide de la fonction tester_tie(), appelée à l’interieur de la fonction ordi() comme vu précédemment.
Cette fonction teste tout simplement pour chaque case si le pion présent n’a plus de possibilités de mouvement, et ajoute au compteur de pions bloqués 1 si jamais le pion ne peut plus bouger.
def tester_tie():
global a1, a2, a3, b1, b2, b3, c1, c2, c3, pions_bloques
pions_bloques = 0
if a1 == "♟":
if b1 == "♙":
if b2 == "♟" or b2 == " ":
pions_bloques += 1
else:
pass
else:
pass
if a2 == "♟":
if b2 == "♙":
if b1 == "♟" or b1 == " ":
if b3 == "♟" or b3 == " ":
pions_bloques += 1
else:
pass
else:
pass
else:
pass
if a3 == "♟":
if b3 == "♙":
if b2 == "♟" or b2 == " ":
pions_bloques += 1
else:
pass
else:
pass
if b1 == "♟":
if c1 == "♙":
if c2 == "♟" or c2 == " ":
pions_bloques += 1
else:
pass
else:
pass
if b2 == "♟":
if c2 == "♙":
if c1 == "♟" or c1 == " ":
if c3 == "♟" or c3 == " ":
pions_bloques += 1
else:
pass
else:
pass
else:
pass
if b3 == "♟":
if c3 == "♙":
if c2 == "♟" or c2 == " ":
pions_bloques += 1
else:
pass
else:
pass
Si jamais tous les pions de l’ordi sont bloqués il y a égalité
if pions_bloques == pions_ordi:
egalite = True
if egalite:
reset_commandes()
boite_ordi.pack_forget()
resultat = "Egalité"
resultat_display.set(resultat)
resultat_Label.config(text = resultat_display.get())
boite_resultat.pack()
L’affichage
Maintenant que toutes les fonction sont définies, il faut afficher tous les différents éléments de la fenêtre:
Et surtout ne pas oublier d’ouvrir la fenêtre en cas d’exéction du script
window.mainloop()
Captures d’écran
Le menu principal
Le menu de personnalisation des couleurs
De nouvelles couleurs…
Une partie d’Hexapawn
La machine dépasserait-elle l’humain ?
Si vous souhaitez vous mesurer à cette IA et vérifier qu’elle apprend bel et bien de ses erreurs, vous pourrez télécharger le script du projet (défi : dépasser un score de 17!).
Le principe du jeu est de trouver le nombre de l’ordinateur en un certains nombres de tentatives. Si le joueur ne trouve pas ce nombre en ce certains nombres de tentatives, la partie prend fin mais aussi lorsque le joueur trouve le nombre généré aléatoirement par l’ordinateur.
Introduction
Ce jeu a été réalisé par un élève en première et spécialité NSI.
Jouez au jeu du plus ou moins sur ordinateur ou sur un émulateur qui soit compatible avec le module tkinter !
Dans le cadre de mon projet, le jeu a été codé en python sous 2 formes différentes :
La première qui permet au joueur de jouer directement via la console d’exécution de son application :
La seconde qui permet au joueur de jouer dans un terminal appart soit dans une nouvelle fenêtre :
Évolution
Jeu dans la console d’exécution
L’importation des modules et variables
Le module randint est un module aléatoire donne accès à diverses fonctions utiles et l’une d’elles est capable de générer des nombres aléatoires. Elle s’écrit de cette façon : randint(start, end)
J’ai crée 5 variables nombres : La 1ère définit notre nombre d’essais maximum, la 2nde notre nombre d’essais au départ, la 3ème le nombre du joueur, la 4ème et la 5ème sont liée car ici nous faisons appel a la variable nombre_max_ordi dans la fonction randit().
from random import randint
essais_max= 5 # nombre d'essais maximum
essais = 1 # nombre essais
nombre_joueur = 0 # nombre du joueur au départ
nombre_max_ordi = 25 # nombre maximum généré par l'ordinateur
nombre_ordi = randint(1,nombre_max_ordi) # nombre choisi par l'ordinateur
Affichage
La fonction print permet d’afficher a l’écran du texte.
print("L'ordinateur a choisi un nombre entre 1 et",nombre_max_ordi, ".")
print("Vous devez le trouver en moins de 5 tentatives !")
Boucle while
En anglais » while » signifie « Tant que ». Pour créer une boucle , il faut donc utiliser ce mot clé suivi d’une indication qui dit quand la boucle s’arrête.
Ici notre boucle ne s’arrêtera pas tant que quand le nombre de l’ordinateur ne sera pas égal au nombre du joueur et que son nombre d’essais soit inférieur ou égal au nombre d’essais maximum.
if, elif et else sont des conditions incrémenté dans notre boucle while.
if signifie « si ». Ici, elle marchera si le nombre du joueur est inférieur a celui de l’ordinateur.
elif est contraction de « else » et « if », qu’on pourrait traduire par « sinon ». Ici elle marchera si le nombre du joueur est supérieur a celui de l’ordinateur.
else signifie « autre ». Elle marchera si les conditions if et elif ne sont pas respectés. Entre autre le joueur aura gagné.
while nombre_ordi != nombre_joueur and essais <= essais_max:
print("vous êtes au", essais, "essai.")
nombre_joueur = int(input("Choisissez un nombre :"))
if nombre_joueur < nombre_ordi:
print("Le nombre que vous avez choisi est trop petit")
elif nombre_joueur > nombre_ordi:
print("Le nombre que vous avez choisi est trop grand")
else:
print("Félicitations ! Vous avez trouvé le nombre de l'ordinateur ","en",essais,"essai(s)")
essais += 1
Condition if
Si le joueur dépasse le nombre d’essais maximum et que si son nombre n’est pas le même que celui de l’ordinateur alors il aura perdu.
if essais>essais_max and nombre_joueur != nombre_ordi :
print("Désolé, vous avez utilisé tous vos essais.")
print("Vous êtes vraiment nul, réessayer jusqu'a que vous gagnez!")
print("L'ordinateur avais choisi le nombre",nombre_ordi,".")
Jeu avec interface graphique
L’importation des modules et variables
Tkinter (de l’anglais Tool kit interface) est la bibliothèque graphique libre d’origine pour le langage Python, permettant la création d’interfacesgraphiques.
Pour créer mon interface graphique, j’ai d’abord créer une fenêtre dont j’ai préciser sa dimension dans laquelle on y retrouva le titre, puis la couleur de fond (qui sera ici du bleu cyan), ainsi que le texte de présentation.
from random import randint
from tkinter import *
fenetre = Tk()#creation fenetre
fenetre.title("Devine le nombre")#titre
fenetre.config(bg = "#87AEAB")# couleur de fond
fenetre.geometry("1080x720") # dimension
texte = Label (fenetre, text = "Bienvenue sur le jeu du + OU -")# texte
texte.pack()
Du coté des variables une seule chose a changé : leurs valeurs ( je vous expliquerai pourquoi plus tard).
essais_max= 4 # nombre d'essais maximum
essais = 1 # nombre essais
nombre_joueur = 0 # nombre proposé par le joueur
nombre_max_ordi = 9 # nombre maximum généré par l'ordinateur
nombre_ordi = randint(0,nombre_max_ordi) # nombre choisi par l'ordinateur
Affichage
Le widget Label est un widget Tkinter standard utilisé pour afficher un texte ou une image à l’écran. Ici il va afficher du texte.
La fonction str() convertit les valeurs en forme de chaîne afin qu’elles puissent être combinées avec d’autres chaînes. Elle est utilisé dans mon programme car on ne peut écrire un texte avec des valeurs autres que des lettres alors que ma variable est un chiffre.
La méthode .pack place les widgets les uns en dessous des autres et ajuste la taille de la fenêtre. On verra plus bas que l’on peut passer des arguments à cette méthode pour placer les widgets différemment (en haut, à droite, à gauche).
Pour résumer si la méthode .pack() n’est pas utilisé a chaque fin de variables, celles-ci ne s’afficheront pas lors de l’exécution du programme.
texte2 = Label (fenetre, text = "L'ordinateur a choisi un nombre entre 1 et " +str(nombre_max_ordi))
texte2.pack()
Label (fenetre, text = "Tu as 4 essais pour le trouver ").pack()
Label (fenetre, text = "A toi de jouer !").pack()
Le cerveau du programme
La fonction chekInput représente la boucle principale, c’est elle qui contient les conditions de notre programme.
En Python, le mot clé global permet de modifier la variable en dehors de la portée courante. Il est utilisé pour créer une variable globale et apporter des modifications à la variable dans un contexte local ( donc ici dans notre fonction).
Puisque c’est une boucle qui tourne à toutes les actions du joueur, c’est l’endroit idéal pour mettre à jour les infos du joueur, comme le nombre d’essais.
Cette fonction ne change pas vraiment de celle du 1er programme appart le texte.
def checkInput(nombre_joueur):
global essais, essais_max, nombre_ordi
Label (fenetre, text = "Vous avez choisi " + str(nombre_joueur) + " :").pack()
print(essais , essais_max)
if nombre_ordi != nombre_joueur and essais <= essais_max:
Label (fenetre, text = "vous êtes au " + str(essais) + " essai.").pack()
essais += 1
nombre_joueur = int(nombre_joueur)
if nombre_joueur < nombre_ordi:
Label (fenetre, text = "Le nombre que vous avez choisi est trop petit").pack()
elif nombre_joueur > nombre_ordi:
Label (fenetre, text = "Le nombre que vous avez choisi est trop grand").pack()
elif nombre_ordi == nombre_joueur:
Label (fenetre, text = "Bien joué, le chiffre était bien : " + str(nombre_ordi)).pack()
elif essais>essais_max and nombre_joueur != nombre_ordi :
Label (fenetre, text = "Désolé, vous avez utilisé tous vos essais. Le chiffre était " + str(nombre_ordi)).pack()
Problème rencontré
Le moment est venu de vous expliquer pourquoi les valeurs de mes variables ont changé.
Tout simplement puisque j’ai crée des boutons de 0 à 9 et je n’avais pas la place d’en mettre plus sinon on aurait pas vu la fin de notre programme.
Voici une photo pour mieux comprendre.
Si il y avait eu plus de bouton le texte qui apparait après chaque clic sur un bouton aurait dépassé de ma fenêtre.
Interaction homme/machine
Voici les 10 boutons allant de 0 a 9.
Pour lier un événement à un widget, on utilise la méthode bind() sur ce widget.
Le premier argument, ‘<Button-1>’, est un «descripteur de séquence» qui indique à tkinter que lorsque le bouton gauche de la souris est pressé, il faut qu’il appelle la fonction chekInput fourni comme deuxième argument.
Une fonction lambda est une petite fonction anonyme qui peut prendre n’importe quel nombre d’arguments, mais ne peut avoir qu’une seule expression.
Ici elle va prendre le chiffre qui lui est associé et le joué dans la fonction chekInput.
La méthode mainloop() permet d’afficher la fenêtre qui vient d’être créée. Pour ceux qui ne l’avais pas deviné, elle marque la fin de notre programme.
fenetre.mainloop()
Anecdote
A la base j’étais dans un groupe de 3 personnes et ont voulais créer un space invaders mais ont s’est vite rendu compte de la difficulté alors ont s’est orienté sur le jeu du morpion. Puis je décida de quitter le groupe et de me mettre en solo car ils ne travaillait pas et c’est ainsi que j’ai codé le jeu du plus ou moins.
Conclusion
Pour pouvoir jouer à mes des versions du jeu, téléchargez le code par l’intermédiaire du lien ci-dessous. Pour la 1ère version il vous faut écrire le nombre dans la console d’exécution et pour la 2nde il vous suffit juste de cliquer sur les boutons. Amusez-vous bien !
Vous aimer les jeux old school ? Ou plus simplement les jeux vidéos ? Alors vous êtes au bon endroit ! Bienvenue sur notre projet Multi Gaming / Old School !
Introduction :
Projet réalisé par R.Moreno, N.Ducatez, M.Leclerc de la classe de première en spécialité NSI.
Jouez à plusieurs jeux tels que : Un lovemetter pour savoir QUI est votre prétendant idéal ! Un jeu du mémory pour faire fonctionner les méninges ! Et pour finir le classique jeu du : pierre, papier, ciseaux ! Avec un menu réaliser en Tkinter.
Commençons donc par le commencement :
Les jeux Tout d’abor mon équipe s’est penché sur le lovemeter qui était plutôt simple a réaliser :
#Le programme du lovemeter
def love():
a = input("Entrer le prénom du premier prétendant : ")
b = input("Entrer le prénom du deuxieme prétendant : ")
love_calcul(a, b)
#Le calcul de l'amour <3
def love_calcul(a, b):
amour=randint(1, 100)
print("Laisser moi réfléchir...")
time.sleep(2)
print("Hmmmmmmm")
time.sleep(1)
print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais ", amour,"% d'amour <3")
Voici notre code, il est assez simple, mais on ne voulais pas le laisser de la sorte ! C’est pour cela que l’on a ajouter des eastereggs.
#Le programme du lovemeter
def love():
a = input("Entrer le prénom du premier prétendant : ")
b = input("Entrer le prénom du deuxieme prétendant : ")
love_calcul(a, b)
#Le calcul de l'amour <3
def love_calcul(a, b):
amour=randint(1, 100)
print("Laisser moi réfléchir...")
time.sleep(2)
print("Hmmmmmmm")
time.sleep(1)
#Un petit secret bien sur :)
if a == "Rick":
webbrowser.open('https://www.youtube.com/watch?v=xvFZjo5PgG0')
elif b == "Rick":
webbrowser.open('https://www.youtube.com/watch?v=xvFZjo5PgG0')
if a == "rick":
webbrowser.open('https://www.youtube.com/watch?v=xvFZjo5PgG0')
elif b == "rick":
webbrowser.open('https://www.youtube.com/watch?v=xvFZjo5PgG0')
#Si un des prétendants se nomme Robert
elif a == "Robert":
print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 42% d'amour quel drôle de nombre quand même ! ")
elif b == "Robert":
print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 42% d'amour quel drôle de nombre quand même ! ")
elif a == "robert":
print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 42% d'amour quel drôle de nombre quand même ! ")
elif b == "robert":
print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 42% d'amour quel drôle de nombre quand même ! ")
#Si un des prétendants se nomme Clemente
elif a == "Clemente":
print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 76% d'amour quel drôle de nombre quand même ! ")
elif b == "Clemente":
print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 76% d'amour quel drôle de nombre quand même ! ")
elif a == "clemente":
print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 76% d'amour quel drôle de nombre quand même ! ")
elif b == "clemente":
print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 76% d'amour quel drôle de nombre quand même ! ")
#Si aucun des prétendants ne corresponds
else:
print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais ", amour,"% d'amour <3")
Après l’ajout de quelque easter egg, on s’est dit que il nous fallait au moins 3 jeux. Alors on a crée un pierre papier ciseaux.
#Le programme du pierre Papier Ciseaux
def pierre_papier_ciseaux():
choix= ("Pierre", "Papier", "Ciseaux")
Score_J = 0
Score_O = 0
# Création de la boucle
a = "Oui"
while a == "Oui":
time.sleep(2)
Choix = input("Taper Pierre , Papier , ou Ciseaux :")
# Si le choix été Pierre
if Choix == "Pierre":
print("Vous avez choisie Pierre")
time.sleep(1)
# Choix de l'ordinateur aléatoirement
print("L'ordinateur choisie ...")
time.sleep(1)
ordi = random.choice(choix)
print("l'ordinateur a choisie :", ordi)
time.sleep(1)
# Si le choix de l'ordinateur est Ciseaux
if ordi == "Ciseaux":
print("Bravo vous avez gagnez")
time.sleep(1)
Score_J += 1
print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
time.sleep(1)
a = input("Voulez-vous rejouer ? :")
# Si le choix de l'ordinateur est Pierre
if ordi == "Pierre":
print("Dommage il y a égalité")
time.sleep(1)
print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
time.sleep(1)
a = input("Voulez-vous rejouer ? :")
# Si le choix de l'ordinateur est Papier
if ordi == "Papier":
print("Dommage vous avez perdu")
time.sleep(1)
Score_O += 1
print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
time.sleep(1)
a = input("Voulez-vous rejouer ? :")
elif Choix == "Papier":
print("Vous avez choisie Papier")
time.sleep(1)
# Choix de l'ordinateur aléatoirement
print("L'ordinateur choisie ...")
time.sleep(1)
ordi = random.choice(choix)
print("l'ordinateur a choisie :", ordi)
time.sleep(1)
# Si le choix de l'ordinateur est ciseaux
if ordi == "Ciseaux":
print("Dommage vous avez perdu")
time.sleep(1)
Score_O += 1
print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
time.sleep(1)
a = input("Voulez-vous rejouer ? :")
# Si le choix de l'ordinateur est pierre
if ordi == "Pierre":
print("Bravo vous avez gagnez")
time.sleep(1)
Score_J += 1
print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
time.sleep(1)
a = input("Voulez-vous rejouer ? :")
# Si le choix de l'ordinateur est Papier
if ordi == "Papier":
print("Dommage il y a égalité")
time.sleep(1)
print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
time.sleep(1)
a = input("Voulez-vous rejouer ? :")
elif Choix == "Ciseaux":
print("Vous avez choisie Ciseaux")
time.sleep(1)
# Choix de l'ordinateur aléatoirement
print("L'ordinateur choisie ...")
time.sleep(1)
ordi = random.choice(choix)
print("l'ordinateur a choisie :", ordi)
time.sleep(1)
# Si le choix de l'ordinateur est ciseaux
if ordi == "Ciseaux":
print("Dommage il y a égalité")
time.sleep(1)
print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
time.sleep(1)
a = input("Voulez-vous rejouer ? :")
# Si le choix de l'ordinateur est pierre
if ordi == "Pierre":
print("Dommage vous avez perdu")
time.sleep(1)
Score_O += 1
print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
time.sleep(1)
a = input("Voulez-vous rejouer ? :")
# Si le choix de l'ordinateur est Papier
if ordi == "Papier":
print("Bravo vous avez gagnez")
time.sleep(1)
Score_J += 1
print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
time.sleep(1)
a = input("Voulez-vous rejouer ? :")
C’est un long programme qui peux faire peur a première vues mais en faite il est plutôt simple et répétitif !
Une fois le pierre papier ciseaux fait, nous nous sommes attaqué à notre dernier jeu, le memory bien plus rapide à faire.
def memoire():
reponse = "Oui" or "oui"
points = 0
while reponse == "Oui" or "oui":
chiffre = randint(10000,99999)
print(chiffre)
time.sleep(1)
clear()
chiffre2 = int(input("Noter le nombre qui vient d'apparaitre :"))
#Si la réponses est juste
if chiffre == chiffre2:
print("Bravo !")
points = points + 1
print("Vous avez ", points , "points")
#Si la réponses est fausse
else:
print("Dommage ! Tu as eu faux")
print("Vous avez",points , "points")
#On continue ?
reponse = input("Veux tu continuer ? : ")
if reponse == "Non" or "non":
break
def clear():
for i in range(80):
print(" ")
Le menu En fin, il nous a fallu créer notre menu, pour pouvoir sélectionner le jeux que l’on souhaite !
Pour cela nous avons insérer une image créée sur Canva en guise de menu
#Affiche l'image qui permet de choisir ce que l'on veux faire
TKI_Principal = tkinter.Tk ( )
IMG_Origine = tkinter.PhotoImage ( file = "image.png" )
BUT_Quitter = tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy )
LAB_Logo = tkinter.Label ( TKI_Principal , image = IMG_Origine , relief = "solid" , bg = "white" )
LAB_Logo.pack ( )
BUT_Quitter.pack ( )
TKI_Principal.bind("l", lambda event: love())
TKI_Principal.bind("m", lambda event: memoire())
TKI_Principal.bind("g", lambda event: pierre_papier_ciseaux())
TKI_Principal.mainloop ( )
Et pour mieux coller à l’univers multi gaming, nous avons ajouter une petit musique qui correspond parfaitement à cet univers.
Problème rencontré Nous avons rencontré des problèmes avec le menu en tkinter mais aussi avec le module python Keyboard.
Solution Pour le menu en tkinter notre équipe a suivie un tuto sur Youtube et nous avons aussi commencer a lire la documentation qui est très complexe et complète ! Et c’est comme cela que nous avons réussi notre objectif de création d’un menu. Quant au module Keyboard notre équipe a donc étudier comment l’importer sur un ordinateur que n’a pas installé le module keybord depuis le terminal de commande (powersheel). La solution était simplement de télécharger le package de code python dans le projet directement.
Conclusion
Pour pouvoir jouer à notre projet, téléchargez le code par l’intermédiaire du lien ci-dessous. Le menu est intuitif et dans le thème du multi gaming, de plus les petites surprises, les eastereggs, ajoutent une touche comique à ces jeux aléatoires .
Jouez à une machine à sous et jeu du nombre inconnu sur python avec de l’argent virtuel ! Obtenez 2 ou 3 fois le même signe et trouvez le nombre inconnu ! Moins de chance de se ruiner !
Présentation du projet
Projet réalisé sur Thonny en Python par COULIBALY Rayan, GARCIA Florian et BRYCKAERT Aurélien de la classe de première 2021-2022 en spécialité NSI.
Nous avons eu l’idée de reconstituer une machine à sous où le but est d’obtenir 2 ou 3 fois le même signe pour ainsi recevoir une somme d’argent variante selon l’argent misé. Nous n’avons mis que 4 symboles différents dans la machine, contrairement à une vraie machine à sous qui en comporte 16 en moyenne.
Nous avons aussi décidé de crée un deuxième mini-jeu : le nombre inconnu. Ce jeu est également connecté au même système d’argent virtuel. Le but est de trouver un nombre caché entre 1 et 1000, la limite est de 10 tentatives mais il faut juste un peu de réflexion pour gagner. L’argent misé sera multiplié par deux et pourra être utilisé dans le jeu de la machine à sous ou dans la boutique.
Style
Pour ce projet, nous avons décidé de créer une machine à sous en style art ASCII. Ce dernier consiste à réaliser une image avec tout type de lettres et de caractères spéciaux. Ceci est totalement esthétique et ne change pas vraiment l’expérience du jeu. Pour le jeu du nombre inconnu, nous n’avons pas pu faire créer un objet en ASCII car il n’y a pas vraiment de moyen pour représenter ce jeu autrement qu’avec du texte. Pour le menu et la boutique, nous avons décidé de faire quelque chose de classique, facile à comprendre. Pour les articles du shop, nous avons décidé de les montrer en art ASCII uniquement quand ils sont achetés par le joueur. C’est comme une récompense pour celui-ci pour d’avoir joué et gagné à nos jeux. Nous n’avons pas fait ces 3 objets en ASCII nous même, voici le lien du site où nous les avions trouvé https://www.asciiart.eu/.
Capture d’écrans
Évolution
La création du projet à commencé en plusieurs parties :
Le design de la machine à sous (visuellement) :
Le groupe à d’abord pensé à comment la machine sera construite, les différents symboles que la machine possèdera ainsi que le nombre de cases qu’elle comportera. Un modèle d’une machine à 6 cases, comportant 7 symboles différents.
Finalement, ça sera un modèle d’une machine à sous contenant 3 cases ainsi que 4 symboles diffèrent qui sera choisie.
Nous devions pour la réalisation du fonctionnement de la machine à sous, créer un script qui prendrait 3 valeurs choisissant aléatoirement un des quatre symboles. Pour que l’aléatoire fonctionne, nous devions importer la fonction random au script (Random signifiant aléatoire en anglais). Nous avions ensuite créé trois valeurs, qui correspondent aux trois symboles qui seront dans les cases de la machine à sous.
Le système d’argent est aussi nécessaire à la réalisation d’une machine à sous. Nous avions décidé que le joueur aurait en début de jeu, une somme de 5000€. Nous avons aussi décidé que le joueur ne pourrait pas miser une somme inférieure ou égale à 10€ dans la machine.
money = [5000]
mise = int(input("Combien veux tu miser ? "))
if mise > money[0]:
print("tu n'as pas assez d'argent pour miser cette somme")
slot()
if mise >= 10:
money[0] = money[0] - mise
print("")
print(" -",mise,"€")
Nous avons ensuite créé les scritps qui récompensent ou non le joueur lorsqu’il gagne ou perd. La mise est multipliée par 5 puis mise au carré lorsque le joueur obtient 3 symboles identiques, et par 4 lorsqu’il obtient 2 symboles identiques et rien si il obtient aucun symboles identiques.
if signe1[num1] == signe2[num2] == signe3[num3]:
gagne = 5*mise**2
money[0] = money[0] + gagne
print("Bravo! tu as gagné ",gagne,"€")
elif signe1[num1] == signe2[num2]:
gagne2 = mise * 4
money[0] = money[0] + gagne2
print("Bravo! tu as gagné ",gagne2,"€")
elif signe2[num2] == signe3[num3]:
gagne3 = mise * 4
money[0] = money[0] + gagne3
print("Bravo! tu as gagné ",gagne3,"€")
elif signe1[num1] == signe3[num3]:
gagne4 = mise * 4
money[0] = money[0] + gagne4
print("Bravo! tu as gagné ",gagne4,"€")
elif signe1[num1] != signe2[num2] != signe3[num3]:
perd = mise*0
money[0] = money[0] + perd
print("Dommage tu as perdu cette fois-ci !")
La programmation du jeu du nombre inconnu :
Pour ce deuxième mini-jeu, nous avions aussi eu besoin de l’aléatoire, en effet le nombre que le joueur doit trouver est compris en 1 et 1000. Nous devions aussi faire en sorte que le joueur possède 10 essais pour trouver le nombre inconnu. Pour faire cela nous avions entré une valeur nommé « nb_coup » égale à 10 qui correspond donc aux nombres d’essais restants du joueur. A chaque réponse, « nb_coup » sera soustraite de 1 et quand cette valeur sera à 0, le joueur aura perdu. La valeur « nb_test » est la nombre écrit par le joueur, cette valeur sera utilisée pour annoncer si le nombre inconnu est supérieur ou inférieur au nombre choisi ou si elle correspond au nombre inconnu.
mise2 = int(input("Combien d'argent jouez vous ?\t"))
if mise2 > money[0]:
print("Tu n'as pas assez d'argent pour miser cette somme")
le_nombre_inconnu()
nb_inconnu = random.randint(1,1000)
nb_coup=10
while nb_coup>0:
print("\n")
nb_test = input("Entrez un nombre : ")
nb_coup = nb_coup - 1
nb_test = int(nb_test)
if nb_test < nb_inconnu :
print("\n")
print(nb_test, ": Plus haut\n")
print("Il te reste", nb_coup, "essai(s)\n")
if nb_test > nb_inconnu :
print("\n")
print(nb_test, ": Plus bas\n")
print("Il te reste", nb_coup, "essai(s)\n")
if nb_test == nb_inconnu :
print(nb_test, ": Trop fort\n")
money[0] = money[0] - mise2
mise2 = mise2 + mise2
mise3 = mise2 + money[0]
print("Bravo, tu as maintenant", mise3," € \n")
La programmation du menu :
Un menu était nécessaire pour choisir à quel jeu le joueur veut-il jouer, soit la machine à sous, soit le jeu du nombre inconnu. C’est un script assez simple à réaliser et est majoritairement composé de « print ». Dans ce menu nous avons 3 choix. Tout d’abord, le choix des deux jeux (machine à sous et nombre inconnu) et le choix pour la boutique. La boutique étant du contenue ajouté en dernier. slot() correspond au script de la machine à sous, le_nombre_inconnu() correspond au jeu du nombre inconnu et shop() correspond à la boutique.
time.sleep(1)
print("\n")
print("|------------------------------------|")
print("|---------- MENU PRINCIPAL ----------|")
print("|------------------------------------|\n")
print("Tu as",money[0],"€\n")
print("|-- A quel jeu voulez vous jouer ? --|\t")
print("\n")
print("1. Machine à sous\n")
print("2. Le nombre inconnu\n")
print("|------------------------------------|\n")
print("3. Shop\n")
choix=int(input("Veuillez selectionner votre choix:\t"))
print("\n")
if choix==1:
slot()
if choix==2:
le_nombre_inconnu()
elif choix==3:
shop()
else:
print("Choix non valide\n")
Pour retourner au menu depuis les jeux, nous avons créé un script proposant au joueur un choix, s’il veut retourner au menu ou continuer à jouer. game() correspond au script du menu, et slot() correspond au script de la machine à sous, comme dit précédemment.
def continuer():
print("Voulez-vous continuer?\n")
print("1.Oui\n")
print("2.Non (retour au menu)\n")
choix2=int(input("Veuillez selectionner votre choix:\t"))
if choix2==1:
slot()
elif choix2==2:
game()
else:
print("Choix non valide\n")
La programmation de la boutique :
L’ajout d’une boutique sert à donné une sorte de but dans notre programme. Les jeux nous faisant gagner ou perdre de l’argent sans réel but n’ont pas vraiment d’intérêts à être joué. La programmation de la boutique est très similaire à celle du menu, en effet plusieurs choix nous sont proposés, comme au menu. Ce script est divisé en deux car on ne voulait pas que la phrase d’accueil de la boutique se répète à chaque fois.
Pour rendre le script plus sympathique et moins agressif, nous avions importer des son de victoire ou de défaite ainsi que durant les apparitions de texte, du temps entre chaque texte pour ne pas rendre le joueur confus à cause d’une surabondance de texte.
import winsound
import time
winsound.PlaySound("", winsound.SND_ASYNC)
time.sleep()
Problèmes rencontrés
Nous n’avons pas vraiment rencontré beaucoup de problèmes durant ce projet, le seul problème était de rassembler tout les scripts dans un seul et même script. Nous avions commencé à programmer chacun dans notre coin en tapant des valeurs se nommant différemment alors qu’elles sont les même.
Heureusement nous avons réussi à tout rassembler, sinon nous n’aurions aurait pas pu finir le projet!
Conclusion
Ainsi, ce projet était vraiment intéressant, nous avions pris plaisir à y travailler dessus. Cela fut enrichissant, car par la pratique, nous avions beaucoup appris !
Tutoriels
