this is my logo :)

CuSO's Place

My ideas and something else




Scopa?

- in python ovviamente -

18/09/2022

10min

coding




Intro

Eccomi tornato con un nuovo progetto di coding!
Ma che sbadato, mi ero dimenticato il canonico "buonsalve", lo volevate? Ora è qui :)
Non so se lo avete notato, ma ora il sito è animato! Tutto molto carino, animazioni lente che accompagnano la lettura, sono fiero del risultato :))
Parlando però del tema del giorno (non la morte della regina d'Inghilterra) fremo dalla voglia di raccontarvi di come ho costruito il codice per questa partita a scopa in python.


info generali

Allora, premetto anche che codesta non sarà la versione finale dello script, infatti tramite la programmazione object-oriented riuscirò a scremarlo e renderlo sia più leggibile che leggero.
Ma allora perchè non ho utilizzato subito questo tipo di programmazione?
Sarò onesto: NON SONO CAPACE
O meglio, non credo di esserlo... Conosco le basi ma non sono certo di riuscire a costruire un progetto del genere, quindi mi sono complicato la vita :)
Dai, prima o poi escono sia "crucisberla V2" che "Scopa V2 | Obj. Oriented"


Disclaimer

Vi ricordo che potete scaricare il codice sorgente dal mio profilo github


guardiamo il codice

Allora, partiamo? Che qua poi escono articoli da 234min e nessuno me li legge :/

                    
import os
import random
import sys
import time
                    
                 

Qui ho semplicemente importato delle librerie, ma tranquilli, sono più di 500 linee di codice. Ci sarà da divertirsi.


Variabili globali

Qui sotto le variabili globali di cui il programma ha bisogno:

                    
mazzo=[
            "1♥", "1♦", "1♣", "1♠",
            "2♥", "2♦", "2♣", "2♠",
            "3♥", "3♦", "3♣", "3♠",
            "4♥", "4♦", "4♣", "4♠",
            "5♥", "5♦", "5♣", "5♠",
            "6♥", "6♦", "6♣", "6♠",
            "7♥", "7♦", "7♣", "7♠",
            "J♥", "J♦", "J♣", "J♠",
            "Q♥", "Q♦", "Q♣", "Q♠",
            "K♥", "K♦", "K♣", "K♠"
            ]
        

mazzo_reset=[
            "1♥", "1♦", "1♣", "1♠",
            "2♥", "2♦", "2♣", "2♠",
            "3♥", "3♦", "3♣", "3♠",
            "4♥", "4♦", "4♣", "4♠",
            "5♥", "5♦", "5♣", "5♠",
            "6♥", "6♦", "6♣", "6♠",
            "7♥", "7♦", "7♣", "7♠",
            "J♥", "J♦", "J♣", "J♠",
            "Q♥", "Q♦", "Q♣", "Q♠",
            "K♥", "K♦", "K♣", "K♠"
            ]
        

carte_valori={
                "1"     :   1,
                "2"     :   2,
                "3"     :   3,
                "4"     :   4,
                "5"     :   5,
                "6"     :   6,
                "7"     :   7,
                "J"      :   8,
                "Q"    :    9,
                "K"     :    10
}

tavolo, manoplayerone,  manoplayertwo , mazzettoplayerone, mazzettoplayertwo   = []  ,  []  ,  []  ,  []  ,  []

player=1

scopeplayerone,scopeplayertwo=0,0

lastpickup=0

ultimamano=false

nomegiocatore1,nomegiocatore2="",""

finepartita=0
                    
                

Le variabili sono abbastanza autoesplicative, sono chiamate con i nomi più leggibili possibile ahaha.
Dai, iniziamo a parlare delle funzioni, così entriamo ne vivo el programma


loading()

