From 7167b4341ef290d56fb96e2af10883a4b925d83b Mon Sep 17 00:00:00 2001
From: Sebastiano Tronto <sebastiano@tronto.net>
Date: Thu, 26 Mar 2026 19:27:18 +0100
Subject: I found my old code!

---
 .../v2.3/src/RobottinoAzioni/RobottinoAzioni.java  | 397 +++++++++++++++++++++
 .../v2.3/src/RobottinoMain/Robottino.java          |  83 +++++
 .../v2.3/src/RobottinoUtils/Grafica.java           | 210 +++++++++++
 .../v2.3/src/RobottinoUtils/Listener.java          |  72 ++++
 .../v2.3/src/RobottinoUtils/PartiDelRobot.java     |  22 ++
 5 files changed, 784 insertions(+)
 create mode 100755 robottino/all_versions/v2.3/src/RobottinoAzioni/RobottinoAzioni.java
 create mode 100755 robottino/all_versions/v2.3/src/RobottinoMain/Robottino.java
 create mode 100755 robottino/all_versions/v2.3/src/RobottinoUtils/Grafica.java
 create mode 100755 robottino/all_versions/v2.3/src/RobottinoUtils/Listener.java
 create mode 100755 robottino/all_versions/v2.3/src/RobottinoUtils/PartiDelRobot.java

(limited to 'robottino/all_versions/v2.3/src')

