VISI301 CMI : projet de recherche et développement

De Wiki du LAMA (UMR 5127)
Aller à la navigation Aller à la recherche
  • Cours du semestre 3 du parcours CMI informatique (licence info) et CMI mathématique (licence math).
  • Responsables pour 2020--2021 : Jacques-Olivier Lachaud et Pierre Hyvernat


Descriptif

L'objectif de ce cours est de développer des compétences dans différents domaines de l'algorithmique et la programmation Python, au travers du développement d'un jeu. Les étudiants découvrent aussi les outils modernes de développement collaboratif (gestionnaire de version, pull requests, intégration continue). 8 séances sont prévues dans l'EDT mais il est attendu du travail personnel supplémentaire. Les projets se font par binôme ou trinôme. Le travail est évalué sur la base d'une démo et du rendu sur le serveur GitHub.

Les étudiants rencontreront à intervalle régulier leurs enseignants tuteurs pour le projet afin de rendre compte de leur avancée dans leur projet (démarche similaire à celle des Travaux Personnels Encadrés). Le type de jeu choisi est laissé volontairement assez libre, de manière à ce que les étudiants développent leur imagination ainsi que leur capacités de réflexion et discussion collaboratives (brain-storming). Ils pourront aussi faire des recherches pour affiner leur modèle de jeu choisi.

Objectifs

L'idée est de réaliser un jeu en python. L'objectif est de finir avec un jeu simple mais fonctionnel. (Par exemple, il est préférable de n'avoir qu'un seul niveau à avoir 99 niveau si le personnage ne peut pas encore se déplacer...)

Voici quelques exemples de jeux dont vous pouvez vous inspirer :

Le type de jeu que vous choisirez aura des conséquences sur le type de code que vous écrirez. Attention, les jeux "textuels" nécessitent, encore plus que les autres, une histoire bien racontée !

Quel que soit votre choix, nous donnerons probablement des consignes supplémentaires.


Si vous ne trouvez pas d'idée, nous imposerons un jeu du premier type avec les consignes suivantes :

  • la carte est représenté par une ou plusieurs grilles de jeu,
  • un ou plusieurs personnages se déplacent dans la grille (le(s) joueur(s), le(s) monstre(s)),
  • actions en tour par tour,
  • des niveaux générés aléatoirement.

Cela permettra de développer pas mal d'aspects différents de l'algorithmique et de la programmation:

  • structures de données pour représenter les plans de jeu, les personnages, les objets éventuels
  • algorithmes de graphes pour générer des niveaux labyrinthiques
  • programmation graphique pour afficher le décor et les éléments de jeu
  • interfaces homme-machine pour diriger le jeu
  • un peu d'intelligence artificielle pour faire jouer les personnages non joueurs (monstres, ennemis, amis ).
  • entrées/sorties pour sauvegarder le jeu/ les niveaux

Ressources

On pourra se baser sur pygame , une bibliothèque Python conçue pour faire des jeux.

Cela permet de faire facilement:

  • les boucles d'interactions
  • les affichages graphiques
  • la gestion du clavier ou de la souris.

Contraintes

  • le projet sera fait en python (plus simple, développement plus rapide)
  • les binômes (ou trinôme) seront tirés aléatoirement pour mélanger les promotions (CMI-math et CMI-info)
  • vous utiliserez une plateforme de développement collaboratif Github

Critères d'évaluation

  • Conception du jeu, réflexion initiale, originalité du jeu
  • Réalisation, fluidité, ressenti général
  • Intérêt du jeu, jouabilité, progressivité, richesse
  • Méthodologie, régularité de l'avancement, communication avec les tuteurs
  • Rendu final, doc utilisateur, packaging, installation
  • Autonomie, recherches personnelles, montée en compétence