Come sempre, mi piace dare un tocco di "veridicità" ai miei script, quindi perchè non aggiungere un loading screen di presentazione?

                    
def loading():
    for i in range(6):
        os.system('cls' if os.name == 'nt' else 'clear')
        print("\n")
        print("caricamento")
        print("° "*(i+1))
        time.sleep(0.5)
    
    time.sleep(1)
    
    os.system('cls' if os.name == 'nt' else 'clear')
    
    print("\n\n")
    print("  ______   ______   ______  _______   ______  \n /      \ /      \ /      \|       \ /      \ \n|  ▓▓▓▓▓▓\  ▓▓▓▓▓▓\  ▓▓▓▓▓▓\ ▓▓▓▓▓▓▓\  ▓▓▓▓▓▓\ \n| ▓▓___\▓▓ ▓▓   \▓▓ ▓▓  | ▓▓ ▓▓__/ ▓▓ ▓▓__| ▓▓\n \▓▓    \| ▓▓     | ▓▓  | ▓▓ ▓▓    ▓▓ ▓▓    ▓▓\n _\▓▓▓▓▓▓\ ▓▓   __| ▓▓  | ▓▓ ▓▓▓▓▓▓▓| ▓▓▓▓▓▓▓▓\n|  \__| ▓▓ ▓▓__/  \ ▓▓__/ ▓▓ ▓▓     | ▓▓  | ▓▓\n \▓▓    ▓▓\▓▓    ▓▓\▓▓    ▓▓ ▓▓     | ▓▓  | ▓▓\n  \▓▓▓▓▓▓  \▓▓▓▓▓▓  \▓▓▓▓▓▓ \▓▓      \▓▓   \▓▓")
    print("-------------------")
    print("╔═══╗    ╔═══╗╔═══╗\n║╔═╗║    ║╔═╗║║╔═╗║\n║║ ╚╝╔╗╔╗║╚══╗║║ ║║\n║║ ╔╗║║║║╚══╗║║║ ║║\n║╚═╝║║╚╝║║╚═╝║║╚═╝║\n╚═══╝╚══╝╚═══╝╚═══╝")
    print("-------------------")
    time.sleep(2.4)

    os.system('cls' if os.name == 'nt' else 'clear')
                    
                

reset()

Poichè il gioco di carte "scopa" è basato su un molteplice numero di partite, mi serviva una funzione per sistemare tutto in vitsta della partita successiva. Letteralmente ripulisce i mazzetti dei giocatori, riforma il mazzo e da in output un messaggio di conferma


                    
def reset():
    os.system('cls' if os.name == 'nt' else 'clear')
    mazzo=mazzo_reset
    tavolo, manoplayerone,  manoplayertwo , mazzettoplayerone, mazzettoplayertwo   = []  ,  []  ,  []  ,  []  ,  []
    scopeplayerone,scopeplayertwo=0,0
    lastpickup=0
    ultimamano=false
    print(f"eseguo il reset: \nmazzo={mazzo};\ntavolo={tavolo}; \nmanoplayerone={manoplayerone};\nmanoplayertwo={manoplayertwo}\nmazzettoplayerone={mazzettoplayerone};\nmazzettoplayertwo={mazzettoplayertwo};\nscopeplayerone={scopeplayerone};\nscopeplayertwo={scopeplayertwo};\nlastpickup={lastpickup};\nultimamano={ultimamano}")
    time.sleep(1.5)
    os.system('cls' if os.name == 'nt' else 'clear')                        
                    
                

askBeforeStart()

Altra piccola chicca che mi piace sempre aggiungere: un tocco di ux semplice ma efficace, serve solo a rendere "personali" le partite; potevo semplicemente chiamare g1 e g2 i due concorrenti, ma chiedergli i rispettivi nomi semrava più cortese.

                    
def askbeforestart(nomegiocatore1,nomegiocatore2,finepartita):
    while nomegiocatore1=="":
        nomegiocatore1=input("giocatore1, come ti chiami?\n")
    while nomegiocatore2=="":
        nomegiocatore2=input("giocatore2, come ti chiami?\n")
    while finepartita==0:
        finepartita=int(input("a quanti punti volete che la partita finisca? (solitamente si gioca a 11 o 21 punti)\n"))
    print(f"ottimo, benvenuti {nomegiocatore1} e {nomegiocatore2}, che vinca il migliore")      
                    
                

tableView()

Questa funzione serve a visualizzare ogni turno il tavolo con al suo interno le carte in gioco.

                    
def tableview():
    os.system('cls' if os.name == 'nt' else 'clear')
    print(f"carte nel mazzo: {len(mazzo)}")
    print("******"*len(tavolo),end="\n")
    print()
    print(" ---- "*len(tavolo))
    for ele in tavolo:
        print("|",end=" ")
        print(ele,end=" |")      
    print()
    print(" ---- "*len(tavolo))
    print()
    print("******"*len(tavolo))
    print()
    print("la tua mano:")
                
            

