builds

Documents/Liste_Rapport.txt

@@ -0,0 +1,72 @@
+Rapport de R<>union du 11 Octobre en visioconf<6E>rence 
+
+Jour du choix du projet et de sa d<>couverte , mise en place des outils et des droits pour les documents.
+R<EFBFBD>union entre Simon, Victor et Ethan pour d<>cider du jeu adopt<70> et recherch<63> . 
+Le choix fut de faire un jetpack Joyride en y incorporent un joueur bot au lieu du joueur ou plusieurs propositions de r<>ponse <20> la demande fut trouv<75> .
+ Diverses maquettes de ses propositions 3 retenus<75>:
+-L<>omniscient(Neuronal)
+-L<>observateur(Neuronal)
+-L<>It<49>rateur(Proc<6F>dural)
+
+R<EFBFBD>union en visioconf<6E>rence ensemble avec M.Florent Madelaine 
+Proposition des subjectivions  pr<70>c<EFBFBD>dente , usage de Unity pour la cr<63>ation du jeu, discutions autour des propositions ou l<>omniscient et l<>observateur serait ceux que nous envisagions de faire en seule joueur bot ( l<>un d<>eux) et la possibilit<69> d<>ajouter un joueur humain.
+Proposition de M.Madelaine d<>incorporer les connaissances et l<>usage de MIN, et MAX appris durant nos cours .
+Les trois IA cit<69> pr<70>c<EFBFBD>demment fut retenus avec pour objectif de les ajouter et de pouvoir les comparer sur des chemins pr<70>-g<>n<EFBFBD>rer ou proc<6F>dural .
+
+
+
+Rapport de R<>union du 18 Octobre en visioconf<6E>rence<63>
+Discutions entre Simon, Victor et Ethan sur les ressources pour aboutir <20> notre projet et des connaissances et outils n<>cessaires pour y parvenir . Apprendre Unity , sprites utilis<69> ou pour plus tard. D<>part du projet sur unity .
+
+Rapport de discutions du 7 Novembre 
+Discutions sur la mise en place du principe du Min , Max dans le projet , possibilit<69> d<>ajouter un syst<73>me de score et des pi<70>ces malus d<>pos<6F> par min pour diminuer le score de max .
+
+Rapport de R<>union du 20 Novembre en visioconf<6E>rence 
+Mise en place et d<>but des premier documents , cahier des charges , gant pr<70>visionnel et mise en place des premiers assets sur le git.
+
+Rapport de R<>union du 24 Novembre en pr<70>sentiel sans Ethan 
+R<EFBFBD>union sur l<>avancement du projet , r<>vision de la g<>n<EFBFBD>ration des niveaux
+
+
+Rapport de R<>union du 28 Novembre en visioconf<6E>rence 
+R<EFBFBD>vision des cahiers des charges fonctionnel et technique afin de les transmettre a M.Madelaine
+Difficult<EFBFBD> sur la mise en place de ces fichiers en markdown sur le git
+
+Rapport de Discutions du 4 D<>cembre 
+R<EFBFBD>solution du probl<62>me suivis d<>une v<>rification et refonte des documents avant d<><64>tre envoy<6F> .
+
+Rapport de R<>union du 20 D<>cembre 
+Mise en place du syst<73>me de raycaste sur le jeu , incorporation des missiles, obstacle et pi<70>ces .
+
+Rapport de R<>union du 1er mars en pr<70>sentiel sans Ethan 
+R<EFBFBD>union sur l<>avancement du projet et la gestions de travail.
+
+Rapport de R<>union du 10 Mars en pr<70>sentiel
+Pr<EFBFBD>sentation du jeu avec une interface et un menu , d<>un syst<73>me de pi<70>ces et missiles .
+discutions autour des performances et de la vitesse du jeu et mise en place de date pour de futur r<>unions .
+
+Rapport de R<>union du 19 Mars en visioconf<6E>rence 
+Remise en route des taches attribu<62>s et cr<63>ations des ressources pour cr<63>er les patterns 
+
+Rapport de R<>union du 25 Mars en pr<70>sentiel 
+R<EFBFBD>union sur l<>avancement du projet,r<>vision des documents disponibles et demand<6E>s.
+
+Rapport de discutions du 2 Avril 
+R<EFBFBD>vision et recherche d<>utilit<69> des formes des patterns en fonction de la vitesse du jeu.
+
+Rapport de R<>union du 3 avril en pr<70>sentiel avec M.Madelaine
+Discutions sur l<>avancement du projet , des manques de documents sur le git , n<>cessite une explication pour d<>ployer et utiliser le jeu<65>.
+Discussions sur la mise en place d<>une difficult<6C> via une augmentation de la vitesse du jeu
+v<EFBFBD>rifier les assets et les optimiser pour diminuer la taille du jeu
+mise en place des documents de suivit et avoir des traces <20>crites des r<>unions.
+
+Rapport de discutions du 24 Avril 
+V<EFBFBD>rification des documents pr<70>sent et remise en conformit<69> 
+recherche d<>information sur l<>optimisation du jeu .
+
+Rapport de discutions en visioconf<6E>rence du 01 Mai 
+Mise en place d<>un mod<6F>le de donn<6E>es ( JSON) pour stocker les donn<6E>es
+Mise en place de micros-services (plusieurs API).
+
+Rapport de r<>union en pr<70>sentiel du 16 Mai
+Refonte des documents existant.

