Articolo originale: How to Build a Wordle Clone with Python di Tantoluwa Heritage Alabi

Tradotto e adattato da: Dario Di Cillo

Risolvere puzzle è un modo per rilassarsi e passare del tempo dopo una lunga giornata, e fa anche bene alla mente.

Ancora meglio, ci sono correlazioni tra l'abitudine di risolvere puzzle e le capacità di risolvere problemi.

Wordle è un nuovo gioco che sfida i giocatori a indovinare una parola di cinque lettere in sei tentativi.

In questo tutorial, costruirai un gioco simile a Wordle con le stesse regole del gioco originale. Realizzeremo il gioco in Python. Lavorando su questa sfida, migliorerai le tue conoscenze delle funzioni e dei loop while, e acquisirai familiarità con il metodo zip.

Prerequisiti

  • Conoscenza di base di Python

Di cosa parleremo:

  • Come funziona il gioco
  • Come scrivere la logica del gioco
  • Risultati del gioco

Come funziona il gioco

Il gioco consisterà in:

  • una variabile che contiene una parola di cinque lettere chiamata parola_nascosta.
  • un input da un utente.
  • una variabile che contiene il numero di tentativi (fino a 6) in cui l'utente prova a indovinare la parola.
  • una condizione per verificare se una lettera è stata indovinata correttamente e nella posizione giusta, indicata da "✅"
  • un'altra condizione per verificare se una lettera è stata indovinata correttamente ma nella posizione sbagliata, indicata da "➕"
  • la condizione finale per verificare se una lettera non è presente nella parola nascosta, indicata da "❌"

Come scrivere la logica del gioco

Primo blocco

Prima di tutto, dobbiamo informare i giocatori delle regole. Questo è necessario in modo che le persone sappiano come giocare.

Iniziamo creando una funzione con il nome istruzioni_gioco.

def istruzioni_gioco():

Poi, passiamo le istruzioni come una stringa nella funzione print per mostrare il risultato. Racchiudiamo le stringhe in una docstring (""" """) perché i simboli ("✅❌❌✅➕") saranno compresi tra virgolette doppie (" "). Inoltre, ogni istruzione apparirà in una nuova riga senza usare il carattere "\n".

print("""Wordle è un gioco per giocatore singolo
Il giocatore deve indovinare una parola nascosta di 5 lettere
Hai a disposizione 6 tentativi
Guida "✅❌❌✅➕"
"✅" Indica che la lettera in quella posizione è stata indovinata correttamente
"➕" Indica che la lettera in quella posizione è presente nella parola nascosta ma in una posizione diversa
"❌" Indica che la lettera in quella posizione è sbagliata e non è presente nella parola nascosta""")

Ogni frase inizia in una nuova riga e apparirà così nella console. Concludiamo chiamando la nostra funzione così che le istruzioni siano visibili sullo schermo.

istruzioni_gioco()

Se ottieni un errore, potresti aver dimenticato di inserire i due punti (:) alla fine della definizione della funzione def istruzioni_gioco(), oppure il tuo codice non è adeguatamente formattato. Presta attenzione agli errori nella console, perché ti daranno una mano a capire dove stai sbagliando.

Mettendo tutto insieme

def istruzioni_gioco():
    print("""Wordle è un gioco per giocatore singolo
Il giocatore deve indovinare una parola nascosta di 5 lettere
Hai a disposizione 6 tentativi
Guida ai progressi "✅❌❌✅➕"
"✅" Indica che la lettera in quella posizione è stata indovinata correttamente
"➕" Indica che la lettera in quella posizione è presente nella parola nascosta, ma in una posizione diversa
"❌" Indica che la lettera in quella posizione è sbagliata e non è presente nella parola nascosta""")

istruzioni_gioco()

Se esegui il codice e non viene mostrato il risultato nella console, significa che probabilmente hai dimenticato di chiamare la funzione.

Output

image-4

Secondo blocco

Il prossimo passo consiste nel lavorare sull'input dell'utente e confrontarlo con la parola nascosta. Questo è essenziale per il gioco.

