Discussion :

[SaySay63]

Bonsoir à tous,

Pour passer le temps pendant mes vacances, j'aimerai coder un jeu de Black Jack en Lisp.

Etant débutant dans ce langage et maitrisant plutot les langages orientés objets, j'ai un peu de mal à me faire au principe des listes meme si je sais que Clisp est l'un des premiers langages à avoir permis la prog-obj

J'ai commencé à coder mon programme que je vous met ici :

Code :

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
(load "cartes.l")
 
(setq mainJoueur '())
(setq mainCroup '())
 
(defun tirercarte(liste)  ;tire une carte dans cartes.l
  (parcours (random (length liste)) liste)
)
 
(defun parcours (x l)
  (if (= x 1)(car l)
    (parcours (- x 1)(cdr l)))
)
 
(defun getCart (carte) ;tire une carte dans cartes.l A condition qu'il en reste
  (progn
  (if (not (null cartes))
      (setq carte(tirercarte cartes))
)))
 
(defun valeurcarte (carte) ;valeur de la carte (As = 11)
  (caddr (car carte))
)
 
(defun Distribuer() ;Va placer une carte dans la liste mainJoueur
 (print "Voulez vous tirer une carte? Oui (1) / Non (2)")
     (if (= (read) 1)
	(setq mainJoueur (cons (getCart cartes) mainJoueur))
	 (Distribuer))
)
 
;Calcule les points d'une main
(defun som(l)
 (progn  
   (if (not (null l))
       (+(valeurcarte l)(valeurcarte (cdr l)))
       (som (cdr l))))
)

Avec "cartes.l" qui est la base de donnée des cartes composées des cartes avec leur numéro, leur figure et leur valeur (au black jack )

Je vous la met par ici

Code :

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
(setq cartes '((as coeur 11)
	(deux coeur 2)
	(trois coeur 3)
	(quatre coeur 4)
	(cinq coeur 5)
	(six coeur 6)
	(sept coeur 7)
	(huit coeur 8)
	(neuf coeur 9)
	(dix coeur 10)
	(valet coeur 10)
	(dame coeur 10)
	(roi coeur 10)
 
	(as carreau 11)
	(deux carreau 2)
	(trois carreau 3)
	(quatre carreau 4)
	(cinq carreau 5)
	(six carreau 6)
	(sept carreau 7)
	(huit carreau 8)
	(neuf carreau 9)
	(dix carreau 10)
	(valet carreau 10)
	(dame carreau 10)
	(roi carreau 10)
 
	(as pique 11)
	(deux pique 2)
	(trois pique 3)
	(quatre pique 4)
	(cinq pique 5)
	(six pique 6)
	(sept pique 7)
	(huit pique 8)
	(neuf pique 9)
	(dix pique 10)
	(valet pique 10)
	(dame pique 10)
	(roi pique 10)
 
	(as trefle 11)
	(deux trefle 2)
	(trois trefle 3)
	(quatre trefle 4)
	(cinq trefle 5)
	(six trefle 6)
	(sept trefle 7)
	(huit trefle 8)
	(neuf trefle 9)
	(dix trefle 10)
	(valet trefle 10)
	(dame trefle 10)
	(roi trefle 10)))

Je bloque donc sur la fonction qui me permettrait de compter les points d'une "main" (que ce soit celle du joueur ou du donneur) avec pour seul argument une liste (celle du joueur ou du donneur ).

J'aimerai garder cette fonction sous la forme :

Code :

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

1
2
3
4
5
6
(defun som(l)
 (progn  
   (if (not (null l))
       (+(valeurcarte l)(valeurcarte (cdr l)))
       (som (cdr l))))
)

Mais j'ai beau retourner l'ittération je tombe soit sur
-Nil
-Som non définie
-Dépassement de la pilee

Voila je pense avoir tout dit,
Je vais continuer à chercher de mon côté mais si jamais quelqu'un a une idée a partager qu'il n'hésite pas

Sur ce, malgré l'heure quelque peu tardive, je retourne à mon code.

Bonne nuit tout le monde

[Trap D]

Il me semble que ta fonction somme peut s'écrire sous cette forme :

Code :

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

1
2
3
4
(defun som(l)
   (if (null l) 0
       (+  (valeurcarte (car l)) (som(cdr l))))
)

Je ne suis pas sur du bon nombre de parenthèses !

[SaySay63]

Désolé pour la réponse tardive mais je suis resté dessus jusqu'à 5h ce matin donc j'ai fait une petite grasse mat'

Merci beaucoup pour ta réponse, j'avais fini par trouver quelque chose qui marchait mais la tienne a l'avantage d'être plus courte ^^

Merci beaucoup =)

Problème résolu

Edit : La tienne marche mais il faut juste mettre (valeurcarte l) et non pas (valeurcarte (car l)) sinon il tente de faire l'addition avec la valeur "DEUX" (par exemple) et non pas "2".

