École Internationale PACA Manosque

Defend the cube! (par Louis et Takuma)

Defend the cube! (par Louis et Takuma)

Defend the cube! (par Louis et Takuma)

Introduction
Pour notre second projet d’NSI, nous avons décidé de créer un jeu original (et non une recréation comme le jeu d’asteroids) dont le but est de défendre un objet qui s’appelle “core” par des ennemis. Le joueur peut extraire des ressources à partir des arbres et des roches, crafter des items pour obtenir une meilleure arme, etc.. Quand le joueur perd toute sa vie, il va devenir un fantôme pendant un certain temps jusqu’à qu’il se ressuscite, et quand le core est entièrement détruit, le jeu s’arrête.

Présentation générale/ Description du projet
・Description / mode d’emploi 

Le jeu se présente sous forme d’un jeu 2D dans lequel on est introduit avec un menu qui nous montre 3 choix : “Start a new game”, “Settings” et “Quit”. Les choix sont des boutons; on peut les cliquer à l’aide d'une souris avec des effets visuels pour montrer à l’utilisateur qu’est ce qu’il est en train de faire avec le bouton.

Defend the cube - Generating terrain

Quand le joueur clique sur le bouton “Start a new game”, le programme va générer les objets nécessaires pour le jeu. Pendant cette phase de préparation, 2 messages sont affichés sur la fenêtre: “Loading…” et un autre message qui affiche ce que le programme est en train de faire pour montrer qu’il fait son job sans s’arrêter. La génération du terrain se fait pendant cette phase avant le début du chaque game.

Après le chargement, le joueur peut enfin contrôler le personnage pour commencer à préparer l’invasion. Pour avancer, on appuie sur les touches WASD(clavier qwerty recommandé) et pour utiliser un outil/ envoyer des coups de poing, on fait des clics gauches.

Le personnage possède aussi un inventaire. Le joueur peut appuyer sur la touche E pour ouvrir l’inventaire et crafter / ranger / déplacer ses items en faisant des “drags and drops” (avec le click droit pour n’en déplacer qu’un et le click gauche pour tout déplacer). Si le joueur veut utiliser certains items, il doit déplacer cet item dans la barre d'outils située en bas à gauche et le sélectionner en cliquant sur l’item.

On remarquera la présence d’un “menu de craft” (comme nous l’appelons) qui nous permet de fabriquer des objets à partir de combinaisons d’autres objets.
Par exemple, pour faire des blocs de bois, il nous faut mettre le paterne ici à droite

Le jeu se déroule sans limite de temps et le but est de défendre le “core” (une sorte de boîte violette) situé au milieu du terrain en tuant avec des armes les ennemis qui viennent vers le joueur ou le core (le joueur ne peut pas donner des dommages aux ennemis sans arme).
Cependant, le joueur ne possède rien au début du jeu. Il doit donc taper sur les arbres, roches pour obtenir des ressources et crafter des armes de base. Les ennemis vont venir attaquer progressivement et le jeu termine quand le core perd toute sa vie.

・Historique
Afin d’avoir des idées, on a utilisé un outil en ligne qui s’appelle “Game idea generator”. Les concepts principaux sont le tower defense, topdown, ressources, crafting. Chaque concepts existent depuis même avant l’année 2000. Par exemple, un des premiers jeux de tower defense est Dungeon Keeper, publié en 1997. Malgré la vieillesse de ces types de jeux, aujourd’hui on a toujours des jeux qui sont activement joués comme Minecraft dans lequel on peut craft des items et farmer des ressources. On a voulu mélanger différentes idées pour en faire un jeu amusant.
On a aussi utilisé pour la génération du terrain le bruit de Voronoï et le bruit OpenSimplex (lui même inspiré du bruit simplex lui même encore inspiré du bruit de Perlin), pour ce dernier, nous avons utilisé le module OpenSimplex de python (il faut l’installer avec pip)
・Notre objectif
On voulait créer un jeu plus complexe, moderne que le jeu qu’on a recréé précédemment en tant que challenge, et essayer de dépasser la limite de la programmation avec pygame. Un autre but est de mélanger les concepts des différents jeux afin d’en créer un jeu original (par exemple le système de tower defense avec un système de ressources et de crafting).

