LISP: Jeu Qui est-ce?

Bonjour à tous, je suis débutant en LISP, j'ai un projet à rendre, basé sur le jeu du Qui est-ce?

Voici mon code à l'heure actuelle, je vais tenter de bien l'explliquer au fur et à mesure.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
; Constructeur de la classe personne
(define	make-personne	(lambda (prenom0 sexe0 barbe0 moustache0 lunettes0 cheveux0 yeux0 chapeaux0)
                          (let	((prenom prenom0)
                                 (sexe sexe0)   
                                 (barbe	barbe0)
                                 (moustache moustache0)        
                                 (lunettes lunettes0)
                                 (cheveux cheveux0)   
                                 (yeux yeux0)    
                                 (chapeaux chapeaux0)   
                                 )
                            (lambda	(message	.	params)
                              (cond	((eqv?	message	'getPrenom)	prenom)
                                        ((eqv?	message	'getSexe)	sexe)     
                                        ((eqv?	message	'getBarbe)	barbe)
                                        ((eqv?	message	'getMoustache)	moustache)
                                        ((eqv?	message	'getLunettes)	lunettes)
                                        ((eqv?	message	'getCheveux)	cheveux)
                                        ((eqv?	message	'getYeux)	yeux)
                                        ((eqv?	message	'getChapeaux)	chapeaux)                                        
                                        ((eqv?	message	'affiche)	(list prenom sexe barbe moustache lunettes cheveux yeux chapeaux))                                        
                                        (else
                                         (print	(list  " je ne comprends pas "	message))
                                         )
                                        )
                              )
                            )
                          )
  )

Ici on défini une personne (c'est à dire un des 24 personnages de départ du jeu du Qui est-ce?). Les différences physiques (données dans l'énoncé) sont comme vous pouvez le voir, le sexe, la présence de barbe ou non, la présence de moustache ou non, la présence de lunette ou non, la présence de chapeau ou non, la couleur des yeux, la couleur des cheveux.
La méthode affiche nous renvoie l'intitulé complet d'une personne (exemple avec Sam: '(Sam homme #f moustache lunettes chauve marron #f) )

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
; suspects  
  (define Sam (make-personne 'Sam 'homme #f 'moustache 'lunettes 'chauve 'marron #f))
  (define Alex (make-personne 'Alex 'homme #f #f #f 'noir 'marron #f))
  (define Peter (make-personne 'Peter 'homme #f 'moustache #f 'blanc 'bleu #f))
  (define Maria (make-personne 'Maria 'femme #f #f #f 'chatain 'marron 'chapeaux))
  (define Anne (make-personne 'Anne 'femme #f #f #f 'noir 'marron #f))
  (define Claire (make-personne 'Claire 'femme #f #f #f 'roux 'vert 'chapeaux))
  (define Philip (make-personne 'Philip 'homme 'barbe 'moustache #f 'noir 'marron #f))
  (define Alfred (make-personne 'Alfred 'homme 'barbe 'moustache #f 'roux 'bleu #f))
  
  (define Bill (make-personne 'Bill 'homme 'barbe 'moustache #f 'chauve 'marron #f))
  (define Herman (make-personne 'Herman 'homme #f #f #f 'chauve 'bleu #f))
  (define Anita (make-personne 'Anita 'femme #f #f #f 'blond 'bleu #f))
  (define Paul (make-personne 'Paul 'homme #f #f 'lunettes 'blanc 'marron #f))
  (define Franz (make-personne 'Franz 'homme #f #f #f 'roux 'vert #f))
  (define Max (make-personne 'Max 'homme 'barbe 'moustache #f 'noir 'marron #f))
  (define Richard (make-personne 'Richard 'homme 'barbe 'moustache 'lunettes 'chauve 'marron #f))
  (define Bernard (make-personne 'Bernard 'homme #f #f #f 'chatain 'marron 'chapeaux))
  
  (define Robert (make-personne 'Robert 'homme #f #f #f 'chatain 'bleu #f))
  (define Susan (make-personne 'Susan 'femme #f #f #f 'blanc 'bleu #f))
  (define Charles (make-personne 'Charles 'homme #f 'moustache #f 'blond 'marron #f))
  (define David (make-personne 'David 'homme 'barbe 'moustache #f 'blond 'marron #f))
  (define Tom (make-personne 'Tom 'homme #f #f 'lunettes 'chauve 'bleu #f))
  (define Joe (make-personne 'Joe 'homme #f #f 'lunettes 'blond 'vert #f))
  (define George (make-personne 'George 'homme #f #f #f 'blanc 'vert 'chapeaux))
  (define Eric (make-personne 'Eric 'homme #f #f #f 'blond 'marron 'chapeaux))

Ici on définit nos 24 personnes du jeu.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 ; prédicat homme? 
(define homme? (lambda (p)
                 (eqv? (p 'getSexe) 'homme)
                 )
  )
 ; prédicat femme? 
(define femme? (lambda (p)
                 (eqv? (p 'getSexe) 'femme)
                 )
  )
 ; prédicat barbe? 
(define barbe? (lambda (p)
                 (eqv? (p 'getBarbe) 'barbe)
                 )
  )
 ; prédicat moustache? 
(define moustache? (lambda (p)
                 (eqv? (p 'getMoustache) 'moustache)
                 )
  )
 ; prédicat lunettes? 
(define lunettes? (lambda (p)
                 (eqv? (p 'getLunettes) 'lunettes)
                 )
  )
 ; prédicat cheveux? 
(define cheveux? (lambda (p)
                 (eqv? (p 'getCheveux) 'cheveux)
                 )
  )
; prédicat chauve?
(define chauve? (lambda (p)
                 (eqv? (p 'getCheveux) 'chauve)
                 )
  )
; prédicat cheveuxNoir?
(define cheveuxNoir? (lambda (p)
                 (eqv? (p 'getCheveux) 'noir)
                 )
  )
; prédicat cheveuxBlanc?
(define cheveuxBlanc? (lambda (p)
                 (eqv? (p 'getCheveux) 'blanc)
                 )
  )
; prédicat cheveuxChatain?
(define cheveuxChatain? (lambda (p)
                 (eqv? (p 'getCheveux) 'chatain)
                 )
  )
; prédicat cheveuxRoux?
(define cheveuxRoux? (lambda (p)
                 (eqv? (p 'getCheveux) 'roux)
                 )
  )
; prédicat cheveuxBlond?
(define cheveuxBlond? (lambda (p)
                 (eqv? (p 'getCheveux) 'blond)
                 )
  )
 ; prédicat yeux? 
(define yeux? (lambda (p)
                 (eqv? (p 'getYeux) 'yeux)
                 )
  )
 ; prédicat yeuxBleu? 
(define yeuxBleu? (lambda (p)
                 (eqv? (p 'getYeux) 'bleu)
                 )
  ) ; prédicat yeuxVert? 
(define yeuxVert? (lambda (p)
                 (eqv? (p 'getYeux) 'vert)
                 )
  ) ; prédicat yeuxMarron? 
(define yeuxMarron? (lambda (p)
                 (eqv? (p 'getYeux) 'marron)
                 )
  )
 ; prédicat chapeau? 
(define chapeau? (lambda (p)
                 (eqv? (p 'getChapeaux) 'chapeaux)
                 )
  )

Puis on définit des prédicats qui auront valeur de question.
Comme on ne peut répondre dans ce jeu que par oui ou par non, la question "quelle est la couleur des cheveux?" n'a pas lieu d'être. On doit alors créer une question pour chaque couleur de cheveux présente sur les suspects. Idem pour la couleur des yeux. Pour le reste il s'agit de présence (vrai) ou pas (faux) d'un attribut physique (ou alors "est-ce un homme?" vrai, ou faux)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#| CLASSE JEUX

Attributs 
   les suspects de départ (24)
   les coupables
   nombre de questions posées

Méthodes
   afficherSuspects
   afficherCoupable
   poserQuestion
   proposerCoupable
   rejouer
|#

(define make-jeux (lambda ()
                     (letrec ((lesSuspects (list Sam
                                              Alex
                                              Peter
                                              Maria
                                              Anne
                                              Claire
                                              Philip
                                              Alfred
                                              Bill
                                              Herman
                                              Anita
                                              Paul
                                              Franz
                                              Max
                                              Richard
                                              Bernard
                                              Robert
                                              Susan
                                              Charles
                                              David
                                              Tom
                                              Joe
                                              George
                                              Eric)
                                           )
                              
                              (afficherSuspects
                               (lambda (l1)
                                  (if (null? l1)
                                          '()
                                          
                                           (cons ((car l1) 'affiche)
                                                 (afficherSuspects (cdr l1))
                                                 )
                                   )                                   
                                )
                            )
                              (coupable Sam)
                              (afficherCoupable
                               (lambda (p)
                                 (p 'affiche)
                                 )
                               )
                              
                              (poserQuestion 
                               (lambda (suspects coupable)
                                 (define reponse #t)
                                  (reponse (chapeau? (coupable)))
                                 (reponse)
                                 )
                               )
                         )
                       
                           
                       (lambda (message . params)
                         (cond ((eqv? message 'afficherSuspects) (afficherSuspects lesSuspects))
                               )
                                   
                         (cond ((eqv? message 'afficherCoupable) (afficherCoupable coupable))
                                   )
                         
                         (cond ((eqv? message 'poserQuestion) (poserQuestion lesSuspects coupable))
                                   )
                         )
                     )
                   )
  )
  
(define jeu (make-jeux))

Ma classe de jeu qui doit permettre (comme indiquée en haut en commentaire: - d'afficher la liste des 24 personnes dites "suspects" au début du jeu
- d'afficher le coupable (normalement généré aléatoirement dans la liste des 24, pour le moment je choisi Sam comme étant le coupable à chaque partie)
- de poser une question (c'est là où j'en suis dans mon développement). Le but est en fait assez simple. On devra utiliser un prédicat/une question (saisi par le joueur). Cette question devra être posé au coupable (actuellement la question posée est écrite en dur et sera toujours "a t-il un chapeau?"), puis on posera la même question à tous les suspects de la liste. Ceux qui ne répondent pas la même chose que le coupable sont éjectés de la liste). A la fin il n'en restera qu'un (comme dirait Denis Brognard)
- de proposer un coupable (méthode pas encore écrite)
- de rejouer (réinitialisation de la liste des suspects et choix aléatoire d'un nouveau coupable - pas encore écrite)

Je code avec Dr Racket. Il m'exécute le code actuel sans erreur.

Mon problème: je saisi en console (jeu 'afficherSuspects), méthode qui fonctionnait bien en début de journée et assez basique. Rien ne s'affiche actuellement. J'essaie (jeu 'afficherCoupable), idem. Mais je n'ai même pas une erreur en console.

J'aurai d'autres questions par la suite, mais tant qu'une commande basique comme celle-ci ne m'affiche rien je ne peux pas continuer à l'aveuglette.

Merci de votre aide!