Plus de commentaires, bug toujours pas corrigé ... :/

tarotinator/.gitignore

@@ -1 +1,2 @@
 dist/
+dist-newstyle/

tarotinator/src/Cartes.hs

@@ -6,7 +6,7 @@ data ValeurCouleur = As | Deux | Trois | Quatre | Cinq | Six | Sept | Huit | Neu
 data Couleur = Pique | Coeur | Carreau | Trefle deriving (Eq, Show, Ord)
 data Carte = Valeur (ValeurCouleur, Couleur) | Atout Int | Excuse deriving (Eq, Ord)
 
-data TypePrise = Prise | Garde | GardeSans | GardeContre | Chelem deriving (Eq, Ord)
+data TypePrise = Prise | Garde | GardeSans | GardeContre | Chelem deriving (Eq, Ord, Show)
 data Annonce = MisereTete | MisereAtout | Poignee [Carte] | DoublePoignee [Carte] | TriplePoignee [Carte]
 
 instance Show Carte where
@@ -93,17 +93,26 @@ ifeq x y oo on
     | x==y = oo
     | otherwise = on
     
+    
+deleteAllOrError :: Eq e => [e] -> [e] -> [e]
+deleteAllOrError [] l = l
+deleteAllOrError (e:s) l = deleteOrError e (deleteAllOrError s l)
+
 deleteOrError :: Eq e => e -> [e] -> [e]
 deleteOrError e [] = error "Cannot remove from empty list."
 deleteOrError e (h:l)
     | e==h = l
     | otherwise = h:(deleteOrError e l)
 
+-- Appelle la fonction précisée par le second paramètre.
 pentuplator :: (j0,j1,j2,j3,j4) -> Int -> ((j0 -> (a,j0)),(j1 -> (a,j1)),(j2 -> (a,j2)),(j3 -> (a,j3)),(j4 -> (a,j4))) -> (a,(j0,j1,j2,j3,j4))
 pentuplator (s0,s1,s2,s3,s4) 0 (f0,f1,f2,f3,f4) = let (o,s') = f0 s0 in (o,(s',s1,s2,s3,s4))
 pentuplator (s0,s1,s2,s3,s4) 1 (f0,f1,f2,f3,f4) = let (o,s') = f1 s1 in (o,(s0,s',s2,s3,s4))
 pentuplator (s0,s1,s2,s3,s4) 2 (f0,f1,f2,f3,f4) = let (o,s') = f2 s2 in (o,(s0,s1,s',s3,s4))
 pentuplator (s0,s1,s2,s3,s4) 3 (f0,f1,f2,f3,f4) = let (o,s') = f3 s3 in (o,(s0,s1,s2,s',s4))
 pentuplator (s0,s1,s2,s3,s4) 4 (f0,f1,f2,f3,f4) = let (o,s') = f4 s4 in (o,(s0,s1,s2,s3,s'))
---pentuplator p0 i p2 = pentuplator p0 (mod i 5) p2
+--pentuplator p0 i p2 = pentuplator p0 (mod i 5) p2 -- Enlevé pour que ça plante et que ce soit mieux détéctable.
 
+-- Inverse les paramètres de la fonction.
+parametinverter :: (a -> b -> c) -> (b -> a -> c)
+parametinverter f x y = f y x

tarotinator/src/Main.hs

@@ -34,7 +34,7 @@ main = do
     if (Data.List.null steps)
         then putStrLn "Personne n'a pris..."
         else do
-            putStrLn $ "Le joueur " ++ (show attaquant) ++ "a pris"
+            putStrLn $ "Le joueur " ++ (show (attaquant+1)) ++ " a pris"
             let
                 EtatPartie(_,_,cartesInit,points) = fst $ head steps
             for_ (zip [1..5] cartesInit) (uncurry printDecks)

tarotinator/src/Tarot.hs

@@ -128,7 +128,7 @@ calculerJeuPli main etats jeux pli points = (EtatPartie (vraiIndiceGagnant, etat
     where 
         indiceGagnant = 5-(fromJust $ elemIndex (fromJust $ gagnantPli pli) (pli))
         vraiIndiceGagnant = (mod (main+indiceGagnant-1) 5)
-        newJeux = [deleteOrError c jeu | (c,jeu)<-(zip (rotate (4-main) pli) jeux)]
+        newJeux = [deleteOrError c jeu | (c,jeu)<-(zip (rotate (main-1) pli) jeux)]
         
 
 
@@ -156,7 +156,8 @@ jouerPli (EtatPartie (2,(jr1,jr2,jr3,jr4,jr5),jeux,points)) = let (pli,(e3,e4,e5
 jouerPli (EtatPartie (3,(jr1,jr2,jr3,jr4,jr5),jeux,points)) = let (pli,(e4,e5,e1,e2,e3))=calculerPliJoue 3 (jr4,jr5,jr1,jr2,jr3) in calculerJeuPli 3 (e1,e2,e3,e4,e5) jeux pli points
 jouerPli (EtatPartie (4,(jr1,jr2,jr3,jr4,jr5),jeux,points)) = let (pli,(e5,e1,e2,e3,e4))=calculerPliJoue 4 (jr5,jr1,jr2,jr3,jr4) in calculerJeuPli 4 (e1,e2,e3,e4,e5) jeux pli points
 
--- j0 est le premier joueur à parler
+-- «Demande» réellement aux IAs la prise qu'elles comptent effectuer.
+-- Params: Pentuple d'IAs, avec s0 le premier joueur à parler.
 calculerPrisesAux ::  (JoueurIA j1, JoueurIA j2, JoueurIA j3, JoueurIA j4, JoueurIA j5) => (j1,j2,j3,j4,j5) -> ([Maybe TypePrise],(j1,j2,j3,j4,j5))
 calculerPrisesAux (s0,s1,s2,s3,s4) = (prises,(s0',s1',s2',s3',s4'))
     where
@@ -166,7 +167,9 @@ calculerPrisesAux (s0,s1,s2,s3,s4) = (prises,(s0',s1',s2',s3',s4'))
         (prise3,s3') = prise s3 (prise2:prise1:prise0:[])
         (prise4,s4') = prise s4 (prise3:prise2:prise1:prise0:[])
         prises = prise4:prise3:prise2:prise1:prise0:[]
--- s0 est le premier joueur de l'index, le second paramètre est l'indice du joueur qui parle en premier.
+
+-- «Demande» aux IOs la prise qu'elles comptent effectuer.
+-- Params: Pentuple d'IAs, avec s0 le premier joueur de l'index, le second paramètre est le numéro du joueur qui parle en premier.
 calculerPrises ::  (JoueurIA j1, JoueurIA j2, JoueurIA j3, JoueurIA j4, JoueurIA j5) => (j1,j2,j3,j4,j5) -> Int -> ([Maybe TypePrise],(j1,j2,j3,j4,j5))
 calculerPrises (s0,s1,s2,s3,s4) 0 = let (prises, (s0',s1',s2',s3',s4')) = calculerPrisesAux (s0,s1,s2,s3,s4) in (prises, (s0',s1',s2',s3',s4'))
 calculerPrises (s0,s1,s2,s3,s4) 1 = let (prises, (s1',s2',s3',s4',s0')) = calculerPrisesAux (s1,s2,s3,s4,s0) in (prises, (s0',s1',s2',s3',s4'))
@@ -191,32 +194,40 @@ calculerPointsJoueurs pointsJoueurs attaquant (Just coattaquant) typePrise chien
             Chelem -> 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).
+vraimentJouerPartie :: (JoueurIA j0, JoueurIA j1, JoueurIA j2, JoueurIA j3, JoueurIA 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) (cartes,chien) cartesInitiales prises = (steps,pointsAttaque,attaque)
+vraimentJouerPartie meneur (Just typePrise) (s20,s21,s22,s23,s24) chien cartesInitiales prises = (steps,pointsAttaque,attaque)
     where
-        attaque = mod (4-(fromJust $ elemIndex (Just typePrise) prises) - 1 - meneur) 5 -- L'attaque est l'indice 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)
+        (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.
         
-        (ecartEffectue,(s40,s41,s42,s43,s44))
+        (ecartEffectue,(s40,s41,s42,s43,s44)) -- Demande juste à l'attaquant de faire son écart, si son type de prise le demande.
             | faireEcart typePrise = pentuplator (s30,s31,s32,s33,s34) attaque (ecarteur,ecarteur,ecarteur,ecarteur,ecarteur)
-            | otherwise = ([],(s30,s31,s32,s33,s34))
+            | otherwise = ([],(s30,s31,s32,s33,s34)) -- Sinon, met le chien à vide.
                 where 
                     ecarteur :: JoueurIA j => j -> ([Carte],j)
-                    ecarteur = \s -> ecart s chien
+                    ecarteur = parametinverter ecart chien
         
         ((annonces0,s50),(annonces1,s51),(annonces2,s52),(annonces3,s53),(annonces4,s54)) = (annonce s40, annonce s21, annonce s22, annonce s23, annonce s24)
         
+        cartesApresEcart
+            | faireEcart typePrise = replaceNth cartesInitiales attaque (deleteAllOrError ecartEffectue ((cartesInitiales !! attaque) ++ chien)) -- on ajoute le chien à la main, puis on enlève l'écart.
+            | otherwise = cartesInitiales
+        
         annonces = [annonces0,annonces1,annonces2,annonces3,annonces4]
         
-        (s60,s61,s62,s63,s64) = (debutPartieAux s50 (mod (attaque-0) 5), debutPartieAux s51 (mod (attaque-1) 5), debutPartieAux s52 (mod (attaque-2) 5), debutPartieAux s53 (mod (attaque-3) 5),debutPartieAux s54 (mod (attaque-4) 5))
+        (s60,s61,s62,s63,s64) = (debutPartieAux s50 0, debutPartieAux s51 1, debutPartieAux s52 2, debutPartieAux s53 3,debutPartieAux s54 4)
             where 
                 debutPartieAux :: JoueurIA j => j -> Int -> j
-                debutPartieAux s i
+                debutPartieAux s i -- initialise l'IA s avec i le numéro du joueur
-                    | faireEcart typePrise = debutPartie s i typePrise carteAppelee chien (rotate i annonces)
+                    | faireEcart typePrise = debutPartie s (mod (attaque-i) 5) typePrise carteAppelee chien (rotate i annonces)
-                    | otherwise = debutPartie s i typePrise carteAppelee [] (rotate i annonces)
+                    | otherwise = debutPartie s (mod (attaque-i) 5) typePrise carteAppelee [] (rotate i annonces)
         
-        etat0 = EtatPartie (meneur,(s60,s61,s62,s63,s64),cartesInitiales,[chien,[],[],[],[]])
+        etat0 = EtatPartie (meneur,(s60,s61,s62,s63,s64),cartesApresEcart,rotate attaque [chien,[],[],[],[]])
         
         cartesJouees = iterate (jouerPli . fst) (etat0,[])
         
@@ -229,10 +240,11 @@ vraimentJouerPartie meneur (Just typePrise) (s20,s21,s22,s23,s24) (cartes,chien)
         pointsAttaque = calculerPointsJoueurs pointsJoueurs attaque coattaquant typePrise chien ecartEffectue
 
         
--- Cette fonction joue une partie avec les 5 types d'IA spécifiés, le tas de cartes à distribuer, et les indices des cartes à mettre dans le chien, et renvoie les états le long du jeu, ainsi que les différents plis.
+-- 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) =>
     (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) (cartes,chien) cartesInitiales prises
+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.