Mysaa/projprog
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Mysaa 2022-01-18 02:27:24 +01:00
parent 0b3b169303
commit 88a32145d0
Signed by: Mysaa
GPG Key ID: DBA23608F23F5A10
4 changed files with 43 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
tarotinator/.gitignore vendored
View File

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

13
tarotinator/src/Cartes.hs
View File

@ -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

2
tarotinator/src/Main.hs
View File

@ -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)

44
tarotinator/src/Tarot.hs
View File

@ -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
| faireEcart typePrise = debutPartie s i typePrise carteAppelee chien (rotate i annonces)
| otherwise = debutPartie s i typePrise carteAppelee [] (rotate i annonces)
debutPartieAux s i -- initialise l'IA s avec i le numéro du joueur
| 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),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.