Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Scheme Discussion :

LISP: Jeu Qui est-ce?


Sujet :

Scheme

  1. #1
    Membre régulier
    Homme Profil pro
    Inscrit en
    novembre 2010
    Messages
    273
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : France

    Informations forums :
    Inscription : novembre 2010
    Messages : 273
    Points : 73
    Points
    73
    Par défaut 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 scheme : Sélectionner tout - Visualiser dans une fenêtre à part
    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 scheme : Sélectionner tout - Visualiser dans une fenêtre à part
    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 scheme : Sélectionner tout - Visualiser dans une fenêtre à part
    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 scheme : Sélectionner tout - Visualiser dans une fenêtre à part
    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!

  2. #2
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    avril 2008
    Messages
    1 846
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Côtes d'Armor (Bretagne)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : avril 2008
    Messages : 1 846
    Points : 5 039
    Points
    5 039
    Par défaut
    Bonjour,

    où en es-tu?

Discussions similaires

  1. [Python 3.X] Jeu du "Qui est ce" python
    Par Benchouxx dans le forum Programmation multimédia/Jeux
    Réponses: 1
    Dernier message: 19/04/2015, 11h52
  2. [VB.NET] Comment supprimer un fichier qui est utilisé ?
    Par Toon94 dans le forum Windows Forms
    Réponses: 12
    Dernier message: 13/06/2010, 12h59
  3. Réponses: 2
    Dernier message: 16/10/2003, 17h17
  4. Une table qui existe mais qui est inconnu! ?
    Par Nino dans le forum InterBase
    Réponses: 6
    Dernier message: 13/06/2003, 11h47

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo