You are not logged in.

Computer Science in 1ère

The forum to cure all your computer anxieties

#1 06-Jan-2020 19:50:57

LBruneteau
Member
From: Rezé
Registered: 12-Sep-2019
Posts: 33
Website

Poker

Coucou les camarades, j'ai continué mon projet de poker en python. J'ai décidé de créer un module avec toutes les fonctions de base du jeu. Je n'ai pas encore fini, mais pour l'instant ça donne ça:

'''
Module poker
fonctions de base du jeu
'''

import random as r

def chaine(chiffre:int) -> str:
    '''
    convertit un nombre en JQKA et en str.
    '''

    INT_TO_STR:dict = {11:'J' , 12:'Q' , 13:'K' , 14:'A'}
    if chiffre > 10:
        lettre:str = INT_TO_STR[chiffre]
    else:
        lettre:str = str(chiffre)
    return lettre

def entier(lettre:str) -> int:
    '''
    convertit un nombre en str vers un entier. Permet d'obtenir 11 12 13 14 à partir de JQKA
    '''

    STR_TO_INT:dict = {'J':11 , 'Q':12 , 'K':13 , 'A':14}
    if lettre.isnumeric():
        chiffre:int = int(lettre)
    else:
        chiffre:int = STR_TO_INT[lettre]
    return chiffre

def jeuCartes() -> list:
    '''
    Cree un jeu de 52 cartes
    '''

    SYMBOLES:list = ["♠","♥","♣","♦"]
    jeu:list = []
    for s in SYMBOLES:
        for c in range (2 , 15):
            c = chaine(c)
            jeu.append([s , c])
    return jeu

def pioche(jeu:list , tirs:int):
    '''
    Met un nombre donne de carte d'un jeu donné dans une liste et retire les cartes du jeu
    '''

    carte_piochees:list = []
    for t in range (tirs):
        numero_carte:int = r.randint(1,len(jeu)-1)
        carte:list = jeu[numero_carte]
        carte_piochees.append(carte)
        del(jeu[numero_carte])
    return jeu , carte_piochees

def mainChiffre(main:list) ->list:
    '''
    renvoie uniquement les chiffres d'une main
    '''

    liste:list = []
    for i in main:
        c = entier(i[1])
        liste.append(c)
    return liste

def hauteur(main:list) -> int:
    main_chiffre = mainChiffre(main)
    return max(main_chiffre)

def triMain(main:list) ->list:
    '''
    Trie les mains de façon à donner les cartes plus faibles d'abord
    '''

    chiffres:list = mainChiffre(main)
    chiffres.sort()
    main_triee:list = []
    for c in chiffres:
        for carte in main:
            index:int = main.index(carte)
            if entier(carte[1]) == c:
                main_triee.append(carte)
                del main[index]
    return main_triee

def estFlush(main:list) -> bool:
    """
    Renvoie True si on a une couleur
    """

    flush:bool = True
    compteur:int = 0
    while flush and (compteur < len(main) - 1):
            flush = main[compteur][0] == main[compteur + 1][0]
            compteur += 1
    return flush

def estQuinte(main:list) -> bool:
    """
    Retourne True si la main est une suite
    """

    main = triMain(main)
    compteur:int = 0
    quinte:bool = True
    while quinte and (compteur < len(main) - 1):
            quinte = (entier(main[compteur][1]) + 1) == (entier(main[compteur + 1][1]))
            compteur += 1
    return quinte

def estQuinteFlush(main:list) -> bool:
    """
    """

    return estQuinte(main) and estFlush(main)

def estQuinteFlushRoyale(main):
    main2 = main.copy()
    print(main2)
    return estQuinteFlush(main) and (hauteur(main2) == 14)

def listePaires(main:list) -> list:
    liste = [0,0,0,0,0]
    l = len(main)
    for k in range(l):
        carte = main[k][1]
        for i in range(l):
            c = main[i][1]
            if carte == c:
                liste[i] += 1
    return liste

def estCarre(main):
    liste_paires = listePaires(main)
    est_carre =  4 in liste_paires
    if est_carre:
        carre = entier(main[liste_paires.index(4)][1])
    else:
        carre = 0
    return carre

def estBrelan(main):
    liste_paires = listePaires(main)
    est_brelan = 3 in liste_paires
    if est_brelan:
        brelan = entier(main[liste_paires.index(3)][1])
    else:
        brelan = 0
    return brelan

