Consignes

Vous devrez soumettre votre travail (un unique fichier Caml valide) en utilisant l'interface TPLab.

Le seul fait que votre programme fonctionne ne suffit pas pour avoir une bonne note. Les points suivants seront pris en compte :

la lisibilité de votre programme (choix pertinent pour les noms de variables etc.),
la présence de commentaires aux endroits appropriés,
...

Attention : les points suivants ne rapportent rien, mais ne pas les respecter pourra retrancher jusqu'à 10 points sur la note finale :

chaque fichier devra comporter un commentaire au début avec vos nom, prénom, filière et numéro du TP.
Une exécution du fichier dans Emacs ne devra pas provoquer d'erreur.

Préliminaires : références et champs « mutables »

Les références vues en cours sont en fait un cas particulier de structure avec un champs mutable :

# let r = ref 0;;
- val r : int ref = {contents = 0}

Ceci signifie qu'une référence est unes structure à un seul champs (appelé "contents") et que ce champs est modifiable (on dit aussi mutable). La définition

# let r = ref ... ;;

est de fait équivalente à

# let r = { contents = ... } ;;

Pour déclarer un type « structure » avec des champs mutables, on utilise

# type st = {
    a : int;
    mutable b : int;
    c : bool;
    mutable d : float
  };;

Notez bien que tous les champs ne sont pas forcément mutables...

Pour accéder à un champs mutable, on fait comme d'habitude : "s.champs". En particulier,
```
# !r;;
```
est équivalent à
```
# r.contents;;
```

On créé une nouvelle valeur de la manière habituelle :

# let s = {a = 1; b = 2; c = true; d = 3.14};;
val s : st = {a = 1; b = 2; c = true; d = 3.14}

Pour modifier un champs mutable, on utilise la notation "s.champs <- valeur". En particulier,
```
# r := 1;;
```
est équivalent à
```
# r.contents <- 1;;
```

Testez en créant une structure avec champs mutables et en modifiant certains champs.
Vérifiez ce qu'il se passe si on essaie de modifier un champs non mutable.

Retrouvez le type des expressions suivantes

let _ = s.a			    (*1*)
let _ = s.a <- 12		    (*2*)
let _ = s.a <- s.a + 1 ; s.a + 1    (*3*)

On utilise le type

type boule = { rayon : int ; mutable hauteur : int }

Écrivez une fonction

  let positionne (b:boule) (l:boule list) = ...

de type boule -> boule list -> unit qui met à jours la hauteur de la boule "b". La nouvelle hauteur sera la plus petite hauteur qui permette à la boule "b" de rentrer dans la liste "l".

Par exemple, pour le dessin suivant, il faudra modifier la "hauteur" de la boule "b" pour la positionner comme à gauche.

Le jeu SPHERES

Pour ceux qui travaillent sur leur portable, il faut installer les bibliothèques OpenGL / Glut. Pour une distribution Ubuntu standard, il faut ajouter le paquet "liblablgl-ocaml-dev".

Le code de SPHERES a été écrit par Christophe Raffalli suite à une discussion autour de Caml et OpenGL. Il s'agit d'un petit prototype de jeu simple où le but est d'éviter des sphères se déplaçant dans l'espace...

Le code, à trous, est disponible ici. Vous devrez extraire le contenu de l'archive avec

$ tar xvf tp7.tar

Si tout c'est bien passé, vous aurez alors un répertoire TP7 contenant les fichiers suivants :

