Programmare in java: 4. Duello sotto la luna

Programmare in java: 4. Duello sotto la luna – simulazione animata in console

Introduzione

    Nella storia dell’informatica, il gioco è stato più di un passatempo: è stato un esperimento.

Quando nel 1952 il matematico Alexander “Sandy” Douglas creò OXO — una versione elettronica del tris per il computer EDSAC — non cercava intrattenimento, ma un modo per dimostrare l’interazione tra uomo e macchina. Pochi anni dopo, nel 1958, William Higinbotham sviluppò Tennis for Two su un oscilloscopio: due linee, un punto luminoso e un’idea nuova di partecipazione.

Il gioco, da dimostrazione tecnica, divenne linguaggio. Negli anni Sessanta, nei laboratori universitari e nei centri di ricerca, nacquero Spacewar! e i primi prototipi di simulazioni: mondi chiusi governati da regole, in cui il caso era programmato e la vittoria significava comprendere il sistema.

Con la diffusione delle prime console e dei personal computer negli anni Settanta e Ottanta, il videogioco passò dal laboratorio al salotto, trasformandosi da esperimento accademico a forma culturale. Eppure, alla base, restò invariata la sua essenza: una sfida tra ordine e imprevisto, tra algoritmo e intuizione.

Oggi, scrivere un gioco in codice significa ripercorrere quella stessa traiettoria: progettare strutture, simulare mondi, restituire alla macchina la capacità di sorprendere. In fondo, ogni gioco — anche digitale — è una metafora dell’intelligenza stessa: un luogo dove la logica modella, e la mente gioca con sé stessa.

Ogni videogioco, anche il più semplice, è un atto di traduzione — l’idea diviene un linguaggio formale nella forma, e la mente trova nel codice un nuovo spazio per immaginare.

Risultato

    Il programma è stato sviluppato in Java con un approccio orientato alla chiarezza logica e alla modularità.

L’architettura si fonda sull’uso estensivo delle interfacce, che costituiscono il punto di contatto tra astrazione e implementazione concreta.
In un linguaggio fortemente tipizzato come Java, le interfacce definiscono un contratto astratto: ogni classe che le implementa è tenuta a fornire le implementazioni concrete dei metodi dichiarati astratti, pur lasciando piena libertà sul comportamento interno. Sul piano più generale, assicurano compatibilità tra tipizzazione e modularità, favorendo l’estendibilità, l’evolvibilità e il controllo semantico.

Nel caso specifico, la scelta di utilizzare l’interfaccia comune per i personaggi consente di sostituire o aggiungere nuove abilità e/o avatar senza alterare il comportamento del sistema. Pur utilizzando nel codice un’unica istanza della classe Abilita, l’approccio permette di introdurre in futuro varianti o comportamenti differenziati per ciascun avatar, senza compromettere la logica esistente.

In modo analogo, l’impiego del costrutto switch con espressioni lambda mostra la capacità del linguaggio di modellare processi condizionali in forma compatta e funzionale.

Tale scelta, oltre a migliorare la leggibilità, traduce in codice l’idea di un sistema dinamico: regole precise che generano comportamenti emergenti e riproducibili. Al contempo, rappresenta l’incontro tra struttura e creatività: un sistema governato dalla logica, ma animato dall’imprevedibilità dell’interazione.

“Un piccolo duello, tra codice e immaginazione, dove la logica si fa gioco e la console diventa teatro.”
 


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.
  3. Larghezza della finestra console consigliata: almeno 100 caratteri, per evitare interruzioni di riga durante l’animazione e garantire una resa ottimale dei duelli.


▶ 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 Abilita.txt, che contiene il codice sorgente completo in formato .txt.
    • Clicca sul link Scarica File per scaricare il file Animate.txt, che contiene il codice sorgente completo in formato .txt.
    • Clicca sul link Scarica File per scaricare il file AvatarsCombat.txt, che contiene il codice sorgente completo in formato .txt.
    • Clicca sul link Scarica File per scaricare il file Combat.txt, che contiene il codice sorgente completo in formato .txt.
    • Clicca sul link Scarica File per scaricare il file LunaCombat.txt, che contiene il codice sorgente completo in formato .txt.
    • Clicca sul link Scarica File per scaricare il file Personaggio.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 personaggi; poi importa i sette file e avvia la classe Main.java come Java Application.
  1. B. Se invece vuoi eseguirlo senza IDE, crea una cartella chiamata personaggi e inserisci al suo interno i sette file .java.
  2. B. Apri il terminale nella cartella che contiene personaggi/ 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 personaggi.Main