shuffle()

Letteralmente mischia il mazzo, non saprei che altro aggiungere.


def shuffle():
    random.shuffle(mazzo)
                

start() e distro()

start() serve ad avviare il gioco, richiama shuffle() e distro(), la quale serve per "distribuire" le carte ai giocatori, infine, dispone 4 carte sul tavolo.

                    
def start():
    shuffle()
    distro()
    for _ in range(4):
        tavolo.append(mazzo[0])
        del mazzo[0]
    drop(player)
                    
                        
def distro():
    for i in range (3):
        manoPlayerOne.append(mazzo[0])
        del mazzo[0]
        manoPlayerTwo.append(mazzo[0])
        del mazzo[0]
                    
                

checkPickUp()

Quetsa funzione è essenziale per lo sviluppo del gioco, infatti serve per controllare in serie le possibilità di cattura: inizia con "carta a carta", per poi passare alle somme, prima a d, poi a tre ed infine a 4 carte.
Un tratto interessante è che ho dovuto utilizzare un dizionario per inserire il valore e rendere leggibili le carte, quel dizionario "carte_valori" serve appunto per definire il valore alle figure, che sono state chiamate rispettivamente "J", "Q" e "K"; tutto per rendere più fruibile la lettura delle carte durante la partita

                    
def checkPickUp(player,carta):
    if len(tavolo)>=1:
        for j in range(len(tavolo)):
            cartaDaControllare=tavolo[j]
            val_cartaDaControllare=carte_valori[cartaDaControllare[0]]
            val_cartaGiocatore=carte_valori[carta[0]]
            if val_cartaGiocatore==val_cartaDaControllare:
                if player==1:
                    print(f"il giocatore {player} ha preso {cartaDaControllare} con {carta}")
                    mazzettoPlayerOne.append(carta)
                    mazzettoPlayerOne.append(cartaDaControllare)
                    tavolo.remove(cartaDaControllare)
                    lastPickup=1
                    turnSwap(player,carta,ultimamano,scopePlayerOne,scopePlayerTwo)
                else:
                    print(f"il giocatore {player} ha preso {cartaDaControllare} con {carta}")
                    mazzettoPlayerTwo.append(carta)
                    mazzettoPlayerTwo.append(cartaDaControllare)
                    tavolo.remove(cartaDaControllare)
                    lastPickup=2
                    turnSwap(player,carta,ultimamano,scopePlayerOne,scopePlayerTwo)
#------------------------
    if len(tavolo)>=2:
        for j in range(len(tavolo)-1):
            cartaDaControllare=tavolo[j]
            val_cartaDaControllare=carte_valori[cartaDaControllare[0]]
            val_cartaGiocatore=carte_valori[carta[0]]
            for t in range(j+1, len(tavolo)):
                cartaDaControllare2=tavolo[t]
                val_cartaDaControllare2=carte_valori[cartaDaControllare2[0]]
            if val_cartaGiocatore==(val_cartaDaControllare+val_cartaDaControllare2):
                    if player==1:
                        print(f"il giocatore {player} ha preso {cartaDaControllare} e {cartaDaControllare2} con {carta}")
                        mazzettoPlayerOne.append(carta)
                        mazzettoPlayerOne.append(cartaDaControllare)
                        mazzettoPlayerOne.append(cartaDaControllare2)                           
                        tavolo.remove(cartaDaControllare)
                        tavolo.remove(cartaDaControllare2)
                        lastPickup=1
                        turnSwap(player,carta,ultimamano,scopePlayerOne,scopePlayerTwo)
                    else:
                        print(f"il giocatore {player} ha preso {cartaDaControllare} e {cartaDaControllare2} con {carta}")
                        mazzettoPlayerTwo.append(carta)
                        mazzettoPlayerTwo.append(cartaDaControllare)
                        mazzettoPlayerTwo.append(cartaDaControllare2)                           
                        tavolo.remove(cartaDaControllare)
                        tavolo.remove(cartaDaControllare2)
                        lastPickup=2
                        turnSwap(player,carta,ultimamano,scopePlayerOne,scopePlayerTwo)
