Programmare in java: 5. Gioco dell’impiccato

Programmare in java: 5. Gioco dell’impiccato

Introduzione

    Tra i giochi “di carta e matita”, l’impiccato è uno dei più semplici e, allo stesso tempo, uno dei più carichi di tensione nella sua eleganza. Una parola nascosta, qualche trattino e un omino che si costruisce errore dopo errore: ogni scelta sbagliata aggiunge un tratto al disegno, finché la figura è completa e la partita si chiude con un GAME OVER. Nessuna tecnologia, solo alfabeto, intuizione e un po’ di suspense.

Le origini precise del gioco non sono del tutto chiare. Alcuni storici lo collegano ai passatempi scolastici di fine Ottocento, quando l’alfabetizzazione cominciò ad allargarsi e la lingua scritta divenne terreno di sfida. In un’aula o in un doposcuola, insegnanti e studenti usavano l’impiccato per allenare ortografia, vocabolario e velocità mentale. Il disegno dell’omino non rappresentava una vera condanna, ma la posta in gioco simbolica di una scommessa con le parole.

Dietro la sua leggerezza, l’impiccato nasconde una logica precisa. Ogni tentativo modifica lo spazio delle possibilità: una lettera indovinata restringe il campo, un errore lo lascia quasi intatto. Giocare bene significa osservare il pattern delle lettere scoperte, scegliere le consonanti più frequenti, ragionare per ipotesi. È una piccola lezione di statistica informale, di ricerca guidata dal feedback.

Nel linguaggio della programmazione, questo gioco diventa ancora più interessante. La “parola segreta” si trasforma in una stringa, i trattini in un modello da aggiornare, i tentativi in un ciclo controllato da condizioni. L’omino disegnato a mano lascia il posto a una rappresentazione testuale in console, ma la struttura rimane la stessa: una sfida tra conoscenza e limite, tra informazione disponibile e informazione nascosta.

Scrivere un programma per l’impiccato significa, in fondo, tradurre un gioco dell’infanzia in un algoritmo. Il codice prende il posto del foglio, ma il cuore resta identico: indovinare una parola, un carattere alla volta, prima che l’omino si completi.

Risultato (estratto dell’esecuzione)

    Il programma è stato sviluppato in Java con un’attenzione particolare all’architettura, alla modularità e alla possibilità di estensione. La logica del gioco non è legata a una singola lingua né a una singola interfaccia testuale, ma a una classe che riceve dall’esterno alfabeti, messaggi, parole segrete e il rendering dell’impiccato in base allo stato interno.

Sul piano del linguaggio, il progetto utilizza alcuni strumenti tipici di una progettazione in Java. L’uso di un’interfaccia con metodo di default per l’estrazione delle parole mostra come sia possibile definire un’implementazione predefinita, un comportamento astratto riutilizzabile e, allo stesso tempo, specializzarlo in una classe che lo implementa tramite covarianza del tipo di ritorno: il contratto dell’interfaccia rimane valido, ma la classe specializzata adatta il dato al modello interno del gioco. Infine il dynamic dispatch organizza il flusso logico in esecuzione.

La parte linguistica è organizzata attraverso più componenti all’interno di una interfaccia dedicata, tra cui un enum annidato che raccoglie e centralizza tutti i messaggi del gioco come costanti simboliche: a ogni testo è associato un identificatore semantico. Questo rende la localizzazione una proprietà strutturale: una nuova lingua coincide con una nuova interfaccia analoga, dotata di un nuovo insieme coerente di alfabeti, parole e messaggi, senza modificare la logica di gioco centrale e la struttura del progetto.

Sul piano tecnico, la lettura delle parole usufruisce delle API di java.nio.file per lavorare con percorsi e file in modo dichiarativo, mentre l’utilizzo delle Java Stream API ha permesso di ottenere una struttura dati adatta all’elaborazione della logica di gioco.

Nel complesso, la scelta di tenere nettamente separata la gestione dell’I/O dalla logica e di rappresentare i dati in forme via via più specifiche rende evidente il passaggio di responsabilità tra interfacce, implementazioni e modello di gioco. In sintesi, si mette in evidenza come un gioco console-based, tradizionale e minimalista, possa divenire un progetto strutturato tramite aspetti tipici di Java — multiereditarietà di tipo, enum, covarianza, Stream API, dynamic dispatch —, con una chiara separazione dei livelli.
 


