Enfin ça fonctionne, juste un problème de recopiage. Horreur.

tarotinator/README.md

@@ -11,6 +11,12 @@ Pour aller plus loin
 
 (Ceci est une TODO list)
 
-Ajouter la prise à l'IA.
-
 Ajouter la possiblité de random l'IA (avec par exemple une classe qui fonctionne avec de IO)
+
+Faire une HumainIA (fera pareil avec IO).
+
+Faire en sorte que les imports soient explicites.
+
+Utiliser Set partout où c'est adéquat.
+
+Essayer de trouver un type pour (liste de taille 5), qui permette de rendre les fonctions complètement définies.

tarotinator/src/Main.hs

@@ -16,18 +16,19 @@ printDecks i cartes = do
     
 printPli :: (JoueurIA j0, JoueurIA j1, JoueurIA j2, JoueurIA j3, JoueurIA j4) => (Show j0, Show j1, Show j2, Show j3, Show j4) => (EtatPartie j0 j1 j2 j3 j4,[Carte]) -> IO ()
 printPli (EtatPartie(meneur,ias,jeux,points),pli) = do
-    putStrLn $ "Cartes des joueurs" ++ (show jeux)
+    --putStrLn $ "Cartes des joueurs" ++ (show jeux)
-    putStrLn $ "D'après les joueurs" ++ (show ias)
+    --putStrLn $ "D'après les joueurs" ++ (show ias)
     putStrLn $ show $ reverse pli
     putStrLn $ "-> Gagné par joueur " ++ (show (meneur+1))    
 
 main :: HasCallStack => IO ()
 main = do
     tasDeCartes <- shuffleM $ Data.Set.toList deck
-    putStrLn $ show $ distribuer tasDeCartes [1,6,22] 2
+    --putStrLn $ show $ distribuer tasDeCartes [1,6,23] 2
     let
         states0 = (MonJeu [], MonJeu [], MonJeu [], MonJeu [], MonJeu [])
         
+        -- On décide que joueur 3 commence.
         (steps,pointsAttaque,attaquant) = jouerPartie states0 tasDeCartes 2 [1,6,23]
         
         

tarotinator/src/Tarot.hs

@@ -122,13 +122,14 @@ calculerPoints pli points jeux vraiIndiceGagnant
     where
         newPoints = (pli ++ (points !! vraiIndiceGagnant))
 
--- Ici, les indices des joueurs sont locaux, et non globaux.
+-- Calcule le nouvel état de la partie à partir du pli que les joueurs ont fait.
+-- Params: numéro du joueur qui avait la main, pentuplet des états des joueurs, liste des cinq jeux des joueurs, le premier élément est celui du joueur 1, le pli, dont la carte la plus profonde est au joueur «main», liste des cinq paquets de points des joueurs (premier élément, joueur 1.
 calculerJeuPli :: (JoueurIA j1, JoueurIA j2, JoueurIA j3, JoueurIA j4, JoueurIA j5) => Int -> (j1,j2,j3,j4,j5) -> [[Carte]] -> [Carte] -> [[Carte]] -> (EtatPartie j1 j2 j3 j4 j5, [Carte])
 calculerJeuPli main etats jeux pli points = (EtatPartie (vraiIndiceGagnant, etats, newJeux, calculerPoints pli points jeux vraiIndiceGagnant), pli)
     where 
-        indiceGagnant = 5-(fromJust $ elemIndex (fromJust $ gagnantPli pli) (pli))
+        indiceGagnant = 4-(fromJust $ elemIndex (fromJust $ gagnantPli pli) pli) -- La indiceGagnant-ème carte à joué a remporté le pli.
-        vraiIndiceGagnant = (mod (main+indiceGagnant-1) 5)
+        vraiIndiceGagnant = (mod (main+indiceGagnant) 5) -- Le joueur vraiIndiceGagnant a remporté le pli.
-        newJeux = [deleteOrError c jeu | (c,jeu)<-(zip (rotate (main-1) pli) jeux)]
+        newJeux = [deleteOrError c jeu | (c,jeu)<-(zip (rotate (-main) (reverse pli)) jeux)] -- Pour chaque jeu, on supprime la carte jouée.
         
 
 
@@ -195,13 +196,13 @@ calculerPointsJoueurs pointsJoueurs attaquant (Just coattaquant) typePrise chien
         }
         
 -- Cette fonction joue une partie, et ne fait rien si personne ne prend.