#-----------------------    
    if len(tavolo)>=3:
        for j in range(len(tavolo)-2):
            cartaDaControllare=tavolo[j]
            val_cartaDaControllare=carte_valori[cartaDaControllare[0]]
            val_cartaGiocatore=carte_valori[carta[0]]
            for t in range(j+1, len(tavolo)-1):
                cartaDaControllare2=tavolo[t]
                val_cartaDaControllare2=carte_valori[cartaDaControllare2[0]]
                for i in range (t+1, len(tavolo)):
                    cartaDaControllare3=tavolo[i]
                    val_cartaDaControllare3=carte_valori[cartaDaControllare3[0]]
                if val_cartaGiocatore==(val_cartaDaControllare+val_cartaDaControllare2+val_cartaDaControllare3):
                        if player==1:
                            print(f"il giocatore {player} ha preso {cartaDaControllare} e {cartaDaControllare2} e {cartaDaControllare3} con {carta}")
                            mazzettoPlayerOne.append(carta)
                            mazzettoPlayerOne.append(cartaDaControllare)
                            mazzettoPlayerOne.append(cartaDaControllare2)    
                            mazzettoPlayerOne.append(cartaDaControllare3)                         
                            tavolo.remove(cartaDaControllare)
                            tavolo.remove(cartaDaControllare2)
                            tavolo.remove(cartaDaControllare3)
                            lastPickup=1
                            turnSwap(player,carta,ultimamano,scopePlayerOne,scopePlayerTwo)
                        else:
                            print(f"il giocatore {player} ha preso {cartaDaControllare} e {cartaDaControllare2} e {cartaDaControllare3} con {carta}")
                            mazzettoPlayerTwo.append(carta)
                            mazzettoPlayerTwo.append(cartaDaControllare)
                            mazzettoPlayerTwo.append(cartaDaControllare2)                           
                            mazzettoPlayerTwo.append(cartaDaControllare3)                           
                            tavolo.remove(cartaDaControllare)
                            tavolo.remove(cartaDaControllare2)
                            tavolo.remove(cartaDaControllare3)
                            lastPickup=2
                            turnSwap(player,carta,ultimamano,scopePlayerOne,scopePlayerTwo)
#-----------------------   
    if len(tavolo)>=4:
        for j in range(len(tavolo)-3):
            cartaDaControllare=tavolo[j]
            val_cartaDaControllare=carte_valori[cartaDaControllare[0]]
            val_cartaGiocatore=carte_valori[carta[0]]
            for t in range(j+1, len(tavolo)-2):
                cartaDaControllare2=tavolo[t]
                val_cartaDaControllare2=carte_valori[cartaDaControllare2[0]]
                for i in range (t+1, len(tavolo)-1):
                    cartaDaControllare3=tavolo[i]
                    val_cartaDaControllare3=carte_valori[cartaDaControllare3[0]]
                    for w in range(i+1, len(tavolo)):
                        cartaDaControllare4=tavolo[w]
                        val_cartaDaControllare4=carte_valori[cartaDaControllare4[0]]
                        if val_cartaGiocatore==(val_cartaDaControllare+val_cartaDaControllare2+val_cartaDaControllare3+val_cartaDaControllare4):
                                if player==1:
                                    print(f"il giocatore {player} ha preso {cartaDaControllare} e {cartaDaControllare2} e {cartaDaControllare3} e {cartaDaControllare4} con {carta}")
                                    mazzettoPlayerOne.append(carta)
                                    mazzettoPlayerOne.append(cartaDaControllare)
                                    mazzettoPlayerOne.append(cartaDaControllare2)    
                                    mazzettoPlayerOne.append(cartaDaControllare3)                         
                                    mazzettoPlayerOne.append(cartaDaControllare4)                         
                                    tavolo.remove(cartaDaControllare)
                                    tavolo.remove(cartaDaControllare2)
                                    tavolo.remove(cartaDaControllare3)
                                    tavolo.remove(cartaDaControllare4)
                                    lastPickup=1
                                    turnSwap(player,carta,ultimamano,scopePlayerOne,scopePlayerTwo)
                                else:
                                    print(f"il giocatore {player} ha preso {cartaDaControllare} e {cartaDaControllare2} e {cartaDaControllare3} e {cartaDaControllare4} con {carta}")
                                    mazzettoPlayerTwo.append(carta)
                                    mazzettoPlayerTwo.append(cartaDaControllare)
                                    mazzettoPlayerTwo.append(cartaDaControllare2)                           
                                    mazzettoPlayerTwo.append(cartaDaControllare3)                           
                                    mazzettoPlayerTwo.append(cartaDaControllare4)                           
                                    tavolo.remove(cartaDaControllare)
                                    tavolo.remove(cartaDaControllare2)
                                    tavolo.remove(cartaDaControllare3)
                                    tavolo.remove(cartaDaControllare4)
                                    lastPickup=2
                                    turnSwap(player,carta,ultimamano,scopePlayerOne,scopePlayerTwo)
    tavolo.append(carta)
    turnSwap(player,carta,ultimamano,scopePlayerOne,scopePlayerTwo)
                    
                