Link utili

▶ Esegui il programma su Replit:

  1. Clicca sul link Apri su Replit per accedere al progetto.
  2. Se non hai un account Replit, registrati gratuitamente oppure accedi con Google/GitHub.
  3. Una volta nel progetto, premi “Run” per avviare l’esecuzione.
  4. Puoi consultare il file sorgente e, se desideri, scaricarlo o copiarlo dal pannello di codice a sinistra.


▶ Requisiti:

  1. Java JDK 8 o superiore installato (verifica con java -version).
  2. Console o IDE compatibile con UTF-8.


▶ Scarica la versione portatile del codice:

  1. Effettua queste tre semplici operazioni:
    • Clicca sul link Scarica File per scaricare il file Main.txt, che contiene il codice sorgente completo in formato .txt.
    • Clicca sul link Scarica File per scaricare il file ImpiccatoGame.txt, che contiene il codice sorgente completo in formato .txt.
    • Clicca sul link Scarica File per scaricare il file IOImpiccato.txt, che contiene il codice sorgente completo in formato .txt.
    • Clicca sul link Scarica File per scaricare il file ItalianLanguage.txt, che contiene il codice sorgente completo in formato .txt.
  2. Rinomina i file cambiando l’estensione da .txt a .java.
  3. A. Se usi un IDE Java (VS Code, IntelliJ, NetBeans, Eclipse), crea un nuovo progetto java vuoto e aggiungi il package impiccato; poi importa i quattro file e avvia la classe Main.java come Java Application.
  1. B. Se invece vuoi eseguirlo senza IDE, crea una cartella chiamata impiccato e inserisci al suo interno i quattro file .java.
  2. B. Apri il terminale nella cartella che contiene impiccato/ e usa uno dei comandi seguenti:

macOS / Linux :

mkdir -p out && javac -encoding UTF-8 -d out $(find . -name "*.java") && java -Dfile.encoding=UTF-8 -cp out impiccato.Main


Windows (PowerShell):

mkdir out; javac -encoding UTF-8 -d out (Get-ChildItem -Recurse -Filter *.java).FullName; java -Dfile.encoding=UTF-8 -cp out impiccato.Main


Windows (Prompt dei comandi): esegui i comandi uno alla volta (senza ; tra di essi). Esempio:

mkdir out
javac -encoding UTF-8 -d out *.java
java -Dfile.encoding=UTF-8 -cp out impiccato.Main


▶ Utilizzo:

Dopo l’avvio, la console ti guida passo-passo:

  1. inserisci un carattere (‘ESC’ per uscire) e premi ‘INVIO’ per indovinare la parola segreta,
  2. termina il gioco:
    • indovinando la parola segreta,
    • esaurendo gli 8 tentativi a disposizioni,
    • digitando il carattere ‘ESC’ per uscire e premendo INVIO’ .


Codice

    Il gioco dell’impiccato, in questa versione, diventa un piccolo sistema a stati finiti: a ogni lettera inserita cambiano simultaneamente la maschera sulla parola segreta, il numero di tentativi disponibili, la memoria delle scelte effettuate e la rappresentazione grafica in ASCII dell’impiccato.

Allo stesso modo, la separazione delle responsabilità e la modularità del codice rispecchiano un principio di chiarezza logica dove il flusso del gioco si mantiene trasparente, leggibile e adattabile.

Mentre la traiettoria di una partita oscilla tra inferenza probabilistica e alea, con un esito che dipende dalla qualità delle ipotesi del giocatore.

