From 0d67130cb6935a29cfaab032f5a3b491ed29e5ef Mon Sep 17 00:00:00 2001 From: Mysaa Date: Sun, 16 Jan 2022 13:55:32 +0100 Subject: [PATCH] =?UTF-8?q?D=C3=A9placement=20du=20code=20de=20jeu=20en=20?= =?UTF-8?q?fonctions=20de=20Module.=C2=A0Gestion=20des=20prises=20diff?= =?UTF-8?q?=C3=A9rentes.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tarotinator/src/Cartes.hs | 4 +-- tarotinator/src/Main.hs | 19 +++++------- tarotinator/src/Tarot.hs | 61 ++++++++++++++++++++++++++++++++----- tarotinator/src/TarotIAs.hs | 12 +++++--- 4 files changed, 70 insertions(+), 26 deletions(-) diff --git a/tarotinator/src/Cartes.hs b/tarotinator/src/Cartes.hs index c1e0435..0e2b737 100644 --- a/tarotinator/src/Cartes.hs +++ b/tarotinator/src/Cartes.hs @@ -6,8 +6,8 @@ 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 -data Annonce = MisereTete | MisereAtout | Poignee of [Carte] | DoublePoignee of [Carte] | TriplePoignee of [Carte] +data TypePrise = Prise | Garde | GardeSans | GardeContre | Chelem deriving (Eq, Ord) +data Annonce = MisereTete | MisereAtout | Poignee [Carte] | DoublePoignee [Carte] | TriplePoignee [Carte] instance Show Carte where show (Excuse) = "Excuse" diff --git a/tarotinator/src/Main.hs b/tarotinator/src/Main.hs index 3985496..8524def 100644 --- a/tarotinator/src/Main.hs +++ b/tarotinator/src/Main.hs @@ -5,6 +5,7 @@ import System.Random.Shuffle import Data.Set import Data.Foldable import Data.List +import Data.Maybe printResults :: Int -> [Carte] -> IO () @@ -20,21 +21,15 @@ printDecks i cartes = do main :: IO () main = do - donne <- shuffleM $ Data.Set.toList deck + tasDeCartes <- shuffleM $ Data.Set.toList deck let - (cartes,chien) = distribuer donne [1,2,3] 0 - [cartes1,cartes2,cartes3,cartes4,cartes5] = cartes - (s0,s1,s2,s3,s4) = (distrib cartes1 0, distrib cartes2 1, distrib cartes3 2, distrib cartes4 3, distrib cartes5 4) :: (RandomIA,RandomIA,RandomIA,RandomIA,RandomIA) - -- C'est le premier qui prends, parce que ..... j'ai décidé. - (s0',s1',s2',s3',s4') = (debutPartie s0 0, debutPartie s1 0, debutPartie s2 0, debutPartie s3 0,debutPartie s4 0) + states0 = (MonJeu [], MonJeu [], MonJeu [], MonJeu [], MonJeu []) - etat0 = EtatPartie (0,(s0',s1',s2',s3',s4'),[cartes1,cartes2,cartes3,cartes4,cartes5],[chien,[],[],[],[]]) + steps = jouerPartie states0 tasDeCartes 2 [1,6,23] - cartesJouees = iterate (jouerPli . fst) (etat0,[]) - - steps = Prelude.take 15 $ Prelude.drop 1 cartesJouees - for_ (zip [1..5] cartes) (uncurry printDecks) - printDecks 6 chien + 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 diff --git a/tarotinator/src/Tarot.hs b/tarotinator/src/Tarot.hs index 5fccfc0..cfba69c 100644 --- a/tarotinator/src/Tarot.hs +++ b/tarotinator/src/Tarot.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE ConstraintKinds #-} module Tarot where import Cartes @@ -7,10 +8,16 @@ import Data.List.HT (rotate) -- 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 - -- Distrib crée l'état initial lorsque les cartes ont été distribuées. l'entier est la position du joueur qui commence. - distrib :: [Carte] -> Int -> s - -- debutPartie est appelee avant le premier pli. l'entier est la position du joueur qui a pris - debutPartie :: s -> Int -> s + -- Distrib crée l'état initial lorsque les cartes ont été distribuées. l'entier est la position du joueur qui commence par rapport à «moi» + distrib :: s -> [Carte] -> Int -> s + -- Renvoie le type de prise que «je» compte faire après les annonces des autres. + prise :: s -> [Maybe TypePrise] -> (Maybe TypePrise, s) + -- Renvoie les annonces faites aux autres. + annonce :: s -> ([Annonce],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 -- 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. @@ -145,10 +152,48 @@ jouerPli (EtatPartie (1,(jr1,jr2,jr3,jr4,jr5),jeux,points)) = let (pli,(e2,e3,e4 jouerPli (EtatPartie (2,(jr1,jr2,jr3,jr4,jr5),jeux,points)) = let (pli,(e3,e4,e5,e1,e2))=calculerPliJoue 2 (jr3,jr4,jr5,jr1,jr2) in calculerJeuPli 2 (e1,e2,e3,e4,e5) jeux pli points 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 +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 + (prise0,s0') = prise s0 [] + (prise1,s1') = prise s1 (prise0:[]) + (prise2,s2') = prise s2 (prise1:prise0:[]) + (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. +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')) +calculerPrises (s0,s1,s2,s3,s4) 2 = let (prises, (s2',s3',s4',s0',s1')) = calculerPrisesAux (s2,s3,s4,s0,s1) in (prises, (s0',s1',s2',s3',s4')) +calculerPrises (s0,s1,s2,s3,s4) 3 = let (prises, (s3',s4',s0',s1',s2')) = calculerPrisesAux (s3,s4,s0,s1,s2) in (prises, (s0',s1',s2',s3',s4')) +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 + 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 + + 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. + + ((annonces0,s0''),(annonces1,s1''),(annonces2,s2''),(annonces3,s3''),(annonces4,s4'')) = (annonce s0', annonce s1', annonce s2', annonce s3', annonce s4') + + (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)) + + etat0 = EtatPartie (meneur,(s0',s1',s2',s3',s4'),[cartesJ1,cartesJ2,cartesJ3,cartesJ4,cartesJ5],[chien,[],[],[],[]]) + + cartesJouees = iterate (jouerPli . fst) (etat0,[]) + + steps = Prelude.take 15 $ Prelude.drop 1 cartesJouees diff --git a/tarotinator/src/TarotIAs.hs b/tarotinator/src/TarotIAs.hs index e10ef1d..de0284a 100644 --- a/tarotinator/src/TarotIAs.hs +++ b/tarotinator/src/TarotIAs.hs @@ -8,9 +8,13 @@ import Tarot data RandomIA = MonJeu ([Carte]) instance JoueurIA RandomIA where - distrib cartes pos = MonJeu cartes -- Notre état est les cartes que l'on a - debutPartie cartes i = cartes -- On s'en fiche de l'info - jouer (MonJeu cartes) pli = (joué, MonJeu (delete joué cartes)) + 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)) + | otherwise = (Nothing, (MonJeu cartes)) + annonce self = ([], self) -- On ne fait pas d'annonce. Jamais. + debutPartie self typePrise 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 cartes pli = cartes + finTour self pli = self -- On s'en fiche de l'info.