Domanda POKER HOLD'EM IN PYTHON

Stato
Discussione chiusa ad ulteriori risposte.

danielescoti

Utente Bronze
8 Aprile 2016
26
10
0
38
visto che l'altro giorno a lezione mi stavo annoiando ho deciso di creare un programmino per giocare a poker in 2,3 su terminale.
è rudimentale e esteticamente brutto, manca ancora tanto, però ci sto lavorando.
se qualcuno ha qualche idea e\o soluzione ai problemi me lo faccia sapere!

grazie in anticipo

Python:
#poker da migliorare
#devo trovare delle librerie per il poker
#ancora da implementare chips call raise all-in e tutto quello che riguarda le puntate
#devo mettere i semi alle carte al posto delle lettere

import random, time

#mazzo

global mazzo

mazzo = ['AP', '2P', '3P', '4P', '5P', '6P', '7P', '8P','9P', '10P', 'JP', 'QP', 'KP',
'AF', '2F', '3F', '4F', '5F', '6F', '7F', '8F','9F', '10F', 'JF', 'QF', 'KF',
'AC', '2C', '3C', '4C', '5C', '6C', '7C', '8C','9C', '10C', 'JC', 'QC', 'KC',
'AQ', '2Q', '3Q', '4Q', '5Q', '6Q', '7Q', '8Q','9Q', '10Q', 'JQ', 'QQ', 'KQ']

#i caratteri dei semi non funzionano in ascii come posso fare?

#creazione dei giocatori

def creazioneGiocatori():
    global numeroGiocatori
    numeroGiocatori = int(input('Numero Giocatori'))
    global listaGiocatori
    listaGiocatori = []
    for i in range(numeroGiocatori):
        listaGiocatori.append(str('Giocatore_'+str(i+1)))
    print(listaGiocatori)

#distribuzione mani iniziali

def distribuzioneCarte():
    global manoGiocatore
    manoGiocatore = []
    global listaMani
    listaMani = []
    for giocatore in listaGiocatori:
        manoGiocatore = [giocatore]
        for i in range(2):
            carta = random.choice(mazzo)
            manoGiocatore.append(carta)
            mazzo.remove(carta)
        print(manoGiocatore)
        listaMani.append(manoGiocatore)
        checkMano = int(input('Hai guardato bene la tua mano? 1/0?'))
        while True:
            if checkMano == 1:
                #print(('\n'*50))
                #print('.next.')
                #time.sleep(4)
                #print(('\n'*50))
                break
            else:
                time.sleep(1)
                checkMano = int(input('Hai guardato bene la tua mano? 1/0?'))

def fold():
    for giocatore in listaGiocatori:
        if giocatore != 'placeHolder':
            foldCheck = int(input(str(giocatore + ' Vuoi foldare la mano? 1/0?')))
            if foldCheck == 1 and giocatore != 'placeHolder':
                del listaMani[listaGiocatori.index(giocatore)]
                listaGiocatori.insert(listaGiocatori.index(giocatore), 'placeHolder')
                listaMani.insert(listaGiocatori.index(giocatore)-1, 'placeHolder')
                del listaGiocatori[listaGiocatori.index(giocatore)]

        #funziona ora devo rimuovere i placeHolder per lo showdown

def flop():
    global flopCheck
    flopCheck = int(input('FLOP? 1/0?'))
    if flopCheck == 1:
        global flop
        flop = []
        mazzo.remove(random.choice(mazzo))
        for i in range(3):
            CartaFlop = random.choice(mazzo)
            flop.append(CartaFlop)
            mazzo.remove(CartaFlop)
        print(flop)
    else:
        print('mano terminata')
        return 0

def turn():
    global turnCheck
    turnCheck = int(input('TURN? 1/0?'))
    if turnCheck == 1:
        global turn
        turn = []
        mazzo.remove(random.choice(mazzo))
        cartaTurn = random.choice(mazzo)
        turn.append(cartaTurn)
        mazzo.remove(cartaTurn)
        print(flop, turn)
    else:
        print('mano terminata')
        return 0

def river():
    global riverCheck
    riverCheck = int(input('RIVER? 1/0?'))
    if riverCheck == 1:
        global river
        river = []
        mazzo.remove(random.choice(mazzo))
        cartaRiver = random.choice(mazzo)
        river.append(cartaRiver)
        mazzo.remove(cartaRiver)
        print(flop, turn, river)
    else:
        print('mano terminata')
        return 0

def showdown():
    showDownCheck = int(input('SHOWDOWN? 0/1'))


    if showDownCheck == 1:
        for mano in listaMani:
            if mano == 'placeHolder':
                listaMani.remove(mano)
        for mano in listaMani:
            print(mano)
    else:
        print('mano terminata')
        return 0


creazioneGiocatori()
distribuzioneCarte()
fold()
flop()
fold()


if flopCheck == 1:
    turn()
    fold()
    if turnCheck == 1:
        river()
        fold()
        if riverCheck == 1:
            showdown()
 