Makefile (le fichier pour lancer la compilation automatique),
objects_luke_skywalker.ml (le fichier qui contient les fonctions sur les sphères),
random.ml (un générateur pseudo-aléatoire),
spheres.ml (la fonction principale, qui donne l'exécutable),
vector.ml (quelques définitions pour les opérations sur les vecteurs dans l'espace à 3 dimensions),
dependfile (les dépendances entre fichiers, pour le compilateur).

Le seul fichier que vous devrez modifier est le fichier objects_luke_skywalker.ml !

Mettez vous dans le répertoire spheres et:

changez le nom du fichier objects_luke_skywalker.ml en mettant votre nom et prénom (sans accents),
ouvrez le fichier Makefile et modifiez la première ligne:
```
NOM = luke_skywalker
```
en mettant votre nom et prénom, exactement comme vous l'avez mis pour le fichier objects_....ml.
lancer la commande de « précompilation » depuis un terminal
```
$ make depend
```
compilez le jeu avec la commande
```
$ make
```
lancez le jeu avec la commande
```
$ ./spheres
```
Vous devriez voir des sphères apparaitre sur l'écran. Vous pouvez vous déplacez (légèrement) avec les flèches et quitter avec la touche q.

À partir de maintenant, vous n'avez besoin d'exécuter que les commandes 4 et 5. La précompilation n'est plus nécessaire.

Ouvrez le fichier objects_....ml et lisez le (en diagonal). Il n'y a rien de très compliqué dans ce fichier...

La partie que vous devrez modifier se trouve vers la fin du fichier (vers la ligne 100).

La première chose à faire est de faire bouger les sphères. Pour ceci, modifiez la fonction move_spheres_and_check (dernière fonction du fichier) en ajoutant une ligne pour modifier la position de chaque sphère en fonction de sa vitesse. Comme cette fonction est appelée "refresh" fois par seconde, il faut faire

  position := position + (1/refresh) * vitesse

Attention, position est un vecteur de l'espace à 3 dimensions. Vous pouvez utiliser les fonctions du fichier "vector.ml" pour les opérations usuelles sur les vecteurs...

Recompilez et lancez le jeu :

$ make
$ ./spheres

Vous devriez maintenant voir les sphères bouger et venir vers vous...

Si le programme s'arrête rapidement en affichant un message

$ ./spheres
Computer too slow sorry.

c'est probablement que vous n'avez pas la 3D accélérée ou un ordinateur "lent". Vous pouvez régler le taux de rafraichissement (avec l'option "-r" et la précision des sphères avec l'option "-d". Par exemple, la ligne suivante lance le jeux avec un rafraichissement de 10 images par secondes (le minimum) et une précision assez basse pour les sphères :

$ ./spheres -d 10 -r 10

Continuez à modifier la fonction "move_spheres_and_check" pour :

arrêter le jeux quand le "vaisseau" rentre en collision avec une sphère
incrémenter le nombre de points (champs mutable de la structure "our_ship")
supprimer les sphères qui sont à une distance de plus de 30 de l'origine

Lorsqu'une sphère est générée (avec la fonction "``random_sphere''", il se peut qu'elle se trouve en collision avec des sphères existantes.

Écrivez la fonction "intersect" qui vérifie si deux sphères s'intersectent,
écrivez la fonction "avoid_others" qui modifie la position (sur l'axe des z) d'une sphère pour qu'elle ne touche plus aucune des sphères existantes

Écrivez maintenant la fonction "check_collisions_between"qui teste les collision de sphère pendant le jeu. Lorsque deux sphères rentrent en collision, elles rebondissent l'une sur l'autre. On met donc à jours leurs vecteurs vitesses en utilisant la fonction (déjà écrite) "bounce".

Ajoutez une fonctionnalité au jeu. Vous pouvez faire ce que vous voulez, mais voici quelques idées :

ajouter un champs "weight" aux sphères et modifier la fonction "bounce" pour le prendre en compte,
créez des sphères particulières (blanches) que l'on doit au contraire essayer de toucher,
incrémenter les points proportionnellement à la distance de la sphere (plus on est proche, plus on gagne des points)
...

Pour ceux qui les souhaitent, vous pouvez également modifier les autres fichiers (notamment le fichier "spheres.ml". Dans ce cas, envoyez moi :

votre version de "objets_....ml" de base
une archive avec tous les fichiers ~....ml" pour vos modifications.

TP7 : références, code impératif, OpenGL

info-421, Pierre Hyvernat et Christophe Raffalli

Printemps 2012

Consignes

Préliminaires : références et champs « mutables »

Le jeu SPHERES