def estPaire(main):
    liste_paires = listePaires(main)
    nb_paires = liste_paires.count(2)
    les_paires = []
    if nb_paires >= 2:
        les_paires.append(entier(main[liste_paires.index(2)][1]))
    if nb_paires == 4:
        for c in liste_paires:
            n = entier(main[liste_paires][1])
            if n not in les_paires and c == 2:
                les_paires.append(n)
                les_paires.sort()
    return les_paires

def estFull(main):
    return (len(estPaires(main)) == 1) and (estBrelan(main) > 0)
 

Je n'ai pas encore terminé ni beaucoup testé, mais j'ai un problème avec la fonction hauteur() et la fonction estQuinteFlushRoyale(). J'ai créé une main quinte flush royale pour faire un test. hauteur(main) donne bien 14, comme l'As, estQuinteFlush(main) renvoie True. cependant la fonction hauteur me donne une ValueError: max() arg is an empty sequence quand je l'appelle via la fonction estQuinteFlushRoyale(main). j'ai rajouté print(main) au début de la fonction hauteur, et la liste est bel et bien vide... La fonction mainChiffre() utilisée dans la fonction hauteur marche bien. J'ai essayé de faire main.copy() mais ce n'est pas mieux... Quelqu'un peut m'aider s'il vous plaît? Le fichier du module est sur mon gitlab si vous en avez besoin.

Offline

#2 06-Jan-2020 20:37:47

LBruneteau
Member
From: Rezé
Registered: 12-Sep-2019
Posts: 33
Website

Re: Poker

J'envisage également de créer une classe Joueur pour rendre le jeu jouable

Offline

#3 07-Jan-2020 20:32:35

LBruneteau
Member
From: Rezé
Registered: 12-Sep-2019
Posts: 33
Website

Re: Poker

J'ai corrigé mes quelques bugs, notamment celui de la hauteur. Il suffisait de travailler sur une copie de la liste en faisant

 copie = list(original)

J'ai rajouté des fonctions pour évaluer les mains et les comparer entre elles. Je pense qu'une grosse partie du travail est faite, mais il me reste encore du travail, notamment rajouter une fonction pour donner le nom des combinaisons possédées et rendre le code plus lisible. Le code source est ici.

'''
Module poker
fonctions de base du jeu
'''

def chaine(chiffre:int) -> str:
    '''
    convertit un nombre en JQKA et en str.
    chaine(13)
    >>>'K'
    '''

    INT_TO_STR:dict = {11:'J' , 12:'Q' , 13:'K' , 14:'A'} #Dictionnaire contenant les corres entre les int et les str
    if chiffre > 10: #S'il faut mettre une lettre à la place du chiffre
        lettre:str = INT_TO_STR[chiffre] #On utilise le dictionnaire
    else: #Sinon
        lettre:str = str(chiffre) #On convertit simplement en chaîne de caractère
    return lettre #On retourne la lettre

def entier(lettre:str) -> int:
    '''
    convertit un nombre en str vers un entier. Permet d'obtenir 11 12 13 14 à partir de JQKA
    entier("J")
    >>>11
    '''

    STR_TO_INT:dict = {'J':11 , 'Q':12 , 'K':13 , 'A':14} #Dictionnaire str vers int pour les lettres
    if lettre.isnumeric(): #Si la lettre est un nombre
        chiffre:int = int(lettre) #On convertit en entier
    else: #Sinon -> Si c'est une lettre
        chiffre:int = STR_TO_INT[lettre] #On prend l'équivalent dans le dictionnaire
    return chiffre #On retourne le chiffre obtenu

def jeuCartes() -> list:
    '''
    Cree un jeu de 52 cartes
    chaque  carte est une liste [[symbole:str , nombre:str] , [symbole:str , nombre:str] ...]
    Aucun paramètre
    j = jeuCartes()
    print(j[0])
    >>>["♠","2"]
    '''

    symboles:list = ["♠","♥","♣","♦"] #Une liste des 4 symboles dans un jeu de cartes
    jeu:list = [] #Pour l'instant le jeu est une liste vide
    for s in symboles: #s prend les valeurs de chaque symbole
        for c in range (2 , 15): #c prend les valeurs de 2 à 14 -> les chiffres d'un jeu
            c:str = chaine(c) #on transforme le chiffre en chaîne de caractère avec la fonction
            jeu.append([s , c]) #On ajoute dans le jeu une liste avec un symbole et un chiffre
    return jeu #On retourne le jeu