Bilan
・Points positifs
- On a réussi à coder un jeu qui ressemble assez à un vrai jeu moderne malgré la difficulté de coder un jeu sur python à partir de zéro.
- On a gagné beaucoup d'expériences et de connaissances sur la programmation objet et sur le module pygame, ainsi que les différents algorithmes comme A*, perlin noise.
- On a créé la bibliothèque GameManager qu’on pourra utiliser dans notre future projet.

・Points négatifs
- On a fait de notre mieux sur l’organisation du code mais le code a commencé à être très compliqué à force d’ajouter des classes.
- On a pas réussi(pas assez de temps) à implémenter le mode multijoueur.

・Experience personelle
On sait mieux coder un jeu avec pygame, on maîtrise plus la programmation objet, et on a encore ressenti l’importance de git(github) quand on travaille sur un projet avec plusieurs personnes.

・Conclusion
Au final, on a fini avec un jeu simple à jouer et aussi très modulable (on peut ajouter très facilement des objets, modifier la génération de terrain et bien d’autres variables du jeu. On en est très fiers et de plus, ce même programme nous permettra de créer d’autres jeux ou applications de genre simulation. On a beaucoup appris sur les algorithmes de pathfinding et de génération aléatoire de terrain (donc le bruit de Perlin, OpenSimplex, Voronoï, etc). Notre projet est en soit une grande réussite et pour nous une prouesse de faire un jeu aussi optimisé sur python. On s’est bien amusé à le faire.

Bataille Navale (par Isabel et Nelly)

Bataille Navale (par Isabel et Nelly)

Bataille Navale (par Isabel et Nelly)

Notre Projet
Nous avons décidé de faire une bataille navale à l'aide du langage de programmation
python, afin de faire notre second projet de l’année de première en spécialité NSI. Notre
problématique est: Comment créer un jeu conçu pour être joué sur papier sur python?

Pourquoi avons-nous choisi la bataille navale ?
Nous avons choisi ce jeu car nous le trouvons ludique et relaxant. Vu notre intérêt en jouant, nous avons décidé de créer notre propre version.
La bataille navale est un des plus grands jeux de notre enfance, c’est un jeu familial, etc

Malheureusement il est temps pour nous  de grandir, et d'être des étudiants responsables, c’est pour cela que ce jeu peut permettre à des étudiant isolés de pouvoir malgré tout jouer au jeu qui a bercé
son enfance.

La programmation

Les tableaux
Tout d’abord notre programme commence par la création d’un tableau, permettant de placer les bateaux par la suite.
Premièrement, on a créé le tableau de jeu  du joueur principal, remplis de zéro de taille 8 x 8.
Le tableau de l’adversaire et celui où l'on devine les bateaux sont créés de la même manière, mais celui de l'adversaire ne sera pas affiché pendant la partie pour ne pas révéler ses bateaux. Puis nous avons défini la fonction affiche() qui permet l’affichage formaté des tableaux sur l'interpréteur avec des des lettres en tant que colonnes, et des chiffres en tant qu'indicateur de lignes. La fonction va commencer par afficher les  lettres des colonnes, puis elle va huit fois (la taille du tableau) afficher le chiffre de 1 +1 (car il commence par 0) et la ligne du tableau associée. Nous avons de plus créé un dictionnaire qui associe une lettre à
un chiffre.

Cette grille est la grille de base, qui nous permettra d’afficher les bateaux à l’aide de leurs position indiquée par le joueur, ou bien pour attaquer l’adversaire.

Le plaçage des bateaux
L’utilisateur peut donc commencer à placer ses bateaux. Pour cela la fonction choix() lui demande les coordonnées de chaque bateau qu’il veut placer, il en existe 4 différents: un torpilleur de 2 cases, un contre torpilleur de 3 cases, un croiseur de 4 cases, un porte avion de 5 cases.
Il commence donc par indiquer le chiffre de la ligne, puis la lettre indiquant la colonne et enfin si le bateau est orienté  verticalement ou horizontalement. La fonction vérifie simultanément si la case est vide (0) ou occupée(1) et redemande de nouvelles coordonnées dans le deuxième cas.

Ici, nous avons conçu le système de placement en prenant en compte la volonté de l’utilisateur, demandée ci-dessus.
Grâce à la fonction placage_des_bateaux(), le programme place les bateaux aux coordonnés choisis au préalable par le joueur dans le tableau tableau_joueur.
Une boucle de 2 à 6, permet de répéter tout cela 5 fois, et crée donc cinq bateaux de deux à cinq cases. Les deux conditions après avoir appelles la fonction choix() vérifient que le bateau ne sortira pas des limites du tableau. Si cela est vérifié, alors la fonction parcourt le tableau_joueur place la première case du bateau en échangeant un 0 par un 1. Il continue dans la direction choisie (horizontale ou verticale) le nombre des cases indiqué par la boucle de départ.
En plaçant les lignes et les colonnes , nous faisons -1 car les tableaux commencent de zéro, donc sans le -1, il y aurait un décalage avec la demande du joueur.

Cette fonction permet de placer les bateaux du joueur adverse de façon aléatoire, nous avons donc utilisé random pour cela. Ce module est appelé au début du programme par un import.
Le placage des bateaux adversaires est constitué de trois fonctions.
Premièrement la fonction direction() qui renvoie un chiffre au hasard entre 0 et 1. Puis la fonction case() qui prendra en paramètres la taille et la direction du bateau. Elle renvoie une liste avec une lettre et un numéro choisi au hasard et la direction. La
fonction soustrait de plus la taille du bateau au choix de la lettre et du numéro; pour éviter un dépassement du tableau lors du placage. Enfin, nous avons créé la fonction poser() qui prend en paramètres les données de la fonction case, un tableau et la taille du tableau. Cette fonction vérifie si la direction est horizontale (0) ou verticale (1) puis vérifie sur la place du bateau qu’il n’y a pas de bateaux déjà placés à cet endroit. Si oui, la fonction renvoie False la boucle while not est_pose, continue jusqu'à ce que est_pose == True. La boucle while not tourne à l'infini jusqu'à ce que sa condition soit remplie.
Une boucle de 2 à 6 permet à nouveau de définir la taille des bateaux, nous avons donc également quatres bateaux de deux à cinq cases sur le tableau de l’adversaire. Nous associons donc les résultats de la fonction case() a la variable case_ que nous mettons
en paramètres de poser() en l’appelant.
Nous avons choisis de faire plusieurs fonctions pour aérer le programme et le rendre plus agréable à lire.

Attaquer et jouer
Le joueur va pouvoir enfin attaquer
l'adversaire et inversement! Pour cela,
nous avons créé deux fonctions:
attaque_joueur() et attaque_adv(). La
première fonction utilise la fonction
choix() pour définir les variables ligne et
colonne avec lesquelles elle va vérifier si
on a déjà choisi cet endroit et si un
bateau adverse se trouve en cette
position (renvoie “Touché!” et remplace
le 0 par un 3 dans le tableau_devine) ou
non (renvoie "Raté" et remplace le 0 par
un 7 dans le tableau_devine). La
deuxième fonction fonctionne de la
même manière mais utilise des positions
choisis au hasard et renvoie si le joueur
a été touché ou non

Qu'avons-nous appris au cours du projet?
Au cours de ce projet nous avons appris et nous avons pu nous améliorer sur la création de tableaux, sur la cohésion de groupe et la répartition du travail. Nous avons de plus pu nous familiariser avec les listes, et des conditions.


Qu’est-ce qu’on aurait pu ajouter ou améliorer?
Une interface graphique aurait amélioré notre projet mais nous avons essayé de privilégier la finition de celui-ci.
Ajouter des asserts pour limiter les erreurs dans l'interpréteur et éviter de devoir recommencer le programme à chaque fois.

Calculs streak (par Adrien et Elias)

Calculs streak (par Adrien et Elias)

Calculs Streak (par Adrien et Elias)

Ce jeu s'appelle “calculs streak”. Le jeu consiste à résoudre des calculs le plus rapidement possible. Pour rendre cela plus amusant nous avons rajouté un “personnage” qui réagit aux réponses du joueur :  bonne réponse prend des dégâts, mauvaise réponse ; regagne de la vie, et finalement si le joueur arrive à venir à bout du boss celui-ci meurt

Un historique:

 Au début nous voulions faire un jeu de réactivité mais sans trop savoir quoi faire, nous avons essayé plusieurs choses comme un jeu ou l’on doit cliquer le plus vite possible sur des cases mais nous n’étions pas satisfait de ce projet. Nous le considérons tout le temps inachevé tout en ne sachant pas quoi ajouter… Après quelques réflexions nous avons décidé de partir sur un jeu de calcul mental pour lier utilité et agréabilité (c’est pour vos élèves). Au début il n’y avait pas d’interface graphique juste des calculs qui apparaissent dans l’invité de commande sous la forme: 3 plus 4, 8 fois -3 et 5 moins -9. Notre but était de créer un jeu dans lequel nous devions être investi à 100% ainsi l’idée des lettres a la place des opérateurs nous semblait être un bon choix, après nous avons rajouté un timer et nous avons fait essayé le jeu à plusieurs élèves. Un avis est ressorti unanimement, le fait de mettre des mot à la place des opérateurs était vraiment énervant, nous avons donc changer ça. finalement nous avons coder la partie graphique avec l’aide de pygame.

Un panorama de ce qui existe dans ce domaine:

Il y a énormément de jeux qui existent dans ce domaine, notamment des petits quizz sur internet pour s'entraîner à calculer plus vite

 L’objectif de ce que l’on a cherché à réaliser par ce projet:

Nous voulions coder un jeu qui normalement est assez monotone et en faire quelque chose de graphique et si possible introduire un peu de compétition           .

Les difficultés rencontrées, les solutions techniques choisies:

Notre premier gros problème a été au niveau des calculs, en effet lorsque nous avons changé et que nous sommes passés de lettres a +, - et * nous ne savions pas comment faire l’opération car +, - et * étaient en str et les nombres en int, nous avons essayé de les mettre en int mais sans succès. Finalement Mr Perez nous a fourni de l’aide en nous passant un bout de code qui est eval(), cela nous a permis de mélanger les str des +, - et * avec le saint des chiffres.

Tous les autres problèmes étaient sur la partie interface graphique, en premier nous avions comment faire tourner la boucle de l’animation du monstre et celle des calculs en même temps, heureusement Takuma et Louis nous ont aidés en nous conseillant la bibliothèque thread ( jusque là nous utilisions multiprocessing mais il ne fonctionnait pas bien et nous apportait plus d’erreurs qu’autre chose).

Une description du programme réalisé

La description du programme est directement sur le programme via les commentaires.

 Les tests/debugging effectués:

Nous avons tout testé à chaque fois que nous avons implémenté quelque chose, cela nous a permis d’avancer assez rapidement

Wordle (par Aaron, Axzell et Inès)

Wordle (par Aaron, Axzell et Inès)

Wordle (par Aaron, Axzell et Inès)

Nous avons choisi de faire wordle en tant que projet car en première option on avait en tête de faire le tic tac toe sauf que l'idée était déjà prise 🙁 Donc Mme.FOUNAUD nous a conseillé de faire autant que projet Wordle, vu que c’était intéressant car cela continuait le projet que l'on avait avant (le mastermind), dans notre jeu il y a le même fonctionnement, à part une seule règle qui change du vrai jeu, c’est que nous, au lieu de composer 5 couleurs, ici on cherche un mot qui doit contenir 6 lettres. On a donc commencé à faire des recherches pour créer un tableau, mettre les lettres en place, mettre des couleurs…etc.

Le programme en lui même nous n’avons pas eu de vrai difficultés à le faire, les vrais difficultés nous les avons rencontrés au moment de mettre les couleurs, mettre les lettres en place, vérifier les placements des lettres, trouver une liste de mots correspondants aux critères: 6 lettres,  tilisés quotidiennement, plutôt faciles à trouver.

Cependant, la gestion du temps de la création de notre programme a été très favorable, car on a réussi à se partager les tâches du travail sans soucis.

Composition du World.Py
La création de notre jeu a été conçue en trois parties. 

Au tout début on avait eu l'idée de faire un fonction pour qu'elle puisse créer une boucle lorsqu'un mot n'était pas trouvé. Mais cela n'a pas pu se faire, donc on a basculé sur une boucle 'for' pour tout d'abord créer la grille du jeu. donc suite à ça, on a enchaîné avec une boucle ‘while’ qui puisse déterminer la quantité d'essai pour atteindre le mot attendu par  le joueur. 

Ensuite pour donner plus de ressemblance au jeu original, on a  décidé de rajouter les couleurs. Pour ajouter les couleurs aux lettres on a créé une fonction (couler_lettre) qui nous permettra de savoir si une lettre est correcte ou non. Pour les couleurs on a utilisé un dictionnaire qui dispose les couleurs dont les lettres apparaîtront selon le mot recherché (vert pour une lettre à la bonne place et la  bonne lettre; jaune pour lettre bonne mais a la mauvaise place et finalement rouge pour indiquer que la lettre n'est pas la bonne et qu'on en a pas besoin de cette lettre dans le mot recherché → image 1).

Finalement on a mit en place une boucle qui affiche soit gagné (lorsque le mot a été trouvé dans le délai d'essais) soit perdu (lorsque le mot n'a pas été trouvé).

Conclusion (point à améliorer)
Notre point à améliorer serait d' apprendre  pour plus tard pouvoir créer un jeu avec un minimum d'interface graphique pour profiter plus du jeu, apprendre encore plus au niveau de la programmation et  surtout faire que le jeu ait un côté plus amusant.

Tetris (par Antoine et Marco)

Tetris (par Antoine et Marco)

Tetris, par Antoine et Marco

Cette fois-ci nous avons codé le 3ème jeu le plus vendu au monde: Tetris

 

Il s’agit d’un jeu qui entre dans nos capacités de programmation tout en nous demandant une bonne part de réflexion.

 

Nous avons codé le jeu sur Python à l’aide des logiciels Replit et PyCharm. La bibliothèque Pygame nous a elle permit de gérer l’interface graphique.

 

Voici quelques Sprites du jeu:

Pixel:

Pièce en “L”:

Voici quelques lignes de code:

 Rotation vers la gauche:

def rot_left():

   """ permet de faire pivoter le tableau de la pièce manipulable en sens anti-horaire"""

   tmp = list(map(lambda x: x.copy(), piece))  # copie pièce de façon a ne pas avoir de problème de muabilité

   for i in range(len(piece)):

       for j in range(len(piece)):

          piece[-j - 1][i] = tmp[i][j]  # notre pièce est pivotée à l'aide de la copie de la pièce d'origine\

          # afin de ne pas se fier à un  pièce en pleine modification

Ce projet nous a permis consolider et affirmer nos bases acquises lors du premier projet et nous a beaucoup aidé sur la manipulation de tableau.