Commits

Germano Gabbianelli committed 6a22ae0

Initial files

Comments (0)

Files changed (9)

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
+syntax: glob
+bin/
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>diadia</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

.settings/org.eclipse.jdt.core.prefs

+#Sun Mar 18 16:46:28 CET 2012
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6

src/Attrezzo.java

+
+/**
+ * Una semplice classe che modella un attrezzo.
+ * Gli attrezzi possono trovarsi all'interno delle stanze
+ * del labirinto.
+ * Ogni attrezzo ha un nome ed un peso.
+ *
+ * @author  Paolo Merialdo
+ * @see Stanza
+ * @version 0.1
+ *
+ */
+public class Attrezzo {
+   private String nome;
+   private int peso;
+
+  /**
+   * Crea un attrezzo
+   * @param nome il nome che identifica l'attrezzo
+   * @param peso il peso dell'attrezzo
+   */
+   public Attrezzo(String nome, int peso) {
+      this.peso = peso;
+      this.nome = nome;
+   }
+
+  /**
+   * Restituisce il nome identificatore dell'attrezzo
+   * @return il nome identificatore dell'attrezzo
+   */
+   public String getNome() {
+      return this.nome;
+   }
+
+  /**
+   * Restituisce il peso dell'attrezzo
+   * @return il peso dell'attrezzo
+   */
+   public int getPeso() {
+      return this.peso;
+   }
+
+   /**
+	* Restituisce una rappresentazione stringa di questo attrezzo
+	* @return la rappresentazione stringa
+	*/
+   public String toString() {
+		  return this.getNome()+" ("+this.getPeso()+"kg)";
+	   }
+
+}
+
+import java.util.Scanner;
+
+/**
+ * Questa classe modella un comando.
+ * Un comando consiste al piu' di due parole:
+ * il nome del comando ed un parametro
+ * su cui si applica il comando.
+ * (Ad es. alla riga digitata dall'utente "vai nord"
+ *  corrisponde un comando di nome "vai" e parametro "nord").
+ *
+ * @author  Paolo Merialdo (da un'idea di Michael Kolling and David J. Barnes) *
+ * @version 0.1
+ */
+
+public class Comando {
+    private String nome;
+    private String parametro;
+
+    public Comando(String istruzione) {
+		Scanner scannerDiParole = new Scanner(istruzione);
+
+		// prima parola: nome del comando
+		if (scannerDiParole.hasNext())
+			this.nome = scannerDiParole.next(); 
+
+		// seconda parola: eventuale parametro
+		if (scannerDiParole.hasNext())
+			this.parametro = scannerDiParole.next();
+    }
+
+    public String getNome() {
+        return this.nome;
+    }
+
+    public String getParametro() {
+        return this.parametro;
+    }
+
+    public boolean sconosciuto() {
+        return (this.nome == null);
+    }
+}
+
+import java.util.Scanner;
+
+/**
+ *  Classe principale di diadia, un semplice gioco di ruolo ambientato al dia.
+ *  Per giocare crea un'istanza di questa classe e invoca il letodo gioca
+ *
+ *  Questa e' la classe principale crea e istanzia tutte le altre
+ *
+ * @author  Paolo Merialdo (da un'idea di Michael Kolling and David J. Barnes) *
+ * @version 0.1
+ */
+
+public class DiaDia {
+	private Partita partita;
+    private static final String MESSAGGIO_BENVENUTO = 
+		"Ti trovi nell'Universita', ma oggi e' diversa dal solito...\n" +
+		"Meglio andare al piu' presto in biblioteca a studiare. Ma dov'e'?\n"+
+		"I locali sono popolati da strani personaggi, " +
+		"alcuni amici, altri... chissa!\n"+
+		"Ci sono attrezzi che potrebbero servirti nell'impresa:\n"+
+		"puoi metterli nella borsa, usarli, posarli quando ti sembrano inutili\n" +
+		"o regalarli se pensi che possano ingraziarti qualcuno.\n\n"+
+		"Per conoscere le istruzioni usa il comando 'aiuto'.";
+    private static String[] elencoComandi = {"vai", "aiuto", "fine"};
+
+    public DiaDia() {
+    	this.partita = new Partita();
+    }
+
+	public void gioca() {
+		String istruzione; 
+	    Scanner scannerDiLinee;
+
+		System.out.println(MESSAGGIO_BENVENUTO);
+	    scannerDiLinee = new Scanner(System.in);		
+		do		
+			istruzione = scannerDiLinee.nextLine();
+		while (!processaIstruzione(istruzione));
+	}   
+    
+        
+	/**
+	 * Processa una istruzione 
+	 *
+	 * @return true se l'istruzione e' eseguita e il gioco continua, false altrimenti
+	 */
+	private boolean processaIstruzione(String istruzione) {
+		Comando comandoDaEseguire = new Comando(istruzione);
+
+		if (comandoDaEseguire.getNome().equals("fine")) {
+			this.fine(); 
+			return true;
+		} else if (comandoDaEseguire.getNome().equals("vai"))
+			this.vai(comandoDaEseguire.getParametro());
+		else if (comandoDaEseguire.getNome().equals("aiuto"))
+			this.aiuto();
+		else
+			System.out.println("Comando sconosciuto");
+		if (this.partita.vinta()) {
+			System.out.println("Hai vinto!");
+			return true;
+		} else
+			return false;
+	}   
+    
+    // implementazioni dei comandi dell'utente:
+
+    /**
+     * Stampa informazioni di aiuto.
+     */
+    private void aiuto() {
+		for(int i=0; i< elencoComandi.length; i++) 
+			System.out.print(elencoComandi[i]+" ");
+		System.out.println();
+	    }
+
+    /**
+     * Cerca di andare in una direzione. Se c'e' una stanza ci entra 
+     * e ne stampa il nome, altrimenti stampa un messaggio di errore
+     */
+	 private void vai(String direzione) {
+		 if(direzione==null)
+			 System.out.println("Dove vuoi andare ?");
+		 Stanza prossimaStanza = null;
+		 prossimaStanza = this.partita.getStanzaCorrente().getUscita(direzione);
+		 if (prossimaStanza == null)
+			 System.out.println("Direzione inesistente");
+		 else {
+			this.partita.setStanzaCorrente(prossimaStanza);
+			int cfu = this.partita.getCfu();
+			this.partita.setCfu(cfu--);
+		 }
+		System.out.println(partita.getStanzaCorrente().getNome());
+	 }
+
+    /**
+     * Comando "Fine".
+     */
+    private void fine() {
+    	System.out.println("Grazie di aver giocato!");  // si desidera smettere
+    }
+
+	public static void main(String[] argc) {
+		DiaDia gioco = new DiaDia();
+		gioco.gioca();
+	}
+}
+
+/**
+ * Questa classe modella una partita del gioco
+ *
+ * @author  Paolo Merialdo, Valter Crescenzi (da un'idea di Michael Kolling and David J. Barnes)
+ * @see Stanza
+ * @version 0.1
+ */
+
+public class Partita {
+	private Stanza stanzaCorrente;
+	private Stanza stanzaVincente;
+	private boolean finita;
+	private int cfu;
+	private static int CFU_INIZIALI = 20;
+	
+	public Partita(){
+		creaStanze();
+		this.finita = false;
+		this.cfu = CFU_INIZIALI;
+	}
+
+    /**
+     * Crea tutte le stanze e le porte di collegamento
+     */
+    private void creaStanze() {
+
+		/* crea gli attrezzi */
+    	Attrezzo lanterna = new Attrezzo("lanterna",3);
+		Attrezzo osso = new Attrezzo("osso",1);
+    	
+		/* crea stanze del labirinto */
+		Stanza atrio = new Stanza("Atrio");
+		Stanza aulaN11 = new Stanza("Aula N11");
+		Stanza aulaN10 = new Stanza("Aula N10");
+		Stanza laboratorio = new Stanza("Laboratorio Campus");
+		Stanza biblioteca = new Stanza("Biblioteca");
+		
+		/* collega le stanze */
+		atrio.impostaUscita("nord", biblioteca);
+		atrio.impostaUscita("est", aulaN11);
+		atrio.impostaUscita("sud", aulaN10);
+		atrio.impostaUscita("ovest", laboratorio);
+		aulaN11.impostaUscita("est", laboratorio);
+		aulaN11.impostaUscita("ovest", atrio);
+		aulaN10.impostaUscita("nord", atrio);
+		aulaN10.impostaUscita("est", aulaN11);
+		aulaN10.impostaUscita("ovest", laboratorio);
+		laboratorio.impostaUscita("est", atrio);
+		laboratorio.impostaUscita("ovest", aulaN11);
+		biblioteca.impostaUscita("sud", atrio);
+
+        /* pone gli attrezzi nelle stanze */
+		aulaN10.addAttrezzo(lanterna);
+		atrio.addAttrezzo(osso);
+
+		// il gioco comincia nell'atrio
+        stanzaCorrente = atrio;  
+		stanzaVincente = biblioteca;
+    }
+
+	public Stanza getStanzaVincente() {
+		return stanzaVincente;
+	}
+
+	public void setStanzaCorrente(Stanza stanzaCorrente) {
+		this.stanzaCorrente = stanzaCorrente;
+	}
+
+	public Stanza getStanzaCorrente() {
+		return this.stanzaCorrente;
+	}
+	
+	/**
+	 * Restituisce vero se e solo se la partita e' stata vinta
+	 * @return vero se partita vinta
+	 */
+	public boolean vinta() {
+		return this.getStanzaCorrente()== this.getStanzaVincente();
+	}
+
+	/**
+	 * Restituisce vero se e solo se la partita e' finita
+	 * @return vero se partita finita
+	 */
+	public boolean isFinita() {
+		return finita || vinta() || (cfu == 0);
+	}
+
+	/**
+	 * Imposta la partita come finita
+	 *
+	 */
+	public void setFinita() {
+		this.finita = true;
+	}
+
+	public int getCfu() {
+		return this.cfu;
+	}
+
+	public void setCfu(int cfu) {
+		this.cfu = cfu;		
+	}	
+}
+
+/**
+ * Classe Stanza - una stanza in un gioco di ruolo.
+ * Una stanza e' un luogo fisico nel gioco.
+ * E' collegata ad altre stanze attraverso delle uscite.
+ * Ogni uscita e' associata ad una direzione.
+ * @author Paolo Merialdo (a partire da un'idea di Michael Kolling e David J. Barnes)
+ * @see Attrezzo
+ * @version 0.1
+*/
+
+public class Stanza {
+	private static final int NUMERO_MASSIMO_DIREZIONI = 4;
+	private String nome;
+    private Attrezzo attrezzo;
+	private Stanza[] stanzeConfinanti;
+	private int numeroDirezioni;
+    private String[] direzioni;
+
+    /**
+     * Crea una stanza. Inizialmente non ci sono uscite.
+     * @param nome il nome della stanza
+     */
+    public Stanza(String nome) {
+        this.nome = nome;
+        this.numeroDirezioni = 0;
+        this.direzioni = new String[NUMERO_MASSIMO_DIREZIONI];
+        this.stanzeConfinanti = new Stanza[NUMERO_MASSIMO_DIREZIONI];
+    }
+
+    /**
+     * Imposta le uscite della stanza. Ogni direzione porta ad un'altra stanza.
+     *
+     * @param direzione direzione in cui sara' posta la stanza.
+     * @param stanza stanza da collegare alla stanza corrente tramite l'uscita
+     * indicata in direzione.
+     */
+    public void impostaUscita(String direzione, Stanza stanza) {
+        boolean aggiornato = false;
+    	for(int i=0; i<this.direzioni.length; i++)
+        	if (direzione.equals(this.direzioni[i])) {
+        		this.stanzeConfinanti[i] = stanza;
+        		aggiornato = true;
+        	}
+    	if (!aggiornato)
+    		if (this.numeroDirezioni < NUMERO_MASSIMO_DIREZIONI) {
+    			this.direzioni[numeroDirezioni] = direzione;
+    			this.stanzeConfinanti[numeroDirezioni] = stanza;
+    		    this.numeroDirezioni++;
+    		}
+    }
+
+    /**
+     * Restituisce la stanza dell'uscita specificata
+     * @param direzione
+     */
+	public Stanza getUscita(String direzione) {
+        Stanza stanza = null;
+		for(int i=0; i<this.numeroDirezioni; i++)
+        	if (this.direzioni[i].equals(direzione))
+        		stanza = this.stanzeConfinanti[i];
+        return stanza;
+	}
+
+    /**
+     * Restituisce la nome della stanza.
+     * @return il nome della stanza
+     */
+    public String getNome() {
+        return this.nome;
+    }
+
+    /**
+     * Restituisce la descrizione della stanza.
+     * @return la descrizione della stanza
+     */
+    public String getDescrizione() {
+        return this.toString();
+    }
+
+    /**
+     * Restituisce l'attrezzo presente nella stanza.
+     * @return l'attrezzo presente nella stanza.
+     * 		   null se non ci sono attrezzi.
+     */
+    public Attrezzo getAttrezzo() {
+        return this.attrezzo;
+    }
+
+    /**
+     * Colloca un attrezzo nella stanza.
+     * @param attrezzo l'attrezzo da collocare nella stanza.
+     *        Impostare a null per rappresentare l'assenza
+     *        di attrezzi nella stanza.
+     */
+    public void addAttrezzo(Attrezzo attrezzo) {
+        this.attrezzo = attrezzo;
+    }
+
+   /**
+	* Restituisce una rappresentazione stringa di questa stanza,
+	* stampadone la descrizione, le uscite e gli eventuali attrezzi contenuti
+	* @return la rappresentazione stringa
+	*/
+    public String toString() {
+    	String s = new String();
+    	s += this.nome;
+    	s += "\nUscite: ";
+    	for (String direzione : this.direzioni)
+    		if (direzione!=null)
+    			s += " " + direzione;
+    	s += "\nAttrezzi nella stanza: ";
+    	s += attrezzo.toString()+" ";
+    	return s;
+    }
+
+    /**
+	* Controlla se un attrezzo esiste nella stanza (uguaglianza sul nome).
+	* @return true se l'attrezzo esiste nella stanza, false altrimenti.
+	*/
+	public boolean hasAttrezzo(String nomeAttrezzo) {
+		boolean attrezzoPresente;
+		if (this.attrezzo.getNome().equals(nomeAttrezzo))
+			attrezzoPresente = true;
+		else
+			attrezzoPresente = false;
+		return attrezzoPresente;
+	}
+
+	/**
+     * Restituisce l'attrezzo nomeAttrezzo se presente nella stanza.
+	 * @param nomeAttrezzo
+	 * @return l'attrezzo presente nella stanza.
+     * 		   null se l'attrezzo non e' presente.
+	 */
+	public Attrezzo getAttrezzo(String nomeAttrezzo) {
+		if (attrezzo.getNome().equals(nomeAttrezzo))
+			return attrezzo;
+		else
+			return null;
+	}
+
+	/**
+	 * Rimuove un attrezzo dalla stanza (ricerca in base al nome).
+	 * @param nomeAttrezzo
+	 */
+	public boolean removeAttrezzo(Attrezzo attrezzo) {
+		if (attrezzo!=null){
+			this.attrezzo = null;
+			return true;
+		}
+		else
+			return false;
+	}
+
+
+	public String[] getDirezioni() {
+		String[] direzioni = new String[this.numeroDirezioni];
+	    for(int i=0; i<this.numeroDirezioni; i++)
+	    	direzioni[i] = this.direzioni[i];
+	    return direzioni;
+    }
+
+}