Enfin j'me comprends quoi...

[SaySay63]

Bon pour ceux que ca intéresserai, j'ai fini de coder la première partie de mon BlackJack en Lisp

Pour le moment on va dire qu'il s'agit d'un mode simple ou il n'y a pas encore de mise et ou on joue seul contre l'ordinateur.

Je suis ouvert à tout si jamais vous me proposez des améliorations ou toute autre critique (constructive )

Code :

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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
(load "cartes.l")
 
(setq mainCroup '())
(setq mainJoueur '())
 
;(print "BIENVENUE A LAS VEGAS, LA OU (PRESQUE) TOUT EST POSSIBLE")
 
;tire une carte dans cartes.l
(defun tirercarte(liste)  
  (parcours (random (length liste)) liste)
)
 
(defun parcours (x l)
  (if (= x 1)(car l)
    (parcours (- x 1)(cdr l)))
)
 
 
;tire une carte dans cartes.l A condition qu'il en reste
(defun getCart (carte) 
  (progn
  (if (not (null cartes))
      (setq carte(tirercarte cartes))
)))
 
 
 ;valeur de la carte (As = 11)
(defun valeurcarte (carte)
  (caddr (car carte))
)
 
 ;Va placer une carte dans la liste mainJoueur
(defun Distribuer()
 
	(setq mainJoueur (cons (getCart cartes) mainJoueur))
)
 
;Calcule les points d'une main
(defun som(l)
 (if (null l) 0
   (+ (valeurcarte l) (som (cdr l))))
)
 
;Total de la main du croupier
 
(setq scorBank (som mainCroup))
 
 
; --------------------------- DEBUT DU JEU --------------------------------
 
 
;Fonction jeu
 
(defun jeu()
 
	(setq mainCroup  (cons (getCart cartes) mainCroup ))
 
	(jeu2)
)
 
 
(defun jeu2()
 
	   (print "La main du crouper est : ")
	   (print mainCroup)
 
	  (cond 
 
 
 ;Si score > 21 proposer de rejouer sinon sortir du programme  
        ((> (som mainJoueur) 21)
	 (print "Perdu! Vous avez dépassé 21. Voulez vous rejouer? Oui(1) Non(2)")
	 	(if (= (read) 1)
	    (progn 
	      (load "BlackJack.l")
	      (jeu)))
		(exit))
 
 
 ;En cas de BlackJack proposer de rejouer sinon sortir du programme	                 
	((= (som mainJoueur) 21)
	 (print "BlackJack! Voulez vous rejouer? Oui(1) Non(2)")
	 	(if (= (read) 1)
	    (progn 
	      (load "BlackJack.l")
	      (jeu)))
		(exit))
 
 
 ;Tant que score du joueur < 22 proposer de tirer une carte
 ;Si NON alors le croupier joue
 
	((< (som mainJoueur) 22)
	     (progn
 
	 (print "Voulez vous tirer une carte? Oui (1) / Non (2)")
 
	     (if (= (read) 1)
	  (progn 
	     (Distribuer)
 
	     (print "Votre main est : ")
	     (print mainJoueur)
 
	     (print "Votre total est de : ")
	     (print (som mainJoueur))
	     (jeu2))))
 
	     (croupier))
 
))
 
 
 ;Fais jouer le croupier après le tour du joueur
 ;Si le croupier à moins de 2 cartes dans sa main
 ;Si le croupier à moins de 17 points
 ;Si le croupier a moins de points que le joueur
 
(defun croupier()
 
(if (< (length mainCroup) 2)   
 (progn
 
  (cond 
 
          ( (and (< (som mainCroup) 17)(< (som mainCroup) (som mainJoueur)))
 
	        (setq mainCroup  (cons (getCart cartes) mainCroup ))
	        ))
    (print "La main du croupier est : ")
    (print mainCroup)
 
    (print "Avec un total de : ")
    (print (som mainCroup))
))
 
 
(cond
 
   ( (= (som mainJoueur)(som mainCroup)) (print "Vous avez perdu"))
   ( (< (som mainJoueur)(som mainCroup)) (print "Vous avez perdu"))
   ( (> (som mainJoueur)(som mainCroup)) (print "Vous avez gagné"))
 
)
 
)

A part quelques petits problèmes d'affichage (la saisie des entrées (1) ou (2) pour piocher/recommencer qui se fait au milieu de la phrase (*) et le fait que le programme nous affiche trois fois "Vous avez gagné/perdu" a la fin) tout devrait fonctionner

(*) Quel est l'équivalent de '\n' en lisp pour revenir à la ligne siouplé? J'ai cherché sur internet mais je n'ai pas trouvé et ça me permettrait de résoudre le premier problème



Et malgré tout j'vous souhaite un joyeux noyel