def pioche(jeu:list , tirs:int):
    '''
    Met un nombre donne de carte d'un jeu donné dans une liste et retire les cartes du jeu
    Les cartes tirées sont aléatoires
    jeu , carte = pioche(jeuCartes() , 1)
    print(carte)
    >>>["♣" , "K"]
    '''

    from random import randint #On importe la fonction randint du module random
    carte_piochees:list = [] #Une liste qui contiendra les cartes qui seront piochées
    for t in range (tirs): #Répéter tirs fois
        numero_carte:int = randint(1,len(jeu)-1) #Donner un nombre aléatoire qui correspondra à un index de cartes
        carte:list = jeu[numero_carte] #Prendre la carte correspondante au numéro
        carte_piochees.append(carte) #Ajouter la carte aux cartes piochées
        del(jeu[numero_carte]) #Supprimer la carte du paquet
    return (jeu , carte_piochees) #Renvoyer le jeu et les cartes

def mainChiffre(main:list) ->list:
    '''
    renvoie uniquement les chiffres d'une main
    '''

    liste:list = []
    for i in list(main):
        c = entier(i[1])
        liste.append(c)
    return liste

def listePaires(main:list) -> list:
    liste = [0,0,0,0,0]
    l = len(main)
    main2 = list(main)
    for k in range(l):
        carte = main2[k][1]
        for i in range(l):
            c = main2[i][1]
            if carte == c:
                liste[i] += 1
    return liste

def hauteur(main:list) -> int:
    main2 = list(main)
    liste_paires:list = listePaires(main2)
    liste_1:list = []
    for k in range(len(main2)):
        if liste_paires[k] == 1:
            liste_1.append(entier(main2[k][1]))
    try:
        return max(liste_1)
    except ValueError:
        return 0

def triMain(main:list) ->list:
    '''
    Trie les mains de façon à donner les cartes plus faibles d'abord
    '''

    main2 = list(main)
    chiffres:list = mainChiffre(main2)
    chiffres.sort()
    main_triee:list = []
    for c in chiffres:
        for carte in main2:
            index:int = main2.index(carte)
            if entier(carte[1]) == c:
                main_triee.append(carte)
                del main2[index]
    return main_triee

def estFlush(main:list) -> bool:
    """
    Renvoie True si on a une couleur
    """

    main2 = list(main)
    flush:bool = True
    compteur:int = 0
    while flush and (compteur < len(main2) - 1):
            flush = main2[compteur][0] == main2[compteur + 1][0]
            compteur += 1
    return flush

def estQuinte(main:list) -> bool:
    """
    Retourne True si la main est une suite
    """

    main2 = list(main)
    main2 = triMain(main2)
    compteur:int = 0
    quinte:bool = True
    while quinte and (compteur < len(main2) - 1):
            quinte = (entier(main2[compteur][1]) + 1) == (entier(main2[compteur + 1][1]))
            compteur += 1
    return quinte

def estQuinteFlush(main:list) -> bool:
    """
    """

    main2 = list(main)
    return estQuinte(main2) and estFlush(main2)

def estQuinteFlushRoyale(main):
    main2 = list(main)
    return estQuinteFlush(main2) and (hauteur(main2) == 14)

def estCarre(main):
    main2 = list(main)
    liste_paires = listePaires(main2)
    est_carre =  4 in liste_paires
    if est_carre:
        carre = entier(main2[liste_paires.index(4)][1])
    else:
        carre = 0
    return carre

def estBrelan(main):
    main2 = list(main)
    liste_paires = listePaires(main2)
    est_brelan = 3 in liste_paires
    if est_brelan:
        brelan = entier(main2[liste_paires.index(3)][1])
    else:
        brelan = 0
    return brelan

def estPaire(main:list):
    main2 = list(main)
    main_chiffre = mainChiffre(main2)
    l = len(main2)
    liste_paires = listePaires(main2)
    les_paires = []
    for k in range(l):
        if liste_paires[k] == 2:
            numero = main_chiffre[k]
            if numero not in les_paires:
                les_paires.append(numero)
    les_paires.sort()
    les_paires.reverse()
    return les_paires

def estFull(main):
    main2 = list(main)
    paires = estPaire(main2)
    brelan = estBrelan(main2)
    p = len(paires) == 1
    b = brelan > 0
    return p and b

