ancient-projects

RobottinoAzioni.java (17762B)

---

 // Dichiaro che questa classa farà parte del package RobottinoAzioni, che verrà poi importato dalle classi Robottino e Grafica.
 package RobottinoAzioni;
 
 // Anche qui impoerto i package necessari.
 import java.util.Scanner;
 import java.util.Vector;
 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");
 
 				// Riceve in input il numero e ne assegna il valore alla variabile "num".
 				int num = sc2.nextInt();
 
 				// 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 = sc2.nextInt();
 
 				// 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";
 			}
 			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, non viene eseguita nessuna operazione (tranne restituire una stringa vuota)
 		// Perché il ciclo do-while nel metodo main, appena verificherà la condizione che il comando è 
 		// uguale a "exit", terminerà da solo l'esecuzione del programma.
 		else if (comando.equalsIgnoreCase("exit")) 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 = "Comunque il robottino " + nomeRobot.elementAt(this.robotIndex) + "non sta facendo niente";
 				break;
 			case 1:
 				Return = "Immagini che il robottino " + nomeRobot.elementAt(this.robotIndex) + "abbia " + stat[0] + ".";
 				break;
 			case 2:
 				Return = "Immagini che il robottino " + nomeRobot.elementAt(this.robotIndex) + "abbia " + stat[0] + " e " + stat[1] + ".";
 				break;	
 			case 3: 
 				Return = "Immagini che il robottino " + nomeRobot.elementAt(this.robotIndex) + "abbia " + stat[0] + ", " + stat[1] + " e " + stat[2] + ".";
 				break;
 			case 4: 
 				Return = "Immagini che il robottino " + nomeRobot.elementAt(this.robotIndex) + "abbia " + stat[0] + ", " + stat[1] + ", " + stat[2] + " e " + stat[3] + ".";
 				break;
 		}
 		return Return;
 	}
 	//Fine del metodo Azioni
 }