diff --git a/robottino/all_versions/v2.3/src/RobottinoAzioni/RobottinoAzioni.java b/robottino/all_versions/v2.3/src/RobottinoAzioni/RobottinoAzioni.java
new file mode 100755
index 0000000..27d568a
--- /dev/null
+++ b/robottino/all_versions/v2.3/src/RobottinoAzioni/RobottinoAzioni.java
@@ -0,0 +1,397 @@
+// Dichiaro che questa classa farà parte del package RobottinoAzioni, che verrà poi importato dalle classi Listener e Grafica.
+package RobottinoAzioni;
+
+// Anche qui impoerto i package necessari.
+// java.util.Scanner gestisce gli input da tastiera
+import java.util.Scanner;
+
+// java.util.Vector
+import java.util.Vector;
+
+// Package definito da me.
+import RobottinoUtils.*;
+
+public class RobottinoAzioni {
+
+	// Creo gli oggetti statici che riempiranno il vettore pdrA:
+	// pdrA è un vettore multidimensionale che a sua volta contiene vettori
+	// (il primo si chiama pdrB, i successivi non avranno nome) che coontengono 
+	// 4 istanze di PartiDelRobot, cioè i 4 arti del robot.
+	// Poi creo un vettore che conterrà i nomi dei robot.
+	// Creo il vettore principale...
+	public static Vector pdrA = new Vector(1);
+
+	// ...e il "sottovettore" come istanze della classe Vector
+	public static Vector pdrB = new Vector(4);
+
+	// Creo le quattro istanze di PartidelRobot utilizzando l'apposito costruttore
+	// passo a tutte una stringa e un valore boleano che determina lo stato
+	// (alzato/a se true, abbassato/a se false).
+	public static PartiDelRobot leftArm = new PartiDelRobot(false, "il braccio sinistro alzato");
+	public static PartiDelRobot rightArm = new PartiDelRobot(false, "il braccio destro alzato");
+	public static PartiDelRobot leftLeg = new PartiDelRobot(false, "la gamba sinistra alzata");
+	public static PartiDelRobot rightLeg = new PartiDelRobot(false, "la gamba destra alzata");
+
+	// Il vettore nomeRobot per i nomi
+	// il vettore può contenere stringhe, poichè non sono tipi primitivi ma oggetti della classe String
+	public static Vector nomeRobot = new Vector(1);
+
+	// La variabile robotIndex serve a tenere in memoria su quale robot si sta operando:
+	// in seguito verrà usata quando l'utente deciderà di creare più di un robot
+	// e poi di dare comandi a uno o all'altro/i.
+	int robotIndex = 0;
+
+	// Dichiarazione del metodo Azioni.
+	public String Azioni(String comando, Vector nomeRobot, Vector pdrA) {
+
+		// Crea un'istanza della classe Scanner per
+		// ricevere gli input nel caso in cui debba essere dato il nome
+		// al robottino o scelto un robottino da una lista.
+		Scanner sc2 = new Scanner(System.in);
+	
+		// La variabile contatore memorizza il numero di variabili "PartiDelRobot.statoParte"
+		// che hanno valore true, ossia il numero di arti alzati di un robottino
+		// in modo da poter scegliere la frase giusta da dare come output
+		// al posto dell'immagine del robottino con tali arti alzati.
+		int contatore = 0;
+	
+		// Questo array ha il compito di memorizzare le stringhe corrispondenti agli alzati
+		// per motivi simili a quelli della variabile "contatore".
+		String stat[] = {"", "", "", ""};
+	
+		// La stringa Return verrà successivamente modificata e restituita in alcuni casi.
+		String Return = "Errore - si consiglia di picchiare il programmatore";
+	
+		// Per far si che il programma non distingua tra lettere maiuscole o minuscole per quanto riguardo gli input
+		// è stato usato il metodo "equalsIgnoreCase" della classe String.
+		// I quattro casi successivi cambiano il valore della varibalie "statoParte" relativa all'arto
+		// Che deve mouversi (quindi cambiare la sua posizione).
+		if (comando.equalsIgnoreCase("leftarmmove"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(0)).statoParte = 
+							!((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(0)).statoParte;
+
+		else if (comando.equalsIgnoreCase("rightarmmove"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(1)).statoParte = 
+							!((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(1)).statoParte;
+
+		else if (comando.equalsIgnoreCase("leftlegmove"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(2)).statoParte = 
+							!((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(2)).statoParte;
+
+		else if (comando.equalsIgnoreCase("rightlegmove"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(3)).statoParte = 
+							!((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(3)).statoParte;
+
+		// I casi successivi modificano il valore della varibile analogamente ai 4 precedenti.
+		else if (comando.equalsIgnoreCase("leftarmon"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(0)).statoParte = true;
+
+		else if (comando.equalsIgnoreCase("rightarmon"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(1)).statoParte = true;
+
+		else if (comando.equalsIgnoreCase("leftlegon"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(2)).statoParte = true;
+
+		else if (comando.equalsIgnoreCase("rightlegon"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(3)).statoParte = true;
+
+		else if (comando.equalsIgnoreCase("leftarmoff"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(0)).statoParte = false;
+
+		else if (comando.equalsIgnoreCase("rightarmoff"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(1)).statoParte = false;
+
+		else if (comando.equalsIgnoreCase("leftlegoff"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(2)).statoParte = false;
+
+		else if (comando.equalsIgnoreCase("rightlegoff"))
+			((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(3)).statoParte = false;
+
+		// Il caso successi si verica quando il comando è "exploud".
+		else if (comando.equalsIgnoreCase("exploud")) {
+
+			// Scrive sullo schermo la seguente frase, che comprende il nome del robottino che non è ancora stato fatto eliminare
+			System.out.println 
+			("Che atroce! Hai fatto esplodere il robottino " + nomeRobot.elementAt(this.robotIndex) + "! Aspetta che te ne faccio un altro");
+			System.out.println ("...");
+
+			// Con un ciclo for rendo false tutte le variabili "statoParte" per far sì che il robottino sia come nuovo.
+			for (int i = 0; i < 4; i++) {
+				((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(i)).statoParte = false;
+			}
+
+			// E azzero anche il nome del robot
+			this.nomeRobot.setElementAt("", this.robotIndex);
+			
+			return "Fatto, puoi continuare a giocare";
+		}
+
+		// Caso per il comando "bier".
+		// La reazione a questo comando è un semplice output quasi totalmente scorrelato al robottino
+		// se non per il fatto che appare il nome del robottino attuale.
+		else if (comando.equalsIgnoreCase("bier")) {
+			System.out.println ("Il robottino " + nomeRobot.elementAt(this.robotIndex) + "sta trangugiando una birra...");
+			System.out.println ("Buurrrrrrrrp!");
+			return "La birra analcolica fa schifo!";
+		}
+
+		// Per il comando "rename", rinomina.
+		else if (comando.equalsIgnoreCase("rename")) {
+
+			System.out.println ("Con questo comando quoi cambiare il nome del robottino " + nomeRobot.elementAt(this.robotIndex));
+			System.out.println ("Digita il nuovo nome e premi INVIO per coninuare");
+
+			// Cambia il nome del robottino attuale con quello dell'input.
+			this.nomeRobot.setElementAt(sc2.nextLine(), this.robotIndex);
+
+			// Se il nome non è vuoto, aggiunge un carattere di spazio per migliorare la visualizzazione nelle frasi di output.
+			if (!(((String)nomeRobot.elementAt(this.robotIndex)).equalsIgnoreCase("")))
+				this.nomeRobot.setElementAt(this.nomeRobot.elementAt(this.robotIndex) + " ", this.robotIndex);
+
+			// Semplice output con il nuovo nome.
+			return "Ora il robottino si chiama " + nomeRobot.elementAt(this.robotIndex);
+		}
+
+		// Per il comando "porky".
+		// Ancora meno che per "bier".
+		else if (comando.equalsIgnoreCase("porky")) {
+			System.out.println ("Porky è un grande");
+			System.out.println ("Per maggiori informazioni visita il sito");
+			return "http://kakati.forumfree.net/";
+		}
+
+		// Il comando "xxx" ha funzioni analoghe a bier.
+		else if (comando.equalsIgnoreCase("xxx")) {
+			System.out.println ("Il robottino " + nomeRobot.elementAt(this.robotIndex) + "ha incontrato una bella robottina...");
+			return "*Censura*";
+		}
+
+		// "dance" setta tutte le variabili "statoParte" a false...
+		else if (comando.equalsIgnoreCase("dance")) {
+
+			System.out.println ("Immagini che il robottino " + nomeRobot.elementAt(this.robotIndex) + " stia ballando...");
+			System.out.println ("Il robottino ha smesso di ballare");
+
+			//...con questo ciclo for
+			for (int i = 0; i < 4; i++) {
+				((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(i)).statoParte = false;
+			}
+
+			return "Il robottino " + nomeRobot.elementAt(this.robotIndex) + "si è fermato ed è  tornato nella posizione originale";
+
+		// Per il comando "newrobot", che crea un nuovo robottino.
+		}
+		else if (comando.equalsIgnoreCase("newrobot")) {
+
+			// Aggiunge un elemento a "pdrA" con il metodo "addElement", della classe Vector.
+			// È stata necessaria la dicitura this. per modificare realmente il vettore.
+			// Se non lo avessi fatto non sarebbe successo, in quanto i metodi operano
+			// su i valori e non sulle variabili/oggetti.
+			this.pdrA.addElement(pdrB);
+
+			// Aggiungo le 4 parti del robot.
+			// Forse avete già notato (ma quì sono più evidenti) alcuni cast che ho fatto:
+			// sono per far si che il compilatore capisca che il metodo viene invocato da un oggetto
+			// della classe vector, che senza cast considererebbe della classe Object.
+			((Vector)(this.pdrA.elementAt(pdrA.size()-1))).addElement (leftArm);
+			((Vector)(this.pdrA.elementAt(pdrA.size()-1))).addElement (rightArm);
+			((Vector)(this.pdrA.elementAt(pdrA.size()-1))).addElement (leftLeg);
+			((Vector)(this.pdrA.elementAt(pdrA.size()-1))).addElement (rightLeg);
+
+			// Semplice output con richiesta di nome per il nuovo robottino.
+			System.out.println ("È stato creato un nuovo robot. Vuoi dare un nome al nuovo robot?");
+			System.out.println ("Inserisci il nuovo nome e premi INVIO oppure lascia vuoto e premi INVIO");
+
+			String newName = sc2.nextLine();
+
+			if (!(((String)nomeRobot.elementAt(this.robotIndex)).equalsIgnoreCase("")))
+				this.nomeRobot.setElementAt(this.nomeRobot.elementAt(this.robotIndex) + " ", this.robotIndex);
+
+			this.nomeRobot.addElement(newName);
+
+			return "È stato creato il robottino " + newName;
+		}
+
+		// Il comando "deleterobot", per eliminare un robot.
+		else if (comando.equalsIgnoreCase("deleterobot")) {
+
+			// Se c'è più di un robot esegue l'eliminazione.
+			if (pdrA.size()>1) {
+				System.out.println ("Quale robottino vuoi eliminare?");
+				System.out.println ("");
+
+				// Con un ciclo for scrive i nomi di tutti i robot preceduti da un numero in sequenza.
+				// Il numero è il corrispondente del loro indice di vettore.
+				for (int i = 0; i<this.pdrA.size(); i++) {
+					System.out.println (i + ". " + this.nomeRobot.elementAt(i));
+				}
+
+				// Dà le istruzioni all'utente affinché capisca come eliminare un robot.
+				System.out.println ("");
+				System.out.println("Scegliere il robottino da eliminare digitando il numero corrispondente e premendo INVIO");
+				System.out.println("Digitare un qualunque altro numero e premere INVIO per annullare");
+
+				int num = this.pdrA.size()+1;
+
+				try {
+
+					// Riceve in input il numero e ne assegna il valore alla variabile "num".
+					num = sc2.nextInt();
+
+				} catch (Exception e) {
+					System.out.println("Puoi inserire solo numeri");
+				}
+
+				// Elimina gli elementi corrispondenti al robottino (nome e robot) dai
+				// rispettivi vettori con il metodo "removeElementAt" della classe Vector.
+				if (num<this.pdrA.size()) {
+					this.pdrA.removeElementAt(num);
+					this.nomeRobot.removeElementAt(num);
+					return "È stato eliminato il robottino numero " + num;
+				}
+
+				// Se il numero ricevuto in input è superiore all'indice dei robot
+				// non elimina alcun robot.
+				else return "Operazione annullata";
+			}
+
+			// Se c'è solo un robot non esegue l'eliminazione.
+			else return "Hai solo un robottino, non puoi eliminarlo!";
+		}
+
+		// Il comando "changerobot" per cambiare il robot a cui dare le istruzioni
+		else if (comando.equalsIgnoreCase("changerobot")) {
+
+			// L'esecuzione è simile a quella per il comando "deleterobot", con la differenza che il robot non viene eliminato
+			// ma viene semplicemente cambiato il valore della variabile "robotIndex".
+			if (pdrA.size()>1) {
+				System.out.println ("A quale robottino vuoi dare i comandi?");
+				System.out.println ("");
+				for (int i = 0; i<this.pdrA.size(); i++) {
+					System.out.println (i + ". " + this.nomeRobot.elementAt(i));
+				}
+				System.out.println ("");
+				System.out.println ("Digita il numero corrispondente alla tua scelta e premi INVIO");
+
+				int newIndex = this.pdrA.size()+1;
+
+				try {
+
+					newIndex = sc2.nextInt();
+
+				} catch (Exception e) {
+					System.out.println("Puoi inserire solo numeri");
+				}
+
+				// Prima di cambiare valore alla variabile di indice verifica che il numero sia valido.
+				if (newIndex<this.pdrA.size()) {
+					this.robotIndex = newIndex;
+					return "È stato selezionato il robottino numero " + this.robotIndex + ": " + this.nomeRobot.elementAt
+																(this.robotIndex);
+				}
+
+				// Se non lo è non esegue l'assegnamento.
+				else return "Numero non valido - Operazione annullata";
+			}
+			else {
+				return "Hai solo un robottino, non puoi cambiarlo con un altro!";
+			}
+		}
+
+		// Il comando "robotlist" visualizza una lista dei robot presenti.
+		else if (comando.equalsIgnoreCase("robotlist")) {
+			for (int i = 0; i<this.pdrA.size(); i++) {
+				System.out.println (i + ". " + this.nomeRobot.elementAt(i));
+			}
+			return "";
+		}
+
+		// Il comando "l", per la legenda, visualizza la lista dei comandi con relativa descrizione.
+		else if (comando.equalsIgnoreCase("l")) {
+			System.out.println ("Legenda comandi");
+			System.out.println ("");
+			System.out.println ("Comandi relativi agli arti");
+			System.out.println ("");
+			System.out.println ("LeftArmMove: cambia la posizione corrente del braccio sinistro del robot");
+			System.out.println ("RightArmMove: cambia la posizione corrente del braccio destro del robot");
+			System.out.println ("LeftLegMove: cambia la posizione corrente della gamba sinistra del robot");
+			System.out.println ("RightLegMove: cambia la posizione corrente della gamba destra del robot");
+			System.out.println ("LeftArmOn: se il braccio sinistro non è alzato, lo alza, altrimenti la posizione resta invariata");
+			System.out.println ("RightArmOn: se il braccio destro non è alzato, lo alza, altrimenti la posizione resta invariata");
+			System.out.println ("LeftLegOn: se la gamba sinistra non è alzata, la alza, altrimenti la posizione resta invariata");
+			System.out.println ("RightLegOn: se la gamba destra non è alzata, la alza, altrimenti la posizione resta invariata");
+			System.out.println ("LeftArmOff: se il braccio sinistro non è abbassato, lo abbassa, altrimenti la posizione resta invariata");
+			System.out.println ("RightArmOff: se il braccio destro non è abbassato, lo abbassa, altrimenti la posizione resta invariata");
+			System.out.println ("LeftLegOff: se la gamba sinistra non è abbassata, la abbassa, altrimenti la posizione resta invariata");
+			System.out.println ("RightLegOff: se la gamba destra non è abbassata, la abbassa, altrimenti la posizione resta invariata");
+			System.out.println ("");
+			System.out.println ("Altri comandi:");
+			System.out.println ("");
+			System.out.println ("NewRobot: aggiunge un nuovo robot");
+			System.out.println ("ChangeRobot: cambia il robot attuale");
+			System.out.println ("RobotList: visualizza la lista dei robot");
+			System.out.println ("Rename: rinomina il robottino");
+			System.out.println ("");
+			System.out.println ("Comandi a sorpresa:");
+			System.out.println ("");
+			System.out.println ("Exploud");
+			System.out.println ("Bier");
+			System.out.println ("Porky");
+			System.out.println ("xxx");
+			System.out.println ("dance");
+			System.out.println ("");
+			System.out.println ("Exit: esci dal programma");
+
+			return "";
+			
+		}
+
+		// Se il comando è exit, esce dal programma.
+		else if (comando.equalsIgnoreCase("exit")) {
+			System.exit(0);
+			return "";
+		}
+
+		// Se l'input non è tra i comandi prestabiliti, visualizza la seguente scritta sullo schermo.
+		else
+			System.out.println ("Comando non riconosciuto - digitare l per una legenda dei comandi disponibili");
+			System.out.println ("");
+
+		// Quì di seguito viene chiarito l'utilizzo di "contatore" e "sta[]".
+		// Per ogni varibile "statoParte" che ha valore true, contatore viene incrementato
+		// e l'elemento successivo dell'array "stat[]" assume il valore della stringa corrispondente.
+		for (int i = 0, j = 0; i < 4; i++) {
+			if (((PartiDelRobot)((Vector)pdrA.elementAt(this.robotIndex)).elementAt(i)).statoParte) {
+				contatore += 1;
+				stat[j++] = ((PartiDelRobot)((Vector)pdrA.elementAt(this.robotIndex)).elementAt(i)).stringaParte;
+			}
+		}
+
+		// La restituzione finale delle frasi, con uno switch che a seconda del valore di contatore
+		// restituisce una frase o l'altra.
+		switch (contatore) { 
+			case 0:
+				Return = "Il robottino "+nomeRobot.elementAt(this.robotIndex)+"non ha nessun arto alzato";
+				break;
+			case 1:
+				Return = "Il robottino "+nomeRobot.elementAt(this.robotIndex)+"ha "+stat[0] + ".";
+				break;
+			case 2:
+				Return = "Il robottino "+nomeRobot.elementAt(this.robotIndex)+"ha "+stat[0]+" e "+stat[1]+".";
+				break;	
+			case 3: 
+				Return = "Il robottino "+nomeRobot.elementAt(this.robotIndex)+"ha "+stat[0]+", "+stat[1]+" e "+stat[2]+".";
+				break;
+			case 4: 
+				Return = "Il robottino "+nomeRobot.elementAt(this.robotIndex)+"ha "+stat[0]+", "+stat[1]+", "+stat[2]+" e "+stat[3]+". Sta per cadere! Ah no, può restare sospeso in aria";
+				break;
+		}
+		return Return;
+	}
+	//Fine del metodo Azioni
+}
+
+
+
+
+
diff --git a/robottino/all_versions/v2.3/src/RobottinoMain/Robottino.java b/robottino/all_versions/v2.3/src/RobottinoMain/Robottino.java
new file mode 100755
index 0000000..37471cf
--- /dev/null
+++ b/robottino/all_versions/v2.3/src/RobottinoMain/Robottino.java
@@ -0,0 +1,83 @@
+// Robottino versione 2.2
+// Da questa versione illustrerò tutte le parti del programma con dei commenti come questo.
+
+// Dichiaro che questa classe fa parte del package RobottinoMain, che verrà poi importato
+// dalle classi che dovranno interagire con essa.
+package RobottinoMain;
+
+// Importo la classe Grafica per poter "costruire" una finestra.
+import RobottinoUtils.Grafica;
+
+// E il package Robottinoazioni per poterne inizializzare i vettori
+import RobottinoAzioni.*;
+
+// java.util.Vector serve a gestire i vettori.
+// I vettori sono come array, ma hanno due differenze principali:
+// 1) la loro lunghezza può variare durante l'esecuzione del programma
+// (per questo li ho preferiti agli array);
+// 2) possono contenere soltanto oggetti, e non tipi primitivi.
+import java.util.Vector;
+
+// Dichiaro la classe.
+public class Robottino {
+	
+
+	// Istanzio la classe Thread per poter utilizzare il metodo sleep(int millisecondi)
+	// che in un metodo dell'interfaccia  WindowListener, overridato nella classe Listener
+	// servirà a mettere il programma in uno stato di pausa.
+	// Sarebbe comunque possibile invocarlo, ma così sarà più facile da modificare in futuro.
+	public static Thread threadMain;
+
+	// Inizio del metodo main...
+	public static void main(String[] args) { 
+
+		threadMain = new Thread(Thread.currentThread());
+
+		// Aggiungo gli elementi ai vettori.
+		// non potevo farlo prima, poiché al di fuori di un metodo è possibile soltanto
+		// dichiarare oggetti/variabili (e inizializzarli) o dichiarare un metodo
+		// e in RobottinoAzioni è presente solo il metodo Azioni che viene richiamato più volte.
+		RobottinoAzioni.pdrB.addElement(RobottinoAzioni.leftArm);
+		RobottinoAzioni.pdrB.addElement(RobottinoAzioni.rightArm);
+		RobottinoAzioni.pdrB.addElement(RobottinoAzioni.leftLeg);
+		RobottinoAzioni.pdrB.addElement(RobottinoAzioni.rightLeg);
+		RobottinoAzioni.pdrA.addElement(RobottinoAzioni.pdrB);
+		RobottinoAzioni.nomeRobot.addElement("");
+
+		// Crea la finestra tramite un'istanza della classe Grafica, del package RobottinoUtils
+		Grafica finestra = new Grafica();
+
+		// Output iniziale nellla shell
+		System.out.println ("**********************************************");
+		System.out.println ("**********************************************");
+		System.out.println ("*************Programma interattivo************");
+		System.out.println ("**********************************************");
+		System.out.println ("***Software realizzato da Sebastiano Tronto***");
+		System.out.println ("**********************************************");
+		System.out.println ("**********************************************");
+		System.out.println ("Questo programma simula un robot al quale ven-");
+		System.out.println ("gono assegnati ordini tramite comandi, simil-" );
+		System.out.println ("mente a quanto bisognava fare con i computer " );
+		System.out.println ("alcuni anni fa."                               );
+		System.out.println ("Dato che all'epoca i comandi che dovevano es-" );
+		System.out.println ("sere dati erano (e sono tutt'ora) in similin-" );
+		System.out.println ("glese, ho cercato di mantenerli tali."         );
+		System.out.println ("Da questa versione (v2.3) i comandi devono es-");
+		System.out.println ("sere dati attraverso i menu File, Modifica o " );
+		System.out.println ("Azioni della finestra."                        );
+		System.out.println (""                                              );
+		System.out.println ("Tuttavia la reazione del robottino verrà vi-"  );
+		System.out.println ("sualizzata attraverso la shell."               );
+		System.out.println ("");
+	}
+	// Fine del metodo main.
+}
+
+
+
+
+
+
+
+
+
diff --git a/robottino/all_versions/v2.3/src/RobottinoUtils/Grafica.java b/robottino/all_versions/v2.3/src/RobottinoUtils/Grafica.java
new file mode 100755
index 0000000..b845a7f
--- /dev/null
+++ b/robottino/all_versions/v2.3/src/RobottinoUtils/Grafica.java
@@ -0,0 +1,210 @@
+// Dichiaro che questa classa farà parte del package RobottinoUtils, che verrà poi importato dalla classe Robottino.
+package RobottinoUtils;
+
+// Importo i package standard relativi al funzionamento delle finestre e della grafica in generale.
+import java.awt.*;
+
+// E i package RobottinoAzioni e RobottinoUtils da me definiti.
+import RobottinoAzioni.*;
+import RobottinoUtils.Listener;
+
+// La classe è una sottoclasse di Frame per poter sfruttare gli effetti grafici
+// ma implementa anche l'interfaccia WindowListener, necessaria per gestire gli eventi collegati alle finestre
+// (riduzione a icona, chiusura...); per questo devo successivamente ridefinire tutti i
+// metodi dell'interfaccia.
+public class Grafica extends Frame {
+
+	// Creo un'istanza della classe Listener che userò come listener per gli eventi.
+	public static Listener listener;
+
+	// Il costruttore senza argomenti.
+	public Grafica () {
+
+		// Il metodo "setBounds" posiziona e dimensiona la finestra.
+		setBounds (this.orizzontale, this.verticale, this.larghezza, this.altezza);
+
+		// "setTitle" per il titolo della finestra.
+		setTitle ("Robottino v2.2");
+
+		// "setVisible" per poterla visualizzare.
+		setVisible (true);
+
+		// E addWindowListener per l'ascoltatore (listener).
+		listener = new Listener();
+		addWindowListener (listener);
+
+		// Aggiungo la barra del menu con i vari sottomenu
+		setMenuBar (barraMenu);
+
+		// Il menu file.
+		NewRobot.addActionListener(listener);
+		NewRobot.setActionCommand("newrobot");
+
+		ChangeRobot.addActionListener(listener);
+		ChangeRobot.setActionCommand("changerobot");
+
+		DeleteRobot.addActionListener(listener);
+		DeleteRobot.setActionCommand("deleterobot");
+
+		Exit.addActionListener(listener);
+		Exit.setActionCommand("exit");
+
+		file.add(NewRobot);
+		file.add(ChangeRobot);
+		file.add(DeleteRobot);
+		file.addSeparator();
+		file.add(Exit);
+
+		barraMenu.add(file);
+
+		// Il braccio sinistro.
+		LeftArmMove.addActionListener(listener);
+		LeftArmMove.setActionCommand("leftarmmove");
+
+		LeftArmOn.addActionListener(listener);
+		LeftArmOn.setActionCommand("leftarmon");
+
+		LeftArmOff.addActionListener(listener);
+		LeftArmOff.setActionCommand("leftarmoff");
+
+		LeftArm.add(LeftArmMove);
+		LeftArm.add(LeftArmOn);
+		LeftArm.add(LeftArmOff);
+
+		// Il braccio destro.
+		RightArmMove.addActionListener(listener);
+		RightArmMove.setActionCommand("rightarmmove");
+
+		RightArmOn.addActionListener(listener);
+		RightArmOn.setActionCommand("rightarmon");
+
+		RightArmOff.addActionListener(listener);
+		RightArmOff.setActionCommand("rightarmoff");
+
+		RightArm.add(RightArmMove);
+		RightArm.add(RightArmOn);
+		RightArm.add(RightArmOff);
+
+		// La gamba sinistra.
+		LeftLegMove.addActionListener(listener);
+		LeftLegMove.setActionCommand("leftlegmove");
+
+		LeftLegOn.addActionListener(listener);
+		LeftLegOn.setActionCommand("leftlegon");
+
+		LeftLegOff.addActionListener(listener);
+		LeftLegOff.setActionCommand("leftlegoff");
+
+		LeftLeg.add(LeftLegMove);
+		LeftLeg.add(LeftLegOn);
+		LeftLeg.add(LeftLegOff);
+
+		// La gamba destra.
+		RightLegMove.addActionListener(listener);
+		RightLegMove.setActionCommand("rightlegmove");
+
+		RightLegOn.addActionListener(listener);
+		RightLegOn.setActionCommand("rightlegon");
+
+		RightLegOff.addActionListener(listener);
+		RightLegOff.setActionCommand("rightlegoff");
+
+		RightLeg.add(RightLegMove);
+		RightLeg.add(RightLegOn);
+		RightLeg.add(RightLegOff);
+
+		// Menu rinomina.
+		Rename.addActionListener(listener);
+		Rename.setActionCommand("rename");
+
+		Menu modifica = new Menu("Modifica");
+		modifica.add(LeftArm);
+		modifica.add(RightArm);
+		modifica.add(LeftLeg);
+		modifica.add(RightLeg);
+		modifica.addSeparator();
+		modifica.add(Rename);
+
+		barraMenu.add(modifica);
+
+		// Menu azioni.
+		Exploud.addActionListener(listener);
+		Exploud.setActionCommand("exploud");
+
+		Bier.addActionListener(listener);
+		Bier.setActionCommand("bier");
+
+		xxx.addActionListener(listener);
+		xxx.setActionCommand("xxx");
+
+		Dance.addActionListener(listener);
+		Dance.setActionCommand("dance");
+
+		azioni.add(Exploud);
+		azioni.add(Bier);
+		azioni.add(xxx);
+		azioni.add(Dance);
+
+		barraMenu.add(azioni);
+
+		// Menu info.
+		Porky.addActionListener(listener);
+		Porky.setActionCommand("porky");
+
+		l.addActionListener(listener);
+		l.setActionCommand("l");
+
+		RobotList.addActionListener(listener);
+		RobotList.setActionCommand("robotlist");
+
+		info.add(Porky);
+		info.add(l);
+		info.add(RobotList);
+
+		barraMenu.add(info);
+	}
+
+	// Le variabili pubbliche di classe per il metodo "setBounds".
+	public int orizzontale = 0;
+	public int verticale = 0;
+	public int larghezza = 500;
+	public int altezza = 500;
+
+	// E i vari Menu e MenuItem.
+	MenuBar barraMenu = new MenuBar();
+	Menu file = new Menu("File");
+	MenuItem NewRobot = new MenuItem("Nuovo robot");
+	MenuItem ChangeRobot = new MenuItem("Dai i comandi a un altro robot");
+	MenuItem DeleteRobot = new MenuItem("Elimina un robot");
+	MenuItem Exit = new MenuItem("Esci");
+	Menu LeftArm = new Menu("Braccio sinistro");
+	MenuItem LeftArmMove = new MenuItem("Cambia posizione");
+	MenuItem LeftArmOn = new MenuItem("Alza");
+	MenuItem LeftArmOff = new MenuItem("Abbassa");
+	Menu RightArm = new Menu("Braccio destro");
+	MenuItem RightArmMove = new MenuItem("Cambia posizione");
+	MenuItem RightArmOn = new MenuItem("Alza");
+	MenuItem RightArmOff = new MenuItem("Abbassa");
+	Menu LeftLeg = new Menu("Gamba sinistra");
+	MenuItem LeftLegMove = new MenuItem("Cambia posizione");
+	MenuItem LeftLegOn = new MenuItem("Alza");
+	MenuItem LeftLegOff = new MenuItem("Abbassa");
+	Menu RightLeg = new Menu("Gamba destra");
+	MenuItem RightLegMove = new MenuItem("Cambia posizione");
+	MenuItem RightLegOn = new MenuItem("Alza");
+	MenuItem RightLegOff = new MenuItem("Abbassa");
+	MenuItem Rename = new MenuItem("Rinomina");
+	Menu azioni = new Menu("Azioni");
+	MenuItem Exploud = new MenuItem("Esplodi");
+	MenuItem Bier = new MenuItem("Birra");
+	MenuItem xxx = new MenuItem("xxx");
+	MenuItem Dance = new MenuItem("Balla");
+	Menu info = new Menu("?");
+	MenuItem Porky = new MenuItem("Informazioni sul programmatore");
+	MenuItem l = new MenuItem("Legenda Comandi");
+	MenuItem RobotList = new MenuItem("Lista robot");
+}
+
+
+
+
diff --git a/robottino/all_versions/v2.3/src/RobottinoUtils/Listener.java b/robottino/all_versions/v2.3/src/RobottinoUtils/Listener.java
new file mode 100755
index 0000000..90e617c
--- /dev/null
+++ b/robottino/all_versions/v2.3/src/RobottinoUtils/Listener.java
@@ -0,0 +1,72 @@
+// Questa classe è il listener per gli eventi relativi alle finestre.
+// Dichiaro che farà parte del package RobottinoUtils
+package RobottinoUtils;
+
+// Importo i package necessari.
+import java.awt.event.*;
+import RobottinoMain.*;
+import RobottinoAzioni.*;
+
+public class Listener implements WindowListener, ActionListener {
+
+	RobottinoAzioni robottinoazioni = new RobottinoAzioni();
+
+	// Ridefinisco i metodi dell'interfaccia WindowListener:
+	// Metodo invocato quando la finestra è stata chiusa:
+	public void windowClosed (WindowEvent evt) {
+
+		// Invoco il metodo sleep(int millisecondi) per mettere il programma in uno stato di attesa
+		// di durata pari ai millisecondi indicati come argomento.
+		System.out.println("La finestra è stata chiusa, il programma terminarà fra 3 secondi");
+		try {
+			Robottino.threadMain.sleep(1000);
+		} catch (Exception e) { e.printStackTrace(); }
+		System.out.println("2");
+		try {
+			Robottino.threadMain.sleep(1000);
+		} catch (Exception e) { e.printStackTrace(); }
+		System.out.println("1");
+		try {
+			Robottino.threadMain.sleep(1000);
+		} catch (Exception e) { e.printStackTrace(); }
+		System.out.println("Programma terminato");
+		System.exit(0);
+	}
+
+	// Metodo invocato quando la finestra è in fase di chiusura:
+	public void windowClosing (WindowEvent evt) {
+		System.out.println ("Chiusura finestra in corso");
+		evt.getWindow().dispose();
+	}
+
+	// Metodo invocato quando una finestra viene ridotta a icona:
+	public void windowIconified (WindowEvent evt) {
+		System.out.println("La finestra è stata ridotta a icona");
+	}
+
+	// Metodo invocato quando una finestra ridotta a icona viene ingrandita:
+	public void windowDeiconified (WindowEvent evt) {
+		System.out.println("La finestra ridotta a icona è stata ingrandita");
+	}
+
+	// Metodo invocato quando una finestra viene aperta:
+	public void windowOpened (WindowEvent evt) {}
+
+	// Metodo invocato quando una finestra diventa attiva:
+	public void windowActivated (WindowEvent evt) {}
+
+	// Metodo invocato quando una finestra viene disattivata:
+	public void windowDeactivated (WindowEvent evt) {}
+
+	// Metodo invocato quando viene utilizzata la barra del menu:
+	// descrive tutte le azioni da compiere per ogni evento ricevuto
+	// dal menu.
+	public void actionPerformed (ActionEvent e) {
+		System.out.println (robottinoazioni.Azioni(e.getActionCommand(), RobottinoAzioni.nomeRobot, RobottinoAzioni.pdrA));
+	}
+}
+
+
+
+
+
diff --git a/robottino/all_versions/v2.3/src/RobottinoUtils/PartiDelRobot.java b/robottino/all_versions/v2.3/src/RobottinoUtils/PartiDelRobot.java
new file mode 100755
index 0000000..d6cf869
--- /dev/null
+++ b/robottino/all_versions/v2.3/src/RobottinoUtils/PartiDelRobot.java
@@ -0,0 +1,22 @@
+// Dichiaro che questa classa farà parte del package RobottinoUtils, che verrà poi importato dalla classe Robottino.
+package RobottinoUtils;
+
+// Dichiaro la classe.
+public class PartiDelRobot {
+
+	// Creo un costruttore senza argomenti.
+	// Se non lo facessi sarei obbligato a passare gli argomenti
+	// del secondo costruttore ogni volta che voglio istanziare la classe.
+	public PartiDelRobot() {}
+
+	// Il secondo costruttore riceve come argomenti un booleano che passerà il valore a "statoParte"
+	// e una stringa che passa il valore a "stringaParte".
+	public PartiDelRobot(boolean b, String s) {
+		this.stringaParte = s;
+		this.statoParte = b;
+	}
+
+	// Infine le due variabili pubbliche della classe.
+	public String stringaParte;
+	public boolean statoParte;
+}
-- 
cgit v1.3