def evalMain(main:list):
    main2 = list(main)
    h = hauteur(main2)
    liste_combi = [0,0,0]
    liste_combi.append(h)
    carre = estCarre(main2)
    brelan = estBrelan(main2)
    paires = estPaire(main2)
    if estQuinteFlushRoyale(main2):
        liste_combi[0] = 9
    elif estQuinteFlush(main2):
        liste_combi[0] = 8
    elif carre > 0:
        liste_combi[0] = 7
        liste_combi[1] = carre
    elif estFull(main2):
        liste_combi[0] = 6
        liste_combi[1] = estBrelan(main2)
        liste_combi[2] = estPaire(main2)[0]
    elif estFlush(main2):
        liste_combi[0] = 5
    elif estQuinte(main2):
        liste_combi[0] = 4
    elif brelan > 0:
        liste_combi[0] = 3
        liste_combi[1] = brelan
    elif len(paires) == 2:
        liste_combi[0] = 2
        liste_combi[1] = paires[0]
        liste_combi[2] = paires[1]
    elif len(paires) == 1:
        liste_combi[0] = 1
        liste_combi[1] = paires[0]
    return liste_combi

def comparMain(main1 , main2):
    score_1 = evalMain(list(main1))
    score_2 = evalMain(list(main2))
    compteur_main = 0
    gagnant = 0
    while gagnant == 0 and compteur_main < 4:
        if score_1[compteur_main] > score_2[compteur_main]:
            gagnant = 1
        elif score_1[compteur_main] < score_2[compteur_main]:
            gagnant = 2
        compteur_main += 1
    return gagnant
 

Ensuite il me restera une classe Joueur à faire pour rendre le jeu jouable, avec la possibilité de faire les actions de base du jeu comme checker , se coucher... , puis à ajouter une interface graphique au tout

Offline

#4 08-Jan-2020 00:46:57

Vader
Administrator
Registered: 05-Oct-2018
Posts: 220

Re: Poker

Ah, la passion fait pousser des ailes...

Pour copier une liste, comme évoqué en cours, il faut faire attention : Python copie des références, pas leurs liens.  Nous en avions parlé en classe. Nous avions évoqué aussi :


copie = original[:]
 

Les fonctions jusqu'à pioche me semblent trop compliquées. Pourquoi ne pas faire simplement :


vals = [str(k) for k in range(2,11)] + ['J', 'Q', 'K', 'A']  
jeu = [(valeur,couleur) for valeur in vals for couleur in symboles]
 

Ensuite, il faut essayer d'être plus générique dans les fonctions qui testent les combinaisons. Par exemple, une fonction hauteurs qui renvoie combien il y a de cartes par hauteur.

Par exemple, un carré renverra {1, 4} : 4 cartes de la même hauteur, 1 carte d'une autre hauteur.
Un full : {2, 3}. Il y a bien d'autres moyens.

Offline

#5 08-Jan-2020 21:54:36

Pacôme Giraudeau
Member
Registered: 12-Sep-2019
Posts: 67

Re: Poker

LBruneteau wrote:

J'ai corrigé de nombreux bugs, dont celui de la hauteur. Il suffisait de travailler sur une copie de la main avec copie = list(original). Ça empêche la liste originale d'être modifiée. J' ai également ajouté des fonctions pour évaluer les mains et les comparer entre elles. Il me reste à faire une fonction pour donner le nom de la main, à rendre le code plus compréhensible et agréable à lire et à analyser , et à créer le jeu, notamment avec une classe joueur et les actions de base du jeu, comme miser, checker ou se coucher. Code source ici, retrouvez-le aussi sur mon gitlab pour le télécharger par exemple


'''
Module poker
fonctions de base du jeu
'''

def chaine(chiffre:int) -> str:
    '''
    convertit un nombre en JQKA et en str.
    chaine(13)
    >>>'K'
    '''

    INT_TO_STR:dict = {11:'J' , 12:'Q' , 13:'K' , 14:'A'} #Dictionnaire contenant les corres entre les int et les str
    if chiffre > 10: #S'il faut mettre une lettre à la place du chiffre
        lettre:str = INT_TO_STR[chiffre] #On utilise le dictionnaire
    else: #Sinon
        lettre:str = str(chiffre) #On convertit simplement en chaîne de caractère
    return lettre #On retourne la lettre

def entier(lettre:str) -> int:
    '''
    convertit un nombre en str vers un entier. Permet d'obtenir 11 12 13 14 à partir de JQKA
    entier("J")
    >>>11
    '''

    STR_TO_INT:dict = {'J':11 , 'Q':12 , 'K':13 , 'A':14} #Dictionnaire str vers int pour les lettres
    if lettre.isnumeric(): #Si la lettre est un nombre
        chiffre:int = int(lettre) #On convertit en entier
    else: #Sinon -> Si c'est une lettre
        chiffre:int = STR_TO_INT[lettre] #On prend l'équivalent dans le dictionnaire
    return chiffre #On retourne le chiffre obtenu

