Vous l'avez surement remarqué, mais le code actuel n'est presque pas commenté, j'espère que les nom de variables assez explicite permettront malgré tout de rendre l'ensemble compréhensible. Je vais tâcher de vous expliquer dans les grandes lignes la façon dont le code a été structuré à travers les différents dossier.

Contient tout le code source de l'ia

• main.py Permet se lancer directement l'ia ou peut être lancé par le simulateur pour démarrer l'ia
• constantes.py Contient toutes les constantes utiles à l'ia

Pour discuter avec les tourelles et le petit robot

• - commSimulateur.py Uniquement destiné à simuler la communication dans le cas où l'ia est démarré par le simulateur
• - parser_c.py Parse les ordres directement depuis le fichier de define des arduino.
• - communicationGlobale.py Gérer toute la communication, son but est d'assurer la bonne réception des tous les messages
• - conversion.py Effectue la conversion des ordres des types usuels vers le binaire
• - serial_comm.py Gère un port de communication série
• - metaData.py Gère toutes les autres données, tel que le temps, la couleur de départ
• - pullData.py Maintient les données ci dessus à jour avec les données réel.
• - script_*.xml Contient le script de départ d'un robot

Stocke toutes les données relatives aux robots et aux tourelles.

• - data.py Classe principale, elle instancie toutes les autres
• - ourBot.py et enemyBot.py stocke les données des robots
• - tourelle.py gère les tourelles

Gère les évènements et apport une réponse au besoin. - eventManager.py Gère les évènements et notamment l'envoi des actions au bon moment. - collision.py Détecte un collision sur le chemin prévu - timeManager.py Gère le temps de jeu - subProcessCommunicate.py Gère la communication avec les subprocess de choix d'objectif (un sub par robot)

• - subProcessManager.py Gère le démarrage d'un subprocess ainsi que sa communication avec son père
• - goalsChoice.py Choisi les objectifs à effectuer en fonction des données
• - goalsLibrary.py Contient des fonctions de base pour le choix et la gestion des objectifs
• - goalsManager.py Charge et gère les objectifs disponibles
• - goal.py Représente un objectif
• - elemGoal.py Représente un des points d'entrée d'un objectif ainsi que toutes données associé à cette entrée
• - goals.xml Contient la liste des objectifs et de leurs points d'entrée
• - elemScripts.xml Contient la liste des tous les enchainements d'actions possible.

Permet à la camera embarqué dans le robot de renvoyer la position des triangles ainsi que leur couleur

• - visio.py Interface vers le lib de viso: /superviso

Ce code n'a pratiquement pas évoluée depuis l'année 2012. On a rencontré quelques difficultés avec celui-ci cette année 2014, mais globalement ça fonctionne très bien. Regroupe le code pour la construction du graph de recherche et la recherche de chemin pour le robot, en prenant en compte les parties de la table qui son inaccessible. Le graph possède une fonction de mise à jour permettant de prendre en compte le déplacement des obstacles. Deux stratégies sont fournies pour la construction du graph : un découpage par tiles et un découpage par polygones convexes (polygones qui n'ont pas d'angle rentrant).

Le découpage le plus intuitif, on demande à l'ia de découper la carte en carré de x*x, puis de noircir les carrés non accessibles. Avec cette implémentation on est partagé entre precision et performance, dans un environement complexe avec beaucoup d'obstacles on voudra avoir un bonne précision, mais qui dit bonne précision dit plus de carré et donc plus de temps de calcul (aussi bien pour le calcul du chemin que pour le noirciment dynamique des cases).

Découpage plus complexe à réaliser, le but est de découper la zone accessible en un minimum de polygones convexes. Avec cette implémentation le calcul du plus court chemin est fortement accéléré car le nombre de noeud est très faible, la taille du graphe ne dépend plus de la taille de la carte mais de la complexité de celle-ci (nombre d'obstacles et formes de ces obstacles). Le calcul des polygones convexes est réalisé à l'aide un petit programme en c++ qui utilise la libCGAL, une librairie mathématique de haute voltige.

Une seule classe permet de calculer le chemin à partir de l'un ou l'autre des découpages ci-dessus, l'algorithm utilisé est A* (ou A star). À noter que le nabgraph “soomth” le chemin renvoyé par A* pour le rendre plus droit si possible, c'est l'algorithme de funnel qui s'en charge.

Dans le dossier vizgraph il y a les outils nécessaire pour observer le découpage réalisé selon l'un ou l'autre des algorithmes, on peut aussi déplacer un objet fictif pour forcer la mise à jour du graph pui demander le calcul d'un chemin. Pour chaque opération on peut voir le temps d'execution.