Gioco dell'impiccato package impiccato
Main.java
ImpiccatoGame.java
IOImpiccato.java
ItalianLanguage.java
1/*
2 Gioco dell'impiccato
3
4 Package: impiccato
5
6 Descrizione:
7 Implementazione da console del gioco dell'impiccato.
8
9 Il programma:
10 – legge da file di testo una lista di parole segrete;
11 – gestisce una partita tra due giocatori, Giocatore 1 (computer) e
12 Giocatore 2 (user);
13 – mostra lo stato corrente della parola (lettere indovinate e da scoprire),
14 i tentativi rimanenti e le lettere già scelte;
15 – valida l'input consentendo solo lettere dell'alfabeto della lingua impostata;
16 – prevede l'estensione a più lingue definendo altre interfacce con
17 la stessa struttura di ItalianLanguage (alfabeto, file delle parole,
18 messaggi);
19 – centralizza i messaggi testuali in un enum e li espone tramite
20 un'interfaccia dedicata (ItalianLanguage), semplificando una
21 futura localizzazione;
22 – incapsula l'input da file e il rendering dell'impiccato in
23 un'interfaccia dedicata (IOImpiccato), per separare logica di gioco
24 e gestione delle risorse.
25
26
27 Autore: Alessio Severi
28 Licenza: MIT License
29
30 MIT License
31
32 Copyright (c) 2025 Alessio Severi
33
34 Permission is hereby granted, free of charge, to any person obtaining a copy
35 of this software and associated documentation files (the "Software"), to deal
36 in the Software without restriction, including without limitation the rights
37 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
38 copies of the Software, and to permit persons to whom the Software is
39 furnished to do so, subject to the following conditions:
40
41 The above copyright notice and this permission notice shall be included in all
42 copies or substantial portions of the Software.
43
44 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
45 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
46 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
47 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
48 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
49 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
50 SOFTWARE.
51
52*/
53
54package impiccato;
55
56import java.util.Scanner;
57
58
59/**
60 * Classe di avvio dell'applicazione.
61 * Contiene il metodo {@code main} che crea un'istanza del gioco
62 * e ne avvia l'esecuzione da console.
63 */
64public class Main {
65
66 /**
67 * Punto di ingresso dell'applicazione.
68 * Inizializza uno {@link java.util.Scanner} per leggere da standard input,
69 * crea un'istanza di {@link ImpiccatoGame} e avvia una nuova partita.
70 *
71 * @param args argomenti da linea di comando (non utilizzati).
72 */
73 public static void main(String[] args) {
74
75 try(Scanner sc = new Scanner(System.in)){
76
77 ImpiccatoGame ig = new ImpiccatoGame();
78
79 // start gioco
80 ig.play(sc);
81
82
83 }
84
85 }
86}
1// © 2025 Alessio Severi — vedi licenza nel file Main.java
2
3
4package impiccato;
5
6import java.nio.file.Path;
7import java.util.ArrayList;
8import java.util.Arrays;
9import java.util.List;
10import java.util.Scanner;
11
12
13
14/**
15 * Rappresenta il gioco dell'impiccato.
16 * Gestisce lo stato della partita e coordina il flusso della partita,
17 * delegando la lettura della parola segreta e la localizzazione dei messaggi
18 * alle interfacce {@link IOImpiccato} e {@link ItalianLanguage}.
19 */
20public class ImpiccatoGame implements IOImpiccato, ItalianLanguage {
21
22
23 /**
24 * Numero massimo di errori consentiti prima che la partita venga persa.
25 */
26 private static final int MAX_COUNT = 8;
27
28
29 /**
30 * Collezione dei caratteri inseriti correttamente dal giocatore
31 * durante la composizione della parola segreta.
32 */
33 private final List<Character> charIn = new ArrayList<>(Arrays.asList('\000'));
34
35 /**
36 * Collezione dei caratteri inseriti dal giocatore
37 * durante la composizione della parola segreta.
38 */
39 private final List<Character> charInU = new ArrayList<>();
40
41 /**
42 * Conteggio dei tentativi effettuati dal giocatore.
43 */
44 private int count = 0;
45
46
47 static {
48 // saluto di benvenuto nella lingua della classe
49 System.out.println("\n\n" + Message.WELCOME.text() + "\n\n");
50 }
51
52
53
54 @Override
55 /**
56 * Estrae una parola casuale dal file indicato e la trasforma in
57 * una lista di caratteri da utilizzare come parola segreta.
58 *
59 * @param path percorso del file contenente l'elenco delle parole.
60 * @param msg1 messaggio da mostrare in caso di errore di lettura.
61 * @return lista di caratteri che rappresenta la parola segreta.
62 */
63 public List<Character> estraiParola(Path path, String msg1) {
64
65
66 String parolaScelta = (String)IOImpiccato.super.estraiParola(path, msg1);
67
68
69 System.out.print(Message.GUESS_PROMPT.text() + "\n" );
70
71
72 return parolaScelta.chars().mapToObj(i -> (char)i).toList();
73
74 }
75
76
77
78 /**
79 * Gestisce l'inserimento di una lettera da parte del giocatore.
80 * Controlla la validità dell'input, aggiorna il numero di tentativi
81 * rimanenti e registra le lettere corrette e inserite nelle collezioni interne.
82 *
83 * @param sc scanner utilizzato per leggere l'input da console.
84 * @param sacchetto lista delle lettere ancora disponibili.
85 * @param parola lista di caratteri che rappresenta la parola segreta.
86 * @return {@code true} se l'input è valido e la partita può proseguire,
87 * {@code false} in caso di errore bloccante sull'input.
88 */
89 public boolean estraiLettera(Scanner sc, List<Character> sacchetto, List<Character> parola) {
90
91
92 // estrazione lettera e sistemazione sacchetto
93
94 int index;
95 String str = Message.CHOICE_PROMPT.text();
96 String str2 = Message.LETTER_CHOICE.text();
97
98
99
100 System.out.println("\n\n" + str);
101
102 char car = Character.toLowerCase(sc.next().charAt(0));
103
104 sc.nextLine();
105
106 System.out.println("\033[1A\r"+ "\033[K");
107 System.out.println(str2 + "'" + Character.toUpperCase(car) + "'\n");
108
109
110 if((index = sacchetto.indexOf(car)) == –1) {
111
112 // '\033' carattere di esc
113 if(car == '\033'){
114
115 System.out.println("\033[2A\r"+ str2.replace(Message.LETTER.text(), Message.CHARACTER.text()) + "'ESC'");
116 System.out.println("\n\n" + Message.EXIT.text() + "\n\n");
117
118 System.exit(0);
119 }
120
121 else if(Character.isAlphabetic(car))
122
123 System.out.println(Message.NOTICE_LETTER.text() + ": " + charInU);
124
125 else {
126
127 System.out.println("\033[2A\r"+ str2.replace(Message.LETTER.text(), Message.CHARACTER.text()) + "'" + car + "'\n");
128 System.out.println(Message.WARNING_CHAR.text());
129 }
130
131
132 return true;
133 }
134
135 charInU.add(Character.toUpperCase(car));
136 sacchetto.remove(index);
137
138
139 // controllo corrispondenze tra la parola e la lettera
140 if(parola.contains(car)){
141
142 System.out.println(Message.WIN_LETTER.text());
143
144 charIn.add(car);
145
146 }
147 else{
148
149 String a= ((++count == MAX_COUNT – 1) ? Message.REMAIN_ONE.text() : Message.REMAIN_MANY.text());
150 String b= ((count == MAX_COUNT – 1) ? Message.ATTEMPT_ONE.text() : Message.ATTEMPTS_MANY.text());
151
152 System.out.println(Message.LOSE_LETTER.text() + a + Message.STILL.text() + (MAX_COUNT – count) + b);
153 IOImpiccato.printImpiccato(count);
154 }
155
156 return false;
157 }
158
159
160
161 /**
162 * Stampa a video lo stato corrente della parola da indovinare,
163 * mostrando le lettere già individuate e mascherando le restanti.
164 *
165 * Inoltre mostra un riepilogo delle lettere precedentemente scelte.
166 *
167 * @param parola lista di caratteri che rappresenta la parola segreta.
168 * @return {@code true} se la parola è stata indovinata completamente,
169 * {@code false} altrimenti.
170 */
171 public boolean componiParola(List<Character> parola) {
172
173
174 boolean flag = true;
175
176
177 System.out.print("\n" + Message.SECRET_WORD.text());
178
179 for (int i = 0; i < parola.size(); i++){
180
181 for (int j = 0; j < charIn.size(); j++){
182
183
184 if(parola.get(i).equals(charIn.get(j))){
185
186 System.out.print(Character.toUpperCase(charIn.get(j)));
187 break;
188 }
189 else if(j == charIn.size() – 1){
190
191 System.out.print("_");
192 if(flag) flag = false;
193 }
194 }
195 System.out.print(" ");
196
197 }
198
199 System.out.print("\n\n" + Message.USER_LETTERS.text() + charInU);
200
201 return flag;
202
203
204 }
205
206
207
208 /**
209 * Valuta la condizione di vittoria o sconfitta della partita in base
210 * allo stato corrente della parola e al numero di tentativi utilizzati.
211 *
212 * @param flag indica se la parola è stata indovinata.
213 * @param parola lista di caratteri che rappresenta la parola segreta.
214 */
215 public void controlWinLos(boolean flag, List<Character> parola) {
216
217 if(count == MAX_COUNT || flag){
218
219 if(count == MAX_COUNT){
220
221 System.out.println("\033[A\033[F" + Message.USER_LETTERS.text() + charInU);
222 System.out.print("\n" + Message.LOSE_GAME.text() + "\033[K");
223
224 parola.stream().map(Character::toUpperCase).forEach(System.out::print);
225
226 System.out.println();
227
228 }
229 else
230 System.out.println("\n\n" + Message.WIN_GAME.text());
231
232
233 System.out.println("\n\n" + Message.EXIT.text() + "\n\n");
234
235 }
236
237
238 }
239
240
241
242 /**
243 * Avvia una nuova partita dell'impiccato.
244 * Inizializza il sacchetto delle lettere, estrae la parola segreta
245 * e gestisce il ciclo principale di gioco finché non si verifica
246 * una condizione di vittoria o di sconfitta.
247 *
248 * @param sc scanner utilizzato per leggere l'input da console.
249 */
250 public void play(Scanner sc) {
251
252
253 boolean flag;
254
255 List<Character> sacchetto = riempiSacchetto();
256
257 List<Character> parola = estraiParola(pathFile(), Message.ERROR_FILE.text());
258
259 componiParola(parola);
260
261
262 while(true){
263
264 if(!estraiLettera(sc, sacchetto, parola)){
265
266 flag = componiParola(parola);
267
268 controlWinLos(flag, parola);
269
270 if ((count == MAX_COUNT) || (flag))
271 break;
272
273 }
274
275 }
276
277 }
278
279
280}
281
282
1// © 2025 Alessio Severi — vedi licenza nel file Main.java
2
3
4package impiccato;
5
6import java.io.IOException;
7import java.nio.file.Files;
8import java.nio.file.Path;
9import java.util.List;
10import java.util.Random;
11
12
13/**
14 * Astrazione delle operazioni di input/output legate alla gestione
15 * del gioco dell'impiccato.
16 *
17 * Fornisce un metodo di utilità per l'estrazione della parola segreta
18 * da file e un metodo statico per la stampa grafica dell'impiccato
19 * in base al numero di errori commessi.
20 */
21interface IOImpiccato {
22
23
24 /**
25 * Estrae una parola casuale dal file indicato.
26 * In caso di problemi di lettura, gestisce l'eccezione I/O
27 * e restituisce {@code null}.
28 *
29 * @param path percorso del file contenente l'elenco delle parole.
30 * @param msg1 messaggio da mostrare in caso di errore di lettura.
31 * @return parola estratta come oggetto generico, oppure {@code null}
32 * se si è verificato un errore.
33 */
34 default Object estraiParola(Path path, String msg1) {
35
36
37 final Random rn = new Random();
38
39 List<String> lista = null;
40
41
42 try {
43 lista = Files.readAllLines(path);
44
45 }
46 catch (IOException e) {}
47
48
49 if (lista == null || lista.isEmpty()) {
50
51 System.out.println(msg1 + path + "\n\n");
52 System.exit(1);
53 }
54
55
56
57 return lista.get(rn.nextInt(lista.size()));
58
59
60 }
61
62
63
64
65 /**
66 * Stampa a video la rappresentazione testuale dell'impiccato
67 * in funzione del numero di tentativi errati effettuati.
68 *
69 * @param count numero di errori commessi dal giocatore.
70 */
71 public static void printImpiccato(int count) {
72
73 // disegno il sostegno e la corda
74 String s1=(" |ˉˉˉˉˉ|");
75 String s2=(" | ");
76 String s3=(" | ");
77 String s4=(" | ");
78 String s5=("_|_ ");
79
80 String[] array1= { s2, s3, s4};
81
82
83 System.out.println("\n" + s1);
84
85 for (int i = 0; i < 3; i++) System.out.print(array1[i] + "\n");
86
87 System.out.println(s5);
88
89
90
91 // disegno l'impiccato
92 String s6=("ò_ò\033[1B\033[4D°-|-°\033[1B\033[3D∫la");
93
94
95 System.out.print("\033[4A"); // salgo di 4 righe
96 System.out.print("\033[6C"); // vado 6 colonne a destra
97
98
99 int tent = count + 2;
100
101 // Compensa i caratteri ANSI che occupano spazio
102 if (count >= 2) tent += 8; // dopo 'ò_ò' ci sono 2 escape = 8 caratteri
103 if (count >= 6) tent += 8; // dopo '°-|-°' ci sono altri 2 escape = 8 caratteri
104
105 for (int i = 0; i < tent; i++) System.out.print(s6.charAt(i));
106
107
108 System.out.print("\033[3B"); // Scendo di 3 righe
109
110 if(count == 1) System.out.println("");
111
112 }
113
114}
1// © 2025 Alessio Severi — vedi licenza nel file Main.java
2
3
4package impiccato;
5
6import java.nio.file.Path;
7import java.util.ArrayList;
8import java.util.List;
9
10
11/**
12 * Definisce gli elementi legati alla user experience (localizzazione linguistica)
13 * del gioco dell'impiccato in una determinata lingua:
14 *
15 * – metodi di utilità per le lettere alfabetiche e
16 * il percorso dei file di risorse
17 * – un enumeratore per i messaggi testuali
18 */
19interface ItalianLanguage {
20
21
22 /**
23 * Crea e restituisce il sacchetto delle lettere alfabetiche disponibili per il gioco.
24 * L'implementazione predefinita popola la lista con le lettere dell'alfabeto
25 * nella lingua corrente.
26 *
27 * @return lista di caratteri che rappresenta il sacchetto delle lettere.
28 */
29 default List<Character> riempiSacchetto() {
30
31 final List<Character> sacchetto = new ArrayList<>();
32
33 // char car = 97;
34 char car = 'a';
35
36
37 while(Character.isAlphabetic(car))
38 sacchetto.add(car++);
39
40 return sacchetto;
41
42
43 }
44
45
46 /**
47 * Elenco dei messaggi testuali utilizzati dal gioco.
48 * Ogni costante rappresenta un messaggio specifico mostrato
49 * all'utente in diverse fasi della partita.
50 */
51 enum Message {
52
53
54 WELCOME("Benvenuto nel gioco dell'impiccato"),
55 ERROR_FILE("Errore: impossibile leggere le parole dal file "),
56 GUESS_PROMPT("Giocatore 1: Indovina la parola segreta:"),
57 USER_LETTERS("Giocatore 1: Riepilogo lettere scelte: "),
58 CHOICE_PROMPT("Giocatore 1: Scegli un carattere ('ESC' per uscire) e premi 'INVIO': "),
59 LETTER_CHOICE("Giocatore 2: Scelgo la lettera "),
60 LETTER("la lettera"),
61 CHARACTER("il carattere"),
62 NOTICE_LETTER("Giocatore 1: Lettera già scelta"),
63 WARNING_CHAR("Giocatore 1: Carattere non ammesso"),
64 WIN_LETTER("Giocatore 1: Lettera indovinata!"),
65 REMAIN_ONE("resta"),
66 REMAIN_MANY("restano"),
67 ATTEMPT_ONE(" tentativo."),
68 ATTEMPTS_MANY(" tentativi."),
69 LOSE_LETTER("Giocatore 1: Lettera non indovinata, "),
70 STILL(" ancora "),
71 SECRET_WORD("Giocatore 1: La parola è "),
72 LOSE_GAME("Giocatore 1: Hai perso, la parola da indovinare era: "),
73 WIN_GAME("Giocatore 1: Hai vinto!!"),
74 EXIT("Giocatore 1: Grazie di aver giocato. Arrivederci!");
75
76
77 private final String text;
78
79 Message(String text) {
80 this.text = text;
81 }
82
83 /**
84 * Restituisce il testo associato al messaggio.
85 *
86 * @return stringa localizzata corrispondente al messaggio.
87 */
88 public String text() {
89 return text;
90 }
91
92
93 }
94
95
96 /**
97 * Restituisce il percorso del file che contiene l'elenco delle parole
98 * da utilizzare per l'estrazione della parola segreta.
99 *
100 * È pensato per essere esteso in futuro, ad esempio restituendo
101 * percorsi diversi in base a più file di risorse.
102 *
103 * @return percorso del file delle parole.
104 */
105 default Path pathFile() {
106
107 // Estensioni: per es. aggiungi altre pah e ritorna una path casuale
108 // tra quelle elencate
109 Path path1 = Path.of("impiccato/files/parole.txt");
110
111 return path1;
112 }
113
114}
Java 17+ MIT © 2025 Alessio Severi