Nella quarta lezione creiamo il primo livello del "Solitario del Ferroviere" con cui realmente potete iniziare a giocare, con questo livello di difficoltà è più semplice giocare perché  le carte indovinate e quelle non indovinate sono scoperte, in modo da rendere più facile la scelta della carta da pensare,  come mostra l'immagine seguente.

Il pulsante cambia, come abbiamo visto nella prima lezione, permette di scegliere la carta da pensare, mentre il  pulsante gira, come abbiamo visto nella seconda lezione e nella terza lezione permette di girare le carte del mazzo. Quando la carta pensata è uguale alla carta girata, l'immagine small della carta indovinata viene aggiunta in corrispondenza del cerchio verde, altrimenti viene aggiunta in corrispondenza del cerchio rosso.  

Quando le carte da girare finiscono, se ci sono carte non indovinate, è possibie mischiare e riprendere il gioco, come mostra l'immagine seguente.

Il gioco finisce quando s'indovinano tutte le carte, in quel caso è possibile iniziare una nuova partita, come mostra l'immagine seguente.

Col passare del tempo i punti diminuiscono ed ogni volta che le carte vengono mischiate il punteggio si dimezza. Se il punteggio arriva a 0 senza aver completato il solitario, appare la finestra modale (modale=impedisce qualunque operazione e permette solo di uscire), "GAME OVER" che indica la fine del gioco, come mostra l'immagine seguente.

Come aggiornare il punteggio

Il punteggio (score) all'inizio del gioco vale 1000, questo valore si decrementa di uno ogni 10 secondi e viene dimezzato ogni volta che si mischiano le carte.

Per gestire l'aggiornamento del punteggio è stata utilizzata la funzione tick() che viene eseguita ogni 200 millisecondi:

# chiama la funzione tick ogni 200 millisecondi
label_clock.after(200, tick)

Per decrementare il punteggio ogni 10 secondi si usa la variabile conta_score. Questa variabile  s'incrementa di uno, ogni volta che viene eseguita la funzione tick(), quando diventa uguale a 50, significa che sono trascorsi 10 secondi (1 secondo=5 x 200 millisecondi => 10 secondi/200 millisecondi = 50) e viene decrementato il punteggio di uno, come mostra il blocco di codice segunte, inserito nella funzione tick():

conta_score+=1
if conta_score>50:
   score=score-1
   conta_score=0

Per dimezzare il punteggio ogni volta che le carte vengono mischiate, è stata inserita l'istruzione score=int(score/2) nella funzione mischia(), come mostra il blocco di codice seguente:

def mischia():
    ...
    global tentativi
    global score
    tentativi=tentativi+1
    score=int(score/2)
    ...

Come visualizzzare le carte small indovinate e non indovinate

La visualizzazione delle carte small indovinate oppure non indovinate serve per rendere il livello di difficolta del solitario più semplice, perché è più facile scegliere la carta da pensare. 

Per caricare le carte small abbiamo usato la funzione carica_immagini_carte_small(), che aggiunge i riferimenti delle immagini nella lista immagini_carte_small e restituisce il riferimento della lista creata. 