Crea una funzione chiamata verifica_parola. All'interno del blocco di codice, crea una variabile chiamata parola_nascosta e assegnale una parola di cinque lettere di tua scelta. parola_nascosta è la parola che l'utente proverà a indovinare correttamente.

def verifica_parola():
  parola_nascosta = "amico"

Dato che il giocatore ha 6 tentativi, assegna il valore 6 a una nuova variabile chiamata tentativo e crea un'istruzione while.

La cosa migliore qui, è usare un loop while perché il processo prosegue finché il giocatore non indovina o esaurisce i tentativi. La condizione per l'istruzione while è che il numero di tentativi sia maggiore di 0.

def verifica_parola():
  parola_nascosta = "amico"
  tentativi = 6
  while tentativi > 0:
    

L'input dell'utente viene creato all'interno del loop while e le condizioni vengono controllate per la parola_nascosta. Se l'input dell'utente è uguale alla parola_nascosta, il loop termina e il gioco è finito.

def verifica_parola():
  parola_nascosta = "amico"
  tentativi = 6
  while tentativi > 0:
    parola_utente = str(input("Indovina la parola: "))
    if parola_utente == parola_nascosta:
      print("Hai indovinato la parola correttamente! Hai vinto 🕺🕺🕺 ")
      break

Le f-string ( f" ") sono un altro metodo di unire variabili e stringhe insieme senza usare il segno "+".

Ecco un esempio:

# Invece di
print("Tentativi residui: " + tentativi + "\n") # '\n' viene usato per una nuova riga

# usa questo
print(f"Tentativi residui: {tentativi} \n") # le variabili dentro 'print' sono racchiuse tra parentesi graffe

Per i casi in cui l'input dell'utente non è uguale alla parola_nascosta, introduci un'istruzione else e tutte le condizioni saranno controllate all'interno di questo blocco else. I tentativi diminuiscono di 1 e quelli rimasti vengono mostrati nella console mentre l'utente gioca.

def verifica_parola():
  parola_nascosta = "amico"
  tentativi = 6
  while tentativi > 0:
    parola_utente = str(input("Indovina la parola: "))
    if parola_utente == parola_nascosta:
      print("Hai indovinato la parola correttamente! Hai vinto 🕺🕺🕺 ")
      break
    else:
      tentativi = tentativi - 1
      print(f"Tentativi residui: {tentativi} \n")      

Se l'input dell'utente non corrisponde alla parola_nascosta, ci sono tre condizioni da verificare:

  • Se la lettera è nella posizione sbagliata ma presente nella parola_nascosta, mostra "➕" al suo fianco.
  • Se la lettera è presente nella parola_nascosta ed è nella posizione giusta, mostra "✅" al suo fianco.
  • Se la lettera non è presente nella parola_nascosta, mostra "❌" al suo fianco.

Per confrontare le lettere dell'input dell'utente e della parola_nascosta, aggiungi un'istruzione formata da un loop for insieme a una funzione zip().

for i, j in zip(parola_utente, valore_default):

Una funzione zip() è una funzione integrata che itera su elementi come liste e tuple. Può estrarre i valori da variabili multiple della stessa dimensione.

Per le stringhe, non puoi usare direttamente la funzione zip() da sola. Il loop for viene incluso per ottenere le lettere dalle variabili che contengono le stringhe.

Ecco un esempio:

Un utente inserisce una parola di cinque lettere (che viene salvata in parola_utente), e viene creata una variabile valore_default con una parola di cinque lettere. Iterando sulle due variabili allo stesso tempo con zip(), tutte le lettere verranno mostrate nella console e separate da un trattino.

Blocco di codice:

parola_utente = input("scrivi una parola di 5 lettere: ")
valore_default = "gatto"
for i, j in zip(parola_utente, valore_default):
  print(i + " - " +  j)

Output:

image-3

Torniamo al nostro clone di Wordle:

def verifica_parola():
  parola_nascosta = "amico"
  tentativi = 6
  while tentativi > 0:
    parola_utente = str(input("Indovina la parola: "))
    if parola_utente == parola_nascosta:
      print("Hai indovinato la parola correttamente! Hai vinto 🕺🕺🕺 ")
      break
    else:
      tentativi = tentativi - 1
      print(f"Tentativi residui: {tentativi} \n")
      for lettera, carattere in zip(parola_nascosta, parola_utente):
            if carattere in parola_nascosta and carattere in lettera:
                print(carattere + " ✅ ")
            elif carattere in parola_nascosta:
                print(carattere + " ➕ ")
            else:
                print(carattere + " ❌ ")
     