Windows (PowerShell):

mkdir out; javac -encoding UTF-8 -d out (Get-ChildItem -Recurse -Filter *.java).FullName; java -Dfile.encoding=UTF-8 -cp out personaggi.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 personaggi.Main


▶ Utilizzo:

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

  1. Tuttavia, l’utente può impostare nel Main, per ciascun round, la fase lunare e l’avatar in tre modalità:
    • Da codice, modificando i parametri dell’avatar e/o della luna piena (es. “eroe”, “vampiro”, “licantropo” per l’avatar, e “on”, “off” per impostare lo scenario con la luna piena). Questa modalità è utile per test o configurazioni personalizzate già predefinite.
    • In modalità interattiva, inserendo la parola “input” nei parametri dell’avatar e/o della luna piena: in questo caso, durante l’esecuzione il programma chiederà in console di digitare i valori tra quelli sopra menzionati.
    • In modalità automatica (“auto”) per impostare l’avatar e analogamente impostare lo scenario, in particolare l’avatar e lo scenario vengono scelti casualmente.
  2. Se in un round i due avatar coincidono, il programma attiva automaticamente la modalità allenamento, permettendo un duello del personaggio con sé stesso.
  3. In caso di errore dei parametri modificati da codice o input non valido (es. scrivere nomi errati per la scelta dell’avatar o valori diversi da “input” / “auto”/”on” / “off” come sopra descritto), il sistema applica valori di default garantendo comunque l’esecuzione del round. Questo comportamento implementa un principio di resilienza logica: il programma non interrompe mai il flusso, ma si adatta e mantiene sempre una configurazione valida. È una scelta progettuale che:
    • mantiene il Main snello e leggibile,
    • preserva la modularità del codice,
    • e conferisce al sistema un comportamento “intelligente”, tipico delle simulazioni interattive robuste.
replit.com
A

Duello sotto la luna

@alessioseveri27


Codice

    Il progetto è articolato in più classi e interfacce che collaborano secondo ruoli distinti ma complementari.

Personaggio e Abilita gestiscono lo stato e la forza dei combattenti.

Le interfacce LunaCombat e AvatarsCombat aggiungono logiche specifiche di contesto, come la fase lunare o la scelta dell’avatar: modella tre strategie di comportamento diverse, implementate tramite metodi default e statici. Inoltre nel licantropo cambia lo stato iniziale della forza e l’abilità di combattimento a seconda della fase lunare: un piccolo pattern “Observer” naturale — il mondo cambia e il personaggio interagisce con il suo nuovo stato. Cosicché l’animazione in console non è solo un effetto grafico, ma la rappresentazione testuale di un ciclo di vita: la scena si aggiorna, i personaggi reagiscono, e il mondo (la luna) continua a influenzarli.

La classe Combat coordina il flusso principale di gioco e l’interazione con l’utente, mentre Animate estende Combat per la resa visiva, mostrando una breve animazione in console dei combattenti.

Il punto di ingresso del programma, contenuto nel file Main.java, orchestra i round di combattimento richiamando progressivamente le classi e le interfacce descritte, rendendo visibile in console l’evoluzione della simulazione.

La combinazione di queste componenti realizza un sistema polimorfico a livello logico-funzionale, dove il tipo di avatar determina il comportamento e la forza del personaggio, in un ambiente influenzato dallo stato della luna.

Allo stesso modo, la separazione delle responsabilità e la modularità del codice rispecchiano un principio di chiarezza logica: ogni interfaccia e classe opera come parte di un sistema coerente, dove il flusso del gioco si mantiene trasparente, leggibile e adattabile.

In sintesi, l’intero sistema si comporta come un piccolo ecosistema interattivo, in cui logica, animazione e mondo simulato si riflettono a vicenda in un equilibrio dinamico e leggibile.

