Discussion :

[sovietstar]

Bonjour, j'ai un programme en Ocaml light a realiser en utilisant le recursif au maximum, sauf que je me heurte a un probleme.
Comment utiliser le recursif pour faire apparaitre des boules (36 en tout il me semble), ou cercles pleins, de couleur differentes, sachant que les coordonnees sont differentes pour chacune.
J'ai deja associe 4 couleurs differentes a un chiffre, et je voudrais faire en sorte que les chiffres presents dans le tableau (sous forme d'une suite de liste) donnent la couleur de la boule.
Merci d'avance!

[prgasp77]

Bonjour sovietstar et bienvenu sur les forums développez. Bon ton message est un peu bancal, on sent bien que tu débutes dans le monde de caml . T'en fait pas on va y remédier.

Alors première chose, il existe deux grandes implémentation de caml : OCaml (anciennement Objectove Caml) et Caml Light. J'imagine que tu travailles avec la seconde. Je n'ai jamais touché à Caml Light, je te dirais donc comment je procéderais en OCaml ; mais il y a souvent un moyen de traduire de l'un à l'autre. Une fonction standard en OCaml qui s'appelant Module.fonction s’appellerait module__fonction en Caml Light. À toi de faire des recherches dans le cas contraire.

Seconde chose, ton exercice, si je comprends bien, c'est d'afficher à l'écran des disques dont le nombre, les positions et les couleurs sont des données que tu possèdes déjà. La grande question est : est-ce que ces données te sont données sous une forme particulière directement en caml ou c'est à toi d'imaginer la structure adéquate ? Dans le second cas, je te propose de définir un disque par le triplet (couleur, abscisse, ordonnée) et de regrouper l'ensemble des données pour tes 36 disques sous la forme d'une liste de ces triplets (ça sera bien pratique plus tard). abscisse et ordonnées seraient des int ou des float ; couleur serait quand à elle un variant : type color = Red | Orange | Yellow | Lime | Green | ... | Purple.

Ensuite vient l'interprétation de ces données. Il y a deux approches identiques. La première est de définir une fonction récursive qui prend en argument une liste de « disques à dessiner », en dessine un (celui décrit par la tête de la liste passée en argument) et passe la queue de ladite liste en argument à elle même :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
let rec draw_discs l = match l with
| [] -> ()
| head::tail -> begin
   draw_disc head ;
   draw_discs tail
end