Analizziamo quello che sta accadendo qui:

for lettera, carattere in zip(parola_nascosta, parola_utente) - questa istruzione significa iterare attraverso la parola_nascosta con la variabile lettera e iterare attraverso parola_utente con la variabile carattere. Tutte le lettere nella parola_nascosta vengono raggiunte da lettera e tutte le lettere in parola_utente vengono raggiunte da carattere.

Poi, la terza condizione menzionata prima, verrà verificata confrontando le lettere in parola_utente (l'input utente) con parola_nascosta (la parola da indovinare):

def verifica_parola():
  parola_nascosta = "amico"
  tentativi = 6
  while tentativi > 0:
    parola_utente = str(input("Indovina la parola: "))
    if parola_utente == parola_nascosta:
      print("Hai indovinato la parola correttamente! Hai vinto 🕺🕺🕺 ")
      break
    else:
      tentativi = tentativi - 1
      print(f"Tentativi residui: {tentativi} \n")
      for lettera, carattere in zip(parola_nascosta, parola_utente):
            if carattere in parola_nascosta and carattere in lettera:
                print(carattere + " ✅ ")
            elif carattere in parola_nascosta:
                print(carattere + " ➕ ")
            else:
                print(carattere + " ❌ ")
      if tentativi == 0:
        print(" Hai perso 🙁 ")

Lo step finale è la chiamata della funzione:

def verifica_parola():
  parola_nascosta = "amico"
  tentativi = 6
  while tentativi > 0:
    parola_utente = str(input("Indovina la parola: "))
    if parola_utente == parola_nascosta:
      print("Hai indovinato la parola correttamente! Hai vinto 🕺🕺🕺 ")
      break
    else:
      tentativi = tentativi - 1
      print(f"Tentativi residui: {tentativi} \n")
      for lettera, carattere in zip(parola_nascosta, parola_utente):
            if carattere in parola_nascosta and carattere in lettera:
                print(carattere + " ✅ ")
            elif carattere in parola_nascosta:
                print(carattere + " ➕ ")
            else:
                print(carattere + " ❌ ")
      if tentativi == 0:
        print(" Hai perso 🙁 ")

verifica_parola()

Mettendo tutto il codice insieme, dovrebbe avere questo aspetto:

def istruzioni_gioco():
    print("""Wordle è un gioco per giocatore singolo
Il giocatore deve indovinare una parola nascosta di 5 lettere
Hai a disposizione 6 tentativi
Guida ai progressi "✅❌❌✅➕"
"✅" Indica che la lettera in quella posizione è stata indovinata correttamente
"➕" Indica che la lettera in quella posizione è presente nella parola nascosta, ma in una posizione diversa
"❌" Indica che la lettera in quella posizione è sbagliata e non è presente nella parola nascosta""")

istruzioni_gioco()

def verifica_parola():
  parola_nascosta = "amico"
  tentativi = 6
  while tentativi > 0:
    parola_utente = str(input("Indovina la parola: "))
    if parola_utente == parola_nascosta:
      print("Hai indovinato la parola correttamente! Hai vinto 🕺🕺🕺 ")
      break
    else:
      tentativi = tentativi - 1
      print(f"Tentativi residui: {tentativi} \n")
      for lettera, carattere in zip(parola_nascosta, parola_utente):
            if carattere in parola_nascosta and carattere in lettera:
                print(carattere + " ✅ ")
            elif carattere in parola_nascosta:
                print(carattere + " ➕ ")
            else:
                print(carattere + " ❌ ")
      if tentativi == 0:
        print(" Hai perso 🙁 ")

verifica_parola()

Output:

image-8

Conclusione

Ottimo lavoro! Hai creato un gioco puzzle con Python. Puoi trovare il codice di esempio qui.

Potresti notare che non funziona esattamente come Wordle in alcuni casi particolari, perché non provi a creare la logica mancante per questi casi?