def jeuCartes() -> list:
    '''
    Cree un jeu de 52 cartes
    chaque  carte est une liste [[symbole:str , nombre:str] , [symbole:str , nombre:str] ...]
    Aucun paramètre
    j = jeuCartes()
    print(j[0])
    >>>["♠","2"]
    '''

    symboles:list = ["♠","♥","♣","♦"] #Une liste des 4 symboles dans un jeu de cartes
    jeu:list = [] #Pour l'instant le jeu est une liste vide
    for s in symboles: #s prend les valeurs de chaque symbole
        for c in range (2 , 15): #c prend les valeurs de 2 à 14 -> les chiffres d'un jeu
            c:str = chaine(c) #on transforme le chiffre en chaîne de caractère avec la fonction
            jeu.append([s , c]) #On ajoute dans le jeu une liste avec un symbole et un chiffre
    return jeu #On retourne le jeu

def pioche(jeu:list , tirs:int):
    '''
    Met un nombre donne de carte d'un jeu donné dans une liste et retire les cartes du jeu
    Les cartes tirées sont aléatoires
    jeu , carte = pioche(jeuCartes() , 1)
    print(carte)
    >>>["♣" , "K"]
    '''

    from random import randint #On importe la fonction randint du module random
    carte_piochees:list = [] #Une liste qui contiendra les cartes qui seront piochées
    for t in range (tirs): #Répéter tirs fois
        numero_carte:int = randint(1,len(jeu)-1) #Donner un nombre aléatoire qui correspondra à un index de cartes
        carte:list = jeu[numero_carte] #Prendre la carte correspondante au numéro
        carte_piochees.append(carte) #Ajouter la carte aux cartes piochées
        del(jeu[numero_carte]) #Supprimer la carte du paquet
    return (jeu , carte_piochees) #Renvoyer le jeu et les cartes

def mainChiffre(main:list) ->list:
    '''
    renvoie uniquement les chiffres d'une main
    '''

    liste:list = []
    for i in list(main):
        c = entier(i[1])
        liste.append(c)
    return liste

def listePaires(main:list) -> list:
    liste = [0,0,0,0,0]
    l = len(main)
    main2 = list(main)
    for k in range(l):
        carte = main2[k][1]
        for i in range(l):
            c = main2[i][1]
            if carte == c:
                liste[i] += 1
    return liste

def hauteur(main:list) -> int:
    main2 = list(main)
    liste_paires:list = listePaires(main2)
    liste_1:list = []
    for k in range(len(main2)):
        if liste_paires[k] == 1:
            liste_1.append(entier(main2[k][1]))
    try:
        return max(liste_1)
    except ValueError:
        return 0

def triMain(main:list) ->list:
    '''
    Trie les mains de façon à donner les cartes plus faibles d'abord
    '''

    main2 = list(main)
    chiffres:list = mainChiffre(main2)
    chiffres.sort()
    main_triee:list = []
    for c in chiffres:
        for carte in main2:
            index:int = main2.index(carte)
            if entier(carte[1]) == c:
                main_triee.append(carte)
                del main2[index]
    return main_triee

def estFlush(main:list) -> bool:
    """
    Renvoie True si on a une couleur
    """

    main2 = list(main)
    flush:bool = True
    compteur:int = 0
    while flush and (compteur < len(main2) - 1):
            flush = main2[compteur][0] == main2[compteur + 1][0]
            compteur += 1
    return flush

def estQuinte(main:list) -> bool:
    """
    Retourne True si la main est une suite
    """

    main2 = list(main)
    main2 = triMain(main2)
    compteur:int = 0
    quinte:bool = True
    while quinte and (compteur < len(main2) - 1):
            quinte = (entier(main2[compteur][1]) + 1) == (entier(main2[compteur + 1][1]))
            compteur += 1
    return quinte

def estQuinteFlush(main:list) -> bool:
    """
    """

    main2 = list(main)
    return estQuinte(main2) and estFlush(main2)

def estQuinteFlushRoyale(main):
    main2 = list(main)
    return estQuinteFlush(main2) and (hauteur(main2) == 14)

