From d7a505607d083c9df4cf69289e92add834d70963 Mon Sep 17 00:00:00 2001
From: Philipp3107 <minephil31@gmail.com>
Date: Wed, 21 Dec 2022 16:44:49 +0100
Subject: [PATCH] updated Exceptions with Enum of errormessages and Exception
 Storage. Also added a new Exception *ArrayEmptyException* and an Exception
 Storage to get the last Exception that occured.

---
 Main.java                                     |  38 ++++++-
 domain/C3PO.java                              |  37 +++++--
 domain/R2D2.java                              |  93 ++++++----------
 domain/RobotBasics.java                       | 101 ++++++++++++++++--
 out/production/Robot_Factory_PR/Main.class    | Bin 1110 -> 1973 bytes
 out/production/Robot_Factory_PR/README.md     |  26 ++++-
 .../Robot_Factory_PR/domain/C3PO.class        | Bin 607 -> 2439 bytes
 .../Robot_Factory_PR/domain/R2D2.class        | Bin 2967 -> 1250 bytes
 .../Robot_Factory_PR/domain/RobotBasics.class | Bin 1170 -> 3805 bytes
 out/production/Robot_Factory_PR/makefile      |   9 +-
 .../exceptions/ArrayEmptyException.class      | Bin 0 -> 489 bytes
 .../robot/exceptions/ExceptionStorage.class   | Bin 0 -> 1032 bytes
 .../robot/exceptions/RobotException$1.class   | Bin 0 -> 802 bytes
 .../robot/exceptions/RobotException.class     | Bin 373 -> 1605 bytes
 .../RobotIllegalStateException.class          | Bin 421 -> 510 bytes
 .../exceptions/RobotMagicValueException.class | Bin 415 -> 504 bytes
 .../robot/exceptions/robotExceptions.class    | Bin 0 -> 1135 bytes
 robot/exceptions/ArrayEmptyException.java     |   7 ++
 robot/exceptions/ExceptionStorage.java        |  35 ++++++
 robot/exceptions/RobotException.java          |  18 +++-
 .../RobotIllegalStateException.java           |   5 +-
 .../exceptions/RobotMagicValueException.java  |   9 +-
 robot/exceptions/robotExceptions.java         |   5 +
 robot/interfaces/RobotInstructions.java       |   8 +-
 24 files changed, 297 insertions(+), 94 deletions(-)
 create mode 100644 out/production/Robot_Factory_PR/robot/exceptions/ArrayEmptyException.class
 create mode 100644 out/production/Robot_Factory_PR/robot/exceptions/ExceptionStorage.class
 create mode 100644 out/production/Robot_Factory_PR/robot/exceptions/RobotException$1.class
 create mode 100644 out/production/Robot_Factory_PR/robot/exceptions/robotExceptions.class
 create mode 100644 robot/exceptions/ArrayEmptyException.java
 create mode 100644 robot/exceptions/ExceptionStorage.java
 create mode 100644 robot/exceptions/robotExceptions.java