lastChance()

Avete presente quando voi arrivate all'ultima mano e dovete "prendere tutte le carte rimaste"? Bene, questa funzione serve solo per quello, controlla chi sia stato l'ultimo a prendere e trasferisce le carte restanti nel suo mazzo.

                    
def lastChance(tavolo):
    if lastPickup==1:
        for ele in tavolo:
            mazzettoPlayerOne.append(ele)
        print(f"essendo l'ultima mano, il giocatore 1 prende {tavolo}")
        tavolo=[]
    else:
        for ele in tavolo:
            mazzettoPlayerTwo.append(ele)
        print(f"essendo l'ultima mano, il giocatore 2 prende {tavolo}")
        tavolo=[]
    scoreCheck()
                    
                

turnSwap()

Fosse così semplice "passare il turno" all'altro giocatore non avrei creato questa funzione... In realtà non è nulla di speciale, semplicemente mette un indicatore per definire a chi tocca, e permette al resto del programma di decidere quali mani visualizzare e a chi assegnare le carte prese durante quel turno.
Piccolo dettaglio che forse non avrete notato: questa funzione richiama anche "scoreCheck()", la funzione per il conteggio finale dei punti... Ma di lei parleremo più tardi.

                    
def turnSwap(player, carta, ultimamano,scopePlayerOne,scopePlayerTwo):
    if len(mazzo)==0 and len(manoPlayerOne)==0:
        ultimamano=True
    if len(tavolo)==0 and ultimamano==False:
        print(f"il giocatore {player} ha fatto scopa con {carta}")
        if player==1:
            scopePlayerOne+=1
        else:
            scopePlayerTwo+=1
    if player==1:
        player=2
    else:
        player=1
    if len(manoPlayerTwo)==0 and len(mazzo)>=6:
        distro()
    if len(manoPlayerTwo)==0 and ultimamano==True:
        lastChance(tavolo)
    #time.sleep(1.3)
    drop(player)
                    
                

drop()

Aspettate! Ho mostrato tutte le funzioni "conseguenziali" al turno dei giocatori, ma come fare per "giocare"? Bene, ecco a voi la funzione "drop()".
Essa avrà lo scopo di far scegliere al giocatore che carte "droppare" sul tavolo, poi richiamerà "checkPickUp()" per controllare se vi siano delle catture.

                    
def drop(player):
    tableView()
    inp=0
    if player==1:
        print(manoPlayerOne,end="\n\n")
    else:
        print(manoPlayerTwo,end="\n\n")
    while not 1<=inp<=len(manoPlayerTwo) and inp!=" ":
        inp=int(input(f"Giocatore {player} che carta vuoi giocare?"))
    if player==1:
        carta=manoPlayerOne[inp-1]
        del manoPlayerOne[inp-1]
        checkPickUp(player,carta)
    else:
        carta=manoPlayerTwo[inp-1]
        del manoPlayerTwo[inp-1]
        checkPickUp(player,carta)
                    
                

carte(), ori(), settebello() e primiera()