Duello sotto la luna package personaggi
Main.java
Personaggio.java
Abilita.java
Animate.java
Combat.java
LunaCombat.java
AvatarsCombat.java
1
2/*
3
4 Duello sotto la luna – simulazione animata in console
5
6 Package: personaggi
7
8 Descrizione:
9 Simulazione di un duello in Java tra avatar animati in console.
10 L’utente sceglie il tipo di combattimento (allenamento o sfida),
11 l’avatar e lo scenario, influenzati dalla fase lunare.
12
13 Il progetto integra interfacce, con metodi statici e default, e classi per l'animazione
14 in console, per modellare la logica dei personaggi e gli effetti della fase lunare,
15 realizzando un comportamento polimorfico di tipo funzionale.
16 L’architettura modulare rende il codice leggibile, estensibile e riutilizzabile.
17
18
19 Autore: Alessio Severi
20 Licenza: MIT License
21
22 MIT License
23
24 Copyright (c) 2025 Alessio Severi
25
26 Permission is hereby granted, free of charge, to any person obtaining a copy
27 of this software and associated documentation files (the "Software"), to deal
28 in the Software without restriction, including without limitation the rights
29 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
30 copies of the Software, and to permit persons to whom the Software is
31 furnished to do so, subject to the following conditions:
32
33 The above copyright notice and this permission notice shall be included in all
34 copies or substantial portions of the Software.
35
36 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
37 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
38 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
39 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
40 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
41 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
42 SOFTWARE.
43
44*/
45
46
47
48package personaggi;
49
50public class Main {
51 public static void main(String[] args) {
52
53
54
55 // In ordine: Eroe (0), Licantropo (1), Vampiro (2)
56 Personaggio[] avatars_play = {
57 new Abilita(), // 0 → Eroe
58 new Abilita(), // 1 → Licantropo
59 new Abilita() // 2 → Vampiro
60 };
61
62
63 Animate controller= new Animate(avatars_play);
64
65 // 1° combattimento: Eroe vs Licantropo (luna piena)
66 controller.setCombat("off", new String[]{"eroe", "eroe"});
67 controller.stampaHeaderRound();
68 controller.stampaAnimate();
69 controller.stampaRisulatatiCombatAvatars();
70
71
72 // 2° combattimento: Eroe vs Licantropo (luna NON piena)
73 controller.setCombat("auto", new String[]{"auto", "licantropo"});
74 controller.stampaHeaderRound();
75 controller.stampaAnimate();
76 controller.stampaRisulatatiCombatAvatars();
77
78
79 // 3° combattimento: Eroe vs Vampiro (luna piena)
80 controller.setCombat("input", new String[]{"input", "vampiro"});
81 controller.stampaHeaderRound();
82 controller.stampaAnimate();
83 controller.stampaRisulatatiCombatAvatars();
84
85
86 controller.stampaRisulatatiAvatars();
87
88 Combat.chiudiScanner(); // solo a fine programma
89 }
90
91}
92
1
2
3// © 2025 Alessio Severi — vedi licenza nel file Main.java
4
5
6package personaggi;
7
8public interface Personaggio {
9
10
11 int MOSTRO_FORZA_INIZIALE= 15;
12 int MOSTRO_TIPO_COMBATTIMENTO= 2;
13 int UOMO_FORZA_INIZIALE= 10;
14 int UOMO_TIPO_COMBATTIMENTO= 3;
15
16
17 String[] AVATAR_NAME= {"Eroe", "Licantropo", "Vampiro"};
18
19
20 void setForzaFisica();
21 void setLuna(boolean luna);
22 int getForza();
23 int getN_combat();
24
25
26}
27
1
2
3// © 2025 Alessio Severi — vedi licenza nel file Main.java
4
5
6package personaggi;
7
8
9public class Abilita implements Personaggio {
10
11
12 private int n_combat;
13 private int forza;
14 private boolean luna;
15
16
17
18 @Override
19 public void setForzaFisica(){
20
21 if(n_combat== 0) forza = (luna) ? MOSTRO_FORZA_INIZIALE : UOMO_FORZA_INIZIALE;
22
23 forza -= (luna) ? MOSTRO_TIPO_COMBATTIMENTO : UOMO_TIPO_COMBATTIMENTO;
24 n_combat++;
25 }
26
27
28 @Override
29 public void setLuna(boolean luna){
30
31 this.luna= luna;
32 }
33
34
35 @Override
36 public int getN_combat() {
37 return n_combat;
38 }
39
40
41 @Override
42 public int getForza() {
43 return forza;
44 }
45
46
47}
48
1
2// © 2025 Alessio Severi — vedi licenza nel file Main.java
3
4package personaggi;
5
6public class Animate extends Combat {
7
8 private final String COLORE1 = "\033[34m"; // blu per eroe
9 private final String COLORE2 = "\033[31m"; // rosso per vampiro/
10 private final String COLORE3 = "\033[32m"; // verde licantropo
11
12 private final int TIME = 80;
13 private final int LENGTH_TERMINAL = 100;
14 private final int LENGTH = 20;
15
16 private final String[][] animate_avatars = new String[2][];
17
18 public Animate(Personaggio[] avatars) {
19 super(avatars);
20 }
21
22 public void setAnimateAvatar() {
23
24 for (int i = 0; i < 2; i++) {
25
26 animate_avatars[i] = switch (fifhters[i].toLowerCase()) {
27 case "eroe" -> new String[] { COLORE1 + " __(ò_ó) ",
28 COLORE1 + "|* |-§≠|===>",
29 COLORE1 + " \\/ / \\ "
30 };
31 case "vampiro" -> new String[] { COLORE2 + " (㇏(•̀.•́)ノ) ",
32 COLORE2 + " ) ཀ ( ",
33 COLORE2 + " ) / \\ ( "
34 };
35 case "licantropo" -> new String[] { COLORE3 + " ᕦ(•̀.•́)ᕤ ",
36 COLORE3 + " Ǝ= ཀ =E ",
37 COLORE3 + " / \\ "
38 };
39 default -> new String[] { "", "", "" }; // obbligatorio in uno switch expression
40
41 };
42 if ("allenamento".equals(modalita_combat))
43 break;
44
45 }
46 }
47
48 public void stampaSingleAvatars() {
49
50 String testa = animate_avatars[0][0];
51 String torso = animate_avatars[0][1];
52 String gambe = animate_avatars[0][2];
53
54 String spazio;
55
56 System.out.println();
57
58 for (int posizione = 0; posizione < LENGTH; posizione++) {
59 spazio = " ".repeat(posizione);
60
61 // Stampa le tre righe con spazi iniziali per animazione
62 System.out.print("\r");
63 System.out.println();
64 System.out.print(spazio + testa + "\n");
65 System.out.print(spazio + torso + "\n");
66 System.out.print(spazio + gambe + "\n");
67 System.out.println();
68
69 try {
70
71 Thread.sleep(TIME); // tempo per effetto animato
72
73 } catch (InterruptedException e) {
74
75 Thread.currentThread().interrupt();
76 }
77
78 // Torna indietro di 3 righe per riscrivere sopra
79 System.out.print("\033[F\033[F\033[F\033[F\033[F");
80 }
81
82 System.out.println("\n\n\n\n\n\n\n");
83 }
84
85 public void stampaDoubleAvatars() {
86
87 // Corpo eroe da sinistra
88 String testa1 = animate_avatars[0][0];
89 String torso1 = animate_avatars[0][1];
90 String gambe1 = animate_avatars[0][2];
91
92 // Corpo eroe da destra
93 String testa2 = animate_avatars[1][0];
94 String torso2 = animate_avatars[1][1];
95 String gambe2 = animate_avatars[1][2];
96
97 if (fifhters[0].toLowerCase().equals("licantropo"))
98 testa2 = " " + testa2;
99
100 // Limita la distanza massima in base alla larghezza del terminale
101 int width = LENGTH_TERMINAL;
102 int tot = testa1.length() + testa2.length();
103 int maxFree = Math.max(0, width – tot);
104
105 // Assicura che il ciclo non faccia “andare a capo” le righe
106 int passoFinale = Math.min(LENGTH, maxFree);
107 int spazio1;
108 int spazio2;
109
110 System.out.println("\n\n\n\n\n");
111
112 for (int passo = 0; passo <= passoFinale; passo++) {
113
114 spazio1 = Math.min(passo, maxFree);
115 spazio2 = maxFree – spazio1;
116
117 // Torna su 4 righe e cancella
118 System.out.print("\033[F\033[F\033[F\033[F\033[F");
119 for (int i = 0; i < 4; i++)
120 System.out.println(" ".repeat(LENGTH_TERMINAL)); // Riga vuota
121
122 // Risale
123 System.out.print("\033[F\033[F\033[F\033[F");
124
125 // Stampa eroi
126 System.out.println();
127 System.out.println(" ".repeat(spazio1) + testa1 + " ".repeat(spazio2 – spazio1 – testa1.length()) + testa2);
128 System.out.println(" ".repeat(spazio1) + torso1 + " ".repeat(spazio2 – spazio1 – torso1.length()) + torso2);
129 System.out.println(" ".repeat(spazio1) + gambe1 + " ".repeat(spazio2 – spazio1 – gambe1.length()) + gambe2);
130 System.out.println();
131
132 try {
133
134 Thread.sleep(TIME); // tempo per effetto animato
135
136 } catch (InterruptedException e) {
137
138 Thread.currentThread().interrupt();
139 }
140 }
141
142 System.out.println("\n\n");
143
144 }
145
146 public void stampaAnimate() {
147
148 setAnimateAvatar();
149
150 switch (modalita_combat) {
151 case "allenamento" -> stampaSingleAvatars();
152 case "combattimento" -> stampaDoubleAvatars();
153 default -> stampaSingleAvatars();
154 } // senza assegnamento non devo metter il ;
155 }
156
157}
158
1
2
3// © 2025 Alessio Severi — vedi licenza nel file Main.java
4
5
6package personaggi;
7
8import java.util.Scanner;
9
10public class Combat implements LunaCombat, AvatarsCombat{
11
12
13
14 public static final Scanner sc = new Scanner(System.in); // unico punto di accesso
15
16
17 private final String COLOR4= "\033[0m"; // reset colore
18
19 protected final Personaggio[] avatars; // copia della copia del riferimento dell'stanza della classe Personaggio
20 protected final boolean[] tipo_personaggio= {false, true, true}; // eroe, licantropo, vampiro
21
22 protected final String[] fifhters= {null, null};
23 protected String modalita_combat;
24 protected int n_round;
25
26
27
28
29
30 public Combat(Personaggio[] avatars) {
31 this.avatars = avatars;
32 }
33
34
35
36 public void setCombat(String choose_moon, String[] choose_avatars_combat) {
37
38 tipo_personaggio[LICANTROPO]= switch (choose_moon.toLowerCase()) {
39 case "auto" -> LunaCombat.setLunaCombat(); // genera random
40 case "input" -> setLunaCombatI(); // input da tastiera — se ovveride: { yield LunaCombat.super.setLunaCombat(3); } — this.setLunaCombat(3);
41 default -> setLunaCombat(choose_moon); // interpreta stringa "luna_on"/"luna_off" — idem
42 };
43
44 int[] avatars_combat= new int[avatars.length];
45
46
47 for (int i = 0; i < 2; i++) {
48
49 avatars_combat[i]= switch (choose_avatars_combat[i].toLowerCase()) {
50 case "auto" -> AvatarsCombat.setAvatarCombat(); // genera random
51 case "input" -> setAvatarCombatI(); // input da tastiera — se ovveride: { yield LunaCombat.super.setLunaCombat(3); } — this.setLunaCombat(3);
52 default -> setAvatarCombat(choose_avatars_combat[i]);
53
54 };
55 }
56
57
58 for (int i = 0; i < 2; i++) {
59
60 avatars[avatars_combat[i]].setLuna(tipo_personaggio[avatars_combat[i]]);
61 avatars[avatars_combat[i]].setForzaFisica();
62
63 fifhters[i]= Personaggio.AVATAR_NAME[avatars_combat[i]];
64
65
66 if(avatars_combat[0]== avatars_combat[1]){
67 modalita_combat= "allenamento";
68 break;
69 }
70
71 if(i== 1) modalita_combat= "combattimento";
72
73
74 }
75
76 n_round++;
77
78
79 }
80
81
82 // scenario di battaglia/allenamento
83 public String getLunaCombat(){
84
85 return (tipo_personaggio[LICANTROPO]) ? "Luna piena 🌕": "Luna NON piena 🌑";
86 }
87
88
89
90 // esempio: 1° combattimento: Eroe vs Licantropo (luna piena)
91 public void stampaHeaderRound(){
92
93 StringBuilder stringa= new StringBuilder();
94
95 stringa.append(n_round);
96 stringa.append("° round – ");
97 stringa.append(modalita_combat);
98 stringa.append(": ");
99 stringa.append(fifhters[0]);
100
101 if(modalita_combat.equals("combattimento")){
102
103 stringa.append(" vs ");
104 stringa.append(fifhters[1]);
105 }
106
107
108 stringa.append(" (");
109 stringa.append(getLunaCombat());
110 stringa.append(")");
111
112 System.out.println("\n\n"+stringa);
113 }
114
115
116 public void stampaRisulatatiCombatAvatars(){
117
118 System.out.println("\n"+COLOR4 + "Risulatato " + modalita_combat + ":");
119
120 // Stampa risultato finale
121 for (int i = 0; i < 2; i++) {
122
123 for (int j = 0; j < avatars.length; j++){
124
125 if(Personaggio.AVATAR_NAME[j].toLowerCase().equals(fifhters[i].toLowerCase()))
126 System.out.println("Personaggio: " + fifhters[i] + " → forza: " + avatars[j].getForza() + " e round compiuti: " + avatars[j].getN_combat());
127
128 }
129 if(modalita_combat.equals("allenamento")) break;
130
131 }
132
133
134 }
135
136
137 public void stampaRisulatatiAvatars(){
138
139 System.out.println("\n\nRisulatati Avatars:");
140
141 // Stampa risultato finale
142 for (int i = 0; i < avatars.length; i++) {
143
144 System.out.println("Personaggio: " + Personaggio.AVATAR_NAME[i] + " → forza: " + avatars[i].getForza() + " e round compiuti: " + avatars[i].getN_combat());
145
146 }
147
148 System.out.println("\n\n");
149
150 }
151
152
153 public static void chiudiScanner() {
154 sc.close(); // lo richiamo solo nel main a fine esecuzione
155 }
156
157}
158
1
2
3// © 2025 Alessio Severi — vedi licenza nel file Main.java
4
5
6package personaggi;
7
8import java.util.Random;
9
10
11public interface LunaCombat {
12
13
14 static boolean LUNA_PIENA = true, LUNA_NON_PIENA = false;
15 static boolean[] LUNA= {LUNA_NON_PIENA, LUNA_PIENA};
16
17
18
19 default boolean setLunaCombat(String lunaString){
20
21
22 // yield va racchiuso tra parentesi graffe
23 return switch (lunaString.toLowerCase()) {
24 case "off" -> LUNA[0];
25 case "on" -> LUNA[1];
26 default -> LUNA[0];
27 };
28
29
30 }
31
32
33 static boolean setLunaCombat(){
34
35 Random rn = new Random();
36
37 return LUNA[rn.nextInt(0, LUNA.length)];
38 }
39
40
41 @SuppressWarnings("ConvertToTryWithResources")
42 default boolean setLunaCombatI(){
43
44
45 System.out.print("\n\nDigita il valore della luna, on se vuoi impostare la luna piena altrimenti digita off: ");
46
47 return setLunaCombat(Combat.sc.nextLine());
48 }
49}
50
1
2
3// © 2025 Alessio Severi — vedi licenza nel file Main.java
4
5
6package personaggi;
7
8import java.util.Random;
9
10public interface AvatarsCombat {
11
12
13 static int EROE= 0, LICANTROPO= 1, VAMPIRO= 2;
14 static int[] AVATAR_NAME= {EROE, LICANTROPO, VAMPIRO};
15
16
17
18 default int setAvatarCombat(String avatarsCombatString){
19
20 // yield va racchiuso tra parentesi graffe
21 return switch (avatarsCombatString.toLowerCase()) {
22 case "eroe" -> AVATAR_NAME[0];
23 case "licantropo" -> AVATAR_NAME[1];
24 case "vampiro" -> AVATAR_NAME[2];
25 default -> AVATAR_NAME[0];
26 };
27
28
29 }
30
31
32 static int setAvatarCombat(){
33
34 Random rn = new Random();
35
36 return rn.nextInt(0, AVATAR_NAME.length);
37 }
38
39
40
41 default int setAvatarCombatI(){
42
43
44 System.out.print("\n\nDigita l'avatar con cui vuoi combattere tra: Eroe o Licantropo o Vampiro: ");
45
46 return setAvatarCombat(Combat.sc.nextLine());
47 }
48
49}
50
Java 17+ MIT © 2025 Alessio Severi