def carica_immagini_carte_small():
    immagini_carte_small=[]
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('1coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('2coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('3coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('4coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('5coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('6coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('7coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('8coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('9coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('10coppe_small.png')))
    return immagini_carte_small

Per visualizzare le immagini small, ogni volta che si gira una carta, viene creata un'etichetta label_img_carta_indovinata se la carta è stata indovinata, altrimenti   label_img_carta_non_indovinata, se la carta non è stata indovinata.
Le etichette usate per visualizzare le carte small sul piano di gioco, si trovano ad una distanza di 50 Pixel, l'una dall'altra. La posizione corrente viene indicata dalle variabili offset_indovinate ed offset_non_indovinate, come mostral'immagine seguente:

Il blocco di codice seguente, incluso nella funzione gira(), mostra come sono gestite le carte small:

    if carta_pensata==mazzo_carte[indice_carta_girata]:
        label_img_carta_indovinata=tk.Label(root, image=immagini_carte_small[mazzo_carte[indice_carta_girata]-1])
        label_img_carta_indovinata.place(x=820+offset_indovinate,y=60)
        offset_indovinate=offset_indovinate+50
        indovinate=indovinate+1
        label_indovinate.config(text=str(indovinate))
        label_indovinate.place(x=820,y=65)
        label_carte_small_si.append(label_img_carta_indovinata)
        suono(5,0.1)
    else:
        label_img_carta_non_indovinata=tk.Label(root, image=immagini_carte_small[mazzo_carte[indice_carta_girata]-1])
        label_img_carta_non_indovinata.place(x=820+offset_non_indovinate,y=153)
        offset_non_indovinate=offset_non_indovinate+50
        non_indovinate=non_indovinate+1
        mazzo_carte_non_indovinate.append(mazzo_carte[indice_carta_girata])
        label_non_indovinate.config(text=str(non_indovinate))
        label_non_indovinate.place(x=820,y=158)
        label_carte_small_no.append(label_img_carta_non_indovinata)

Le liste label_carte_small_si e label_carte_small_no, servono per memorizzare i riferimenti di tutte le etichette che contengono carte smll, in modo da poter essere cancellate quando è necessario, utilizzando i blocchi di codice seguenti: 

# Elimina dal piano di gioco tutte le etichete che contengono carte small indovinate
for i in range(0,10):
    label_carte_small_si[i].place_forget() # Cancella l'etichetta corrispondente al riferimento corrente della lista
label_carte_small_si.clear() # Cancella dalla lista tutti i riferimenti alle etchette che contengono carte small indovinate

# Elimina dal piano di gioco tutte le etichete che contengono carte small non indovinate
for i in range(0,len(mazzo_carte)):
    label_carte_small_no[i].place_forget() # Cancella l'etichetta corrispondente al riferimento corrente della lista
label_carte_small_no.clear() # Cancella dalla lista tutti i riferimenti alle etchette che contengono carte small non indovinate

Come rimescolare le carte non indovinate e riprendere il gioco

Quando le carte del mazzo centrale vengono girate tutte, se ci sono ancora carte non indovinate occore rimescolarle per riprendere il gioco, questa operazione viene svolta dalla funzione mischia().

Prima di tutto bisogna svuotare la lista mazzo_carte, che contiene i valori delle 10 carte da gioco iniziali, il comando seguente esegue questa operazione:

mazzo_carte.clear()

Successivamente bisogna caricare i valori delle carte non indovinate nella lista mazzo_carte, e svuotare la lista che contiene i valori delle carte non indovinate, come mostrano le istruzioni seguenti:

mazzo_carte=mazzo_carte_non_indovinate[:]
mazzo_carte_non_indovinate.clear()

Il blocco di codice seguente mostra le istruzioni fondamentali della funzione mischia() per mescolare le carte non indovinate e riprendere il gioco:

def mischia():
    global mazzo_carte
    global mazzo_carte_non_indovinate
    global non_indovinate
    global offset_non_indovinate
    global label_carte_small_no
    ...
    mazzo_carte.clear()
    mazzo_carte=mazzo_carte_non_indovinate[:]
    mazzo_carte_non_indovinate.clear()
    non_indovinate=0
    offset_non_indovinate=50
     # Elimina dal piano di gioco il pulsante mischia
    pulsante_mischia.place_forget()
    suono(9,4)
    # Elimina dal piano di gioco tutte le etichete che contengono carte small non indovinate
    for i in range(0,len(mazzo_carte)):
        label_carte_small_no[i].place_forget()
    label_carte_small_no.clear()
    start() # Riavvia il gioco

Come iniziare una nuova partita oppure visualizzare la finestra modale "GAME OVER" per interrompere il gioco

Quando le carte vengono indovinate tutte, se il punteggio è maggiore di zero è possibile iniziare una nuova partita,

In qualunque momento il punteggio diventa zero, appare la finestra modale "GAME OVER" e bisogna interrompere il gioco.

Il primo caso (nuova partita) si controlla attraverso il codice seguente, inserito nella funzione gira():

    # Se l'indice della carta girata e minore del del massimo consentito, incrementa l'indice di uno, altrimenti mischia oppure inizia una nuova partita
    if indice_carta_girata<len(mazzo_carte)-1:
       indice_carta_girata=indice_carta_girata+1
       suono(3,0.1)
    else:
       pulsante_gira.place_forget()
       label_girate.place_forget()
       label_mazzo_di_carte.place_forget()
       label_carta_girata.place_forget()
       # Se ci sono ancora carte da indovinare mischia
       if indovinate<10:
          pulsante_mischia.place(x=295,y=370)
          suono(8,0.1)
       # Se non ci sono carte da indovinare inizia una nuova partita
       else:
          pulsante_nuova_partita.place(x=270,y=370)
          suono(7,0.1)
          flag=False

La variabile flag a false blocca l'aggiornamento dei secondi e del punteggio.

Per gestire il secondo caso (GAME OVER) occorre verificare se il punteggio diventa uguale a zero, questo è possibile solo quando viene aggiornato il punteggio all'interno della funzione tick(), come mostra blocco di codice seguente:

        conta_score+=1
        # Se conta_score>50 aggiorna il punteggio
        if conta_score>50:
            score=score-1
            conta_score=0
        # Se score>0 aggiorna le etichette dei secondi, dei tentativi e del punteggio
        if score>0:
            spazi="          "[:(10-len(str(secondi)))]
            str_secondi=spazi+str(secondi)+" "
            label_secondi.config(text=str_secondi)
            spazi="          "[:(10-len(str(tentativi)))]
            label_tentativi.config(text=spazi+str(tentativi)+" ")
            spazi="          "[:(10-len(str(score)))]
            label_score.config(text=spazi+str(score)+" ")
        # Se score==0 visualizza la finestra modale GAME OVER ed interrompe il gioco
       else:
            label_score.config(text="          0 ")
            flag=False
            messagebox.showinfo('Fine Partita', 'GAME OVER')
            esci() # Esegue funzione esci()

# Interrompe il gioco
def esci():
   root.quit()

Analisi del codice Python

# Solitario del ferroviere (Lezione 4)
import pygame                                  # Importa classe pygame per gestire i suoni
import tkinter as tk                           # Importa classe tkinter con alias tk per gestire il pannello di gioco
import time                                        # Importa classe time per gestire l'orologio di sistema 
import random                                  # Importa classe random che permette di ottenere gli indici casuali usati per mischiare le carte
from PIL import Image, ImageTk    # Dalla libreira Pillow importa le classi Image e ImageTk per gestire le immagini del gioco 
from tkinter import messagebox    # Dalla libreira tkinter importa le classe messagebox usata per creare la finestra modale "GAME OVER"

mazzo_carte=[1,2,3,4,5,6,7,8,9,10]  # Contiene i valori della 10 carte da gioco
mazzo_carte_non_indovinate=[]     # Contiene i valori delle carte non indovinate
immagini_carte=[]                             # Contiene i riferimenti delle immagini  della 10 carte da gioco
immagini_carte_small=[]                  # Contiene i riferimenti delle immagini  della 10 carte da gioco small
label_carte_small_no=[]
label_carte_small_si=[]
indice_carta_pensata=0
indice_carta_girata=2
indovinate=0
non_indovinate=0
carta_pensata=1
time1=0                                               # Questa variabile viene usata per il calcolo dei secondi trascorsi
time_start=0                                       # Questa variabile viene usata per il calcolo dei secondi trascorsi
tentativi=1                                           # Questa variabile viene usata per contare quante volte vengono mischiate le carte
offset_indovinate=50                        # Questa variabile viene usata per posizionare le carte small indovinate sul pannello di gioco
offset_non_indovinate=50               # Questa variabile viene usata per posizionare le carte small non indovinate sul pannello di gioco
score=1000                                         # Questa variabile contiene il punteggio
conta_score=0                                    # Questa variabile viene usata per decrementare di uno il punteggio ogni 10 secondi
flag=True                                             # Questa variabile viene usata per interrompere l'aggiornamento dei secondi e del punteggio (nuova partita/game over)

# Questa funzione interrompe il gioco
def esci():
   root.quit()

# Questa funzione viene eseguita ogni 200 millisecondi ed aggiorna il contenuto di tutte le etichette del pannello di gioco
def tick():
    global time1
    global time_start
    global tentativi
    global score
    global conta_score
    global flag
    # legge ora locale del pc
    time2 = time.strftime('%H:%M:%S')
    if time2 != time1:
        time1 = time2
        label_clock.config(text=time2)   # Aggiorna l'orologio in alto a destra del pannello di gioco
    if flag:     # Se flag==true vengono aggiornati i secondi ed il punteggio, altrimenti viene aggiornato solo l'orologio
        secondi=int(time.time()-time_start) # Calcola i secondi trascorsi
        spazi="          "[:(10-len(str(secondi)))]  # Qunatità di spazi usati per impaginare i secondi ed i tentativi
        str_secondi=spazi+str(secondi)+" "
        label_secondi.config(text=str_secondi)
        spazi="          "[:(10-len(str(tentativi)))]
        label_tentativi.config(text=spazi+str(tentativi)+" ")
        conta_score+=1
        if conta_score>50:   # Quando conta_score è ugluale a 50 sono passati 10 secondi e bisogna decrementare di uno il punteggio
            score=score-1
            conta_score=0
        if score>0:
            spazi="          "[:(10-len(str(secondi)))]
            str_secondi=spazi+str(secondi)+" "
            label_secondi.config(text=str_secondi)
            spazi="          "[:(10-len(str(tentativi)))]
            label_tentativi.config(text=spazi+str(tentativi)+" ")
            spazi="          "[:(10-len(str(score)))]
            label_score.config(text=spazi+str(score)+" ")
        else:
            label_score.config(text="          0 ")
            flag=False  # Disattiva l'aggiornamento dei secondi e del punteggio
            messagebox.showinfo('Fine Partita', 'GAME OVER')  # Visualizza la finestra modale "GAME OVER"
            esci()  # Esce dal gioco
    # chiama la funzione tick ogni 200 millisecondi
    label_clock.after(200, tick)

# Questa funzione viene eseguita per mischiare le carte
def mischia_carte(mazzo):
    temp=0
    max=len(mazzo)-1
    for i in range(1,100):
        prima=random.randint(0,max)
        seconda=random.randint(0,max)
        if prima!=seconda:
            temp=mazzo[prima]
            mazzo[prima]=mazzo[seconda]
            mazzo[seconda]=temp

def suono(sound,tempo):
    if sound==1:
       pygame.mixer_music.load("TickSound.mp3")
    elif sound==2:
       pygame.mixer_music.load("ElectronicSound.wav")
    elif sound==3:
       pygame.mixer_music.load("ToggleSound.wav")
    elif sound==4:
       pygame.mixer_music.load("ToneSound.wav")
    elif sound==5:
       pygame.mixer_music.load("OvationSound.wav")
    elif sound==6:
       pygame.mixer_music.load("ElectronicSound.wav")
    elif sound==7:
       pygame.mixer_music.load("CardSound.wav")
    elif sound==8:
       pygame.mixer_music.load("ComputerSound.wav")
    pygame.mixer_music.play()
    time.sleep(tempo)    
    
# Questa funzione viene eseguita per caricare le immagini delle 10 carte da gioco
def carica_immagini_carte():
    immagini_carte=[]
    immagini_carte.append(ImageTk.PhotoImage(Image.open('Carte_Napoletane_retro.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('1coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('2coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('3coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('4coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('5coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('6coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('7coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('8coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('9coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('10coppe.png')))
    return immagini_carte

# Questa funzione viene eseguita per caricare le immagini small delle 10 carte da gioco
def carica_immagini_carte_small():
    immagini_carte_small=[]
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('1coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('2coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('3coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('4coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('5coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('6coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('7coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('8coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('9coppe_small.png')))
    immagini_carte_small.append(ImageTk.PhotoImage(Image.open('10coppe_small.png')))
    return immagini_carte_small

# Questa funzione permette di scegliere la carta pensata
def cambia():
    global indice_carta_pensata
    global carta_pensata
    carta_pensata=indice_carta_pensata
    label_carta_pensata.config(image=immagini_carte[indice_carta_pensata])
    label_carta_pensata.place(x=5,y=40)
    if indice_carta_pensata<10:
       indice_carta_pensata=indice_carta_pensata+1
    else:
       indice_carta_pensata=1
    suono(1,0.1)
    
# Questa funzione viene eseguita per girare le carte e verificare se la carta pensata è uguale alla carta girata
def gira():
    global indice_carta_girata
    global flag
    global mazzo_carte
    global carta_pensata
    global indovinate
    global non_indovinate
    global offset_indovinate
    global offset_non_indovinate
    global label_carte_small_no
    global label_carte_small_si
    label_carta_girata.config(image=immagini_carte[mazzo_carte[indice_carta_girata]])
    label_carta_girata.place(x=455,y=40)
    girate="   "+str(indice_carta_girata+1)+"/"+str(len(mazzo_carte))+"  "
    label_girate.config(text=girate)
    label_girate.place(x=500,y=370)
    if carta_pensata==mazzo_carte[indice_carta_girata]:
        label_img_carta_indovinata=tk.Label(root, image=immagini_carte_small[mazzo_carte[indice_carta_girata]-1])
        label_img_carta_indovinata.place(x=820+offset_indovinate,y=60)
        offset_indovinate=offset_indovinate+50
        indovinate=indovinate+1
        label_indovinate.config(text=str(indovinate))
        label_indovinate.place(x=820,y=65)
        label_carte_small_si.append(label_img_carta_indovinata)
        suono(4,0.1)
    else:
        label_img_carta_non_indovinata=tk.Label(root, image=immagini_carte_small[mazzo_carte[indice_carta_girata]-1])
        label_img_carta_non_indovinata.place(x=820+offset_non_indovinate,y=153)
        offset_non_indovinate=offset_non_indovinate+50
        non_indovinate=non_indovinate+1
        mazzo_carte_non_indovinate.append(mazzo_carte[indice_carta_girata])
        label_non_indovinate.config(text=str(non_indovinate))
        label_non_indovinate.place(x=820,y=158)
        label_carte_small_no.append(label_img_carta_non_indovinata)
    if indice_carta_girata<len(mazzo_carte)-1:
       indice_carta_girata=indice_carta_girata+1
       suono(3,0.1)
    else:
       pulsante_gira.place_forget()
       label_girate.place_forget()
       label_mazzo_di_carte.place_forget()
       label_carta_girata.place_forget()
       if indovinate<10:
          pulsante_mischia.place(x=295,y=370)
          suono(6,0.1)
       else:
          pulsante_nuova_partita.place(x=270,y=370)
          suono(5,0.1)
          flag=False

# Questa funzione viene eseguita quando si clicca sul pulsante mischia, gestisce tutte le operazioni richieste quando si mischiano le carte non indovinate
def mischia():
    global mazzo_carte
    global mazzo_carte_non_indovinate
    global non_indovinate
    global offset_non_indovinate
    global label_carte_small_no
    global tentativi
    global score
    tentativi=tentativi+1
    score=int(score/2)
    mazzo_carte.clear()
    mazzo_carte=mazzo_carte_non_indovinate[:]
    mazzo_carte_non_indovinate.clear()
    non_indovinate=0
    offset_non_indovinate=50
    pulsante_mischia.place_forget()
    suono(7,4)
    for i in range(0,len(mazzo_carte)):
        label_carte_small_no[i].place_forget()
    label_carte_small_no.clear()
    start()

# Questa funzione viene eseguita quando si clicca sul pulsante nuova partita, gestisce tutte le operazioni necessarie per iniziare una nuova partita
def nuova_partita():
   global mazzo_carte
   global mazzo_carte_non_indovinate
   global indovinate
   global non_indovinate
   global offset_indovinate
   global offset_non_indovinate
   global label_carte_small_si
   global tentativi
   global score
   global conta_score
   global time_start
   global flag
   mazzo_carte=[1,2,3,4,5,6,7,8,9,10]
   mazzo_carte_non_indovinate.clear()
   flag=True
   indovinate=0
   offset_indovinate=50
   non_indovinate=0
   offset_non_indovinate=50
   tentativi=1
   score=1000
   conta_score=0
   time_start=0
   label_carta_girata.place_forget()
   pulsante_nuova_partita.place_forget()
   suono(8,2.5)
   for i in range(0,10):
       label_carte_small_si[i].place_forget()
   label_carte_small_si.clear()
   start()

# Questa funzione viene eseguita per inizializzare il pannello di gioco e per gestire tutte le oprazioni richieste quando inizia una nuova partita
def start():
    global indice_carta_pensata
    global carta_pensata
    global indice_carta_girata
    global non_indovinate
    global mazzo_carte
    global time_start
    if time_start==0:
       time_start = time.time()
    label_clock.place(x=1300,y=5)
    pulsante_cambia.place(x=60,y=370)
    label_titolo_carta_pensata.place(x=25,y=5)
    label_carta_pensata.config(image=immagini_carte[1])
    label_carta_pensata.place(x=5,y=40)
    label_titolo_mazzo_di_carte.place(x=260,y=5)
    label_mazzo_di_carte.place(x=240,y=40)
    pulsante_gira.place(x=285,y=370)
    label_girate.config(text="   0/"+str(len(mazzo_carte))+"  ")
    label_girate.place(x=500,y=370)
    label_img_indovinate.place(x=750,y=60)
    label_indovinate.config(text=str(indovinate))
    label_indovinate.place(x=820,y=65)
    label_img_non_indovinate.place(x=750,y=150)
    label_non_indovinate.config(text=str(non_indovinate))
    label_non_indovinate.place(x=820,y=158)
    label_titolo_tempo.place(x=35,y=455)
    label_secondi.place(x=30,y=515)
    label_tentativi.place(x=160,y=515)
    label_titolo_tentativi.place(x=153,y=455)
    label_secondi.place(x=30,y=480)
    label_tentativi.place(x=160,y=480)
    label_titolo_score.place(x=280,y=455)
    label_score.place(x=280,y=480)
    pygame.init()
    indice_carta_pensata=2
    carta_pensata=1
    indice_carta_girata=0
    mischia_carte(mazzo_carte)

# Preparazione pannello di gioco
root = tk.Tk()
root.wm_title('Solitario del ferroviere')
root.geometry("1400x600")
root.resizable(False, False)
immagine_indovinate=ImageTk.PhotoImage(Image.open('verde.png'))
immagine_non_indovinate=ImageTk.PhotoImage(Image.open('rosso.png'))
label_titolo_carta_pensata=tk.Label(root, text="CARTA PENSATA",font=("Helvetica", 14))
label_titolo_mazzo_di_carte=tk.Label(root, text="MAZZO DI CARTE",font=("Helvetica", 14))
pulsante_cambia=tk.Button(root,text="CAMBIA", width=10, height=2, bd = 3,command=cambia, bg="seagreen",font=("Helvetica", 12))
pulsante_gira=tk.Button(root,text="GIRA", width=10, height=2, bd = 3,command=gira, bg="teal",font=("Helvetica", 12))
pulsante_mischia=tk.Button(root,text="MISCHIA", width=10, height=2, bd = 3,command=mischia, bg="mediumpurple",font=("Helvetica", 12))
pulsante_nuova_partita=tk.Button(root,text="NUOVA PARTITA", width=15, height=2, bd = 3,command=nuova_partita, bg="darkorange",font=("Helvetica", 12))
label_girate=tk.Label(root, text="   0/10  ",font=("Helvetica", 25),fg="white",bg="tomato")
label_img_indovinate=tk.Label(root, image=immagine_indovinate)
label_indovinate=tk.Label(root, text=str(indovinate),font=("Helvetica", 24))
label_non_indovinate=tk.Label(root, text=str(non_indovinate),font=("Helvetica", 24))
label_img_non_indovinate=tk.Label(root, image=immagine_non_indovinate)
label_clock = tk.Label(root, font=('arial', 14, 'italic'), bg='darkgray',fg='black')
label_titolo_tempo=tk.Label(root, text="TEMPO",font=("times", 12,"italic"),fg="black")
label_titolo_tentativi=tk.Label(root, text="TENTATIVI",font=("times", 12,"italic"),fg="black")
label_secondi=tk.Label(root, font=('arial', 14, 'normal'), bg='blue',fg='white')
label_tentativi=tk.Label(root, font=('arial', 14, 'normal'), bg='orange',fg='white')
label_titolo_score=tk.Label(root, text="SCORE",font=("times", 12,"italic"),fg="black")
label_score=tk.Label(root, font=('arial', 16, 'normal'), bg='palevioletred',fg='white')
logo=ImageTk.PhotoImage(Image.open('logo_sf.png'))
label_logo=tk.Label(root, image=logo)
label_powered_sf=tk.Label(root, text="2020 - Powered by Skill Factory",font=("times", 14,'italic'))
label_powered_sf.place(x=550,y=557)
label_logo.place(x=805,y=545)
immagini_carte=carica_immagini_carte()
label_carta_pensata=tk.Label(root, image=immagini_carte[1])
label_mazzo_di_carte=tk.Label(root, image=immagini_carte[0])
label_carta_girata=tk.Label(root, image=immagini_carte[0])
immagini_carte_small=carica_immagini_carte_small()
label_sinistra=tk.Label(root, image=immagini_carte_small[0])
label_destra=tk.Label(root, image=immagini_carte_small[0])
start()
tick()
root.mainloop()

Nella prossima lezione implementeremo le funzionalità  per creare il secondo livello di difficoltà del "Solitario del Ferroviere". 

Arrivederci ...

<< Lezione precedente           Lezione successiva >>

 Per scaricare le risorse di questa lezione clicca sul link seguente:risorse_lezione_04