Al posto di dichiarare globalmente la variabile "mazzo" e implementrlo come array semplice, forse sarebbe meglio fare una cosa del genere
Codice:
mazzo = [['AP', '2P', '3P', '4P', '5P', '6P', '7P', '8P','9P', '10P', 'JP', 'QP', 'KP'],
                ['AF', '2F', '3F', '4F', '5F', '6F', '7F', '8F','9F', '10F', 'JF', 'QF', 'KF'],
                ['AC', '2C', '3C', '4C', '5C', '6C', '7C', '8C','9C', '10C', 'JC', 'QC', 'KC'],
                ['AQ', '2Q', '3Q', '4Q', '5Q', '6Q', '7Q', '8Q','9Q', '10Q', 'JQ', 'QQ', 'KQ']]
In questo modo puoi gestirtelo meglio come matrice ( o array bidimensionale )

Ho notato che metti "global" a tutte le altre variabili, questo è un qualcosa che non si fa.
Dovresti definire le variabili che vengono utilizzate in più punti fuori dalle funzioni e poi utilizzarle come parametri durante la chiamata
 
Al posto di dichiarare globalmente la variabile "mazzo" e implementrlo come array semplice, forse sarebbe meglio fare una cosa del genere
Codice:
mazzo = [['AP', '2P', '3P', '4P', '5P', '6P', '7P', '8P','9P', '10P', 'JP', 'QP', 'KP'],
                ['AF', '2F', '3F', '4F', '5F', '6F', '7F', '8F','9F', '10F', 'JF', 'QF', 'KF'],
                ['AC', '2C', '3C', '4C', '5C', '6C', '7C', '8C','9C', '10C', 'JC', 'QC', 'KC'],
                ['AQ', '2Q', '3Q', '4Q', '5Q', '6Q', '7Q', '8Q','9Q', '10Q', 'JQ', 'QQ', 'KQ']]
In questo modo puoi gestirtelo meglio come matrice ( o array bidimensionale )

Ho notato che metti "global" a tutte le altre variabili, questo è un qualcosa che non si fa.
Dovresti definire le variabili che vengono utilizzate in più punti fuori dalle funzioni e poi utilizzarle come parametri durante la chiamata

grazie mille!!! adesso lo faccio

usando la matrice bidimensionale come faccio poi a prendere una carta a random?
scusa ma sono proprio alle basi
 
anzicchè utilizzare un indice per scorrere gli elementi, ne usi due.
puoi fare qualcosa del tipo
Codice:
mazzo[seme][carta]
per accedere al singolo elemento. Così non c'è nemmeno bisogno di specificare il seme visto che ogni singolo array potrebbe rappresentarne uno e i 13 elementi sono le carte. Ci sono tanti modi per farlo, l'importante è che ne comprendi il funzionamento e che ti fai venire in mente l'idea di volerlo migliorare ( fino a un certo punto ovviamente xD )
 
Io userei una lista di tuple per rappresentare il mazzo, in questo modo potresti fare dei controlli anche relativamente elaborati con poco sforzo. Ad esempio in questo codice creo un un nuovo mazzo e controllo quante carte ho uguali a seconda del valore, del seme o del colore.
Python:
import random

black, red = ['picche', 'fiori'], ['cuori', 'quadri']
seeds = black + red
numbers, figures = [ '2', '3', '4', '5', '6', '7', '8', '9', '10' ], [ 'jack', 'queen', 'king', 'ace' ]
values = numbers + figures
deck = [ (v,s) for s in seeds for v in values ]

compare = { 'value' : lambda a,b: a[0] == b[0],
            'seed' : lambda a,b: a[1] == b[1],
            'color': lambda a,b: (a[1] in black and b[1] in black) or (a[1] in red and b[1] in red) }

def maximum(cards, compare):
    return max(sum(compare(x, y) for x in cards) for y in cards)

if __name__ == '__main__':
    random.shuffle(deck)
    hand = [ deck.pop() for i in range(5) ]
    print('your hand is: {}'.format(hand))
    print('{} cards equals by value'.format(maximum(hand, compare['value'])))
    print('{} cards equals by seeds'.format(maximum(hand, compare['seed'])))
    print('{} cards equals by colors'.format(maximum(hand, compare['color'])))

Questo ti permette di controllare se hai fatto coppia, tris, poker, colore o cose di questo tipo. Con altrettanta facilità puoi aggiungere i controlli per vedere se hai fatto scala, dopodiché combini le due cose e diventa semplice capire chi è il vincitore della mano.
 
  • Mi piace
Reazioni: Kolo93
non hai usato la programmazione ad oggetti?
il codice sarebbe più pulito e semplice
Usare gli oggetti per una cosa così semplice? Si potrebbe fare ma non so quanto possa convenire... alla fine non cambia niente.
Usi gli oggetti se hai parecchie entità o comunque un progetto che si possa definire tale, qui si lavora su singola istanza e non viene nemmeno definita una vera e propria partita. Si vede solo il punteggio che si ha.
 