diff --git a/Main.java b/Main.java
index 0b35a7d..3ed5b96 100644
--- a/Main.java
+++ b/Main.java
@@ -5,21 +5,49 @@ public class Main {
    public static void main(String[] args) {
 
 
-      int[] input = {42,6,5,4,3,2,1};
+      int[] input = {42,6,5,4,3,43,1};
       int[] input2 = input;
       C3PO Herbert = new C3PO(1, "Herbert");
       R2D2 Herb = new R2D2(0, "Herb");
+      int[] input3 = {};
       
       //Herbert.triggerPowerSwitch();
-      Herb.triggerPowerSwitch();
+//      Herb.triggerPowerSwitch();
 
 
+//      try{
+//         String sorted = Herb.speak(input);
+//         System.out.println(sorted);
+//      } catch (RobotException re) {
+//         System.out.println(re);
+//      }
+
       try{
-         String array = Herb.speak(input);
-         System.out.println(array);
-      } catch (RobotException e) {
+         int[] sorted = Herb.think(input);
+         for(int i = 0; i < sorted.length; i++){
+            System.out.print(" " + sorted[i]);
+         }
+      }catch(RobotException re){
+         System.out.println(re);
+      }
+
+
+      String re = Herb.getLastException().toString();
+      System.out.println(re);
+
+      Herb.triggerPowerSwitch();
+
+      try{
+         int[] sorted = Herb.think(input);
+         for(int i = 0; i < sorted.length; i++){
+            System.out.print(" " + sorted[i]);
+         }
+      }catch(RobotException e){
          System.out.println(e);
       }
+      re = Herb.getLastException().toString();
+      System.out.println(re);
+
       //System.out.println("Was neues ausgeben");
 
       //just some testing
diff --git a/domain/C3PO.java b/domain/C3PO.java
index 946bb31..8390c99 100644
--- a/domain/C3PO.java
+++ b/domain/C3PO.java
@@ -1,8 +1,7 @@
 package domain;
 
 import robot.exceptions.RobotException;
-import robot.exceptions.RobotIllegalStateException;
-import robot.exceptions.RobotMagicValueException;
+import robot.exceptions.robotExceptions;
 
 import java.util.Arrays;
 import java.util.stream.Collectors;
@@ -18,26 +17,46 @@ public class C3PO extends RobotBasics {
                  .mapToObj(Integer::toString)
                  .collect(Collectors.joining("; "));
       }else{
-         throw new RobotMagicValueException(getName()  + " has an unknown Error. Code 42.");
+         throw new RobotException(robotExceptions.MAGICVALUE, getName());
+        // throw new RobotMagicValueException(getName()  + " has an unknown Error. Code 42.");
       }
    }
    @Override
-   public String speak(int[] zahlen) throws RobotException {
-      //Insertionsort
+   public String speak(int[] input) throws RobotException {
       if(isPowerOn()){
          try{
-            return ausgabe(zahlen);
+            return ausgabe(input);
          }catch(RobotException re){
             return re.toString();
          }
       }else{
-         throw new RobotIllegalStateException(getName() + " is turned off.");
+         throw new RobotException(robotExceptions.ILLEGALSTATE, getName());
+         //throw new RobotIllegalStateException(getName() + " is turned off.");
       }
 
    }
+
+   public int[] sorting(int[] input) throws RobotException{
+      if(input.length != 0 ){
+         if(checkArray(input)){
+            //sort
+         }else{
+            throw new RobotException(robotExceptions.MAGICVALUE, getName());
+            //throw new RobotMagicValueException(getName() + " has an unknown error. Code 42");
+         }
+
+      }
+return new int[0];
+   }
    @Override
-   public int[] think(int[] zahlen) throws RobotException {
-      return new int[0];
+   public int[] think(int[] input) throws RobotException {
+      //Insertionsort
+      if(isPowerOn()){
+         return sorting(input);
+      }else{
+         throw new RobotException(robotExceptions.ILLEGALSTATE, getName());
+        // throw new RobotIllegalStateException(getName() + " is turned off.");
+      }
    }
 }
 
diff --git a/domain/R2D2.java b/domain/R2D2.java
index aa3d424..bc8a856 100644
--- a/domain/R2D2.java
+++ b/domain/R2D2.java
@@ -1,16 +1,9 @@
 package domain;
 
 
+import robot.exceptions.ExceptionStorage;
 import robot.exceptions.RobotException;
-import robot.exceptions.RobotIllegalStateException;
-import robot.exceptions.RobotMagicValueException;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.OptionalInt;
-import java.util.function.IntPredicate;
-import java.util.stream.Collector;
-import java.util.stream.Collectors;
+import robot.exceptions.robotExceptions;
 
 public class R2D2 extends RobotBasics {
    /**
@@ -22,53 +15,45 @@ public class R2D2 extends RobotBasics {
       super(id, name);
    }
 
-   /*Sorting sort = (int[] input) -> {
-      int small;
-      for(int i = 0; i < input.length -1; i++){
-         small = i;
-         for(int j = i + 1; j < input.length; j++){
-            if(input[j] < )
-         }
-      }
-   }*/
 
-   public int[] think(int[] zahlen) throws RobotException {
+   public int[] think(int[] input) throws RobotException {
       if(isPowerOn()){
-         return sorting(zahlen);
+         return selectionSort(input);
       }else{
-         throw new RobotIllegalStateException(getName() + " is turned off!");
+         this.exceptions = new ExceptionStorage( new RobotException(robotExceptions.ILLEGALSTATE, getName()));
+         throw new RobotException(robotExceptions.ILLEGALSTATE, getName());
       }
    }
 
-   public int[] sorting(int[] arr) {
-      //Selectionsort
-      int small;
-      for (int i = 0; i <arr.length - 1; i++) {
-         small = i;
-         for (int j = i + 1; j < arr.length; j++) {
-            //if there is a smaller number on this position
-            if (arr[j] < arr[small]) {
-               small = j;
-               //swap values
-               int temp = arr[i];
-               arr[i] = arr[small];
-               arr[small] = temp;
+   /*
+    * this method sorts
+    * @param input
+    * @return integer array
+    * @throws RobotException
+
+   public int[] sorting(int[] input) throws RobotException {
+      if(checkArray(input)){
+         //Selectionsort
+         int small;
+         for (int i = 0; i <input.length - 1; i++) {
+            small = i;
+            for (int j = i + 1; j < input.length; j++) {
+               //if there is a smaller number on this position
+               if (input[j] < input[small]) {
+                  small = j;
+                  //swap values
+                  int temp = input[i];
+                  input[i] = input[small];
+                  input[small] = temp;
+               }
             }
          }
-      }
-      return arr;
-   }
-
-   //   Diese ganze Methode muss zu C3P0 und ist hier falsch.
-   public String ausgabe(int[] input)throws RobotException{
-      if(input.length != 0 && !checkArray(input)) {
-         return Arrays.stream(input)
-                 .mapToObj(Integer::toString)
-                 .collect(Collectors.joining("; "));
+         return input;
       }else{
-         throw new RobotMagicValueException(getName()  +" has an unknown Error. Code 42.");
+         throw new RobotException(robotExceptions.MAGICVALUE, getName());
       }
-   }
+
+   }*/
 
    /**
     * Die Methode nimmt ein Array aus int entgegen und wandelt diese in einen String um.
@@ -78,21 +63,11 @@ public class R2D2 extends RobotBasics {
     */
    @Override
    public String speak(int[] input) throws RobotException {
-      final boolean[] found_42 = {false};
       if (isPowerOn()) {
-         try{
-            return ausgabe(input);
-         }catch(RobotException re){
-            return re.toString();
-         }
-
+            return ausgabe(input, ";");
       } else {
-         throw new RobotIllegalStateException(getName() + " is turned off!");
-
+         this.exceptions = new ExceptionStorage( new RobotException(robotExceptions.ILLEGALSTATE, getName()));
+         throw new RobotException(robotExceptions.ILLEGALSTATE, getName());
       }
-
-   /*public void something() {
-      System.out.println("Hello");
-   }*/
    }
 }
\ No newline at end of file
diff --git a/domain/RobotBasics.java b/domain/RobotBasics.java
index c016e67..a344531 100644
--- a/domain/RobotBasics.java
+++ b/domain/RobotBasics.java
@@ -1,13 +1,16 @@
 package domain;
 
+import robot.exceptions.ExceptionStorage;
 import robot.exceptions.RobotException;
-import robot.exceptions.RobotIllegalStateException;
+import robot.exceptions.robotExceptions;
 import robot.interfaces.Robot;
 
 import java.util.Arrays;
+import java.util.stream.Collectors;
 
 
 public abstract class RobotBasics implements Robot {
+   protected ExceptionStorage exceptions;
    private int id;
    private String name;
    private boolean power;
@@ -16,7 +19,9 @@ public abstract class RobotBasics implements Robot {
       this.id = id;
       this.name = name;
       this.power = false;
+      this.exceptions = null;
    }
+
    /**
     * @see robot.interfaces.RobotControl;
     */
@@ -58,16 +63,98 @@ public abstract class RobotBasics implements Robot {
     */
    @Override
    public RobotException getLastException() {
-      return null;
+      return exceptions.getLastErrorMessage();
    }
 
-   public boolean checkArray(int[] input){
-      for(int x: input){
-         if(x == 42){
-            return true;
+   /**
+    * This method checks an array of integers and gives back a boolean value.
+    * If the array contains the number 42 the method returns false.
+    * Otherwise, always true.
+    *
+    * If the length of the Array = 0 it throws an EMPTYARRAY-Exception
+    * @param input
+    * @return boolean
+    * @throws RobotException EMPTYARRAY Exception
+    */
+   public boolean checkArray(int[] input) throws RobotException{
+      if(input.length != 0){
+         for(int x: input){
+            if(x == 42){ return false; }
          }
+         return true;
+      }else{
+         this.exceptions = new ExceptionStorage(new RobotException(robotExceptions.EMPTYARRAY, getName()));
+         throw new RobotException(robotExceptions.EMPTYARRAY, getName());
+
       }
-      return false;
+
    }
 
+   /**
+    * This method uses Streams to join any given array to a String.
+    *
+    * @param input int [ ]
+    * @param delemiter String
+    * @return String (array as String)
+    * @throws RobotException
+    */
+   public String ausgabe(int[] input, String delemiter)throws RobotException{
+      if(checkArray(input)) {
+         return Arrays.stream(input)
+                 .mapToObj(Integer::toString)
+                 .collect(Collectors.joining(delemiter + " "));
+      }else{
+         this.exceptions = new ExceptionStorage(new RobotException(robotExceptions.MAGICVALUE, getName()));
+         throw new RobotException(robotExceptions.MAGICVALUE, getName());
+      }
+   }
+
+   /**
+    * Sorts any given array of integers with the insertion Sort algorithm.
+    * @param input int [ ]
+    * @return input int [ ] (sorted)
+    * @throws RobotException
+    */
+   public int[] insertionSort(int[] input) throws RobotException{
+      if(checkArray(input)){
+         return new int[0];
+      }else{
+         this.exceptions = new ExceptionStorage(new RobotException(robotExceptions.MAGICVALUE, getName()));
+         throw new RobotException(robotExceptions.MAGICVALUE, getName());
+      }
+
+   }
+
+   /**
+    * Sorts any given array of integers with the selection Sort algorithm.
+    * @param input
+    * @return
+    * @throws RobotException
+    */
+   public int[] selectionSort(int[] input) throws RobotException{
+      if(checkArray(input)){
+         int small;
+         for(int i = 0; i < input.length; i++){
+            small = i;
+            for(int j = i + 1; j < input.length; j++){
+               if(input[j] < input[small]){
+                  small = j;
+//                  System.out.println(small);
+               }
+            }
+            int temp = input[i];
+            input[i] = input[small];
+            input[small] = temp;
+            /*for(int n = 0; n < input.length; n++){
+               System.out.print( " " + input[n]);
+            }
+            System.out.println();*/
+         }
+         return input;
+      }else{
+         this.exceptions = new ExceptionStorage(new RobotException(robotExceptions.MAGICVALUE, getName()));
+         throw new RobotException(robotExceptions.MAGICVALUE, getName());
+      }
+
+   }
 }
diff --git a/out/production/Robot_Factory_PR/Main.class b/out/production/Robot_Factory_PR/Main.class
index 7070d90035d8d9bc4e713e03533239dd8792c584..813b4d750c1d5af92fbf135bfae0281f211a8116 100644
GIT binary patch
literal 1973
zcmah~&sQ5&6#iZk=1sx?X(+Af4+=sl0ZUp?v`|q=i$nrJg4Bq=hA<6N!c00DT3Oqj
z8&{s5<4zZ>TRm{va#*@><x>9u{|Gm&-%Fr?;n<waym#-r_q*Tyk(b|}Kivf|hLs2c
z2ug$uG(Z!G-ZAf)$&%?5li8&^R>2q0uG^07j|l{O6AKc$K;yEzX4+0NH8h*m5fPA+
zmbYYiegqPRLTVB?)tk;7faQG8c8a44pydEyZt%vSjuQeQ1rR|q4D~u`pbe)48vGU8
zStWzs#dKmZ9mZ>jOPn!q7Uzyo&23bCYmE%ubrNo?#kJk!EQ9(CZJBGMG3MKD-~u`X
zPOq7(R?2k>rhm)!SGcSArsG%W+nY|*(~jVEbV+m@xQHHs)@oiy@yWKVqA7@a0F`&I
zzy;4;a{Z+BO~ESrHlrrzl;Y;Ttm5<;=*JtZX%(*I{0Fes6&6wzYQR7eS6GUo<!8*w
z0gymfZzA)GXrmEa!k~d6yeXjjZmmZGC+S+(IYn()QR`8G-!X7ajZ2JeEfy_r*1d0e
zx%;+XSdkcIKc_h#TvG0`CD4+w9cyNNjUzH|E|sW>W!!>US};9Z$$QEW+szhe8Re`%
z)R3t`TCAs&SP&34pEMmRuIF3J0)a(J0gw2dugsmUv<sPDks(`;iNJ>1PFc;9R$T`L
znlgt5p9EjZYK|$_42M*Db@iil&NmCI(`LDvuEdnYgaq?A^qbpnK_us{dj)I4R>cad
zdJHH;+K#)fU-3P&JZ<?a?sBC?!(s%V;|qx|)pUO)(0vfxcJ8^WR<Z_L8~6#c;Je<2
zz{A6Hx@TAeoiv^0l2z%>xbEtDd9*&6Lz*Lw^BZOB81uu`-Jjojh?H3><!s*?)xksq
z9YVlJJC5b0N@k^ERV3Kri*>mjM_J;wK>PojszIyfhfa*}5>%f6*mY=pU#FDhD!4ZE
zZ9_b&9>2@CItD_#JOQI-fcNk|r7%9gI5l(*^wA<r-Ct3;6Uhgoec5~{s%7&HdN!}g
zY+iD&NBgt+s20j*`lp{k=0maYHX3K1p*bInMYj<f2?ci|BMtFT{}x(DwBWF8lW}eL
zC&VA)bX;qb15a@t*h1$6DK=mHy@{p~t$MVDL_D;G%UihmQuCJ5yuAk|gTs289+&%I
zvQ0k#)Azxo0+YvrJz}*|D8c0=@;#nlhiee3K(`U+TjyOFrY?d(G_qI*t<PYJclQF$
z(dI0DJLuhxyBymMbm3cc<2&>aErEyV!_T~Je&PCro!G%;>|y}F;R^o1Rs6|Ps|Gwk
z6K05!!VUiSOtF_YF~JtyW&95@$=#28r#dlfr;<oI(ma)_LHLM%AlqM&p|2q4$C&0W
zK<1m|Kf}Dnh;ss2HZ_GGFw4^h@?Btzj~Qc*{@0+tps6mAlbEl5r9^XW&x!d5=f@>3
mg`cBS;uEUHzJ~C(2oS)h$aB?6;WIv8V~J9Py8<i}5&svmaMEG`

delta 546
zcmYjOJx?1!5Pf^+_4*Dwe1i|nr;V{OV8{mnY(5ew07Xd@lu#f+F37qVB7!bXP%3Il
zv{jlkDN+*&BT-OL@&oAjE5JJ=p-8KlotZcD-t3;#Uq$T8o3nEOvsgT`f4vS1G*$ev
z=au}oU-wJ?>VCPh_1VTFv_}z#BOt%+mE0YHw#@o+_SLrg!_9wjcfI^7+jhNzg-#?C
zx}xYt&(Xzr%tjyj6_Qb;FrbSfuK$R3T^4m>P=6PxWFN9YX-J?o^WV5PpSDX|l|uG|
z!m!>jJWIO1@BXAb-DtK5p|6cW9We(?V|`iY%$%;64WTK8g8pqfo8-*F;98)iW`t=+
z80F~&y&O7)IIfjPX@fElVi}0u12BehMiw692{UXKaU#OZebhTLA*4Q(y$4RHie@L2
ztD<dM{zHc&tLXiU*h7#xX7@|H!+WG*B48Uu9j)Tl5#}uN*qA|#s79=yiP%=6o3Vx#
zY!VfyS|Wah_@{Wrb=G*Bz;norKn^A`MV~?u(<qQGO<&~A;OKm9xJiN}$Io(wIbstq
ZZpk4P<`rJlj#B((p^&y}f`gY^xC6rqQ7-@h

diff --git a/out/production/Robot_Factory_PR/README.md b/out/production/Robot_Factory_PR/README.md
index d7998ba..260ddad 100644
--- a/out/production/Robot_Factory_PR/README.md
+++ b/out/production/Robot_Factory_PR/README.md
@@ -12,7 +12,6 @@
 
 - Philipp Kotte Matr. : 2211945;
 - Cedric Hermann Matr. : 2210943;
-- XXXXXXX XXXXX Matr. : XXXXXXX;
 
 # Overview
 
@@ -44,6 +43,25 @@
 * [Main](#-classe-main-)
 * [makefile](#-makefile-for-Git-updates-)
 
+# TO-Dos:
+
+* Sortier Algorythem C3PO, R2D2 (mit Ausgabe)
+
+* Bei Erstellung eines Roboters wird einne SerienNr erstellt
+
+* Wichtige getter for Robots (getName)
+
+* Exception Classes (Throwable einfügen)
+
+* RobotFactory, die mit enum(RobotType) Objekt von R2 und C3PO erstellen kann
+
+* Nexus6(Singleton) implementieren, kann nichts (Illegal-State)
+
+* JUnit5 Tests
+
+* Wie fügt man weitere Roboter hinzu erklärung in einer Text Datei
+
+
 ## Domain
 <h2 align="center"> Class R2D2 </h2>
 
@@ -350,3 +368,9 @@ Textdatei in Ihr Projekt, in der Sie die notwendigen Erweiterungen und evtl. Än
 * Testen Sie Ihre Implementierung möglichst umfangreich. Wir werden es auf jeden Fall tun. !
 * Nutzen Sie für die gemeinsame Arbeit an der Implementierung ein Git-Repository und nutzen Sie regelmäßig. 
 * Es müssen von allen Team-Mitgliedern jeweils mindestens fünf Commits mit substanziellem Inhalt auf den main-Branch gepusht werden.
+
+
+
+# Fragen an Hummel
+  
+Was ist mit der Umwandlung von zahlen in arrays den inhalt mit Kommas getrennt gemeint?
\ No newline at end of file
diff --git a/out/production/Robot_Factory_PR/domain/C3PO.class b/out/production/Robot_Factory_PR/domain/C3PO.class
index c81272f70a590cb936018d8621a88aecd5524416..4c06df2a0b584878dd1aad61d10932fd167a83af 100644
GIT binary patch
literal 2439
zcma)7TUQ%Z6#h;^GB8XajWo4f%B{8G*0ffEnp%YjG#V}vine$=Ne*EknMr3RwEY1-
z_!ICC_)2}C7hTn7m%qv7J~KlYNNrs#l5=+U-ru*sv-dfF{qyn_fIE1sB80GlHVqL(
z84_i)#&sjTZWc{vp4)oKW{BR_4c)oJkWA(ByL_LgtK6uh3y!55mCV?tigt7;P&ITy
zW9amAWN)smGN`2;QQDicEdGQclG@6RJy6kwZUu1-=a68CyD1xvUQN4h647=n!D|dd
zGQh)h9XxwFXE=mT9+?D{(WBu!l9Zj->s3M-Nd-f;8%D{|O+yAP`s++5-o-@)y&C$^
z&(M29;Vc3}dyUsO%+=y9LnamA^4i2fWIvV9v>lfiLYW~ILl{;tqG1%58TwkFvu3p_
zN{(rf5X!De+8Y&yX&>5^KD)!Mf_T^vMoDB|1KCVLg}#TY3Q`)zFwStH1<hkeNF@)J
z;d-!0zlM{9KAKB|G$EoH1(V087-$Ry*BAyZ*+^;exFqWG5Nxlr7LNBFxQ-hN-q&yw
zAJB2PxVwg?J1L?r&n@M$n{)Yl3v|-?w*_Qmb53iR!7SBS5zY#)35K5I76}k0*C~7?
z2O+~SlX`pV|C)u5HJYqX7&>%&&3q)RRf8d%l6~KfISup35*6OCE4)Zlk|!;Gmdt{N
zMajF}G3l774WwLmHRPmLS}vboSenZhHs&@KWa=+8<grYtZPRkxo{7rTTRDcdtXU?g
z?!0b@l}4>7tPNhQk|mKhOT4<tEnV(?W1F+1lhUz#V30|YkX~kBGMnLQm}sq^W>7ck
z4Tqd1Y^>n$(%v$SkB6oP4>Drc1>Yl2i+BvTs=Y2drx`%_5u#;KfLbscR!J=CvVabG
z%UqLPO)WTYnhrHAuP+N{$1L03QIu4aArx$Ds9=XW#vK4xXx-R1_e46+YsE6B2)@nb
z)X@dfSqtv|4o;pQ<N@5}M!72N%X!n>Yt%EXdIT(|0ym!2MbQ2K|L8%!IW{<=e&#H%
zRtvf#GI7u~c0P4{sk%b=V@zsQRn%Z8FlFP_8P1)kMYpG@2&*O7YfQ>Z?pn?;gq5vw
z+ZMJ0YJ)2$2~O2`S~&&#442;QN{@mkGlr?xLv-zfCY8DZQTkk=T@GRT1C;T;$!B0s
zX&J&Qeabfu^fpDIVU1Qpo*TZzI_)R`1#D0fxw?l<@@8^K>074#32kot?8K`BTpgb{
zg7Py4C!Qnr67K*na3O@mz;g_~z?BgG#Khrmn7aQf(&I<?@ELCXK{>)Mk6vN`bR&j1
zlJxcsAb}LE$I#>QN_sd=UbFZLUlW)6ZU#1n2efD-!xa5*H3|MmHd*%w0p319x1{*#
z;qv4WKJ%$8HL1|;KqAB_gGVVz`T@OU?I-I1J<OM=sNtqeUG)1m_|_#h(j+z#Af_O+
ztY9i~iX7cTzIruZy-}&&fUDjCqQ4+<Mx^lX>Y-bvJg@`>fuxC$G;vH~5H|t>jW&6V
z26)gR#k)?C_^wHU`y~23g*qgS&s(%PKBg{L&1uqPhBUbqK<;lM_Xm)}V6gyj7~d25
c5PkrsZ;g(sNC|c9;UO%tsARFxz$0Az7rWn33jhEB

literal 607
zcmZvY%SyvQ6o&svW1`Vouk}(z-KmIO2qGvh6oo)gvC>Uf({#|$b|PsM@u_qri1+|L
zl=x3uidX}gbN|le>-+r^z#*0cILP^M$1ns>V5*U{q&DTtq@H9)vaRE`fOnvc&JG2N
z>tS>&A7!~I&2_nwrP^HYZ&ZB@3yk(Ek9RK41>EDLp#%z%HtOu5RafbitT*YIijr71
zt1{Kr?m6A;Mzc>o`o-86aCAdJgrphS>eLQ27Z_^aD|u&UtA!hb({cJ|dDB#exEfKx
z$y2QEGo6^Wk9mQW)NWc<eQ$U5eij>WIKu{>ZO}nfl7}=_r`ql_V)xy)b72iWk7>Ug
zSO$;p2(6HIj?&*OZM{LfQgsmUwYLY;JQj{pTkWP{40&2Cz&HwoSZxB6%;x<tO=+>a
zv~0a2UhLZ;+Lj>8(u&<^pXOi&vy2xRb1CQeFJQ4p+oNS^Ztf%a%PaiixqY7d53fXm
GgQXt<C1)J~

diff --git a/out/production/Robot_Factory_PR/domain/R2D2.class b/out/production/Robot_Factory_PR/domain/R2D2.class
index e0fed2ab4dc0fc8bba44079d0f5f82b0990b1c83..485d9abb495e9e6a8635ca6b356e626d5e168465 100644
GIT binary patch
literal 1250
zcmbW1ZBG+H5Xb*}eK>kt1zIdBDv#o|AXOBr7QrIbG&#{wLV~>7mP=hJcg@{ZeP#R_
zehW1b5=r#EAIdm;EtRHCNPN-j?A*+Me=|FKzyJLB31Afk4GKak!a5>|G9>n$LoV#>
zmQ!*3b?%9(#}Hi+w(wUOQbx&q%ir;Ao!hl+*>{Cq%cplV3?QaL(=iC0VenLAX=8~Y
zCcIb9d&_-kGlY!vYZ-h&#}I}Y;+|Evs=jdSvg7)+k+D}w@0C;}7^Yl_khMNkt%i*7
zvc*%g>^m;6St>>uCVIjG^iFIHDU7MOq~kKKFiiG@2aZlSRjZdwv-rGVmbVMrMTTkf
zyp+5w>8g%vxXz%~EPs<9S`4E`y0=*xl9-geo?^%u=S%l0$aarlMrzD5%=XdfZUCK6
zjQHks+=RiP{c9-0OfNvE6YVDF2asW4L5&MKZefvX<V~-}D^#OF2i6C%*ToQi>g-d-
zkST0yvw2vt+-+W|lP6(1RbJoWu8`}tGwi<+bQW>*%q-;@6tPb*B~r749w++k6ro)E
zfFUC6Mw6yW*`tJb+2_@R7rfElK<gAr+eEyE#VI2t=dYinR(6_h)p{l*aBPbPdr{s4
zOi^bQx=26>B!ehDv$QJFIz<0!W_;lo>?@fHZqrj<H_-4$F^oH8O}4_YguAq&1l+?i
ziAd`{aum(*fMS(E_9J;^{&MCB>Sx3<^GAq($(&$h_XNq^Z@5S=#*Z;^jOp*V(e3+1
ziJ<@@fiT%g5*tOF?#CR)0+>`wyaTh0hj>H)`5=?Uu|h_e97*~;rmshf>QkF4*P<HC
l%qP-EnEzj{0?DmYi#A}Oc!n$2;mUP$4Rvv?5u<`9e*u0s8Pxy)

literal 2967
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

diff --git a/out/production/Robot_Factory_PR/domain/RobotBasics.class b/out/production/Robot_Factory_PR/domain/RobotBasics.class
index 2e6d34124353a5af1ca057b19f4e0b2fb86f2955..f5b0081fd702c04ebbb40504f1708a96e68dba40 100644
GIT binary patch
literal 3805
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
b6A;DsaE(x3VcoutpL1VM+F#&JLf!daGMJUP

literal 1170
zcmZuv%}x_h7(I7>Iur`Dr9}`?5z%(2?MgN%2@pw|6fss=z-l^-W%!wCri0+##Ak44
z+^}JxiNwSO58#vd2(Hj`XGUy*&3yOgJLi1op80wH;|#z8YW+~48qhM(krK%6SZ}S`
zp5?V`Ypor}4h2$AT+a;`1k_S_J&iu34fJO)fQ&$X%ip(LulCY!`Qeh)b?vTz;%*6u
zx@;ZFU>I2e&9n9$wm1IMH^ad7+Viq2pTP(U0(!?kbOK^G42%kl29mYrdZ81%v23Rs
z%kZL9ze-eIr_8dyMVaA->p9O4_FGQy%4+RJ!oF?oty_UB_sO9aZo3?}(70-1p2M`A
zuuda%T^BI8dmecxl*(7dX^nQ;Z6|mkEi@0^(B2jpY=)M-yJ~e3#kAXv?$^ACcZ2Uu
z-iFl;pB>pwCv<&YOj96s?)*DUoL@9?yncJzv3D1Pz<S47OPlpF*~AgouGcwWY|3Wc
zz$_b^{y|_nE3SNpY)?>CnT0mR_g5fLgv!cL`CBM5w5T!`R)hCCZty$CT}%EktOfHs
zggJ2v!>pWQ&{R*6`x>Ff`5h$!<k85KMh-*BGvpE6<mufQj|tr3j!coRh*nZr&NGSI
ziC&FW-s$Ey7$;mPkOHaba6BT+#0?3dz#U4&!}fv)zgz-OT??LysHM}_(Ih~T%DImi
zh%6qX&(spDYBWinCV?`a$)w>5?Nob+i^){?*rP!i);QTT?q4%s?y|YZJv91-xfwi2
zz!g^cGK#qD>}d~Dxj;TdDM5aqvlNjtv#XV}1$9m<YLlNaRw-)LIlZW7%}>y^llPi9
z{_{(fW5rJ6P#5WNiKNR6X^~!5A~6|ifl-(F3(4qb5?Q%2F-u|j0z**G(Py9{MBz94
K1Rn8JLG>?vb+<qO

diff --git a/out/production/Robot_Factory_PR/makefile b/out/production/Robot_Factory_PR/makefile
index 96962c2..c4c8eb2 100644
--- a/out/production/Robot_Factory_PR/makefile
+++ b/out/production/Robot_Factory_PR/makefile
@@ -15,6 +15,13 @@ update_domain:
 	git add domain/
 	git commit -m "Updated domain. Further explanation in README"
 	git push -u origin main
-
+update_exceptions:
+	git add robot/exceptions
+	git commit -m "Updated Exceptions"
+	git push -u origin main
+update_interfaces:
+	git add robot/interfaces
+	git commit -m "updated interfaces"
+	git push -u origin main
 fetch_git:
 	git pull origin main
\ No newline at end of file
diff --git a/out/production/Robot_Factory_PR/robot/exceptions/ArrayEmptyException.class b/out/production/Robot_Factory_PR/robot/exceptions/ArrayEmptyException.class
new file mode 100644
index 0000000000000000000000000000000000000000..a22a604d16f011c2eaa0331d4beb2c0721247811
GIT binary patch
literal 489
zcmZuu%SyvQ6g`v1Mq{+T7Vdl?;tR8M5h;jN5TXk!-B02WN777~OvQYbE5U^y;75sf
zqIO|A7cTc)&bhDo{CfWY(8q=k2OSS?fH`y-wzNu=3B^k)N+VTKg?BbF_`?j{b6H5!
zXE-~ETjVA&C09}W#GiSX^CAm}M$00L4o4p58TMMz3$1xQ7?-A=>KWWi^&l8}u`I;x
zWSj_n&y$=oYq3gsKH^$h{F`*mqpTSA+jGq*9#M5umsD%F&Huj#Lm;$P`bJb0&zk<N
z%^3Wln&?zqNju@@jGm`fgdKQvbo&??ot^vwp=)%=0PpDd<PGeVLI*y1`$uSqT`W?x
a{X;{5B|;>?GI~_RMk`n)HXVqNgY|C>i-G|F

literal 0
HcmV?d00001

diff --git a/out/production/Robot_Factory_PR/robot/exceptions/ExceptionStorage.class b/out/production/Robot_Factory_PR/robot/exceptions/ExceptionStorage.class
new file mode 100644
index 0000000000000000000000000000000000000000..5f07ef76f67140c983a4c0a192d105602c7b90f1
GIT binary patch
literal 1032
zcmah{U2hUm5Iq+tTj&B6S}3g_rBnr~?yD)LFWROiP#bA@U*Lk<u)AjWQuSYHVq@cj
zKfoVlJiB}p+Gru!J2Q9YoHKLh_n)7?036_15)ni-#B?knF0guTUYN$vbOy$|&bjO=
zf%q%SvDAS;v{G#+u#AL;q>dHn0wvGwxXO^9yYi#5T*o&Kr)EpJo;i>Lnk{`lv`URz
z>F<O3SxtQzX@T4q{)}eR==HXbkN0hR-}jSP#XSvK9XYHC?1VCvWlN*)dbX*IH>Q$j
z^p8SUNlzf*_D@Yk(-C-CX<T>KQl8}u>eX@RzbN%2@+fH7&{4#uK;fFW;dag8l$O(R
z+)n~qm3h>KlzK3``#K)rp+Kxhy#mEK35&@ByOle~Rc#aLwc8_7reQhqWMp@wcV>2m
zjATQ=w&_`cKMBUv2g?^I--ez&!sOxVY^kUE)G?>=U&Cf{-Zw8~gI)RR(DPicIeqoq
zK&pm$Gg{`L?%D={WXm0SU3p{$4Xxjl_#$`=lsMK1mpQ^emol_CW1dk6ZuKL6x9N>|
zALCi9{eY<LT|&#Iu8?V7Vg01`{1RK=co`uau!%UoNv5wLLC6eJ+`BY3XzlQ(HU>f&
zyYvVd67vyQ^B7Nvk|RQqA_56dXA<7>CXkv6>1$+OpiMI!$Wn8Tq-!Bneq1o4N=>K)
kDyU96Gk6MCF4ew6`$}WnMLY}^LKuCVFo6;5AjsPL3q8i~m;e9(

literal 0
HcmV?d00001

diff --git a/out/production/Robot_Factory_PR/robot/exceptions/RobotException$1.class b/out/production/Robot_Factory_PR/robot/exceptions/RobotException$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..3c73d7b6364a93ff3f9f017263888057c8efe76b
GIT binary patch
literal 802
zcmah{+iuf95Ix(tabg^rUZ9~|nijWBC?Wz0@c^o1MQ(|3QWS@vs!tnd)wng@%61B0
zz_0KONC+X+58$H^v!+Ufc!*^0%sHOR@y!1E{o@kA9v&K)Lr#ZgVjg*hYAgpbZHN!P
zI8Or^C5?=5CYT|A!Najg7`AHlV|P~k^CAi;>M%@PgUPV*UqV-PoHVc=GwfR4`ylm4
zZGLWL;nq~oUt$tYGUkq3Mf!>BCKga;Fk7zc9N4bcvwIH1=4^#(1WP8CvBIFsco;-H
zWXRR(Egd%*)=v2aZ-hKLX>_DF_DB1H2!~D_%UJcTn7F0-8g2Wa)$H5u8%NQ%P29<7
zr~SHjWOuvvk&b%|<!QCU!Kv_5hQbR!45A?2%bNBXw5A*ih6Oi>L}&bNAmSb$gv2bl
z(&u5H$AQ9EWXVgpe@3&q!iFcuu`l)mm9hNqbRVhiRN0CAP$ofi(iZ7R4t3NS)@N*n
zgmy%dzLW`RHd|37;%3N`L?q=Z?f5R;CswYgEh~?hbyUf25c-H5dBC&pV3$9Quh74!
zr}Pbr+TkZ?uQIqwaDEEc2<9{RnbM0`!76T`g8SGeyMrfqN;Zd0DxA;Cm*^X4_JBq2
iBJyu_ifB&`XxPdEwkaKiYIHuxm>PD;8kuf#%7s7PKfkpA

literal 0
HcmV?d00001

diff --git a/out/production/Robot_Factory_PR/robot/exceptions/RobotException.class b/out/production/Robot_Factory_PR/robot/exceptions/RobotException.class
index a8a54aa106eeea4e8c64384f83bb3523e7901792..c4d701ed7cccbf0a5474ac2d091563a82acd177f 100644
GIT binary patch
literal 1605
zcmbVMTW=Fb6#m9BUfbCu#xc-v-GHG<9PC25n_Do1M6#(=)9}F4WIfo6?HOx!49!2`
z2Ow4IQ;Wn!Jn#efO;yF2wMlFowGvv*>^Wz?bD49_oX`J$`~=`OHq(e<%0b-40VEhs
zX|=6PN&N1Mo(Yr;OTSvdgReY8x+zRegduMVhK;4_ghC|PRS3(~=llgPb+~Mn>P82$
zSzewLrIAF+LE6PMT!#5Qon1=|iJO58%x#84OOqCsw^DSKSr>E2FiiV>t%Wp?cX|}&
z>Hm*1i7W$B$l;KK!!C~C2ZqIo%Z+Cve}SQpufGh8->UImK7!}>k~a|S-XLU%J*A8v
z#W4rRU7Wy425-VgBp6k4lx_r)cNnIYmN&ChIM2l*PBR?o^0ufb>2vcWFfF1&!=)id
z=k`m{WY)5v2(pwokKyX~6?2OrUQrE7^ISEM;!(f5E%al)-62V~s(jwr;ySSWP#8C@
zfFfL+EXsIx%VgL@^@~g1jjZjp#juqa4p<18bGl!fa;9#$-==y*{v2Fn$b73veOy<4
z?Thum#yLOkxoF|kM2|#By>9PA4l?(YGNIADR}-eC8sS_5*V4F-8xG309yb~Cdwv4>
zLbb)P<p(8N=e|*ThvC&|afZNw(G4ye9TDcMO11mFecsMU3C9#|qwfQMI)eXY`?>JV
z*y|gbsPImw9vD$hf?ijKc|quzzLuilsb|lMN!+C_VP1=e9+zHUwxxP0J)yPIMbFmW
zyL6FI_vmFZuc?ehiEhvAcwB3~Q)F;Ar4+i-;bAC32M-v|PNZtT3^;hmaPq&QG#Ccy
zq8h|#j(~a^b_~!SBYGNVX+KBYZ<wNw&Q=PmAHd$jSt-25%-<34N7`qj;{?qChv*cR
zNahVxu#6Srtl<Kg9=KS=d2*4qvvcU;HSyNPTJ~V=4dz$gVWIdZ@t0^>9ecJw>kO^)
zg^xG|)c!z@D3TDBCMr+V>R%Dq26dE-11_n~(9tZ46v8zM;SRDR0j`nU-k4m&hDF1I
z=6fj$@F$W^BmNKa4lblp3B>U;iDDGhW%|bnoWm8Oa-?*XxLeVFC)(Fgp%XhJa`Z<g
LiThZ`1{S^mG?<*r

delta 180
zcmX@g^OZ^b)W2Q(7#JAr7=*YOm>8JZ8CZB2SQ*$R&NBzHIVOs$O!jArRN_f3D#|bN
zO)V}?OiyKG5c0`NEKAhSNz6;v4=yRn%uBbP%*d>q#GuH)4m1S>7=aLI4v^#o8_xt5
zXVcQ&&cL`4D8j_R1tdXsG62<qRB{7ZVh~jfJPf=*9s^L6kAWX-mH?2)#2^R&eGeH2

diff --git a/out/production/Robot_Factory_PR/robot/exceptions/RobotIllegalStateException.class b/out/production/Robot_Factory_PR/robot/exceptions/RobotIllegalStateException.class
index c615c5be8095a2118888bd34e6502df412269278..e7988e5565896a0512efc4de7fd2f71806ca4047 100644
GIT binary patch
delta 188
zcmZ3={EwOI)W2Q(7#JAr7(^y=S*e(7_!Q+Q<(KHERwSnulw{`T73+fqT;Y7{iEe8&
zSxPDkQW+VP2&$g=J~zaZff)!H7}&M6b+$7wZUi!!7`T8W7m#LPU;{#S25ulr0iuk7
fhk+N!18QL4W8i0C1hWJf1c9m<8H9j5CI(>uZn`Ry

delta 102
zcmeyzyp);i)W2Q(7#JAr7=$KrSuu%fOw3p_*?}?3(~f}&2pJgIw6wP~Fm430m>9T#
pBo|nem4TIkje#4;7lWu`;9=ke@__0Y_!#&Z7=cg#$YWv<1OVe;3_Jh;

diff --git a/out/production/Robot_Factory_PR/robot/exceptions/RobotMagicValueException.class b/out/production/Robot_Factory_PR/robot/exceptions/RobotMagicValueException.class
index e142b6853c7cd369886b2467dd2a2db1a4348937..3bc7be972e1cf19c56670fc25353242d98b8e2c9 100644
GIT binary patch
delta 172
zcmbQw{DYb6)W2Q(7#JAr7(^y=S*e(7_!Q+Q<(KHERwSnulw{`T73+fqT;Y7{iEb-2
zSxPDkQW+VP2&$g=I-AFnff)!H7}&M6btWe=iW;*qurY801r#8{3_J|HKps#510MrF
U10$Fvz#z!L1Y`>Vc}xt#0Hs|i>Hq)$

delta 86
zcmeytJfE5C)W2Q(7#JAr7=$KrSuu%fOw3p@*@iKL+m3+=2pJgIw6rI0U=-D4Wng3A
e2J*!qq6|C?yg(jMo`H{npMenw1%Nyz20;K7u?yq?

diff --git a/out/production/Robot_Factory_PR/robot/exceptions/robotExceptions.class b/out/production/Robot_Factory_PR/robot/exceptions/robotExceptions.class
new file mode 100644
index 0000000000000000000000000000000000000000..55a0bc10c43784035861ff19a01a7165c72958bf
GIT binary patch
literal 1135
zcma)4ZEw<07(JI33bk{HI2>*|*>u1ZMA^PT$Oyp&(>b#u3Gq|Gid{-;pe+6@Wr<rf
zntk?18J~MWht32`(%a|UbDlTO_aC3X0jOX{L4aXx;B`DdZ@uqY?|j>Hhj{_if5#Cp
z$QptOF=!24ukTfLqgid%8B+Q@afz$L8X{b+?pOC3wN_PsS?BN-4Vr-K`!Aa9>fvFv
z&EcyW77=AoHU!gPSbsIYj*1wrD~M`{;|4>p>v*ok5Km|HBlFnIJEq&qA9Rkau3u7-
zz)c0q8j`q01uqD7chslK$EGu~4&E?qr)ShP#~cnzGl1a_Y`0gMt-uqA{Hq#n;|@cp
zY`eB!VOW|?HB~k;tuTTr4ZRvhBn*vz-qUa&n|yxJ#*mP7=07$-wSEcYn)jN9U({{a
zdOqrRtU=T4IE3u{qlwJ?<ub%{uWLFjb71pC(`>S9_9<!X@=C}t{#%<`j~I5(HT}_m
zcv3pkA~Te`&U7Wk86jU>d44CA64}V`MuV>P)aDb#|8i@N|Czf5+GB!DF7GaL;{tS&
z1;t681ENW8GGYV?Ph*q#8H!SL@<$zG;S;W%BldwJhAh29;!Yxd5?fP#5dnd!F_t~U
z(m5FC2matcAViz6@DMq1Pu3t7uULRYKS0TDt(;=zqqv?ecOh4h=dI(B;1r@N_sO)8
zJY+(FMCdD6TN*<$+VU8R(GHGjVV9=}<1y8qO#N&s&V3<mY)v}F-4jS6NXa5lM6ezd
ffqI6G6D;snC!0}e7TPs6BhlBSy(cIV7QpsT$F1|d

literal 0
HcmV?d00001

diff --git a/robot/exceptions/ArrayEmptyException.java b/robot/exceptions/ArrayEmptyException.java
new file mode 100644
index 0000000..3b3cfdb
--- /dev/null
+++ b/robot/exceptions/ArrayEmptyException.java
@@ -0,0 +1,7 @@
+package robot.exceptions;
+
+public class ArrayEmptyException extends RobotException{
+    public ArrayEmptyException(robotExceptions type,String errorMessage){
+        super(type, errorMessage);
+    }
+}
diff --git a/robot/exceptions/ExceptionStorage.java b/robot/exceptions/ExceptionStorage.java
new file mode 100644
index 0000000..128f4b6
--- /dev/null
+++ b/robot/exceptions/ExceptionStorage.java
@@ -0,0 +1,35 @@
+package robot.exceptions;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+public class ExceptionStorage {
+    private RobotException message;
+    private LocalDateTime date;
+
+    public ExceptionStorage(RobotException message){
+        this.message = message;
+        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
+        LocalDateTime now = LocalDateTime.now();
+        this.date = now;
+    }
+
+    public void saveLatestErrorMessage(RobotException message){
+        this.message = message;
+        this.date = LocalDateTime.now();
+    }
+
+    public RobotException getLastErrorMessage(){
+        return this.message;
+    }
+
+    /*public boolean emptyErrorStorage(){
+        if(this.message != ""){
+            this.message = "";
+            this.date = LocalDateTime.now();
+            return true;
+        }else{return false;}
+
+    }*/
+
+}
diff --git a/robot/exceptions/RobotException.java b/robot/exceptions/RobotException.java
index ccbfcb2..ada4428 100644
--- a/robot/exceptions/RobotException.java
+++ b/robot/exceptions/RobotException.java
@@ -1,8 +1,22 @@
 package robot.exceptions;
 
 public class RobotException extends Exception{
-   public RobotException(String errorMessage){
-      super(errorMessage);
+   robotExceptions currentType;
+   public RobotException(robotExceptions type, String name){
+      super(getMessage(type, name));
+      this.currentType = type;
+
+   }
+
+   private static String getMessage(robotExceptions types, String name){
+      String message = "";
+      switch (types){
+         case ILLEGALSTATE: message =  name + " is turned off."; break;
+         case MAGICVALUE: message = name + " has an unknown error. Code 42."; break;
+         case EMPTYARRAY: message = name + " got an empty array."; break;
+      }
+      return message;
    }
 
 }
+
diff --git a/robot/exceptions/RobotIllegalStateException.java b/robot/exceptions/RobotIllegalStateException.java
index 70b0e66..e39128e 100644
--- a/robot/exceptions/RobotIllegalStateException.java
+++ b/robot/exceptions/RobotIllegalStateException.java
@@ -1,7 +1,8 @@
 package robot.exceptions;
 
 public class RobotIllegalStateException extends RobotException{
-   public RobotIllegalStateException(String errormessage){
-      super(errormessage);
+
+   public RobotIllegalStateException(robotExceptions type, String errormessage){
+      super(type, errormessage);
    }
 }
diff --git a/robot/exceptions/RobotMagicValueException.java b/robot/exceptions/RobotMagicValueException.java
index b4c8a96..3574087 100644
--- a/robot/exceptions/RobotMagicValueException.java
+++ b/robot/exceptions/RobotMagicValueException.java
@@ -1,7 +1,8 @@
 package robot.exceptions;
 
-public class RobotMagicValueException extends RobotException{
-   public RobotMagicValueException(String errormessage){
-      super(errormessage);
+public class RobotMagicValueException extends RobotException {
+   public RobotMagicValueException(robotExceptions type, String errormessage) {
+      super(type, errormessage);
    }
-}
+
+}
\ No newline at end of file
diff --git a/robot/exceptions/robotExceptions.java b/robot/exceptions/robotExceptions.java
new file mode 100644
index 0000000..656c059
--- /dev/null
+++ b/robot/exceptions/robotExceptions.java
@@ -0,0 +1,5 @@
+package robot.exceptions;
+
+public enum robotExceptions {
+    ILLEGALSTATE, MAGICVALUE, EMPTYARRAY
+}
diff --git a/robot/interfaces/RobotInstructions.java b/robot/interfaces/RobotInstructions.java
index bb83a65..cd9a9e0 100644
--- a/robot/interfaces/RobotInstructions.java
+++ b/robot/interfaces/RobotInstructions.java
@@ -30,23 +30,23 @@ public interface RobotInstructions {
     * Gibt ein Array von Zahlen als String zurück. Die Zahlen werden
     * <b>nicht</b> sortiert.
     *
-    * @param zahlen Zahlen, die ausgegeben werden sollen.
+    * @param numbers Zahlen, die ausgegeben werden sollen.
     * @return Zahlen als String
     * @throws RobotException wenn der Roboter in einem ungültigen Zustand ist,
     *             oder das Array nicht seinen Vorstellungen entspricht.
     */
-   String speak(int[] zahlen) throws RobotException;
+   String speak(int[] numbers) throws RobotException;
 
    /**
     * Sortiert ein Array von Zahlen. Die Reihenfolge hängt von dem Typ des
     * Roboters ab.
     *
-    * @param zahlen Zahlen, die sortiert werden sollen.
+    * @param numbers Zahlen, die sortiert werden sollen.
     * @return Sortierte Zahlen
     * @throws RobotException wenn der Roboter in einem ungültigen Zustand ist,
     *             oder das Array nicht seinen Vorstellungen entspricht.
     */
-    int[] think(int[] zahlen) throws RobotException;
+    int[] think(int[] numbers) throws RobotException;
 
 
 }
\ No newline at end of file