Queste sono le 4 principali fuzioni di conteggio punti, verranno richiamate dalla funzione "scoreCheck()" che ho annunciato poc'anzi.
Credo che la loro funzione sia abbastanza autoesplicativa, letteralmente controllano chi abbia ottenuto il punto secondo determinati conteggi: chi ha più carte, chi ha più "ori", chi ha il "settebello" e chi ha la "primiera"

                    
def carte():
    if len(mazzettoPlayerOne) >20:
        return(1)
    elif len(mazzettoPlayerOne)==20:
        return("patta")
    else:
        return(2)
                    
                
                    
def ori():
    ori=0
    for ele in mazzettoPlayerOne:
        if ele[1]=="♦":
            ori+=1
    if ori>5:
        return(1)
    elif ori==5:
        return("patta")
    else:
        return(2)
                    
                
                    
 def settebello():
    if "7♦" in mazzettoPlayerOne:
        return(1)
    else:
        return(2)
                    
                
                    
def primiera():
    q, p, c, f=False , False, False, False 
    puntiPrimiera1=0
    puntiPrimiera2=0 
    for ele in mazzettoPlayerOne:
        if ele[0]=="7":
            if ele[1]=="♦" and q==False:
                q=True
                puntiPrimiera1+=21
            if ele[1]=="♠" and p==False:
                p=True
                puntiPrimiera1+=21
            if ele[1]=="♥" and c==False:
                c=True
                puntiPrimiera1+=21
            if ele[1]=="♣" and f==False:
                c=True
                puntiPrimiera1+=21
    if puntiPrimiera1 < 70:
        for ele in mazzettoPlayerOne:
            if ele[0]=="6":
                if ele[1]=="♦" and q==False:
                    q=True
                    puntiPrimiera1+=18
                if ele[1]=="♠" and p==False:
                    p=True
                    puntiPrimiera1+=18
                if ele[1]=="♥" and c==False:
                    c=True
                    puntiPrimiera1+=18
                if ele[1]=="♣" and f==False:
                    c=True
                    puntiPrimiera1+=18
    if puntiPrimiera1 < 70:
        for ele in mazzettoPlayerOne:
            if ele[0]=="1":
                if ele[1]=="♦" and q==False:
                    q=True
                    puntiPrimiera1+=16
                if ele[1]=="♠" and p==False:
                    p=True
                    puntiPrimiera1+=16
                if ele[1]=="♥" and c==False:
                    c=True
                    puntiPrimiera1+=16
                if ele[1]=="♣" and f==False:
                    c=True
                    puntiPrimiera1+=16
    
    q, p, c, f=False , False, False, False 
    for ele in mazzettoPlayerTwo:
        if ele[0]=="7":
            if ele[1]=="♦" and q==False:
                q=True
                puntiPrimiera2+=21
            if ele[1]=="♠" and p==False:
                p=True
                puntiPrimiera2+=21
            if ele[1]=="♥" and c==False:
                c=True
                puntiPrimiera2+=21
            if ele[1]=="♣" and f==False:
                c=True
                puntiPrimiera2+=21
    if puntiPrimiera2 < 70:
        for ele in mazzettoPlayerTwo:
            if ele[0]=="6":
                if ele[1]=="♦" and q==False:
                    q=True
                    puntiPrimiera2+=18
                if ele[1]=="♠" and p==False:
                    p=True
                    puntiPrimiera2+=18
                if ele[1]=="♥" and c==False:
                    c=True
                    puntiPrimiera2+=18
                if ele[1]=="♣" and f==False:
                    c=True
                    puntiPrimiera2+=18
    if puntiPrimiera2 < 70:
        for ele in mazzettoPlayerOne:
            if ele[0]=="1":
                if ele[1]=="♦" and q==False:
                    q=True
                    puntiPrimiera2+=16
                if ele[1]=="♠" and p==False:
                    p=True
                    puntiPrimiera2+=16
                if ele[1]=="♥" and c==False:
                    c=True
                    puntiPrimiera2+=16
                if ele[1]=="♣" and f==False:
                    c=True
                    puntiPrimiera2+=16
    
    if puntiPrimiera1>puntiPrimiera2:
        return(1)
    elif puntiPrimiera1 < puntiPrimiera2:
        return(2)
    else:
        return("patta")
                    
                

scoreCheck()