non ho mai usato oggetti.
qualcuno ha qualche idea su come implementare il sistema di puntate?
E' da cambiare la logica del programma, adesso assegna le carte ai giocatori e calcola i punteggi ( mettendo direttamente le 5 sul tavolo )
Il codice attuale lo puoi riutilizzare per la distribuzione delle carte, per partire, e come conteggio punti, per finire.
Ti conviene usare due funzioni che facciano questa cosa e poi procedere man mano scrivendo il resto

Non c'è bisogno di fare tutto super compatto come fa steve, si sta imparando.
A tal proposito suggerirei di usare del codice leggibile @St3ve
 
Se sei agli inizi non è semplice sviluppare un gioco, anche se è completamente testuale, senza AI e dove tutti i giocatori sono sullo stesso pc. Secondo me ti conviene puntare a progetti un po' meno articolati finché non ti fai un po' più di esperienza, mettere insieme tanti elementi diversi (gestione dei soldi e delle puntate, scelta delle carte da tenere/cambiare, vincite, ecc...) non è così semplice come sembra, è qualcosa che si impara col tempo.
Una volta che ti sarai fatto le ossa e avrai imparato almeno a grandi linee le features principali di python (eg. quoto TheButter, la programmazione ad oggetti ti sarebbe utile per questo progetto) potremo discutere su quale sia il modo più conveniente per svolgere questo progetto.
Poi boh... magari ho solo overstimato le cose che avevi intenzione di fare, magari quello che hai intenzione di fare è abbordabilissimo per le tue competenze, valuta tu.


Non c'è bisogno di fare tutto super compatto come fa steve, si sta imparando.
A tal proposito suggerirei di usare del codice leggibile @St3ve
Python ha il vantaggio di mettere a disposizione del programmatore delle featuers complesse in modo banale, ad esempio la struttura dati dizionario è parte del linguaggio e la si può creare usando tre simboli (duepunti e le graffe). Ha i suoi pro e i suoi contro, ma in altri linguaggi questa cosa te la sogni. La alta espressività (fare tanto scrivendo poco) è probabilmente la caratteristica principale di python e, se usata in modo corretto, porta a scrivere un codice meno bug-prone e più manutenibile.

Non c'è assolutamente bisogno di fare tutto compatto, a maggior ragione se si sta imparando, ma questa compattezza fa parte del linguaggio, è per questo che cerco di esaltarla. Programmare in python ragionando in C è qualcosa che può andar bene se si sta imparando a programmare, ma chi ha un po' più di esperienza dovrebbe provare a cercare delle soluzioni nella pythonian way, è per questo che il più delle volte mi vedi proporre delle soluzioni che sfruttano qualche concetto un po' più avanzato. E poi vabbé, anche io sto ancora imparando questo linguaggio... se nell'aiutare qualcuno trovo il modo di far pratica, tanto meglio. Se poi qualcuno le considera soluzioni illeggibili, se mi viene richiesto, posso spiegare cosa ho fatto e si può discutere su quali vantaggi e svantaggi porta rispetto alle altre soluzioni proposte dagli altri utenti (ammesso che ce ne siano).
 
  • Mi piace
Reazioni: Kolo93
Python ha il vantaggio di mettere a disposizione del programmatore delle featuers complesse in modo banale, ad esempio la struttura dati dizionario è parte del linguaggio e la si può creare usando tre simboli (duepunti e le graffe). Ha i suoi pro e i suoi contro, ma in altri linguaggi questa cosa te la sogni. La alta espressività (fare tanto scrivendo poco) è probabilmente la caratteristica principale di python e, se usata in modo corretto, porta a scrivere un codice meno bug-prone e più manutenibile.

Non c'è assolutamente bisogno di fare tutto compatto, a maggior ragione se si sta imparando, ma questa compattezza fa parte del linguaggio, è per questo che cerco di esaltarla. Programmare in python ragionando in C è qualcosa che può andar bene se si sta imparando a programmare, ma chi ha un po' più di esperienza dovrebbe provare a cercare delle soluzioni nella pythonian way, è per questo che il più delle volte mi vedi proporre delle soluzioni che sfruttano qualche concetto un po' più avanzato. E poi vabbé, anche io sto ancora imparando questo linguaggio... se nell'aiutare qualcuno trovo il modo di far pratica, tanto meglio. Se poi qualcuno le considera soluzioni illeggibili, se mi viene richiesto, posso spiegare cosa ho fatto e si può discutere su quali vantaggi e svantaggi porta rispetto alle altre soluzioni proposte dagli altri utenti (ammesso che ce ne siano).

Bella risposta, non avevo considerato questo aspetto del linguaggio. Poi mi hai fatto anche riflettere sul fatto che proponi soluzioni più impegnative ed in effetti credo che non sia il massimo all'inizio, ma comunque bisogna spronarsi fin dall'inizio perchè ogni linguaggio va compreso, non capito.
 
Stato
Discussione chiusa ad ulteriori risposte.