--- Params: numéro du joueur qui commence, le type de prise éfféctué, le pentuple des IAs, le chien issu de la distribution, la liste des cartes des joueurs dont le premier élément est celui du premier à jouer, la liste des prises efféctuées (l'élément le plus profond est la première prise).
+-- Params: numéro du joueur qui commence, le type de prise éfféctué, le pentuple des IAs, le chien issu de la distribution, la liste des cartes des joueurs dont le premier élément est celui du numéro 1, la liste des prises efféctuées (l'élément le plus profond est la première prise).
-vraimentJouerPartie :: (JoueurIA j0, JoueurIA j1, JoueurIA j2, JoueurIA j3, JoueurIA j4) =>
+vraimentJouerPartie :: (JoueurIA j0, JoueurIA j1, JoueurIA j2, JoueurIA j3, JoueurIA j4) => (Show j0, Show j1, Show j2, Show j3, Show j4) =>
     Int -> Maybe TypePrise -> (j0, j1, j2, j3, j4) -> [Carte] -> [[Carte]] -> [Maybe TypePrise] -> ([(EtatPartie j0 j1 j2 j3 j4,[Carte])],[Carte],Int)
 vraimentJouerPartie _ Nothing _ _ _ _ = ([],[],-1)
 vraimentJouerPartie meneur (Just typePrise) (s20,s21,s22,s23,s24) chien cartesInitiales prises = (steps,pointsAttaque,attaque)
     where
-        attaque = mod (meneur+4-(fromJust $ elemIndex (Just typePrise) prises)) 5 -- L'attaque est le numéro du joueur qui a pris la plus grande prise.
+        attaque = mod (meneur+ 4-(fromJust $ elemIndex (Just typePrise) prises)) 5 -- L'attaque est le numéro du joueur qui a pris la plus grande prise.
 
         (carteAppelee,(s30,s31,s32,s33,s34)) = pentuplator (s20,s21,s22,s23,s24) attaque (carte,carte,carte,carte,carte) -- Demande juste à l'attaquant la carte qu'il appelle.
         
@@ -212,7 +213,7 @@ vraimentJouerPartie meneur (Just typePrise) (s20,s21,s22,s23,s24) chien cartesIn
                     ecarteur :: JoueurIA j => j -> ([Carte],j)
                     ecarteur = parametinverter ecart chien
         
-        ((annonces0,s50),(annonces1,s51),(annonces2,s52),(annonces3,s53),(annonces4,s54)) = (annonce s40, annonce s21, annonce s22, annonce s23, annonce s24)
+        ((annonces0,s50),(annonces1,s51),(annonces2,s52),(annonces3,s53),(annonces4,s54)) = (annonce s40, annonce s41, annonce s42, annonce s43, annonce s44)
         
         cartesApresEcart
             | faireEcart typePrise = replaceNth cartesInitiales attaque (deleteAllOrError ecartEffectue ((cartesInitiales !! attaque) ++ chien)) -- on ajoute le chien à la main, puis on enlève l'écart.
@@ -227,11 +228,14 @@ vraimentJouerPartie meneur (Just typePrise) (s20,s21,s22,s23,s24) chien cartesIn
                     | faireEcart typePrise = debutPartie s (mod (attaque-i) 5) typePrise carteAppelee chien (rotate i annonces)
                     | otherwise = debutPartie s (mod (attaque-i) 5) typePrise carteAppelee [] (rotate i annonces)
         
-        etat0 = EtatPartie (meneur,(s60,s61,s62,s63,s64),cartesApresEcart,rotate attaque [chien,[],[],[],[]])
+        etat0 = EtatPartie (meneur,(s60,s61,s62,s63,s64),cartesApresEcart,rotate attaque [chienOuEcart,[],[],[],[]]) -- état initial de la partie, l'écart à défaut le chien est dans les point de l'attaquant.
-        
+            where
+                chienOuEcart
+                    | Data.List.null ecartEffectue = chien
+                    | otherwise = ecartEffectue
         cartesJouees = iterate (jouerPli . fst) (etat0,[])
         
-        steps = Prelude.take 15 $ Prelude.drop 1 cartesJouees
+        steps = Prelude.take 15 $ cartesJouees
         
         (EtatPartie (_,_,_,pointsJoueurs),_) = last steps
         
@@ -242,14 +246,14 @@ vraimentJouerPartie meneur (Just typePrise) (s20,s21,s22,s23,s24) chien cartesIn
         
 -- Cette fonction joue une partie.
 -- Params: pentuple d'IAs, tas de carte à distribuer, numéro du joueur qui commence, les trois nombres entre 1 et 23 à mettre dans le chien.
-jouerPartie :: (JoueurIA j0, JoueurIA j1, JoueurIA j2, JoueurIA j3, JoueurIA j4) =>
+jouerPartie :: (JoueurIA j0, JoueurIA j1, JoueurIA j2, JoueurIA j3, JoueurIA j4) => (Show j0, Show j1, Show j2, Show j3, Show j4) =>
     (j0, j1, j2, j3, j4) -> [Carte] -> Int -> [Int] -> ([(EtatPartie j0 j1 j2 j3 j4,[Carte])],[Carte],Int)
 jouerPartie (s00,s01,s02,s03,s04) tasDeCartes meneur indicesChien = vraimentJouerPartie meneur typePriseM (s20,s21,s22,s23,s24) chien cartesInitiales prises
     where
         (cartes,chien) = distribuer tasDeCartes indicesChien meneur
-        cartesInitiales = rotate (mod (4-meneur) 5) cartes -- le premier joueur recoit le (5-meneur)-ième tas.
+        cartesInitiales = rotate (mod (-meneur) 5) cartes -- le premier joueur recoit le (5-meneur)-ième tas.
         [cartesJ0,cartesJ1,cartesJ2,cartesJ3,cartesJ4] = cartesInitiales
-        (s10,s11,s12,s13,s14) = (distrib s00 cartesJ0 (mod (meneur-0) 5), distrib s01 cartesJ1 (mod (meneur-1) 5), distrib s02 cartesJ2 (mod (meneur-2) 5), distrib s03 cartesJ3 (mod (meneur-3) 5), distrib s04 cartesJ4 (mod (meneur-4) 5))        
+        (s10,s11,s12,s13,s14) = (distrib s00 cartesJ0 (mod (meneur-0) 5), distrib s01 cartesJ1 (mod (meneur-1) 5), distrib s02 cartesJ2 (mod (meneur-2) 5), distrib s03 cartesJ3 (mod (meneur-3) 5), distrib s04 cartesJ4 (mod(meneur-4) 5))        
         (prises,(s20,s21,s22,s23,s24)) = calculerPrises (s10,s11,s12,s13,s14) meneur -- meneur est le premier à annoncer sa prise
         
         typePriseM = maximum prises

tarotinator/tarotinator.cabal

@@ -19,7 +19,7 @@ library
   exposed-modules: Cartes, Tarot
   other-modules:
   -- other-extensions:
-  build-depends:       base >=4.11 && <4.12, containers, random-shuffle, random, MonadRandom, utility-ht, safe
+  build-depends:       base >=4.13 && <4.14, containers, random-shuffle, random, MonadRandom, utility-ht, safe
   hs-source-dirs:      src
   default-language:    Haskell2010
 
@@ -27,6 +27,6 @@ executable tarotinator
   main-is:             Main.hs
   other-modules: Cartes, Tarot, TarotIAs
   -- other-extensions:
-  build-depends:       base >=4.11 && <4.12, containers, random-shuffle, random, MonadRandom, utility-ht, safe
+  build-depends:       base >=4.13 && <4.14, containers, random-shuffle, random, MonadRandom, utility-ht, safe
   hs-source-dirs:      src
   default-language:    Haskell2010