La seconde approche utilise un outil tout fait qui fait exactement la même chose : la fonction List.iter (list__iter ?). C'est fonction prend deux arguments : une fonction f et une liste l ; elle applique f à chacun des éléments de l. Ainsi, List.iter f [a;b;c] applique f a, puis f b et enfin f c. Je te laisse lire la doc d'iter et de map (fonction proche) qui sont très (j'insiste : TRÈS) utiles.



Je te laisse commencer avec ça. Si tu as des questions, des ennuis, retourne vers nous. Mais pour tes prochains messages, prend le temps de les rédiger de manière un peu plus claire, en postant des extrait de codes et des specs un peu plus claires.

Cdlt,

[sovietstar]

Alors oui je debute en Caml light Mais c'est honnetement le pire langage que j'ai jamais vu, je prefere de loin programmer ca sur une casio

Enfin, je suis desole si mon message n'etait pas assez clair, je vais tenter de reexpliquer aussi clairement que possible.

Alors j'ai un projet de Bubble Shooter ou Puzzle bubble (meme jeu, differents noms, je sais pas si tu connais) a realiser...
L'usage du recursif doit se faire au maximum, pratique, mais en imperatif ca serait tellement plus rapide...
Et donc, lors du debut du jeu, je veux faire apparaitre 4 lignes * 9 boules tout en haut de ma fenetre graphique. En imperatif je sais le faire, mais "ca fait pas tres joli" selon le professeur.
J'ai donc realise un tableau sous forme de listes, plus simple qu'une matrice, et j'ai ca pour les boules:

let aleatoire = [[];[];[];[]]

bon je t'epargne les fonctions random se trouvant a l'interieur, et donc pour la fonction aleatoire, ca represente les boules qui apparaissent au debut du jeu de facon aleatoire.
Dans chacun des 9 emplacements d'une liste de la fonction, j'ai un chiffre genere aleatoirement entre 0 et 4 inclus. J'ai associe donc 5 couleurs aux chiffres de 0 a 4.

Mon probleme est le suivant, je n'arrive pas a exprimer en recursif la fonction draw_circle pour les 4 lignes, sachant que les coordonnees varient et qu'il faut prendre en compte les rayons des boules.
De plus, je n'ai pas reussi a trouver une fonction me permettant de prendre en compte la valeur aleatoire generee, pour definir la couleur de la boule.


J'espere que j'ai ete un peu plus clair. Bon en tout cas merci pour ta reponse, je vais jeter un coup d'oeil a tes commandes et je vais voir si je peux faire quelque chose avec ^^

[prgasp77]

Alors oui je debute en Caml light Mais c'est honnetement le pire langage que j'ai jamais vu, je prefere de loin programmer ca sur une casio

L'usage du recursif doit se faire au maximum, pratique, mais en imperatif ca serait tellement plus rapide...

Caml est un langage extrêmement expressif, au contraire. Tu as le sentiment que son « style » te bloque par rapport à un style impératif, mais c'est une question d'habitude. Tu sais comment tu ferais en impératif mais tu es complètement paumé en fonctionnel, et naïvement (comprendre au premier regard, je ne dis pas que tu es naïf) tu en conclus que l'impératif c'est mieux.

De manière générale, j'ai tendance à préférer l'impératif et le bas niveau (typiquement pour moi, le C) quand j'ai besoin d'avoir un contrôle fin sur ce qui est fait et la façon dont mes données sont représentées et agencées en mémoire (par exemple quand je fais de l'embarqué ou du réseau). Inversement, quand le comment est moins important que le quoi (typiquement en algorithmie, peu importe comment est représenté un entier quand je veux trier une liste d'entier), le fonctionnel est vraiment puissant. Tu peux par exemple effectuer un tri par tas/pivot/insertion en seulement quelques lignes ; bonus spécial, un beau code caml ne comporte pas deux lignes identiques (s'il faut faire au moins deux choses semblables, on crée une fonction et on l'appelle deux fois, les fonctions sont bon marché en fonctionnel).

Bref, tu l'aura compris j'aime beaucoup le fonctionnel ; mais je le le loue pas aveuglément : quand il n'est pas adapté, j'opte pour un autre langage. À chaque tâche son outil.

je veux faire apparaitre 4 lignes * 9 boules tout en haut de ma fenetre graphique. [...] J'ai donc realise un tableau sous forme de listes, plus simple qu'une matrice, et j'ai ca pour les boules:

let aleatoire = [[];[];[];[]]

C'est encore plus simple que ce que j'imaginais. Je te propose une solution structurée, lisible et maintenable.

1. Définir une structure de données pour représenter une boule (disque) à dessiner ;
2. définir l'ensemble des boules à dessiner ;
3. les dessiner.

Il est important de diviser ton problème en sous-tâches plus simples.

1. Je me répète ici, mais un triplet (couleur, abscisse, ordonnée) me semble adéquat. Pour x et y tu prendras des entiers qui définiront les coordonnées dans la matrice de boules, (0,0) étant par exemple la boule en haut à gauche et (0,1) celle à sa droite. Pour la couleur, même combat. Tu définis un variant type color = Color1 | ... | Color5. Ainsi, (Red, 1, 2) représente une boule rouge située sur la seconde ligne, troisième en partant de la gauche. Rappel : tu pourra définir ce triplet de cette manière par exemple type bubble = color * int * int.
   Question : pourquoi ne pas utiliser un genre de matrice de color : [[Red ; Yellow ; ...; Blue] ; [Yellow ; ... ] ; ... ] ? Parce que plus tard tu auras besoin, en plus de la couleur, de la position d'une boule, autant la calculer et la stocker tout de suite plutôt que de la retrouver plus tard.
2. Ici on veut définir l'ensemble des boules à dessiner. En gros, on va écrire une fonction prenant un unit − () − en entrée et une liste de boules en sortie.
   let define_bubbles () = ... ;;. Mais comment procéder ? Tu dis vouloir 36 boules. Je te propose une sous fonction récursive, qui prend en argument le numéro (0..35) de la boule à définir, la définie et l'ajoute à la liste des boules suivantes :
   

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

   1
   2
   3
   4
   5
   6
   7
   8
   9
   let define_bubbles () =
      let rec aux n =
         if <condidition d'arrêt>
         then []
         else
            let bubble = (random_color (), n / 9, n % 9) in
            bubble :: (aux (n+1))
      in
      aux 0

   On défini donc une sous fonction récursive (c'est assez courant, on la nomme aux en général, pour auxiliaire). Cette fonction définie la boule #n et retourne la liste composée en tête de la boule définie et en queue les boules suivantes ; elles, seront définies plus tard. Ceci est le schéma typique des fonctions récursives en caml ; il faut que tu le comprenne parfaitement et que tu l'assimile. N'hésite pas à poser une question là dessus. Je te laisse deviner quelle est la condition d'arrêt. Note : la fonction random_color prend un unit en argument et retourne une valeure du type color défini plus haut. Je te laisse gérer ça. C'est pas le plus simple, mais c'est le plus lisible.
3. Le dessin des boules et ensuite un jeu d'enfant. Tu définis une fonction qui prend une boule et la dessine. Puis tu appelles cette fonction sur tous les éléments de la liste retournée par define_bubbles (). Voir mon message précédent.

Poste des extraits de ton code. Pour les formater convenablement, .

[sovietstar]

Le recursif ne me pose pas de probleme dans d'autres langages, c'est juste que sur caml light, la documentation dessus est assez basique et rare, et je me sens donc frustre.

Sinon j'avais pense a une autre facon pour dessiner les boules, tout en me permettant de les decaler d'une ligne a une autre. C'est d'utiliser une fonction recurrente, comme ca:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
let i = n+30 true in
   while n+30<460 do
      draw_circle i 585 30
      if n+30>450 then n+30 := false
done;;

J'ai deja calcule les coordonnees des differentes boules, seulement l'inconvenient c'est que ca ne prend pas en compte leur couleur pour l'instant, et il me faut encore definir n.

Enfin, quant aux fonctions map et iter que tu m'as citee plus haut, j'ai oublie de te le dire, mais c'est une des premieres que jai essaye, sauf que je me heurte a un probleme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
do_list (fun i -> random__int 5) [0;0;0];;
         ^^^^^^^^^^^^^^^^^^^^^^
Cette expression est de type 'a -> int,
mais est utilisée avec le type 'a -> unit.

Je suis sur d'avoir oublie de definir quelque chose, sauf que je n'arrive pas a
voir c'est quoi...

Enfin, je vais essayer la fonction que tu m'as donne.

[prgasp77]

Je ne comprends vraiment pas ce qu'est censé faire ton premier extrait de code. Je ne pense pas que ce soit dû à une mécompréhension de la syntaxe caml, mais plutôt d'un problème de structuration du programme. Tu as l'air paumé. Suis donc mes conseils quant à la division du problème en sous étapes. Tu pourras tester ton programme par morceau et ainsi détecter les erreurs avec grande précision.

Enfin, quant aux fonctions map et iter que tu m'as citee plus haut, j'ai oublie de te le dire, mais c'est une des premieres que jai essaye, sauf que je me heurte a un probleme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
do_list (fun i -> random__int 5) [0;0;0];;
         ^^^^^^^^^^^^^^^^^^^^^^
Cette expression est de type 'a -> int,
mais est utilisée avec le type 'a -> unit.

L'erreur aurait dû te mettre sur la voie : do_list f l affecte les effets de bord de f aux éléments de l, mais ne retourne aucune donnée (elle retourne ()). Ainsi, dans ton extrait, do_list attend en premier argument une fonction de type 'a -> unit, comprendre une fonction qui prend un entier (dans ce cas) et retourne ().

Pour transformer une liste via une fonction [a;b;c] → [f a; f b; f c] il faut utiliser l'équivalent caml light de List.map.