EXAMEN ZZ1 - FEVRIER 2024

CONSIGNES : 

* Tout le code est à placer dans code.h et code.c => PAS D'AUTRES FICHERS
* La compilation se fait par 'make'
* Vous pouvez modifier le fichier de tests (exo1.c) bien entendu si vous ne changez pas la philosophie des tests.
* Si un test fonctionne, ne le recommentez surtout pas
* Le programme doit compiler à la fin de l'examen. Si vous avez fait des copies du répertoire pendant l'examen, 
  seule la copie qui vous donnera la meilleure note sera prise en compte.
* lire tout le sujet avant de commencer et tous les fichiers fournis.

Le sujet peut comporter des inexactitudes mais vise à expliciter le 
le code fourni (tests et déclarations) fait foi

*****************************************************************************

ENONCE : 

Cet exercice va vous faire le ou les déplacements (trajectoires) d'un robot 
dans une arène de taille fixe (de largeur MAXX et de hauteur MAXY)

Le robot a un déplacement simpliste : il avance toujours dans la même direction
sauf quand on lui demande d'en changer

La convention utilisée est la suivante quand on regarde l'arène du dessus :
0 : pas d'information/instruction
1 : aller à droite 
2 : descendre
3 : aller à gauche
4 : monter

IMPORTANT : Certaines fonctions sont à développer puis à réutiliser dans les tests.
Si vous ne réussissez pas à les écrire, sachez que dans les tests d'évaluation 
elles seront remplacées par des versions fonctionnelles.

*****************************************************************************

OCCURENCES

Cette fonction permet de calculer le nombre d'occurences d'un caractère donné
dans une chaine de caractères.
Cette fonction est utilisée dans les tests.

INITIALISER (arene)

La fonction initialiser() permet d'initialiser une arene sans aucune instruction de déplacement.

AFFICHER (arene)

La fonction afficher() permet d'afficher l'arene dans le flux/fichier donné en paramètre
Regardez bien le résultat attendu
L'arene est entourée de X pour bien la voir
Si l'arene est la suivante, cela affiche :
                                XXXXX
???                             X???X
???                             X???X
                                XXXXX
avec les sauts de ligne qui vont bien.

LECTURE (arene)

La fonction lecture() permet de lire des instructions de direction à placer dans l'arène à partir
d'un fichier dont le nom est donné en paramètre.
Cette fonction renvoie 0 s'il y a un problème - le seul problème que vous devez vraiment gérer
est celui ou le fichier n'existe pas. Elle renvoie 1 sinon

Chaque ligne du fichier contient un triplet : ligne, colonne, direction

Le test permet de retrouver l'arène de test.

*****************************************************************************

On veut maintenant regarder la trajectoire des robots dans l'arène.
Pour cela, on va visualiser la trajectoire à partir d'un tableau de même 
dimension que l'arène et afficher le dit tableau.
On appelle la visualisation une "photo".

On repère sur cette photo :
* les bords de l'arène avec des X
* les positions du robot avec des O (pas des 0)
* les informations de déplacement avec un peu d'imagination : 
    > (droite) < (gauche) ^ (haut) et T (bas)

Nous allons procéder par étapes, pour enrichir les fonctions
calculer_trajectoire() et afficher_trajectoire()

Les illustrations sont donnée à titre indicatif.

TEST TRAJECTOIRE SIMPLE

La fonction calculer_trajectoire() prend en parametre l'arène, une "photo" résultat,
 la position de départ en (y, x) du robot ainsi que la direction dans laquelle le robot se déplace.

Le premier test est un affichage d'une trajectoire rectiligne d'une robot qui ne reçoit aucune information contradictoire.
Par exemple, le robot ci-dessous parcourt l'arène de gauche à droite.

XXXXXXXXXXXXXXXX
X              X
XOOOOOOOOOOOOOOX
X              X
X              X
XXXXXXXXXXXXXXXX

TEST TRAJECTOIRE MORCEAU

Pour ce test, le robot reçoit un ordre de tourner : cela dessine un angle
Par exemple, le robot part de gauche et reçoit l'ordre de descendre.

XXXXXXXXXXXXXXXX
X              X
XOOOOOOOOOT    X
X         O    X
X         O    X
XXXXXXXXXXXXXXXX

TEST TRAJECTOIRE CYCLE

Pour ce test, le robot reçoit plusieurs ordres : il forme alors un cycle et n'en sortira plus
(mais la fonction doit, elle, se terminer :-) )

Le robot part du haut de l'arène, descend
Il doit aller à droite, puis descendre, doit aller à gauche, 
monter, aller à droite  et ainsi de suite ...

XXXXXXXXXXXXXXXX
X    O         X
X    >OOOOT    X
X    O    O    X
X    ^OOOO<    X
X              X
XXXXXXXXXXXXXXXX

TEST TRAJECTOIRE CROISEMENT

Pour ce test, il faut affiner la détection de la trajectoire
Le robot part du haut de l'arène et descend.
Il doit aller à droite, descendre, aller à gauche, remonter pour terminer pas loin 
de son point de départ

XXXXXXXXXXXXXXXX
X    O  O      X
X    >OOOOT    X
X       O O    X
X    ^  ^O<    X
X              X
XXXXXXXXXXXXXXXX

Nous vous conseillons de noter pour une case si le robot est passé et 
dans quel sens il est passé. Si le robot est déjà passé dans une case dans
le même sens, on a un cycle, sinon on continue.

Hint : 0 + direction1 * 2 + direction2 * 2 * 2 + direction3 * 2 * 2 * 2
         + direction4 * 2 * 2 * 2 * 2

*****************************************************************************

Cette partie LISTE peut être faite sans faire la partie trajectoire

On a les instructions pour construire une arène non plus dans un fichier
mais avec des "cartes". 
Du point de vue informatique, vous aurez compris que chacune de ces "cartes"
est en fait une cellule d'une liste chainee.
L'ordre de la liste importe peu, on manipule la liste avec une "tête" réelle

On vous demande d'écrire les fonctions :
* pour ajouter une carte/instruction dans la liste (le type de retour n'est pas utilisé/testé)
* pour libérer la liste 
* pour générer l'arène à partir de la liste

On teste sur la meme arène que celle qui a été lue dans un fichier.

That's all folks !!!