résumé des commandes git de base

 configuration (une seule fois sur votre machine)
 ------------------------------------------------
 
   $ git config --global user.name "PRENOM NOM"
   $ git config --global user.email "MON@ADRESSE.EMAIL"
 
 
 information (à utiliser sans modération)
 ----------------------------------------
 
   $ git status
   affiche l'état du dépot (en fait, de la branche courante) : nouveaux 
   fichiers, fichiers modifiés, etc.
 
   $ git log
   affiche la liste des commits du dépot (en fait, de la branche 
   courante)
 
   $ git diff
   ou
   $ git diff FICHIERS
   affiche les différences entre le dépot actuel et le dernier commit 
   (éventuellement, seulement pour les fichiers donnés en argument)
 
 
 sauvegarde des modifications ("commit")
 ---------------------------------------
 
   $ git add FICHIERS
   demande à git de gérer les fichiers FICHIERS
   (On peut donner plusieurs fichiers en même temps, ou utiliser les 
   motifs du shell comme "git add *.py")
   ATTENTION : le fichier n'est pas sauvegardé par cette commande
 
   $ git commit
   ou plus souvent
   $ git commit -a -m "MESSAGE"
   enregistre l'état du dépot (en fait, de la branche courante)
      - l'option '-a' permet d'enregistrer __tous__ les fichiers 
        modifiés. Sans elle, il faut faire "git add FICHIERS" avant le 
        "git commit"
        ATTENTION, les nouveaux fichiers ne sont pas ajoutés par l'option 
        '-a', il faut impérativement faire "git add FICHIERS" pour les 
        nouveaux fichiers.
      - l'option '-m "MESSAGE"' permet de donner une description de ce 
        commit
        Sans cette option, un éditeur de texte (probablement vi) sera 
        lancé pour taper la description du commit. (Si vous ne savez pas 
        utiliser vi, vous pouvez configurer un autre éditeur avec
        $ git config --global core.editor "MON_EDITEUR_FAVORI"
        )
 
 
 communication avec un autre dépot
 ---------------------------------
 
   $ git pull REMOTE
   ou
   $ git pull
   récupère l'état du dépot (en fait de la branche) depuis REMOTE
   Si un dépot distant est configuré (automatiquement si vous avez 
   récupéré le dépot avec "git clone URL"), vous pouvez omettre REMOTE
 
   $ git push REMOTE
   ou
   $ git push
   envoie l'état du dépot (en fait de la branche) vers REMOTE.
   Si un dépot distant est configuré (automatiquement si vous avez 
   récupéré le dépot avec "git clone URL"), vous pouvez omettre REMOTE
 
 
 importer un nouveau dépot ("fork", "clone")
 -------------------------------------------
   $ git clone URL
   récupère un dépot git dans un nouveau répertoire dans le répertoire 
   courant.
   Typiquement, URL est récupérée sur github ("Clone or download")
 
 
 revenir en arrière
 ------------------
 
   $ git checkout HASH
   remet le dépot dans l'état correspondant au commit de hash HASH
   Le hash d'un commit est affiché par "git log". Ça ressemble à 
   ddca8e4f15958e4f5151c5e23c4d673a132334b2
   (il faut donner au moins les 4 premiers caractères du hash...)
 
   ATTENTION, ceci n'est possible que si vous n'avez aucun changement non 
   enregistré.
 
   ATTENTION, il est déconseillé de modifier les fichiers lorsque le 
   dépot est dans un état antérieur. Au besoin, vous pouvez faire
   $ git reset --hard
   pour remettre votre dépot dans l'état exact du commit correspondant.
 
   $ git checkout master
   ou
   $ git checkout -
   remet le dépot dans l'état final
 
 
 Utilisation typique
 -------------------
 
 0/ création d'un dépot vide depuis github ("New" depuis la page 
 "Repositories" de votre compte github)
 
 ou bien
 
 0'/ récupération d'un dépot existant avec "git clone URL"
 
 
 Lors d'une séance de travail :
 
 1/ synchronisation pour récupérer les changement du dépot central (sur 
 github)
   $ git pull
 Normalement, il n'y aura jamais de conflit à cette étape.
 
 2/ visualiser les nouveautés avec
   $ git log
 
 3/ travail, modification de fichiers, création de fichiers, etc.
 
 4/ lorsque vos modifications fonctionnent et sont finies :
   $ git add NOUVEAUX_FICHIERS
   $ git commit -a -m "MESSAGE"
 
 5/ sauvegarde sur le dépot central
   $ git push
 
 
 5/ en cas de conflit (parce que quelqu'un a modifié le dépot central 
 entre temps), résolution du conflit et nouveau commit :
   $ git commit -a -m "RESOLUTION CONFLIT"
   $ git push
 
 
 Pour aller plus loin
 --------------------
 
 Lorsque vous maitrisez les commandes et concepts précédents, vous pouvez 
 vous renseigner sur
 
   - les "branches" qui permettent d'avoir plusieurs versions du dépots 
     "en parallèle"
 
   - les "remotes" qui permettent de communiquer avec plusieurs dépots 
     lors des "git pull" et "git push"
 
   - "git stash" qui permet de mettre de coté des modification 
     momentanément
 
   - les "pull-requests", qui permettent d'avoir plusieurs dépots 
     principaux, et d'échanger des modifications entre eux. (Ceci est un 
     mécanisme propre à github)

Sujets réalisés (2019-2020)

Responsables pour 2019--2020 : Jacques-Olivier Lachaud et Pierre Hyvernat

Sujets réalisés (2018-2019)

Responsables pour 2018--2019 : Jacques-Olivier Lachaud et Pierre Hyvernat

Sujets réalisés (2017-2018)

  • Ambroise Decouttère et Raphaël Tournafond, MazeRunner
Récupérée de « http://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=VISI301_CMI_:_projet_de_recherche_et_développement&oldid=12602 »