Ora che abbiamo visto come conta i punti il mio script, addentriamoci nella funzione dedita al salvataggio degli stessi: "scoreCheck()"
Questa serve per salvare i dati in un file di cache e mostrarli ai giocatori che potranno decidere di giocare un'altra partita trsamite la funzione "replay()" ed accumulare i suddetti punti, oppure eliminarli tramite la funzione "destroy()" e ricominciare da zero una nuova avventura.
Come prevedibile, "destroy()"" "ripulirà" il file dei punti, in questo caso basta aprirlo in "sovracrittura" e richiuderlo lasciandolo vuoto.
D'altro canto, "replay() "resetta il mazzo ed il gioco tramite a funzione "reset()", già spiegata prima, infine avvia il gioco con "start()"

                    
def scoreCheck():
os.system('cls' if os.name == 'nt' else 'clear')
f=open("cache.txt", "r")
l=f.readlines()
if len(l)==4:
    puntiTotPlayerOne=int(l[1])
    puntiTotPlayerTwo=int(l[3])
else:
    puntiTotPlayerOne=0
    puntiTotPlayerTwo=0

puntoCarte=carte()
puntoOri=ori()
puntoSettebello=settebello()
puntoPrimiera=primiera()

punteggi=[puntoCarte, puntoOri, puntoSettebello, puntoSettebello]

for ele in punteggi:
    if ele==1:
        puntiTotPlayerOne+=1
    elif ele==2:
        puntiTotPlayerTwo+=1

puntiTotPlayerOne+=scopePlayerOne
puntiTotPlayerTwo+=scopePlayerTwo


print(f"Ecco i risultati della partita:")
print(f"Carte\t{puntoCarte}")
print(f"Ori\t{puntoOri}")
print(f"Settebello\t{puntoSettebello}")
print(f"Primiera\t{puntoPrimiera}")
print(f"Scope giocatore1\t{scopePlayerOne}")
print(f"Scope giocatore2\t{scopePlayerTwo}")
f.close()
f=open("cache.txt","w")
f.write("Punti giocatore1:\n")
f.write(str(puntiTotPlayerOne)+"\n")

f.write("Punti giocatore2:\n")
f.write(str(puntiTotPlayerTwo)+"\n")

f.close()
f=open("cache.txt", "r")
l=f.readlines()
puntiPartitaP1=l[1]
puntiPartitaP2=l[3]
if puntiPartitaP1 or puntiPartitaP2>=finePartita:
    os.system('cls' if os.name == 'nt' else 'clear')
    if puntiPartitaP1>puntiPartitaP2:
        print(f"Complimenti {nomeGiocatore1}, hai vinto contro {nomeGiocatore2} con un totale di {puntiPartitaP1} a {puntiPartitaP2}!")
        sys.exit()
else:
    print(f"Il vostro punteggio è di {puntiPartitaP1} a {puntiPartitaP2} per {nomeGiocatore1}")
    risp=""
    while risp !="sì" or risp!="no" or risp!="si":
        risp=input("Volete continuare a giocare?\n")
        risp=risp.lower()
    if risp=="sì" or risp=="si":
        print("Ottimo!")
        replay()
    elif risp=="no":
        print("Va bene, allora dite addio ai vostri progressi :) ")
        destroy()       
                    
                
                    
def destroy():
    f=open("cache.txt", "w")
    f.close()
                    
                
                    
def replay():
    reset()
    start()
                    
                

main()

Eccoci alla fine del programma, ormai la funzione madre può essere chiara per tutti.
Nel nostro caso "main()" richiama: "loading()", "askBeforeStart()" ed infine "start()". Nulla di più semplice.

                
def main():
    loading()
    askBeforeStart(nomeGiocatore1,nomeGiocatore2,finePartita)
    start()
                
            

Il prigramma finito

Ormai lo sapete, mi piace inserire il canonico if __name__ == "__main__": ed ecco qui il risultato:

                
if __name__ == "__main__":
    main()
                
            

Conclusioni

Eccoci alla fine di questo interminabile articolo, che ne pensate? Vi ricordo che se volete potete scaricare il codice sorgente da profilo github, lì sarà sempre aggirnato e vi caricherò anche la V2 Obj. Oriented che citai ad inizio articolo.


Spero che questo articolo sia stato di vostro interesse e di avervi strappato un sorriso raccontando un pezzetto di me.
Per ora è tutto, leggi anche altri miei articoli: