Tentatives vaines de debug.

2022-01-17 16:10:25 +01:00 · 2022-01-17 16:10:25 +01:00 · 0b3b169303
commit 0b3b169303
parent 0d67130cb6
5 changed files with 157 additions and 41 deletions
--- a/tarotinator/src/Cartes.hs
+++ b/tarotinator/src/Cartes.hs
@ -36,7 +36,41 @@ valeurCarte _ = 1
 valeurTas :: [Carte] -> Int
 valeurTas l = sum $ Data.List.map valeurCarte l

+-- À partir du nombre de bouts, renvoie le nombre de points à faire.
+pointsContrat :: Int -> Int
+pointsContrat 0 = 56*2
+pointsContrat 1 = 51*2
+pointsContrat 2 = 41*2
+pointsContrat 3 = 36*2

+estUnBout :: Carte -> Bool
+estUnBout (Atout(i)) = i==1 || i==21
+estUnBout Excuse = True
+estUnBout _ = False
+
+estAtout :: Carte -> Bool
+estAtout (Atout(_)) = True
+estAtout Excuse = True
+estAtout (Valeur(_,_)) = False
+
+valeurEstTete :: ValeurCouleur -> Bool
+valeurEstTete Roi = True
+valeurEstTete Dame = True
+valeurEstTete Cavalier = True
+valeurEstTete Valet = True
+valeurEstTete _ = False
+
+estTete :: Carte -> Bool
+estTete (Valeur(val, _)) = valeurEstTete val
+estTete Excuse = True
+estTete (Atout(_)) = False
+
+
+------ Prises ------
+faireEcart :: TypePrise -> Bool
+faireEcart Prise = True
+faireEcart Garde = True
+faireEcart _ = False


 --------------------------------------
@ -54,3 +88,22 @@ addToNth lliste i toAdd = replaceNth lliste i (toAdd ++ (lliste !! i))
 toPentuple :: [a] -> (a,a,a,a,a)
 toPentuple [j1,j2,j3,j4,j5] = (j1,j2,j3,j4,j5)

+ifeq :: Eq a => a -> a -> b -> b -> b
+ifeq x y oo on
+    | x==y = oo
+    | otherwise = on
+    
+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)
+    
+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
+
--- a/tarotinator/src/Main.hs
+++ b/tarotinator/src/Main.hs
@ -7,35 +7,44 @@ import Data.Foldable
 import Data.List
 import Data.Maybe

+import GHC.Stack (HasCallStack)

-printResults :: Int -> [Carte] -> IO ()
-printResults i pts = do
-    putStrLn $ "Joueur " ++ (show i) ++ " : " ++ (show $ valeurTas pts) ++ " point·s."
-    putStrLn (show pts)
    
 printDecks :: Int -> [Carte] -> IO ()
 printDecks i cartes = do
    putStrLn $ "Joueur " ++ (show i) ++ " : " ++ (show $ sort $ cartes)
    
-    
+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 $ "D'après les joueurs" ++ (show ias)
+    putStrLn $ show $ reverse pli
+    putStrLn $ "-> Gagné par joueur " ++ (show (meneur+1))    

-main :: IO ()
+main :: HasCallStack => IO ()
 main = do
    tasDeCartes <- shuffleM $ Data.Set.toList deck
+    putStrLn $ show $ distribuer tasDeCartes [1,6,22] 2
    let
        states0 = (MonJeu [], MonJeu [], MonJeu [], MonJeu [], MonJeu [])
        
-        steps = jouerPartie states0 tasDeCartes 2 [1,6,23]
+        (steps,pointsAttaque,attaquant) = jouerPartie states0 tasDeCartes 2 [1,6,23]
        
-        EtatPartie(_,_,cartesInit,points) = fst $ head steps
-    for_ (zip [1..5] cartesInit) (uncurry printDecks)
-    printDecks 6 (fromJust $ find (\l -> not (l==[])) points)
-    putStrLn ""
-    for_ steps $ \(EtatPartie(i,ias,jeux,points),pli) -> do
-                    putStrLn $ show $ reverse pli
-                    putStrLn $ "-> Gagné par joueur " ++ (show (i+1))
-    let EtatPartie(_,_,_,points) = fst $ last steps
-    
-    putStrLn "Résultats"
-    for_ (zip [1..5] points) (uncurry printResults)
+        
+    if (Data.List.null steps)
+        then putStrLn "Personne n'a pris..."
+        else do
+            putStrLn $ "Le joueur " ++ (show attaquant) ++ "a pris"
+            let
+                EtatPartie(_,_,cartesInit,points) = fst $ head steps
+            for_ (zip [1..5] cartesInit) (uncurry printDecks)
+            printDecks 6 (fromJust $ find (\l -> not (l==[])) points)
+            putStrLn ""
+            for_ steps printPli
+
+            let EtatPartie(_,_,_,points) = fst $ last steps
+            
+            putStrLn "Résultats"
+            putStrLn $ "Points de l'attaque : " ++ (show $ valeurTas pointsAttaque) ++ " point·s."
+            putStrLn (show pointsAttaque)
    
--- a/tarotinator/src/Tarot.hs
+++ b/tarotinator/src/Tarot.hs
@ -5,6 +5,7 @@ import Cartes
 import Data.List
 import Data.Maybe
 import Data.List.HT (rotate)
+import Safe.Foldable (maximumMay)

 -- Du point de vue du joueur, la position d'un joueur est le nombre de tours que notre joueur a d'avance. Donc le joueur 1 est celui qui joue après nous, 0 est nous-même et 9 est celui qui joue avant nous.
 class JoueurIA s where
@ -14,10 +15,12 @@ class JoueurIA s where
    prise :: s -> [Maybe TypePrise] -> (Maybe TypePrise, s)
    -- Renvoie les annonces faites aux autres.
    annonce :: s -> ([Annonce],s)
+    -- Renvoie la carte appelée pour accompagner l'attaque.
+    carte :: s -> (Carte,s)
    -- Si la prise éfféctuée le demande, on envoie le chien, et on demande l'ecart.
    ecart :: s -> [Carte] -> ([Carte],s)
-    -- debutPartie est appelee avant le premier pli. l'entier est la position du joueur qui a pris, le type de sa prise et la liste de toutes les annonces.
-    debutPartie :: s -> Int -> TypePrise -> [[Annonce]] -> s
+    -- debutPartie est appelee avant le premier pli. l'entier est la position du joueur qui a pris, le type de sa prise, la carte appelée, le chien si il a été révélé et la liste de toutes les annonces.
+    debutPartie :: s -> Int -> TypePrise -> Carte -> [Carte] -> [[Annonce]] -> s
    -- Jouer indique la carte à jouer à partir des cartes jouees par les joueurs précédents. Si le second parametre est vide, c'est qu'on commence le tour.
    jouer :: s -> [Carte] -> (Carte, s)
    -- finTour informe des cartes qui ont été jouées pendant le tour.
@ -94,7 +97,7 @@ peutJouer c jeu pli = case (couleurPli pli,c) of {
 -- distribue le jeu à la manière du tarot
 -- L'entrée est le tas de toutes les cartes (déjà coupé) puis trois entiers distincts dans l'ordre croissant entre 1 et 23, le premier à recevoir sa carte.
 -- Ces entiers correspondent à la carte à mettre dans le chien. Ou plutot après combien de groupes de trois il faut la mettre dans le chien.
-distribuer :: [Carte] -> [Int] -> Int-> ([[Carte]],[Carte])
+distribuer :: [Carte] -> [Int] -> Int -> ([[Carte]],[Carte])
 distribuer l ci premier = distribuerAux l ci premier [[],[],[],[],[]] [] -- 0 est le premier joueur
    where
        distribuerAux :: [Carte] -> [Int] -> Int -> [[Carte]] -> [Carte] -> ([[Carte]], [Carte])
@ -125,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 = [delete c jeu | (c,jeu)<-(zip (rotate (5-main) pli) jeux)]
+        newJeux = [deleteOrError c jeu | (c,jeu)<-(zip (rotate (4-main) pli) jeux)]
        


@ -172,29 +175,76 @@ calculerPrises (s0,s1,s2,s3,s4) 3 = let (prises, (s3',s4',s0',s1',s2')) = calcul
 calculerPrises (s0,s1,s2,s3,s4) 4 = let (prises, (s4',s0',s1',s2',s3')) = calculerPrisesAux (s4,s0,s1,s2,s3) in (prises, (s0',s1',s2',s3',s4'))


-- 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.
-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])]
-jouerPartie (s00,s01,s02,s03,s04) tasDeCartes meneur indicesChien = steps
+-- Renvoie les points de l'attaquant (la défense a fait les autres)
+calculerPointsJoueurs :: [[Carte]] -> Int -> Maybe Int -> TypePrise -> [Carte] -> [Carte] -> [Carte]
+calculerPointsJoueurs pointsJoueurs attaquant Nothing typePrise chien ecart = calculerPointsJoueurs pointsJoueurs attaquant (Just attaquant) typePrise chien ecart
+calculerPointsJoueurs pointsJoueurs attaquant (Just coattaquant) typePrise chien ecart = (pointsJoueurs !! attaquant) ++ (pointsCoattaquant) ++ (pointsSupplementaires)
    where
-        (cartes,chien) = distribuer tasDeCartes indicesChien meneur
-        [cartesJ1,cartesJ2,cartesJ3,cartesJ4,cartesJ5] = rotate (mod (4-meneur) 5) cartes -- le premier joueur recoit le (5-meneur)-ième tas.
-        (s0,s1,s2,s3,s4) = (distrib s00 cartesJ1 (mod (meneur-0) 5), distrib s01 cartesJ2 (mod (meneur-1) 5), distrib s02 cartesJ3 (mod (meneur-2) 5), distrib s03 cartesJ4 (mod (meneur-3) 5), distrib s04 cartesJ5 (mod (meneur-4) 5))        
-        (prises,(s0',s1',s2',s3',s4')) = calculerPrises (s0,s1,s2,s3,s4) meneur -- meneur est le premier à annoncer sa prise
+        pointsCoattaquant
+            | coattaquant == attaquant = []
+            | otherwise = pointsJoueurs !! coattaquant
+        pointsSupplementaires = case typePrise of {
+            Prise -> ecart;
+            Garde -> ecart;
+            GardeSans -> chien;
+            GardeContre -> [];
+            Chelem -> chien;
+        }
+
+vraimentJouerPartie _ Nothing _ _ _ _ = ([],[],-1)
+vraimentJouerPartie meneur (Just typePrise) (s20,s21,s22,s23,s24) (cartes,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.
        
-        typePrise = fromJust $ maximum prises
-        attaque = 4-(fromJust $ elemIndex (Just typePrise) prises) - meneur -- L'attaque est l'indice 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)
        
-        ((annonces0,s0''),(annonces1,s1''),(annonces2,s2''),(annonces3,s3''),(annonces4,s4'')) = (annonce s0', annonce s1', annonce s2', annonce s3', annonce s4')
+        (ecartEffectue,(s40,s41,s42,s43,s44))
+            | faireEcart typePrise = pentuplator (s30,s31,s32,s33,s34) attaque (ecarteur,ecarteur,ecarteur,ecarteur,ecarteur)
+            | otherwise = ([],(s30,s31,s32,s33,s34))
+                where  
+                    ecarteur :: JoueurIA j => j -> ([Carte],j)
+                    ecarteur = \s -> ecart s chien
        
-        (s0''',s1''',s2''',s3''',s4''') = (debutPartie s0'' (mod (attaque-0) 5), debutPartie s1'' (mod (attaque-1) 5), debutPartie s2'' (mod (attaque-2) 5), debutPartie s3'' (mod (attaque-3) 5),debutPartie s4'' (mod (attaque-4) 5))
+        ((annonces0,s50),(annonces1,s51),(annonces2,s52),(annonces3,s53),(annonces4,s54)) = (annonce s40, annonce s21, annonce s22, annonce s23, annonce s24)
        
-        etat0 = EtatPartie (meneur,(s0',s1',s2',s3',s4'),[cartesJ1,cartesJ2,cartesJ3,cartesJ4,cartesJ5],[chien,[],[],[],[]])
+        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))
+            where 
+                debutPartieAux :: JoueurIA j => j -> Int -> j
+                debutPartieAux s i
+                    | faireEcart typePrise = debutPartie s i typePrise carteAppelee chien (rotate i annonces)
+                    | otherwise = debutPartie s i typePrise carteAppelee [] (rotate i annonces)
+        
+        etat0 = EtatPartie (meneur,(s60,s61,s62,s63,s64),cartesInitiales,[chien,[],[],[],[]])
        
        cartesJouees = iterate (jouerPli . fst) (etat0,[])
        
        steps = Prelude.take 15 $ Prelude.drop 1 cartesJouees
-
+        
+        (EtatPartie (_,_,_,pointsJoueurs),_) = last steps
+        
+        coattaquant = findIndex (\l -> elem carteAppelee l) cartesInitiales
+        
+        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.
+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
+    where
+        (cartes,chien) = distribuer tasDeCartes indicesChien meneur
+        cartesInitiales = rotate (mod (4-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))        
+        (prises,(s20,s21,s22,s23,s24)) = calculerPrises (s10,s11,s12,s13,s14) meneur -- meneur est le premier à annoncer sa prise
+        
+        typePriseM = maximum prises
+
+
+        
+        



--- a/tarotinator/src/TarotIAs.hs
+++ b/tarotinator/src/TarotIAs.hs
@ -1,19 +1,23 @@
 module TarotIAs where

 import Data.List
+import Data.Set (toList)
+import Safe.Foldable (maximumMay)
 import Cartes
 import Tarot


-data RandomIA = MonJeu ([Carte])
+data RandomIA = MonJeu ([Carte]) deriving Show

 instance JoueurIA RandomIA where
    distrib self cartes pos = MonJeu cartes -- Notre état est les cartes que l'on a, on se fiche de notre passé.
    prise (MonJeu cartes) prises -- On ne prend que si on a le 21 d'atout et que personne n'a fait plus qu'une garde.
-        | (elem (Atout(21)) cartes) && (maximum prises < Just Garde) = (Just Garde, (MonJeu cartes))
+        | (elem (Atout(21)) cartes) && ((maximumMay prises) < Just (Just Garde)) = (Just Garde, (MonJeu cartes))
        | otherwise = (Nothing, (MonJeu cartes))
+    carte (MonJeu(cartes)) = (maximum $ filter (\x -> not (estAtout x)) $ filter (\x -> not (elem x cartes)) $ (toList deck), MonJeu(cartes))
+    ecart (MonJeu(cartes)) chien = let grosTas = sort (chien ++ cartes) in (take 3 grosTas,MonJeu(drop 3 grosTas))
    annonce self = ([], self) -- On ne fait pas d'annonce. Jamais.
-    debutPartie self typePrise annonces i = self -- On s'en fiche de l'info.
+    debutPartie self typePrise carteAppelee chien annonces i = self -- On s'en fiche de l'info.
    jouer (MonJeu cartes) pli = (joué, MonJeu (delete joué cartes)) -- On joue la plus petite carte que l'on aie.
        where joué = minimum [carte | carte<-cartes, peutJouer carte cartes pli]
    finTour self pli = self -- On s'en fiche de l'info.
--- a/tarotinator/tarotinator.cabal
+++ b/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
+  build-depends:       base >=4.11 && <4.12, 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
+  build-depends:       base >=4.11 && <4.12, containers, random-shuffle, random, MonadRandom, utility-ht, safe
  hs-source-dirs:      src
  default-language:    Haskell2010