def estCarre(main):
    main2 = list(main)
    liste_paires = listePaires(main2)
    est_carre =  4 in liste_paires
    if est_carre:
        carre = entier(main2[liste_paires.index(4)][1])
    else:
        carre = 0
    return carre

def estBrelan(main):
    main2 = list(main)
    liste_paires = listePaires(main2)
    est_brelan = 3 in liste_paires
    if est_brelan:
        brelan = entier(main2[liste_paires.index(3)][1])
    else:
        brelan = 0
    return brelan

def estPaire(main:list):
    main2 = list(main)
    main_chiffre = mainChiffre(main2)
    l = len(main2)
    liste_paires = listePaires(main2)
    les_paires = []
    for k in range(l):
        if liste_paires[k] == 2:
            numero = main_chiffre[k]
            if numero not in les_paires:
                les_paires.append(numero)
    les_paires.sort()
    les_paires.reverse()
    return les_paires

def estFull(main):
    main2 = list(main)
    paires = estPaire(main2)
    brelan = estBrelan(main2)
    p = len(paires) == 1
    b = brelan > 0
    return p and b

def evalMain(main:list):
    main2 = list(main)
    h = hauteur(main2)
    liste_combi = [0,0,0]
    liste_combi.append(h)
    carre = estCarre(main2)
    brelan = estBrelan(main2)
    paires = estPaire(main2)
    if estQuinteFlushRoyale(main2):
        liste_combi[0] = 9
    elif estQuinteFlush(main2):
        liste_combi[0] = 8
    elif carre > 0:
        liste_combi[0] = 7
        liste_combi[1] = carre
    elif estFull(main2):
        liste_combi[0] = 6
        liste_combi[1] = estBrelan(main2)
        liste_combi[2] = estPaire(main2)[0]
    elif estFlush(main2):
        liste_combi[0] = 5
    elif estQuinte(main2):
        liste_combi[0] = 4
    elif brelan > 0:
        liste_combi[0] = 3
        liste_combi[1] = brelan
    elif len(paires) == 2:
        liste_combi[0] = 2
        liste_combi[1] = paires[0]
        liste_combi[2] = paires[1]
    elif len(paires) == 1:
        liste_combi[0] = 1
        liste_combi[1] = paires[0]
    return liste_combi

def comparMain(main1 , main2):
    score_1 = evalMain(list(main1))
    score_2 = evalMain(list(main2))
    compteur_main = 0
    gagnant = 0
    while gagnant == 0 and compteur_main < 4:
        if score_1[compteur_main] > score_2[compteur_main]:
            gagnant = 1
        elif score_1[compteur_main] < score_2[compteur_main]:
            gagnant = 2
        compteur_main += 1
    return gagnant
 

Last edited by Pacôme Giraudeau (08-Jan-2020 21:55:02)

Offline

#6 17-Feb-2020 18:50:18

LBruneteau
Member
From: Rezé
Registered: 12-Sep-2019
Posts: 33
Website

Re: Poker

Bonjour tout le monde,
Ça y est j'ai fini mon projet. J'ai enfin un Texas Hold'em jouable en python
Il existe deux versions, une avec easygui et une textuelle.
Le projet est sur mon gitlab https://gitlab.com/LBruneteau/texas-hold-em-python/
Le code source dégoûtant, et utilise mal certaines notions, mais l'essentiel est qu'il fonctionne
Je vais essayer de rajouter du son, j'ai déjà une fonction pour ça
À bientôt, et restez ubuntu !

Offline

#7 17-Feb-2020 19:08:12

LBruneteau
Member
From: Rezé
Registered: 12-Sep-2019
Posts: 33
Website

Re: Poker

je n'arrive pas à mettre mes images en ligne sur gitlab. Quand je clique sur click to upload je ne suis pas invité à entrer le chemin vers mon fichier et le glisser déposer ne marche pas. Ça n'a pas une grosse influence sur le projet, seulement le guide de l'application dans la version graphique n'affiche pas les images. Je réessaierai demain

Offline

#8 18-Feb-2020 15:59:56

Vader
Administrator
Registered: 05-Oct-2018
Posts: 220

Re: Poker

Il y a un petit onglet à cliquer avec un gros + et ensuite il y a "téléverser un fichier"

Offline

#9 18-Feb-2020 16:02:51

LBruneteau
Member
From: Rezé
Registered: 12-Sep-2019
Posts: 33
Website

Re: Poker

c'est ce que j'ai essayé justement

Offline

Board footer

Powered by FluxBB