aboutsummaryrefslogtreecommitdiff
path: root/robottino/all_versions/v3.0
diff options
context:
space:
mode:
Diffstat (limited to 'robottino/all_versions/v3.0')
-rwxr-xr-xrobottino/all_versions/v3.0/Esegui.bat3
-rwxr-xr-xrobottino/all_versions/v3.0/Esegui.sh3
-rwxr-xr-xrobottino/all_versions/v3.0/Readme.txt10
-rwxr-xr-xrobottino/all_versions/v3.0/bin/Immagini/ImmagineRobot.classbin0 -> 1143 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/bin/Immagini/img/laoff.gifbin0 -> 4148 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/bin/Immagini/img/lloff.gifbin0 -> 4552 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/bin/Immagini/img/raoff.gifbin0 -> 5137 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/bin/Immagini/img/rloff.gifbin0 -> 4802 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/bin/Immagini/img/robot.gifbin0 -> 15158 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/bin/RobottinoAzioni/RobottinoAzioni.classbin0 -> 9270 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/bin/RobottinoMain/Robottino.classbin0 -> 1020 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/bin/RobottinoUtils/Grafica.classbin0 -> 5043 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/bin/RobottinoUtils/Listener.classbin0 -> 2193 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/bin/RobottinoUtils/PartiDelRobot.classbin0 -> 394 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/src/Immagini/ImmagineRobot.java35
-rwxr-xr-xrobottino/all_versions/v3.0/src/Immagini/img/laoff.gifbin0 -> 4148 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/src/Immagini/img/lloff.gifbin0 -> 4552 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/src/Immagini/img/raoff.gifbin0 -> 5137 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/src/Immagini/img/rloff.gifbin0 -> 4802 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/src/Immagini/img/robot.gifbin0 -> 15158 bytes
-rwxr-xr-xrobottino/all_versions/v3.0/src/RobottinoAzioni/RobottinoAzioni.java397
-rwxr-xr-xrobottino/all_versions/v3.0/src/RobottinoMain/Robottino.java63
-rwxr-xr-xrobottino/all_versions/v3.0/src/RobottinoUtils/Grafica.java226
-rwxr-xr-xrobottino/all_versions/v3.0/src/RobottinoUtils/Listener.java73
-rwxr-xr-xrobottino/all_versions/v3.0/src/RobottinoUtils/PartiDelRobot.java22
25 files changed, 832 insertions, 0 deletions
diff --git a/robottino/all_versions/v3.0/Esegui.bat b/robottino/all_versions/v3.0/Esegui.bat
new file mode 100755
index 0000000..d413ed8
--- /dev/null
+++ b/robottino/all_versions/v3.0/Esegui.bat
@@ -0,0 +1,3 @@
1cd ./bin
2java RobottinoMain/Robottino
3cd
diff --git a/robottino/all_versions/v3.0/Esegui.sh b/robottino/all_versions/v3.0/Esegui.sh
new file mode 100755
index 0000000..d413ed8
--- /dev/null
+++ b/robottino/all_versions/v3.0/Esegui.sh
@@ -0,0 +1,3 @@
1cd ./bin
2java RobottinoMain/Robottino
3cd
diff --git a/robottino/all_versions/v3.0/Readme.txt b/robottino/all_versions/v3.0/Readme.txt
new file mode 100755
index 0000000..52d532c
--- /dev/null
+++ b/robottino/all_versions/v3.0/Readme.txt
@@ -0,0 +1,10 @@
1Il programma necessita della JVM (Java Virtual Machine) per funzionare correttamente
2
3Se si usano sistemi Windows aprire il file Esegui.bat
4Se si usano sistemi Unix dare i permessi necessari ed eseguire il file Esegui.sh
5Se si usano altri sistemi aprire una shell e digitare i comandi
6
7cd <percorsoFile>/bin
8java Robottino
9
10dove percorsoFile è il percorso di questo file.
diff --git a/robottino/all_versions/v3.0/bin/Immagini/ImmagineRobot.class b/robottino/all_versions/v3.0/bin/Immagini/ImmagineRobot.class
new file mode 100755
index 0000000..6089c8a
--- /dev/null
+++ b/robottino/all_versions/v3.0/bin/Immagini/ImmagineRobot.class
Binary files differ
diff --git a/robottino/all_versions/v3.0/bin/Immagini/img/laoff.gif b/robottino/all_versions/v3.0/bin/Immagini/img/laoff.gif
new file mode 100755
index 0000000..49d9db0
--- /dev/null
+++ b/robottino/all_versions/v3.0/bin/Immagini/img/laoff.gif
Binary files differ
diff --git a/robottino/all_versions/v3.0/bin/Immagini/img/lloff.gif b/robottino/all_versions/v3.0/bin/Immagini/img/lloff.gif
new file mode 100755
index 0000000..3db1ceb
--- /dev/null
+++ b/robottino/all_versions/v3.0/bin/Immagini/img/lloff.gif
Binary files differ
diff --git a/robottino/all_versions/v3.0/bin/Immagini/img/raoff.gif b/robottino/all_versions/v3.0/bin/Immagini/img/raoff.gif
new file mode 100755
index 0000000..88aabc4
--- /dev/null
+++ b/robottino/all_versions/v3.0/bin/Immagini/img/raoff.gif
Binary files differ
diff --git a/robottino/all_versions/v3.0/bin/Immagini/img/rloff.gif b/robottino/all_versions/v3.0/bin/Immagini/img/rloff.gif
new file mode 100755
index 0000000..04bda22
--- /dev/null
+++ b/robottino/all_versions/v3.0/bin/Immagini/img/rloff.gif
Binary files differ
diff --git a/robottino/all_versions/v3.0/bin/Immagini/img/robot.gif b/robottino/all_versions/v3.0/bin/Immagini/img/robot.gif
new file mode 100755
index 0000000..db87686
--- /dev/null
+++ b/robottino/all_versions/v3.0/bin/Immagini/img/robot.gif
Binary files differ
diff --git a/robottino/all_versions/v3.0/bin/RobottinoAzioni/RobottinoAzioni.class b/robottino/all_versions/v3.0/bin/RobottinoAzioni/RobottinoAzioni.class
new file mode 100755
index 0000000..d8aeb55
--- /dev/null
+++ b/robottino/all_versions/v3.0/bin/RobottinoAzioni/RobottinoAzioni.class
Binary files differ
diff --git a/robottino/all_versions/v3.0/bin/RobottinoMain/Robottino.class b/robottino/all_versions/v3.0/bin/RobottinoMain/Robottino.class
new file mode 100755
index 0000000..2a1b0e3
--- /dev/null
+++ b/robottino/all_versions/v3.0/bin/RobottinoMain/Robottino.class
Binary files differ
diff --git a/robottino/all_versions/v3.0/bin/RobottinoUtils/Grafica.class b/robottino/all_versions/v3.0/bin/RobottinoUtils/Grafica.class
new file mode 100755
index 0000000..80ef9bc
--- /dev/null
+++ b/robottino/all_versions/v3.0/bin/RobottinoUtils/Grafica.class
Binary files differ
diff --git a/robottino/all_versions/v3.0/bin/RobottinoUtils/Listener.class b/robottino/all_versions/v3.0/bin/RobottinoUtils/Listener.class
new file mode 100755
index 0000000..e198976
--- /dev/null
+++ b/robottino/all_versions/v3.0/bin/RobottinoUtils/Listener.class
Binary files differ
diff --git a/robottino/all_versions/v3.0/bin/RobottinoUtils/PartiDelRobot.class b/robottino/all_versions/v3.0/bin/RobottinoUtils/PartiDelRobot.class
new file mode 100755
index 0000000..fcc8e9e
--- /dev/null
+++ b/robottino/all_versions/v3.0/bin/RobottinoUtils/PartiDelRobot.class
Binary files differ
diff --git a/robottino/all_versions/v3.0/src/Immagini/ImmagineRobot.java b/robottino/all_versions/v3.0/src/Immagini/ImmagineRobot.java
new file mode 100755
index 0000000..ee0bc1f
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/Immagini/ImmagineRobot.java
@@ -0,0 +1,35 @@
1package Immagini;
2import java.awt.*;
3import java.awt.image.*;
4
5public class ImmagineRobot {
6
7 public Toolkit t;
8 public Image robot;
9 public Image raon;
10 public Image raoff;
11 public Image laon;
12 public Image laoff;
13 public Image rlon;
14 public Image rloff;
15 public Image llon;
16 public Image lloff;
17 public Image birra;
18
19 public ImmagineRobot() {
20
21 t = Toolkit.getDefaultToolkit();
22 robot = t.getImage("./Immagini/img/robot.gif");
23 raon = t.getImage("./Immagini/img/raon.gif");
24 raoff = t.getImage("./Immagini/img/raoff.gif");
25 laon = t.getImage("./Immagini/img/laon.gif");
26 laoff = t.getImage("./Immagini/img/laoff.gif");
27 rlon = t.getImage("./Immagini/img/rlon.gif");
28 rloff = t.getImage("./Immagini/img/rloff.gif");
29 llon = t.getImage("./Immagini/img/llon.gif");
30 lloff = t.getImage("./Immagini/img/lloff.gif");
31 birra = t.getImage("./Immagini/img/birra.gif");
32
33 }
34
35}
diff --git a/robottino/all_versions/v3.0/src/Immagini/img/laoff.gif b/robottino/all_versions/v3.0/src/Immagini/img/laoff.gif
new file mode 100755
index 0000000..49d9db0
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/Immagini/img/laoff.gif
Binary files differ
diff --git a/robottino/all_versions/v3.0/src/Immagini/img/lloff.gif b/robottino/all_versions/v3.0/src/Immagini/img/lloff.gif
new file mode 100755
index 0000000..3db1ceb
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/Immagini/img/lloff.gif
Binary files differ
diff --git a/robottino/all_versions/v3.0/src/Immagini/img/raoff.gif b/robottino/all_versions/v3.0/src/Immagini/img/raoff.gif
new file mode 100755
index 0000000..88aabc4
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/Immagini/img/raoff.gif
Binary files differ
diff --git a/robottino/all_versions/v3.0/src/Immagini/img/rloff.gif b/robottino/all_versions/v3.0/src/Immagini/img/rloff.gif
new file mode 100755
index 0000000..04bda22
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/Immagini/img/rloff.gif
Binary files differ
diff --git a/robottino/all_versions/v3.0/src/Immagini/img/robot.gif b/robottino/all_versions/v3.0/src/Immagini/img/robot.gif
new file mode 100755
index 0000000..db87686
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/Immagini/img/robot.gif
Binary files differ
diff --git a/robottino/all_versions/v3.0/src/RobottinoAzioni/RobottinoAzioni.java b/robottino/all_versions/v3.0/src/RobottinoAzioni/RobottinoAzioni.java
new file mode 100755
index 0000000..27d568a
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/RobottinoAzioni/RobottinoAzioni.java
@@ -0,0 +1,397 @@
1// Dichiaro che questa classa farà parte del package RobottinoAzioni, che verrà poi importato dalle classi Listener e Grafica.
2package RobottinoAzioni;
3
4// Anche qui impoerto i package necessari.
5// java.util.Scanner gestisce gli input da tastiera
6import java.util.Scanner;
7
8// java.util.Vector
9import java.util.Vector;
10
11// Package definito da me.
12import RobottinoUtils.*;
13
14public class RobottinoAzioni {
15
16 // Creo gli oggetti statici che riempiranno il vettore pdrA:
17 // pdrA è un vettore multidimensionale che a sua volta contiene vettori
18 // (il primo si chiama pdrB, i successivi non avranno nome) che coontengono
19 // 4 istanze di PartiDelRobot, cioè i 4 arti del robot.
20 // Poi creo un vettore che conterrà i nomi dei robot.
21 // Creo il vettore principale...
22 public static Vector pdrA = new Vector(1);
23
24 // ...e il "sottovettore" come istanze della classe Vector
25 public static Vector pdrB = new Vector(4);
26
27 // Creo le quattro istanze di PartidelRobot utilizzando l'apposito costruttore
28 // passo a tutte una stringa e un valore boleano che determina lo stato
29 // (alzato/a se true, abbassato/a se false).
30 public static PartiDelRobot leftArm = new PartiDelRobot(false, "il braccio sinistro alzato");
31 public static PartiDelRobot rightArm = new PartiDelRobot(false, "il braccio destro alzato");
32 public static PartiDelRobot leftLeg = new PartiDelRobot(false, "la gamba sinistra alzata");
33 public static PartiDelRobot rightLeg = new PartiDelRobot(false, "la gamba destra alzata");
34
35 // Il vettore nomeRobot per i nomi
36 // il vettore può contenere stringhe, poichè non sono tipi primitivi ma oggetti della classe String
37 public static Vector nomeRobot = new Vector(1);
38
39 // La variabile robotIndex serve a tenere in memoria su quale robot si sta operando:
40 // in seguito verrà usata quando l'utente deciderà di creare più di un robot
41 // e poi di dare comandi a uno o all'altro/i.
42 int robotIndex = 0;
43
44 // Dichiarazione del metodo Azioni.
45 public String Azioni(String comando, Vector nomeRobot, Vector pdrA) {
46
47 // Crea un'istanza della classe Scanner per
48 // ricevere gli input nel caso in cui debba essere dato il nome
49 // al robottino o scelto un robottino da una lista.
50 Scanner sc2 = new Scanner(System.in);
51
52 // La variabile contatore memorizza il numero di variabili "PartiDelRobot.statoParte"
53 // che hanno valore true, ossia il numero di arti alzati di un robottino
54 // in modo da poter scegliere la frase giusta da dare come output
55 // al posto dell'immagine del robottino con tali arti alzati.
56 int contatore = 0;
57
58 // Questo array ha il compito di memorizzare le stringhe corrispondenti agli alzati
59 // per motivi simili a quelli della variabile "contatore".
60 String stat[] = {"", "", "", ""};
61
62 // La stringa Return verrà successivamente modificata e restituita in alcuni casi.
63 String Return = "Errore - si consiglia di picchiare il programmatore";
64
65 // Per far si che il programma non distingua tra lettere maiuscole o minuscole per quanto riguardo gli input
66 // è stato usato il metodo "equalsIgnoreCase" della classe String.
67 // I quattro casi successivi cambiano il valore della varibalie "statoParte" relativa all'arto
68 // Che deve mouversi (quindi cambiare la sua posizione).
69 if (comando.equalsIgnoreCase("leftarmmove"))
70 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(0)).statoParte =
71 !((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(0)).statoParte;
72
73 else if (comando.equalsIgnoreCase("rightarmmove"))
74 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(1)).statoParte =
75 !((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(1)).statoParte;
76
77 else if (comando.equalsIgnoreCase("leftlegmove"))
78 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(2)).statoParte =
79 !((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(2)).statoParte;
80
81 else if (comando.equalsIgnoreCase("rightlegmove"))
82 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(3)).statoParte =
83 !((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(3)).statoParte;
84
85 // I casi successivi modificano il valore della varibile analogamente ai 4 precedenti.
86 else if (comando.equalsIgnoreCase("leftarmon"))
87 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(0)).statoParte = true;
88
89 else if (comando.equalsIgnoreCase("rightarmon"))
90 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(1)).statoParte = true;
91
92 else if (comando.equalsIgnoreCase("leftlegon"))
93 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(2)).statoParte = true;
94
95 else if (comando.equalsIgnoreCase("rightlegon"))
96 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(3)).statoParte = true;
97
98 else if (comando.equalsIgnoreCase("leftarmoff"))
99 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(0)).statoParte = false;
100
101 else if (comando.equalsIgnoreCase("rightarmoff"))
102 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(1)).statoParte = false;
103
104 else if (comando.equalsIgnoreCase("leftlegoff"))
105 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(2)).statoParte = false;
106
107 else if (comando.equalsIgnoreCase("rightlegoff"))
108 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(3)).statoParte = false;
109
110 // Il caso successi si verica quando il comando è "exploud".
111 else if (comando.equalsIgnoreCase("exploud")) {
112
113 // Scrive sullo schermo la seguente frase, che comprende il nome del robottino che non è ancora stato fatto eliminare
114 System.out.println
115 ("Che atroce! Hai fatto esplodere il robottino " + nomeRobot.elementAt(this.robotIndex) + "! Aspetta che te ne faccio un altro");
116 System.out.println ("...");
117
118 // Con un ciclo for rendo false tutte le variabili "statoParte" per far sì che il robottino sia come nuovo.
119 for (int i = 0; i < 4; i++) {
120 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(i)).statoParte = false;
121 }
122
123 // E azzero anche il nome del robot
124 this.nomeRobot.setElementAt("", this.robotIndex);
125
126 return "Fatto, puoi continuare a giocare";
127 }
128
129 // Caso per il comando "bier".
130 // La reazione a questo comando è un semplice output quasi totalmente scorrelato al robottino
131 // se non per il fatto che appare il nome del robottino attuale.
132 else if (comando.equalsIgnoreCase("bier")) {
133 System.out.println ("Il robottino " + nomeRobot.elementAt(this.robotIndex) + "sta trangugiando una birra...");
134 System.out.println ("Buurrrrrrrrp!");
135 return "La birra analcolica fa schifo!";
136 }
137
138 // Per il comando "rename", rinomina.
139 else if (comando.equalsIgnoreCase("rename")) {
140
141 System.out.println ("Con questo comando quoi cambiare il nome del robottino " + nomeRobot.elementAt(this.robotIndex));
142 System.out.println ("Digita il nuovo nome e premi INVIO per coninuare");
143
144 // Cambia il nome del robottino attuale con quello dell'input.
145 this.nomeRobot.setElementAt(sc2.nextLine(), this.robotIndex);
146
147 // Se il nome non è vuoto, aggiunge un carattere di spazio per migliorare la visualizzazione nelle frasi di output.
148 if (!(((String)nomeRobot.elementAt(this.robotIndex)).equalsIgnoreCase("")))
149 this.nomeRobot.setElementAt(this.nomeRobot.elementAt(this.robotIndex) + " ", this.robotIndex);
150
151 // Semplice output con il nuovo nome.
152 return "Ora il robottino si chiama " + nomeRobot.elementAt(this.robotIndex);
153 }
154
155 // Per il comando "porky".
156 // Ancora meno che per "bier".
157 else if (comando.equalsIgnoreCase("porky")) {
158 System.out.println ("Porky è un grande");
159 System.out.println ("Per maggiori informazioni visita il sito");
160 return "http://kakati.forumfree.net/";
161 }
162
163 // Il comando "xxx" ha funzioni analoghe a bier.
164 else if (comando.equalsIgnoreCase("xxx")) {
165 System.out.println ("Il robottino " + nomeRobot.elementAt(this.robotIndex) + "ha incontrato una bella robottina...");
166 return "*Censura*";
167 }
168
169 // "dance" setta tutte le variabili "statoParte" a false...
170 else if (comando.equalsIgnoreCase("dance")) {
171
172 System.out.println ("Immagini che il robottino " + nomeRobot.elementAt(this.robotIndex) + " stia ballando...");
173 System.out.println ("Il robottino ha smesso di ballare");
174
175 //...con questo ciclo for
176 for (int i = 0; i < 4; i++) {
177 ((PartiDelRobot)((Vector)this.pdrA.elementAt(this.robotIndex)).elementAt(i)).statoParte = false;
178 }
179
180 return "Il robottino " + nomeRobot.elementAt(this.robotIndex) + "si è fermato ed è tornato nella posizione originale";
181
182 // Per il comando "newrobot", che crea un nuovo robottino.
183 }
184 else if (comando.equalsIgnoreCase("newrobot")) {
185
186 // Aggiunge un elemento a "pdrA" con il metodo "addElement", della classe Vector.
187 // È stata necessaria la dicitura this. per modificare realmente il vettore.
188 // Se non lo avessi fatto non sarebbe successo, in quanto i metodi operano
189 // su i valori e non sulle variabili/oggetti.
190 this.pdrA.addElement(pdrB);
191
192 // Aggiungo le 4 parti del robot.
193 // Forse avete già notato (ma quì sono più evidenti) alcuni cast che ho fatto:
194 // sono per far si che il compilatore capisca che il metodo viene invocato da un oggetto
195 // della classe vector, che senza cast considererebbe della classe Object.
196 ((Vector)(this.pdrA.elementAt(pdrA.size()-1))).addElement (leftArm);
197 ((Vector)(this.pdrA.elementAt(pdrA.size()-1))).addElement (rightArm);
198 ((Vector)(this.pdrA.elementAt(pdrA.size()-1))).addElement (leftLeg);
199 ((Vector)(this.pdrA.elementAt(pdrA.size()-1))).addElement (rightLeg);
200
201 // Semplice output con richiesta di nome per il nuovo robottino.
202 System.out.println ("È stato creato un nuovo robot. Vuoi dare un nome al nuovo robot?");
203 System.out.println ("Inserisci il nuovo nome e premi INVIO oppure lascia vuoto e premi INVIO");
204
205 String newName = sc2.nextLine();
206
207 if (!(((String)nomeRobot.elementAt(this.robotIndex)).equalsIgnoreCase("")))
208 this.nomeRobot.setElementAt(this.nomeRobot.elementAt(this.robotIndex) + " ", this.robotIndex);
209
210 this.nomeRobot.addElement(newName);
211
212 return "È stato creato il robottino " + newName;
213 }
214
215 // Il comando "deleterobot", per eliminare un robot.
216 else if (comando.equalsIgnoreCase("deleterobot")) {
217
218 // Se c'è più di un robot esegue l'eliminazione.
219 if (pdrA.size()>1) {
220 System.out.println ("Quale robottino vuoi eliminare?");
221 System.out.println ("");
222
223 // Con un ciclo for scrive i nomi di tutti i robot preceduti da un numero in sequenza.
224 // Il numero è il corrispondente del loro indice di vettore.
225 for (int i = 0; i<this.pdrA.size(); i++) {
226 System.out.println (i + ". " + this.nomeRobot.elementAt(i));
227 }
228
229 // Dà le istruzioni all'utente affinché capisca come eliminare un robot.
230 System.out.println ("");
231 System.out.println("Scegliere il robottino da eliminare digitando il numero corrispondente e premendo INVIO");
232 System.out.println("Digitare un qualunque altro numero e premere INVIO per annullare");
233
234 int num = this.pdrA.size()+1;
235
236 try {
237
238 // Riceve in input il numero e ne assegna il valore alla variabile "num".
239 num = sc2.nextInt();
240
241 } catch (Exception e) {
242 System.out.println("Puoi inserire solo numeri");
243 }
244
245 // Elimina gli elementi corrispondenti al robottino (nome e robot) dai
246 // rispettivi vettori con il metodo "removeElementAt" della classe Vector.
247 if (num<this.pdrA.size()) {
248 this.pdrA.removeElementAt(num);
249 this.nomeRobot.removeElementAt(num);
250 return "È stato eliminato il robottino numero " + num;
251 }
252
253 // Se il numero ricevuto in input è superiore all'indice dei robot
254 // non elimina alcun robot.
255 else return "Operazione annullata";
256 }
257
258 // Se c'è solo un robot non esegue l'eliminazione.
259 else return "Hai solo un robottino, non puoi eliminarlo!";
260 }
261
262 // Il comando "changerobot" per cambiare il robot a cui dare le istruzioni
263 else if (comando.equalsIgnoreCase("changerobot")) {
264
265 // L'esecuzione è simile a quella per il comando "deleterobot", con la differenza che il robot non viene eliminato
266 // ma viene semplicemente cambiato il valore della variabile "robotIndex".
267 if (pdrA.size()>1) {
268 System.out.println ("A quale robottino vuoi dare i comandi?");
269 System.out.println ("");
270 for (int i = 0; i<this.pdrA.size(); i++) {
271 System.out.println (i + ". " + this.nomeRobot.elementAt(i));
272 }
273 System.out.println ("");
274 System.out.println ("Digita il numero corrispondente alla tua scelta e premi INVIO");
275
276 int newIndex = this.pdrA.size()+1;
277
278 try {
279
280 newIndex = sc2.nextInt();
281
282 } catch (Exception e) {
283 System.out.println("Puoi inserire solo numeri");
284 }
285
286 // Prima di cambiare valore alla variabile di indice verifica che il numero sia valido.
287 if (newIndex<this.pdrA.size()) {
288 this.robotIndex = newIndex;
289 return "È stato selezionato il robottino numero " + this.robotIndex + ": " + this.nomeRobot.elementAt
290 (this.robotIndex);
291 }
292
293 // Se non lo è non esegue l'assegnamento.
294 else return "Numero non valido - Operazione annullata";
295 }
296 else {
297 return "Hai solo un robottino, non puoi cambiarlo con un altro!";
298 }
299 }
300
301 // Il comando "robotlist" visualizza una lista dei robot presenti.
302 else if (comando.equalsIgnoreCase("robotlist")) {
303 for (int i = 0; i<this.pdrA.size(); i++) {
304 System.out.println (i + ". " + this.nomeRobot.elementAt(i));
305 }
306 return "";
307 }
308
309 // Il comando "l", per la legenda, visualizza la lista dei comandi con relativa descrizione.
310 else if (comando.equalsIgnoreCase("l")) {
311 System.out.println ("Legenda comandi");
312 System.out.println ("");
313 System.out.println ("Comandi relativi agli arti");
314 System.out.println ("");
315 System.out.println ("LeftArmMove: cambia la posizione corrente del braccio sinistro del robot");
316 System.out.println ("RightArmMove: cambia la posizione corrente del braccio destro del robot");
317 System.out.println ("LeftLegMove: cambia la posizione corrente della gamba sinistra del robot");
318 System.out.println ("RightLegMove: cambia la posizione corrente della gamba destra del robot");
319 System.out.println ("LeftArmOn: se il braccio sinistro non è alzato, lo alza, altrimenti la posizione resta invariata");
320 System.out.println ("RightArmOn: se il braccio destro non è alzato, lo alza, altrimenti la posizione resta invariata");
321 System.out.println ("LeftLegOn: se la gamba sinistra non è alzata, la alza, altrimenti la posizione resta invariata");
322 System.out.println ("RightLegOn: se la gamba destra non è alzata, la alza, altrimenti la posizione resta invariata");
323 System.out.println ("LeftArmOff: se il braccio sinistro non è abbassato, lo abbassa, altrimenti la posizione resta invariata");
324 System.out.println ("RightArmOff: se il braccio destro non è abbassato, lo abbassa, altrimenti la posizione resta invariata");
325 System.out.println ("LeftLegOff: se la gamba sinistra non è abbassata, la abbassa, altrimenti la posizione resta invariata");
326 System.out.println ("RightLegOff: se la gamba destra non è abbassata, la abbassa, altrimenti la posizione resta invariata");
327 System.out.println ("");
328 System.out.println ("Altri comandi:");
329 System.out.println ("");
330 System.out.println ("NewRobot: aggiunge un nuovo robot");
331 System.out.println ("ChangeRobot: cambia il robot attuale");
332 System.out.println ("RobotList: visualizza la lista dei robot");
333 System.out.println ("Rename: rinomina il robottino");
334 System.out.println ("");
335 System.out.println ("Comandi a sorpresa:");
336 System.out.println ("");
337 System.out.println ("Exploud");
338 System.out.println ("Bier");
339 System.out.println ("Porky");
340 System.out.println ("xxx");
341 System.out.println ("dance");
342 System.out.println ("");
343 System.out.println ("Exit: esci dal programma");
344
345 return "";
346
347 }
348
349 // Se il comando è exit, esce dal programma.
350 else if (comando.equalsIgnoreCase("exit")) {
351 System.exit(0);
352 return "";
353 }
354
355 // Se l'input non è tra i comandi prestabiliti, visualizza la seguente scritta sullo schermo.
356 else
357 System.out.println ("Comando non riconosciuto - digitare l per una legenda dei comandi disponibili");
358 System.out.println ("");
359
360 // Quì di seguito viene chiarito l'utilizzo di "contatore" e "sta[]".
361 // Per ogni varibile "statoParte" che ha valore true, contatore viene incrementato
362 // e l'elemento successivo dell'array "stat[]" assume il valore della stringa corrispondente.
363 for (int i = 0, j = 0; i < 4; i++) {
364 if (((PartiDelRobot)((Vector)pdrA.elementAt(this.robotIndex)).elementAt(i)).statoParte) {
365 contatore += 1;
366 stat[j++] = ((PartiDelRobot)((Vector)pdrA.elementAt(this.robotIndex)).elementAt(i)).stringaParte;
367 }
368 }
369
370 // La restituzione finale delle frasi, con uno switch che a seconda del valore di contatore
371 // restituisce una frase o l'altra.
372 switch (contatore) {
373 case 0:
374 Return = "Il robottino "+nomeRobot.elementAt(this.robotIndex)+"non ha nessun arto alzato";
375 break;
376 case 1:
377 Return = "Il robottino "+nomeRobot.elementAt(this.robotIndex)+"ha "+stat[0] + ".";
378 break;
379 case 2:
380 Return = "Il robottino "+nomeRobot.elementAt(this.robotIndex)+"ha "+stat[0]+" e "+stat[1]+".";
381 break;
382 case 3:
383 Return = "Il robottino "+nomeRobot.elementAt(this.robotIndex)+"ha "+stat[0]+", "+stat[1]+" e "+stat[2]+".";
384 break;
385 case 4:
386 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";
387 break;
388 }
389 return Return;
390 }
391 //Fine del metodo Azioni
392}
393
394
395
396
397
diff --git a/robottino/all_versions/v3.0/src/RobottinoMain/Robottino.java b/robottino/all_versions/v3.0/src/RobottinoMain/Robottino.java
new file mode 100755
index 0000000..5b9c530
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/RobottinoMain/Robottino.java
@@ -0,0 +1,63 @@
1// Robottino versione 3.0
2
3// Dichiaro che questa classe fa parte del package RobottinoMain, che verrà poi importato
4// dalle classi che dovranno interagire con essa.
5package RobottinoMain;
6
7// Importo la classe Grafica per poter "costruire" una finestra.
8import RobottinoUtils.*;
9
10// E il package Robottinoazioni per poterne inizializzare i vettori
11import RobottinoAzioni.*;
12
13// java.util.Vector serve a gestire i vettori.
14// I vettori sono come array, ma hanno due differenze principali:
15// 1) la loro lunghezza può variare durante l'esecuzione del programma
16// (per questo li ho preferiti agli array);
17// 2) possono contenere soltanto oggetti, e non tipi primitivi.
18import java.util.Vector;
19
20// Dichiaro la classe.
21public class Robottino {
22
23 // Istanzio la classe Thread per poter utilizzare il metodo sleep(int millisecondi)
24 // che in un metodo dell'interfaccia WindowListener, overridato nella classe Listener
25 // servirà a mettere il programma in uno stato di pausa.
26 // Sarebbe comunque possibile invocarlo, ma così sarà più facile da modificare in futuro.
27 public Thread threadMain;
28
29 // Crea la finestra tramite un'istanza della classe Grafica, del package RobottinoUtils.
30 public Grafica finestra;
31
32 // Creo anche un'istanza di questa classe per avere accesso agli elementi non statici.
33 public static Robottino robottino;
34
35 // Inizio del metodo main...
36 public static void main(String[] args) {
37
38 // Inizializzo i vari oggetti.
39 robottino = new Robottino();
40 robottino.finestra = new Grafica();
41 robottino.threadMain = new Thread(Thread.currentThread());
42
43 // Aggiungo gli elementi ai vettori.
44 // non potevo farlo prima, poiché al di fuori di un metodo è possibile soltanto
45 // dichiarare oggetti/variabili (e inizializzarli) o dichiarare un metodo
46 // e in RobottinoAzioni è presente solo il metodo Azioni che viene richiamato più volte.
47 RobottinoAzioni.pdrB.addElement(RobottinoAzioni.leftArm);
48 RobottinoAzioni.pdrB.addElement(RobottinoAzioni.rightArm);
49 RobottinoAzioni.pdrB.addElement(RobottinoAzioni.leftLeg);
50 RobottinoAzioni.pdrB.addElement(RobottinoAzioni.rightLeg);
51 RobottinoAzioni.pdrA.addElement(RobottinoAzioni.pdrB);
52 RobottinoAzioni.nomeRobot.addElement("");
53 }
54}
55
56
57
58
59
60
61
62
63
diff --git a/robottino/all_versions/v3.0/src/RobottinoUtils/Grafica.java b/robottino/all_versions/v3.0/src/RobottinoUtils/Grafica.java
new file mode 100755
index 0000000..84bc8c0
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/RobottinoUtils/Grafica.java
@@ -0,0 +1,226 @@
1// Dichiaro che questa classa farà parte del package RobottinoUtils, che verrà poi importato dalla classe Robottino.
2package RobottinoUtils;
3
4// Importo i package standard relativi al funzionamento delle finestre e della grafica in generale.
5import java.awt.*;
6
7// E i package RobottinoAzioni, RobottinoUtils e Immagini da me definiti.
8import RobottinoAzioni.*;
9import RobottinoUtils.Listener;
10import Immagini.*;
11
12// La classe è una sottoclasse di Frame per poter sfruttare gli effetti grafici
13// ma implementa anche l'interfaccia WindowListener, necessaria per gestire gli eventi collegati alle finestre
14// (riduzione a icona, chiusura...); per questo devo successivamente ridefinire tutti i
15// metodi dell'interfaccia.
16public class Grafica extends Frame {
17
18 // Creo un'istanza della classe Listener che userò come listener per gli eventi.
19 public static Listener listener;
20
21 // E una di ImmagineRobot per le immagini.
22 public static ImmagineRobot immagineRobot = new ImmagineRobot();
23
24 // Il costruttore senza argomenti.
25 public Grafica () {
26
27 // Il metodo "setBounds" posiziona e dimensiona la finestra.
28 setBounds (this.orizzontale, this.verticale, this.larghezza, this.altezza);
29
30 // "setTitle" per il titolo della finestra.
31 setTitle ("Robottino v2.2");
32
33 // "setVisible" per poterla visualizzare.
34 setVisible (true);
35
36 // E addWindowListener per l'ascoltatore (listener).
37 listener = new Listener();
38 addWindowListener (listener);
39
40 // Aggiungo la barra del menu con i vari sottomenu
41 setMenuBar (barraMenu);
42
43 // Il menu file.
44 NewRobot.addActionListener(listener);
45 NewRobot.setActionCommand("newrobot");
46
47 ChangeRobot.addActionListener(listener);
48 ChangeRobot.setActionCommand("changerobot");
49
50 DeleteRobot.addActionListener(listener);
51 DeleteRobot.setActionCommand("deleterobot");
52
53 Exit.addActionListener(listener);
54 Exit.setActionCommand("exit");
55
56 file.add(NewRobot);
57 file.add(ChangeRobot);
58 file.add(DeleteRobot);
59 file.addSeparator();
60 file.add(Exit);
61
62 barraMenu.add(file);
63
64 // Il braccio sinistro.
65 LeftArmMove.addActionListener(listener);
66 LeftArmMove.setActionCommand("leftarmmove");
67
68 LeftArmOn.addActionListener(listener);
69 LeftArmOn.setActionCommand("leftarmon");
70
71 LeftArmOff.addActionListener(listener);
72 LeftArmOff.setActionCommand("leftarmoff");
73
74 LeftArm.add(LeftArmMove);
75 LeftArm.add(LeftArmOn);
76 LeftArm.add(LeftArmOff);
77
78 // Il braccio destro.
79 RightArmMove.addActionListener(listener);
80 RightArmMove.setActionCommand("rightarmmove");
81
82 RightArmOn.addActionListener(listener);
83 RightArmOn.setActionCommand("rightarmon");
84
85 RightArmOff.addActionListener(listener);
86 RightArmOff.setActionCommand("rightarmoff");
87
88 RightArm.add(RightArmMove);
89 RightArm.add(RightArmOn);
90 RightArm.add(RightArmOff);
91
92 // La gamba sinistra.
93 LeftLegMove.addActionListener(listener);
94 LeftLegMove.setActionCommand("leftlegmove");
95
96 LeftLegOn.addActionListener(listener);
97 LeftLegOn.setActionCommand("leftlegon");
98
99 LeftLegOff.addActionListener(listener);
100 LeftLegOff.setActionCommand("leftlegoff");
101
102 LeftLeg.add(LeftLegMove);
103 LeftLeg.add(LeftLegOn);
104 LeftLeg.add(LeftLegOff);
105
106 // La gamba destra.
107 RightLegMove.addActionListener(listener);
108 RightLegMove.setActionCommand("rightlegmove");
109
110 RightLegOn.addActionListener(listener);
111 RightLegOn.setActionCommand("rightlegon");
112
113 RightLegOff.addActionListener(listener);
114 RightLegOff.setActionCommand("rightlegoff");
115
116 RightLeg.add(RightLegMove);
117 RightLeg.add(RightLegOn);
118 RightLeg.add(RightLegOff);
119
120 // Menu rinomina.
121 Rename.addActionListener(listener);
122 Rename.setActionCommand("rename");
123
124 Menu modifica = new Menu("Modifica");
125 modifica.add(LeftArm);
126 modifica.add(RightArm);
127 modifica.add(LeftLeg);
128 modifica.add(RightLeg);
129 modifica.addSeparator();
130 modifica.add(Rename);
131
132 barraMenu.add(modifica);
133
134 // Menu azioni.
135 Exploud.addActionListener(listener);
136 Exploud.setActionCommand("exploud");
137
138 Bier.addActionListener(listener);
139 Bier.setActionCommand("bier");
140
141 xxx.addActionListener(listener);
142 xxx.setActionCommand("xxx");
143
144 Dance.addActionListener(listener);
145 Dance.setActionCommand("dance");
146
147 azioni.add(Exploud);
148 azioni.add(Bier);
149 azioni.add(xxx);
150 azioni.add(Dance);
151
152 barraMenu.add(azioni);
153
154 // Menu info.
155 Porky.addActionListener(listener);
156 Porky.setActionCommand("porky");
157
158 l.addActionListener(listener);
159 l.setActionCommand("l");
160
161 RobotList.addActionListener(listener);
162 RobotList.setActionCommand("robotlist");
163
164 info.add(Porky);
165 info.add(l);
166 info.add(RobotList);
167
168 barraMenu.add(info);
169 }
170
171 // Le variabili pubbliche di classe per il metodo "setBounds".
172 public int orizzontale = 0;
173 public int verticale = 0;
174 public int larghezza = 360;
175 public int altezza = 550;
176
177 // E i vari Menu e MenuItem.
178 MenuBar barraMenu = new MenuBar();
179 Menu file = new Menu("File");
180 MenuItem NewRobot = new MenuItem("Nuovo robot");
181 MenuItem ChangeRobot = new MenuItem("Dai i comandi a un altro robot");
182 MenuItem DeleteRobot = new MenuItem("Elimina un robot");
183 MenuItem Exit = new MenuItem("Esci");
184 Menu LeftArm = new Menu("Braccio sinistro");
185 MenuItem LeftArmMove = new MenuItem("Cambia posizione");
186 MenuItem LeftArmOn = new MenuItem("Alza");
187 MenuItem LeftArmOff = new MenuItem("Abbassa");
188 Menu RightArm = new Menu("Braccio destro");
189 MenuItem RightArmMove = new MenuItem("Cambia posizione");
190 MenuItem RightArmOn = new MenuItem("Alza");
191 MenuItem RightArmOff = new MenuItem("Abbassa");
192 Menu LeftLeg = new Menu("Gamba sinistra");
193 MenuItem LeftLegMove = new MenuItem("Cambia posizione");
194 MenuItem LeftLegOn = new MenuItem("Alza");
195 MenuItem LeftLegOff = new MenuItem("Abbassa");
196 Menu RightLeg = new Menu("Gamba destra");
197 MenuItem RightLegMove = new MenuItem("Cambia posizione");
198 MenuItem RightLegOn = new MenuItem("Alza");
199 MenuItem RightLegOff = new MenuItem("Abbassa");
200 MenuItem Rename = new MenuItem("Rinomina");
201 Menu azioni = new Menu("Azioni");
202 MenuItem Exploud = new MenuItem("Esplodi");
203 MenuItem Bier = new MenuItem("Birra");
204 MenuItem xxx = new MenuItem("xxx");
205 MenuItem Dance = new MenuItem("Balla");
206 Menu info = new Menu("?");
207 MenuItem Porky = new MenuItem("Informazioni sul programmatore");
208 MenuItem l = new MenuItem("Legenda Comandi");
209 MenuItem RobotList = new MenuItem("Lista robot");
210
211
212 // Il metodo per disegnare l'immagine del robot.
213 public void paint(Graphics g){
214 g.drawImage(immagineRobot.robot, 100, 60, this);
215 g.drawImage(immagineRobot.raoff, 66, 248, this);
216 g.drawImage(immagineRobot.laoff, 225, 242, this);
217 g.drawImage(immagineRobot.rloff, 84, 367, this);
218 g.drawImage(immagineRobot.lloff, 148, 367, this);
219 }
220
221
222}
223
224
225
226
diff --git a/robottino/all_versions/v3.0/src/RobottinoUtils/Listener.java b/robottino/all_versions/v3.0/src/RobottinoUtils/Listener.java
new file mode 100755
index 0000000..d9c813a
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/RobottinoUtils/Listener.java
@@ -0,0 +1,73 @@
1// Questa classe è il listener per gli eventi relativi alle finestre.
2// Dichiaro che farà parte del package RobottinoUtils
3package RobottinoUtils;
4
5// Importo i package necessari.
6import java.awt.event.*;
7import RobottinoMain.*;
8import RobottinoAzioni.*;
9
10public class Listener implements WindowListener, ActionListener {
11
12 RobottinoAzioni robottinoazioni = new RobottinoAzioni();
13
14
15 // Ridefinisco i metodi dell'interfaccia WindowListener:
16 // Metodo invocato quando la finestra è stata chiusa:
17 public void windowClosed (WindowEvent evt) {
18
19 // Invoco il metodo sleep(int millisecondi) per mettere il programma in uno stato di attesa
20 // di durata pari ai millisecondi indicati come argomento.
21 System.out.println("La finestra è stata chiusa, il programma terminarà fra 3 secondi");
22 try {
23 Robottino.robottino.threadMain.sleep(1000);
24 } catch (Exception e) { e.printStackTrace(); }
25 System.out.println("2");
26 try {
27 Robottino.robottino.threadMain.sleep(1000);
28 } catch (Exception e) { e.printStackTrace(); }
29 System.out.println("1");
30 try {
31 Robottino.robottino.threadMain.sleep(1000);
32 } catch (Exception e) { e.printStackTrace(); }
33 System.out.println("Programma terminato");
34 System.exit(0);
35 }
36
37 // Metodo invocato quando la finestra è in fase di chiusura:
38 public void windowClosing (WindowEvent evt) {
39 System.out.println ("Chiusura finestra in corso");
40 evt.getWindow().dispose();
41 }
42
43 // Metodo invocato quando una finestra viene ridotta a icona:
44 public void windowIconified (WindowEvent evt) {
45 System.out.println("La finestra è stata ridotta a icona");
46 }
47
48 // Metodo invocato quando una finestra ridotta a icona viene ingrandita:
49 public void windowDeiconified (WindowEvent evt) {
50 System.out.println("La finestra ridotta a icona è stata ingrandita");
51 }
52
53 // Metodo invocato quando una finestra viene aperta:
54 public void windowOpened (WindowEvent evt) {}
55
56 // Metodo invocato quando una finestra diventa attiva:
57 public void windowActivated (WindowEvent evt) {}
58
59 // Metodo invocato quando una finestra viene disattivata:
60 public void windowDeactivated (WindowEvent evt) {}
61
62 // Metodo invocato quando viene utilizzata la barra del menu:
63 // descrive tutte le azioni da compiere per ogni evento ricevuto
64 // dal menu.
65 public void actionPerformed (ActionEvent e) {
66 System.out.println (robottinoazioni.Azioni(e.getActionCommand(), RobottinoAzioni.nomeRobot, RobottinoAzioni.pdrA));
67 }
68}
69
70
71
72
73
diff --git a/robottino/all_versions/v3.0/src/RobottinoUtils/PartiDelRobot.java b/robottino/all_versions/v3.0/src/RobottinoUtils/PartiDelRobot.java
new file mode 100755
index 0000000..d6cf869
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/RobottinoUtils/PartiDelRobot.java
@@ -0,0 +1,22 @@
1// Dichiaro che questa classa farà parte del package RobottinoUtils, che verrà poi importato dalla classe Robottino.
2package RobottinoUtils;
3
4// Dichiaro la classe.
5public class PartiDelRobot {
6
7 // Creo un costruttore senza argomenti.
8 // Se non lo facessi sarei obbligato a passare gli argomenti
9 // del secondo costruttore ogni volta che voglio istanziare la classe.
10 public PartiDelRobot() {}
11
12 // Il secondo costruttore riceve come argomenti un booleano che passerà il valore a "statoParte"
13 // e una stringa che passa il valore a "stringaParte".
14 public PartiDelRobot(boolean b, String s) {
15 this.stringaParte = s;
16 this.statoParte = b;
17 }
18
19 // Infine le due variabili pubbliche della classe.
20 public String stringaParte;
21 public boolean statoParte;
22}

Generated with cgit - Back to sebastiano.tronto.net