Documents/Spécifications_fonctionnelles.md

@@ -0,0 +1,207 @@
+# Projet Jetpack DinoAI
+
+Comparaison de Différentes Intelligences Artificielles dans un Jeu Simple
+
+Cahier des charges fonctionnelles
+
+Par :
+
+Victor Descamps  
+Simon Catanese  
+Ethan Richard
+
+Tuteur :
+
+Florent Madelaine
+
+fait le 18/11/2023
+
+> Les images sont présentes en local avec ce document s'il y a un problème d'affichage nous recommandons d'utiliser l'extension markdown viewer de Firefox
+
+# Sommaire :
+
+- [Contexte](#contexte) 
+
+- - [Sujet](#sujet)
+
+- - [Objectifs](#objectifs)
+
+- - [Le Jeu](#le-jeu)
+
+- - - [Le jeu de base](#le-jeu-de-base)
+
+- - - [Notre jeu](#notre-jeu)
+
+- [Les Bots](#les-bots)
+
+- - [S) L'omnicient (neuronal)](#s-l-omnicient-neuronal-img-title-src-images-img3png-png-alt-loading-ag-353-data-align-inline-width-50)
+  
+  - [M) L’observateur (neuronal)](#m-l-observateur-neuronal-img-title-src-images-img4png-png-alt-loading-ag-364-width-50) 
+  
+  - [M) L'Itérateur (Procédural)](#m-l-itérateur-procédurall-img-title-src-images-img5png-png-alt-loading-ag-372-width-50) 
+  
+  - [C) L'Itérateur Intelligent (Procédural & Neuronal)](#c-l-itérateur-intelligent-t-procédural-neuronal-img-title-src-images-img6png-png-alt-loading-ag-381-width-51)
+
+- [L'application :](#l-application)
+
+- - [Menu principal](#menu-principal)
+  
+  - [Affichage des données](#affichage-des-données)
+  
+  - [Configuration d'une partie](#configuration-d-une-partie)
+  
+  - [Le jeu](#le-jeu-1)
+
+  - [Prévison dees Étapes de création](#prévision-des-étapes-de-création)
+
+# Contexte
+
+### Sujet :
+
+Florent Madelaine. 
+
+Expérimentation Bots pour un ou des jeux. 
+
+Programmer un jeu original avec idéalement des éléments qui en font un challenge pour la réalisation d’IA (hasard, phase d’enchère changeant le payoff, multijoueur, combinatoire importante, ...). Il conviendra de choisir un jeu pour lequel il est possible de réduire la combinatoire du jeu de manière naturelle et de désactiver/activer des règles pour en étudier des variantes naturelles. Il faudra ensuite créer, améliorer et expérimenter avec divers algorithmes pour converger vers des bots offrant un challenge raisonnable pour un humain.
+
+### Objectifs :
+
+Nous avons très rapidement opté pour faire différentes IA qui pourraient jouer toutes seules à un jeu simple. Nous sommes très intéressés par la notion de temps réel et de l’apprentissage. 
+
+Notre objectif serait de comparer différentes méthodes d’analyse du jeu sur des bots différents pour les comparer entre elles sur plusieurs facteurs comme le temps d'apprentissage ou l'efficacité de la méthode.  
+
+Le livrable sera une application exécutable avec un .exe. L’interface doit permettre de lancer le jeu en choisissant les paramètres désirés. L’utilisateur pourra choisir de contrôler l’avatar pour jouer lui-même ou bien déléguer la partie à l’un des bots développés, puis éventuellement apporter des changements de règle au jeu.  
+
+En fonction des paramètres choisis, l’utilisateur peut jouer lui-même ou assister à la partie d’un ou plusieurs bots en même temps. Chaque partie de chaque bot (ou du joueur) enregistre des données stockées au format json ou xml. 
+
+L’utilisateur peut choisir un paramètre “Rush” privilégiant la vitesse de calculs à l’affichage graphique, accélérant le jeu au maximum et réalisant des parties en boucle pour obtenir des données exploitables et comparables le plus vite possible.  
+
+Le menu principal du jeu permet d’accéder à une interface de visualisation des données collectées en jeu, affichables en graphiques et tableaux, permettant de comparer efficacement les performances des différents bots et du joueur humain en fonction des paramètres de partie choisis. 
+
+# Le Jeu :
+
+### Le jeu de base :
+
+Jetpack Joyride est un jeu dit “Runner” car il consiste simplement à aller le plus loin possible tout en survivant aux dangers que le jeu lui oppose. Les règles du jeu sont simples, laissant le joueur décider de se propulser son avatar vers le haut ou de le laisser tomber pour faire bouger son personnage verticalement tandis que le terrain et donc ses obstacles avancent horizontalement vers lui de plus en plus vite.
+
+![capture ecran partie type](images/img1PNG.PNG)
+
+( capture d’écran d’une partie type )
+
+### Notre jeu :
+
+Pour faire jouer nos IA nous allons donc reproduire le jeu sur Unity en adaptant certains aspects pour faciliter la compréhension et l’apprentissage de l’IA :
+
+- Les objets qui ajoutent des règles très situationnelles sont retirés (comme les véhicules ou bonus modifiant l'expérience interactive du jeu).
+
+- Un système de score sera ajouté. La maximisation du score sera l’objectif de l’IA au-delà du temps de survie. Le score aura une augmentation linéaire en fonction du temps de survie et pourra être augmenté en ramassant des pièces. Mais de mauvaises pièces peuvent apparaître et faire baisser le score. Les IA devront ainsi adapter leur chemin pour tenter de maximiser leur score quitte à prendre des risques.
+  
+  <img title="" src="images/img2PNG.PNG" alt="interface du jeu" width="637" data-align="inline">
+
+- Le jeu original peut faire apparaître des missiles pouvant tuer le joueur. Ces missiles ne seront initialement pas implémentés, des tests nous permettront de savoir si ils sont un ajout viable au jeu après le développement du premier bot.
+
+# 
+
+## Les bots :
+
+nb. Pour comprendre la suite, il faut savoir que les IA fonctionnant par apprentissage nécessitent l’apport d’un certain nombre de données de sources définies pour fonctionner, données qu’elles apprennent à corréler par tâtonnement afin de trouver la meilleure approche et apporter les meilleures réponses.
+
+Notation MoSCoW:
+
+Must Should Could Would
+
+### S) L'omnicient (neuronal)  <img title="" src="images/img3PNG.PNG" alt="loading-ag-353" data-align="inline" width="50">
+
+Cette IA avancera à l’aveugle en ayant en tête les positions de chaque objet sur l'écran. On s’attends à ce que l’IA comprenne que l’objet représentant son personnage ne doit pas s’approcher des objets néfastes entraînant la mort ou une baisse de score.
+
+### M) L’observateur (neuronal) <img title="" src="images/img4PNG.PNG" alt="loading-ag-364" width="50">
+
+Cette IA ne connaît pas les coordonnées des objets à l’écran. L’observateur possède en revanche un champ de vision lui permettant de repérer sur certains angles la distance d’objets par rapport à l’avatar. On s'attend à ce que l’IA apprenne à éviter les objets néfastes s’approchant trop de l’avatar. 
+
+### M) L'Itérateur (procédural) <img title="" src="images/img5PNG.PNG" alt="loading-ag-372" width="50">
+
+Le bot Itérateur ne fonctionne pas par apprentissage mais par un algorithme. Au fil de la partie, l'itérateur  doit calculer par itérations différents chemins en essayant de s’approcher du chemin le plus sûr possible. Par intervalle de temps, l'itérateur essaiera de prolonger le meilleur chemin qu’il a trouvé et testera des déviations possibles apportant un éventuel avantage sur l’espérance de survie et d’obtention de points.
+
+### C) L'Itérateur Intelligent t (procédural & neuronal) <img title="" src="images/img6PNG.PNG" alt="loading-ag-381" width="51">
+
+Bot optionnel fonctionnant comme l'Itérateur à la différence que l’on essaiera d’y implémenter un syteme neuronal qui devra permettre de faire de meilleurs choix de prolongement et de déviation de chemin afin d’augmenter l’efficacité et les performances du bot Itérateur. On s'attend à ce que le bot apprenne à trouver des chemins plus sûrs en prenant en compte les chemins déjà testés.
+
+D’autres IA viendront si les idées et les deadlines nous le permettent.
+
+# 
+
+## L’Application :
+
+### Menu principal :
+
+![image menu principal](images/img7PNG.PNG)
+
+Permet de naviguer entre les deux parties majeures de l’application. 
+
+Le bouton “Lancer le jeu” redirige vers un menu de configuration de la partie. 
+
+Le bouton “Consulter les données” redirige vers une interface de visualisation des données récoltées au long des parties enregistrées.
+
+### Affichage des données :
+
+Cette interface traite les données enregistrées automatiquement pendant toutes les parties jouées. Les bots utilisés et les règles de chaque partie permettent de différencier chaque ensemble de données.  
+Les données traitées seront affichées sous forme de tableaux ou graphiques selon ce qui semble le plus adapté.  
+Différents onglets permettent de filtrer l’affichage et obtenir des informations plus précises sur certains aspects.  
+
+L’objectif est de permettre à l’utilisateur de pouvoir comparer facilement de multiples aspects de chaque bots de manière concrète et rigoureuse après avoir recueilli suffisamment de données.  
+
+Il est envisagé d’implémenter une fonctionnalité d’export des données en tableau Exel.
+
+<img title="" src="images/img8PNG.PNG" alt="image affichage des données" data-align="center">
+
+### Configuration d’une partie :
+
+<img title="" src="images/img9PNG.PNG" alt="image configuration d'une partie" data-align="center">
+
+Cette interface permet à l’utilisateur de configurer une partie ou une suite de parties auxquelles il fera participer un ou plusieurs bots ou bien lui-même. 
+
+Les règles du jeu peuvent être modifiées pour soumettre les bots à des conditions de jeu diverses.  
+
+Des éléments comme les missiles ou les pièces peuvent être activés ou désactivés. D’autres paramètres peuvent être modifiés comme la vitesse maximale pouvant être atteinte par le jeu ou le nombre d’essais maximums et la durée de session maximum (la session s’arrête lorsqu’une des deux limites est atteinte).  
+
+Chaque partie peut comporter une seed aléatoire ou garder une seed constante. La seed constante peut être la seed par défaut, conservée dans les fichiers du jeu et non modifiée depuis le début du développement, ou bien une autre seed choisie par l’utilisateur. La seed par défaut peut aussi être modifiée. 
+
+Enfin, le mode Rush permet de maximiser la vitesse du jeu pour accélérer la collecte de données et l’apprentissage des bots. Ce mode de jeu remplace le rendu graphique par une console affichant en temps réel différentes informations. La vitesse du mode rush dépend entièrement de la puissance de l’ordinateur combinée à la complexité de calcul générée par les bots.  
+
+Il est envisagé de permettre de choisir un niveau d'entraînement pour chaque bot. 
+
+### Le jeu :
+
+![image du jeu plus travaillé](images/img10PNG.PNG)
+
+L’écran de jeu exécutera en temps réel la reproduction du jeu Jetpack Joyride en rendu graphique (ou console si le mode Rush est activé).  
+L’avatar, représentant la célèbre mascotte officieusement officielle du BUT INFO, Dino, peut se déplacer de haut en bas. Le décor et les autres éléments du jeu se déplacent de droite à gauche.  
+Dino doit se déplacer verticalement de manière à éviter les lasers et autres malus et attraper le plus de pièces possibles.  
+
+Si plusieurs bots jouent ensemble, leurs avatars apparaîtront en transparence. L’avatar du joueur humain sera toujours opaque.  
+
+Si plusieurs parties sont configurées, chaque partie suivante commencera dès la fin de la partie en cours.  
+
+A la fin de la dernière partie, l’application changera d’interface pour afficher le menu de consultation de données ne comprenant que les données obtenues pendant la session jouée.
+
+### Prévision des Étapes de création
+
+Nous avons décidé d'organiser le processus de création du projet en travaillant simultanément sur plusieurs axes afin de rester constamment informés de son évolution et d'éviter d'être dépassés, tout en permettant à chacun de commencer à travailler sur des aspects additionnels. Ainsi, nous avons structuré la création en plusieurs étapes :
+
+Semaine 1-3 : Apprentissage des outils (Unity, C#, Python, ML Agent)
+
+Semaine 3-4 : Conception de l'interface
+
+Semaine 5-6 : Conception du jeu
+
+Semaine 7-8 : Création de l'IA "Sachant"
+
+Semaine 9-10 : Création de l'IA "Observateur"
+
+Semaine 11-12 : Création de l'IA "Calculateur"
+
+Semaine 13-14 : Création de l'IA "Calculateur Intelligent"
+
+Semaine 15-16 : Collecte de données des IA
+
+diagramme de Gantt disponible dans cahier des charges technique.

Documents/Spécifications_techniques.md

@@ -0,0 +1,223 @@
+# Projet Jetpack DinoAI
+
+Comparaison de Différentes Intelligences Artificielles dans un Jeu Simple
+
+Cahier des charges techniques
+
+Par :
+
+Victor Descamps  
+Simon Catanese  
+Ethan Richard
+
+
+
+Tuteur :
+
+Florent Madelaine
+
+fait le 18/11/2023
+
+# Sommaire :
+
+- [Contexte](#1-contexte)
+
+- - [Sujet](#sujet)
+
+- [Technologies envisagées ](#2-technologies-envisagées)
+
+- - [Plateforme de développement](#2-1-plateforme-de-développement)
+  
+  - [Langage de programmation](#2-2-langage-de-programmation)
+  
+  - [Utilisation de ML-Agents](#2-3-utilisation-de-ml-agents)
+  
+  - [Modélisation des personnages et des environnements](#2-4-modélisation-des-personnages-et-des-environnements)
+  
+  - [Contrôles du jeu](#2-5-contrôles-du-jeu)
+  
+  - [Gestion du jeu](#2-6-gestion-du-jeu)
+  
+  - [Tests et débogage](#2-7-tests-et-débogage)
+
+- [Équipe de développement](#3-équipe-de-développement)
+
+- [Les IA](#4-les-ia)
+
+- - [L'omniscient (Neuronal)](#l-omniscient-neuronal-img-title-src-images-img3png-png-alt-loading-ag-445-data-align-inline-width-50)
+  
+  - [L'observateur (Neuronal](#l-observateur-neuronal-img-title-src-images-img4png-png-alt-loading-ag-455-width-50)
+  
+  - [L'itérateur(Procédural](#l-itérateur-procédural-img-title-src-images-img5png-png-alt-loading-ag-463-width-64)
+  
+  - [L'itérateur intelligent (Procédural et neuronal)](#l-itérateur-intelligent-procédural-et-neuronal-img-title-src-images-img6png-png-alt-loading-ag-481-width-58)
+
+- [Livrables](#5-livrables)
+
+- [Bibliographie](#6-bibliographie)
+  
+  
+
+
+
+# 1. Contexte
+
+## Sujet :
+
+Florent Madelaine. 
+
+Expérimentation Bots pour un ou des jeux. 
+
+Programmer un jeu original avec idéalement des éléments qui en font un challenge pour la réalisation d’IA (hasard, phase d’enchère changeant le payoff, multijoueur, combinatoire importante, ...). Il conviendra de choisir un jeu pour lequel il est possible de réduire la combinatoire du jeu de manière naturelle et de désactiver/activer des règles pour en étudier des variantes naturelles. Il faudra ensuite créer, améliorer et expérimenter avec divers algorithmes pour converger vers des bots offrant un challenge raisonnable pour un humain.
+
+# 2.Technologies envisagées :
+
+## 2.1. Plateforme de développement
+
+Le projet sera développé sur Unity, version 22.3.11f1.
+
+Unity est un moteur de jeu gratuit et simple d’accès offrant une grande liberté de création et une grande collection d’outils divers.
+
+De nombreux cours sont disponibles sur internet pour apprendre son utilisation. 
+
+Unity est aussi compatible avec de nombreuses plateformes dont Windows, MacOs et Linux.
+
+## 2.2. Langage de programmation
+
+Le langage de programmation utilisé sera C# pour le développement dans l'environnement Unity. Il s’agit du langage natif de la plateforme. 
+
+C# est un langage de programmation objet très ressemblant au Java.
+
+## 2.3. Utilisation de ML-Agents
+
+ML-Agents sera intégré pour la conception et l'entraînement des intelligences artificielles. La version 2.0.1 de ML-Agents sera utilisée. 
+
+ML agent est un asset (outil additionnel) interne à Unity qui permet d'encadrer un apprentissage neuronal. Les scripts d'IA seront développés en utilisant ML-Agents pour permettre aux bots d'apprendre à jouer au jeu de manière autonome. 
+
+Les modèles neuronaux seront entraînés en utilisant des algorithmes d'apprentissage par renforcement.  
+
+## 2.4. Modélisation des personnages et des environnements
+
+Des sprites 2D (images) seront créés pour représenter l’avatar, les obstacles et l'environnement du jeu. 
+
+L’outil de graphisme Photoshop sera majoritairement utilisé pour la conception des sprites.
+
+## 2.5 Contrôles du jeu
+
+Les contrôles du jeu seront mis en œuvre pour un joueur humain ainsi que pour les IA.
+
+La seule commande permettra de modifier la position verticale du joueur tandis que le niveau défilera tout seul de droite à gauche.
+
+## 2.6 Gestion du jeu
+
+Un système de gestion de jeu sera mis en place, incluant le chargement du niveau, la gestion des collisions, la génération procédurale d'obstacles et la sauvegarde des scores et de données diverses.
+
+Les données enregistrées durant l’exécution de l’application seront stockées dans des fichiers json ou xml dans le répertoire de l’application.
+
+## 2.7 Tests et débogage
+
+Des scénarios de test exhaustifs seront élaborés pour chaque composant du jeu. 
+
+Les fonctionnalités seront soumises à des tests unitaires. Des outils de débogage de Unity seront utilisés pour résoudre les problèmes potentiels.
+
+# 3. Équipe de développement
+
+- **Ethan, Simon et Victor portent tous les 3 le rôle de chef de projet et de développeur.** 
+
+- **Simon sera également responsable des tests de l’application**
+
+- **Ethan sera aussi impliqué dans la documentation du projet**
+
+- **Victor sera plus spécifiquement impliqué dans l’implémentation des systèmes neuronaux dans le jeu.**
+
+L’outil en ligne Trello nous servira à planifier les tâches. 
+
+# 4.Les IA :
+
+Les concepts d’IA suivant sont expérimentaux et seront sujets à des changements suivant l’avancée du développement du projet et de notre documentation sur la programmation de systèmes neuronaux.
+
+Le rôle des bots est de décider à chaque instant T de faire monter ou de laisser descendre l’avatar. Tous auront une source de données différentes leur permettant de prendre une décision.
+
+## L’omniscient (Neuronal)<img title="" src="images/img3PNG.PNG" alt="loading-ag-445" data-align="inline" width="50">
+
+Ce bot connaît un grand nombre de données brutes. Entre autres : 
+
+- La vitesse de défilement du jeu,
+
+- La position verticale du joueur,
+
+- Les coordonnées des deux points des deux lasers les plus proches,
+
+- Les coordonnées de tout autre danger proche,
+
+- les coordonnées d’une zone comportant des pièces
+
+L’IA devra réussir à faire les bonnes corrélations dans ce grand nombre de données pour prendre les bonnes décisions au cours du temps. Elle n’obtiendra pas de données enrichies pouvant faciliter la prise de décision, ces données brutes seront son seul guide. 
+
+![](images/img11PNG.PNG)
+
+
+
+## L’observateur (Neuronal)<img title="" src="images/img4PNG.PNG" alt="loading-ag-455" width="50">
+
+Ce bot reçoit en temps réel des données de proximité de l’avatar avec les éléments de l’environnement et des données sur la nature de ces éléments.
+
+Un ensemble de RayCast partant de l’avatar dans des directions précises seront utilisés pour recueillir les données nécessaires. 
+
+A la manière d’un radar de voiture, l’IA devra analyser sa proximité avec des obstacles puis prendra une décision pour ajuster sa trajectoire.
+
+L’observateur devra apprendre à éviter les objets néfastes s’approchant trop de l’avatar et essayer de se rapprocher des pièces pour maximiser son score. 
+
+Cinq RayCasts couvrent probablement un champ de vision suffisamment large et dense pour une analyse efficace de l’environnement, mais des nombres différents seront essayés pour essayer de maximiser les performances du bot.
+
+La longueur des RayCasts correspondra à la taille de l’écran, et les premiers objets rencontrés dans leur trajectoire seront traités comme des données utilisables par le système neuronal de l’observateur. Leur distance par rapport à l’avatar et leur nature (bordure, obstacle, bonus, malus) seront transmises au bot. 
+
+![](images/img12PNG.PNG)
+
+
+
+## L’Itérateur (Procédural)<img title="" src="images/img5PNG.PNG" alt="loading-ag-463" width="64">
+
+Le bot itérateur ne fonctionne pas par apprentissage mais par itérations de calculs. 
+
+Son fonctionnement consiste à calculer de nombreux chemins différents par itérations puis à sélectionner le meilleur chemin trouvé pour poursuivre la partie. À chaque intervalle , le bot pourra effectuer et maintenir une action (monter ou descendre) le temps de cet intervalle.  L’ensemble des actions forme un chemin donné.  
+
+Le moteur de jeu va tester virtuellement les chemins à tester et le bot va itérer des calculs de suite d’actions un certain nombre de fois. Les chemins proposés amenant à la collision avec un obstacle seront écartés. Le chemin sans collision et apportant le plus de points au score sera sélectionné et le bot recommencera une suite d’itérations de calculs vers la moitié de ce chemin pour améliorer sa trajectoire. 
+
+Si tous les chemins mènent à une collision avec un obstacle, le chemin retardant le plus la collision sera sélectionné. L’ensemble des actions possibles dans une suite d’intervalles représente un arbre binaire où chaque chemin est un parcours de la base de l’arbre vers une feuille. L’itérateur procède à un parcours en profondeur de l’arbre pour trouver le meilleur chemin.  
+
+Nous envisageons d’utiliser l’approche de l'algorithme glouton afin d’obtenir un chemin satisfaisant sans dépenser trop de temps de calcul en parcourant l’arbre entier.Pendant le parcours de l’arbre, si un chemin testé mène à une collision avec un obstacle ou avec un bonus, l’itérateur reviendra avec une nouvelle suite d’actions jusqu’à quelques itérations avant la collision puis procèdera à un nouveau parcours en profondeur à partir de cette nouvelle base pour essayer d’optimiser son score et sa survie. ![loading-ag-468](images/img13PNG.PNG)
+
+
+
+## L’ itérateur intelligent (Procédural et neuronal)<img title="" src="images/img6PNG.PNG" alt="loading-ag-481" width="58">
+
+Bot optionnel que l’on implémentera si le temps nous le permet. 
+
+Nous n’avons pas encore de concept clair pour ce bot, nous chercherons une possible implémentation de réseau neuronal fonctionnant de pair avec le calcul itératif de chemins pour améliorer les performances du bot précédent.  
+
+# 5. Livrables
+
+Le dépôt git du projet contiendra le build de la dernière version fonctionnelle de l’application en plus des documentations annexes. Le projet Unity en lui-même est partagé entre les membres du PT sur la plateforme de collaboration officielle du Unity. Nous veillerons à inclure le code source du projet final dans le dépôt git en plus du build complet de l’application.
+
+# 6. Bibliographie :
+
+Apprentissage du C# : 
+
+Série de vidéos sur les aspects du C# dans la programmation sous Unity
+
+[Learn C# BASICS in 10 MINUTES! - YouTube](https://www.youtube.com/watch?v=IFayQioG71A&list=PLzDRvYVwl53t2GGC4rV_AmH7vSvSqjVmz&pp=iAQB)
+
+Documentation unity : 
+
+Documentation officiel de la plateforme, utile pour tout besoin technique.
+
+[https://docs.unity.com/](https://docs.unity.com/)
+
+Documentation ML-Agents : 
+
+Documentation officielle de ML-Agents qui nous servira  à implémenter des systèmes neuronaux.
+
+[Toolkit Documentation - Unity ML-Agents Toolkit](https://unity-technologies.github.io/ml-agents/ML-Agents-Toolkit-Documentation/)
+
+

Documents/src/venv/Lib/site-packages/_distutils_hack/__init__.py

@@ -0,0 +1,222 @@
+# don't import any costly modules
+import sys
+import os
+
+
+is_pypy = '__pypy__' in sys.builtin_module_names
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    if is_pypy and sys.version_info < (3, 7):
+        # PyPy for 3.6 unconditionally imports distutils, so bypass the warning
+        # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250
+        return
+    import warnings
+
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils."
+    )
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn("Setuptools is replacing distutils.")
+    mods = [
+        name
+        for name in sys.modules
+        if name == "distutils" or name.startswith("distutils.")
+    ]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    import importlib
+
+    clear_distutils()
+
+    # With the DistutilsMetaFinder in place,
+    # perform an import to cause distutils to be
+    # loaded from setuptools._distutils. Ref #2906.
+    with shim():
+        importlib.import_module('distutils')
+
+    # check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+    assert 'setuptools._distutils.log' not in sys.modules
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class _TrivialRe:
+    def __init__(self, *patterns):
+        self._patterns = patterns
+
+    def match(self, string):
+        return all(pat in string for pat in self._patterns)
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        # optimization: only consider top level modules and those
+        # found in the CPython test suite.
+        if path is not None and not fullname.startswith('test.'):
+            return
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        if self.is_cpython():
+            return
+
+        import importlib
+        import importlib.abc
+        import importlib.util
+
+        try:
+            mod = importlib.import_module('setuptools._distutils')
+        except Exception:
+            # There are a couple of cases where setuptools._distutils
+            # may not be present:
+            # - An older Setuptools without a local distutils is
+            #   taking precedence. Ref #2957.
+            # - Path manipulation during sitecustomize removes
+            #   setuptools from the path but only after the hook
+            #   has been loaded. Ref #2980.
+            # In either case, fall back to stdlib behavior.
+            return
+
+        class DistutilsLoader(importlib.abc.Loader):
+            def create_module(self, spec):
+                mod.__name__ = 'distutils'
+                return mod
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader(
+            'distutils', DistutilsLoader(), origin=mod.__file__
+        )
+
+    @staticmethod
+    def is_cpython():
+        """
+        Suppress supplying distutils for CPython (build and tests).
+        Ref #2965 and #3007.
+        """
+        return os.path.isfile('pybuilddir.txt')
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @classmethod
+    def pip_imported_during_build(cls):
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+
+        return any(
+            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
+        )
+
+    @staticmethod
+    def frame_file_is_setup(frame):
+        """
+        Return True if the indicated frame suggests a setup.py file.
+        """
+        # some frames may not have __file__ (#2940)
+        return frame.f_globals.get('__file__', '').endswith('setup.py')
+
+    def spec_for_sensitive_tests(self):
+        """
+        Ensure stdlib distutils when running select tests under CPython.
+
+        python/cpython#91169
+        """
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    sensitive_tests = (
+        [
+            'test.test_distutils',
+            'test.test_peg_generator',
+            'test.test_importlib',
+        ]
+        if sys.version_info < (3, 10)
+        else [
+            'test.test_distutils',
+        ]
+    )
+
+
+for name in DistutilsMetaFinder.sensitive_tests:
+    setattr(
+        DistutilsMetaFinder,
+        f'spec_for_{name}',
+        DistutilsMetaFinder.spec_for_sensitive_tests,
+    )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    DISTUTILS_FINDER in sys.meta_path or insert_shim()
+
+
+class shim:
+    def __enter__(self):
+        insert_shim()
+
+    def __exit__(self, exc, value, tb):
+        remove_shim()
+
+
+def insert_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass

Documents/src/venv/Lib/site-packages/_distutils_hack/override.py

@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()

Documents/src/venv/Lib/site-packages/distutils-precedence.pth

@@ -0,0 +1 @@
+import os; var = 'SETUPTOOLS_USE_DISTUTILS'; enabled = os.environ.get(var, 'local') == 'local'; enabled and __import__('_distutils_hack').add_shim(); 

Documents/src/venv/Lib/site-packages/pip-23.2.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

Documents/src/venv/Lib/site-packages/pip-23.2.1.dist-info/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008-present The pip developers (see AUTHORS.txt file)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Documents/src/venv/Lib/site-packages/pip-23.2.1.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.1
+Name: pip
+Version: 23.2.1
+Summary: The PyPA recommended tool for installing Python packages.
+Home-page: https://pip.pypa.io/
+Author: The pip developers
+Author-email: distutils-sig@python.org
+License: MIT
+Project-URL: Documentation, https://pip.pypa.io
+Project-URL: Source, https://github.com/pypa/pip
+Project-URL: Changelog, https://pip.pypa.io/en/stable/news/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.7
+License-File: LICENSE.txt
+License-File: AUTHORS.txt
+
+pip - The Python Package Installer
+==================================
+
+.. image:: https://img.shields.io/pypi/v/pip.svg
+   :target: https://pypi.org/project/pip/
+
+.. image:: https://readthedocs.org/projects/pip/badge/?version=latest
+   :target: https://pip.pypa.io/en/latest
+
+pip is the `package installer`_ for Python. You can use pip to install packages from the `Python Package Index`_ and other indexes.
+
+Please take a look at our documentation for how to install and use pip:
+
+* `Installation`_
+* `Usage`_
+
+We release updates regularly, with a new version every 3 months. Find more details in our documentation:
+
+* `Release notes`_
+* `Release process`_
+
+In pip 20.3, we've `made a big improvement to the heart of pip`_; `learn more`_. We want your input, so `sign up for our user experience research studies`_ to help us do it right.
+
+**Note**: pip 21.0, in January 2021, removed Python 2 support, per pip's `Python 2 support policy`_. Please migrate to Python 3.
+
+If you find bugs, need help, or want to talk to the developers, please use our mailing lists or chat rooms:
+
+* `Issue tracking`_
+* `Discourse channel`_
+* `User IRC`_
+
+If you want to get involved head over to GitHub to get the source code, look at our development documentation and feel free to jump on the developer mailing lists and chat rooms:
+
+* `GitHub page`_
+* `Development documentation`_
+* `Development IRC`_
+
+Code of Conduct
+---------------
+
+Everyone interacting in the pip project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.
+
+.. _package installer: https://packaging.python.org/guides/tool-recommendations/
+.. _Python Package Index: https://pypi.org
+.. _Installation: https://pip.pypa.io/en/stable/installation/
+.. _Usage: https://pip.pypa.io/en/stable/
+.. _Release notes: https://pip.pypa.io/en/stable/news.html
+.. _Release process: https://pip.pypa.io/en/latest/development/release-process/
+.. _GitHub page: https://github.com/pypa/pip
+.. _Development documentation: https://pip.pypa.io/en/latest/development
+.. _made a big improvement to the heart of pip: https://pyfound.blogspot.com/2020/11/pip-20-3-new-resolver.html
+.. _learn more: https://pip.pypa.io/en/latest/user_guide/#changes-to-the-pip-dependency-resolver-in-20-3-2020
+.. _sign up for our user experience research studies: https://pyfound.blogspot.com/2020/03/new-pip-resolver-to-roll-out-this-year.html
+.. _Python 2 support policy: https://pip.pypa.io/en/latest/development/release-process/#python-2-support
+.. _Issue tracking: https://github.com/pypa/pip/issues
+.. _Discourse channel: https://discuss.python.org/c/packaging
+.. _User IRC: https://kiwiirc.com/nextclient/#ircs://irc.libera.chat:+6697/pypa
+.. _Development IRC: https://kiwiirc.com/nextclient/#ircs://irc.libera.chat:+6697/pypa-dev
+.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md

Documents/src/venv/Lib/site-packages/pip-23.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

Documents/src/venv/Lib/site-packages/pip-23.2.1.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+pip = pip._internal.cli.main:main
+pip3 = pip._internal.cli.main:main
+pip3.11 = pip._internal.cli.main:main

Documents/src/venv/Lib/site-packages/pip-23.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pip

Documents/src/venv/Lib/site-packages/pip/__init__.py

@@ -0,0 +1,13 @@
+from typing import List, Optional
+
+__version__ = "23.2.1"
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    """This is an internal API only meant for use by pip's own console scripts.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)

Documents/src/venv/Lib/site-packages/pip/__main__.py

@@ -0,0 +1,24 @@
+import os
+import sys
+
+# Remove '' and current working directory from the first entry
+# of sys.path, if present to avoid using current directory
+# in pip commands check, freeze, install, list and show,
+# when invoked as python -m pip <command>
+if sys.path[0] in ("", os.getcwd()):
+    sys.path.pop(0)
+
+# If we are running from a wheel, add the wheel to sys.path
+# This allows the usage python pip-*.whl/pip install pip-*.whl
+if __package__ == "":
+    # __file__ is pip-*.whl/pip/__main__.py
+    # first dirname call strips of '/__main__.py', second strips off '/pip'
+    # Resulting path is the name of the wheel itself
+    # Add that to sys.path so we can import pip
+    path = os.path.dirname(os.path.dirname(__file__))
+    sys.path.insert(0, path)
+
+if __name__ == "__main__":
+    from pip._internal.cli.main import main as _main
+
+    sys.exit(_main())

Documents/src/venv/Lib/site-packages/pip/__pip-runner__.py

@@ -0,0 +1,50 @@
+"""Execute exactly this copy of pip, within a different environment.
+
+This file is named as it is, to ensure that this module can't be imported via
+an import statement.
+"""
+
+# /!\ This version compatibility check section must be Python 2 compatible. /!\
+
+import sys
+
+# Copied from setup.py
+PYTHON_REQUIRES = (3, 7)
+
+
+def version_str(version):  # type: ignore
+    return ".".join(str(v) for v in version)
+
+
+if sys.version_info[:2] < PYTHON_REQUIRES:
+    raise SystemExit(
+        "This version of pip does not support python {} (requires >={}).".format(
+            version_str(sys.version_info[:2]), version_str(PYTHON_REQUIRES)
+        )
+    )
+
+# From here on, we can use Python 3 features, but the syntax must remain
+# Python 2 compatible.
+
+import runpy  # noqa: E402
+from importlib.machinery import PathFinder  # noqa: E402
+from os.path import dirname  # noqa: E402
+
+PIP_SOURCES_ROOT = dirname(dirname(__file__))
+
+
+class PipImportRedirectingFinder:
+    @classmethod
+    def find_spec(self, fullname, path=None, target=None):  # type: ignore
+        if fullname != "pip":
+            return None
+
+        spec = PathFinder.find_spec(fullname, [PIP_SOURCES_ROOT], target)
+        assert spec, (PIP_SOURCES_ROOT, fullname)
+        return spec
+
+
+sys.meta_path.insert(0, PipImportRedirectingFinder())
+
+assert __name__ == "__main__", "Cannot run __pip-runner__.py as a non-main module"
+runpy.run_module("pip", run_name="__main__", alter_sys=True)

Documents/src/venv/Lib/site-packages/pip/_internal/__init__.py

@@ -0,0 +1,19 @@
+from typing import List, Optional
+
+import pip._internal.utils.inject_securetransport  # noqa
+from pip._internal.utils import _log
+
+# init_logging() must be called before any call to logging.getLogger()
+# which happens at import of most modules.
+_log.init_logging()
+
+
+def main(args: (Optional[List[str]]) = None) -> int:
+    """This is preserved for old console scripts that may still be referencing
+    it.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)