diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index a9cdd0d88a066b473ec56f66313bb51bd2456464..ea3af64831862d96dafb73e1aab21617d45b76bf 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,14 +1,11 @@ image: maven:latest +cache: + key: EnigmaCache + stages: - - clean - build - test - - deploy - -Clean Project files: - stage: clean - script: mvn clean Compile new version: stage: build @@ -21,10 +18,4 @@ Run JUnit tests and verify: reports: junit: - target/surefire-reports/TEST-*.xml - - target/failsafe-reports/TEST-*.xml - -Deploy new version as Release: - stage: deploy - script: - - mvn versions:set -DnewVersion=$CI_COMMIT_TAG - - mvn assembly:assembly + - target/failsafe-reports/TEST-*.xml \ No newline at end of file diff --git a/README.md b/README.md index 163ab611cc322893c21892be580514f5eeba300a..cbe467a3db48b637919ac74ff829920264d130ee 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,19 @@ [](https://www.gitrepo.de/alfatrainingkurse/java/enigma/commits/master) -[](https://www.gitrepo.de/alfatrainingkurse/java/enigma/commits/master) -Link zum [Wiki](https://www.gitrepo.de/alfatrainingkurse/java/enigma/wikis/home) \ No newline at end of file +### Eine Enigma Simulation in Java + +Dieses Projekt ist unsere Abschlußprüfung zur Java Fortbildung und deshalb in der Entwicklung nicht so weit fortgeschritten.\ +Wir haben jedoch trotzdem versucht, die Enigma möglichst original getreu nach zu bauen und versucht an die Regeln,\ +aus der damaligen Zeit zu halten. + +Falls ihr Spaß habt daran etwas weiter zu entwickeln, sind Merge-Requests herzlich willkommen.\ +\ +Ebenfalls eingebaut haben wir einen Funkraum. Heißt das man Nachrichten, per Morsecode, an einen externen Server senden kann\ +und auch wieder abholen kann.\ +Bitte beachtet das diese Nachrichten jeder lesen kann, wenn ihr die Standard Einstellungen aus dem Codebuch und die selbe Kenngruppe nutzt.\ +Das Codebuch ist fest, in einer sqlite Datei, im Resources Ordner, hinterlegt.\ +\ +Ebenfalls wichtig ist eure Kenngruppe. Dies hat früher den Personenkreis bezeichnet, welcher diese Nachrichten lesen durfte.\ +Wenn ihr also auf mehreren Clients die selbe Kenngruppe nutzt, dann könnt ihr untereinander eure Nachrichten lesen.\ +\ +Im [Wiki](https://www.gitrepo.de/alfatrainingkurse/java/enigma/wikis/home) findet ihr auch noch einige Informationen zu dem Projekt. diff --git a/src/main/java/projekt/enigma/GuiController.java b/src/main/java/projekt/enigma/GuiController.java index 2e06eb606adf45ee66b00bde2d46fae7ef84a6b4..3fa825e7a815dfe33bea548ab772e9da533466b1 100644 --- a/src/main/java/projekt/enigma/GuiController.java +++ b/src/main/java/projekt/enigma/GuiController.java @@ -1,657 +1,451 @@ package projekt.enigma; -import projekt.enigma.model.Codierer; import javafx.event.ActionEvent; import javafx.fxml.FXML; import javafx.scene.control.*; import javafx.scene.shape.Circle; import org.apache.http.HttpException; +import projekt.enigma.model.Codierer; import java.io.IOException; import java.util.ArrayList; public class GuiController { - private final static String[] walzenNr = {"I", "II", "III", "IV", "V"}; - private final static String[] ringNr = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26"}; - private final static String[] position = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"}; - private ArrayList<MenuItem> mItem; - private String textEingabe; - private String textCodiert; - private boolean resetDisplay; - private Codierer codierer; - - @FXML - private TextField tfStecker1; - - @FXML - private TextField tfStecker2; - - @FXML - private TextField tfStecker3; - - @FXML - private TextField tfStecker4; - - @FXML - private TextField tfStecker5; - - @FXML - private TextField tfStecker6; - - @FXML - private TextField tfStecker7; - - @FXML - private TextField tfStecker8; - - @FXML - private TextField tfStecker9; - - @FXML - private TextField tfStecker10; - - @FXML - private Button btnM; - - @FXML - private Button btnN; - - @FXML - private Button btnB; - - @FXML - private Button btnV; - - @FXML - private Button btnC; - - @FXML - private Button btnX; - - @FXML - private Button btnY; - - @FXML - private Button btnP; - - @FXML - private Button btnL; - - @FXML - private Button btnK; - - @FXML - private Button btnJ; - - @FXML - private Button btnH; - - @FXML - private Button btnG; - - @FXML - private Button btnF; - - @FXML - private Button btnD; - - @FXML - private Button btnS; - - @FXML - private Button btnA; - - @FXML - private Button btnO; - - @FXML - private Button btnI; - - @FXML - private Button btnU; - - @FXML - private Button btnZ; - - @FXML - private Button btnT; - - @FXML - private Button btnR; - - @FXML - private Button btnE; - - @FXML - private Button btnW; - - @FXML - private Button btnQ; - - @FXML - private Circle circL; - - @FXML - private Circle circM; - - @FXML - private Circle circN; - - @FXML - private Circle circB; - - @FXML - private Circle circV; - - @FXML - private Circle circC; - - @FXML - private Circle circX; - - @FXML - private Circle circY; - - @FXML - private Circle circP; - - @FXML - private Circle circK; - - @FXML - private Circle circJ; - - @FXML - private Circle circH; - - @FXML - private Circle circG; - - @FXML - private Circle circF; - - @FXML - private Circle circD; - - @FXML - private Circle circS; - - @FXML - private Circle circA; - - @FXML - private Circle circO; - - @FXML - private Circle circI; - - @FXML - private Circle circU; - - @FXML - private Circle circZ; - - @FXML - private Circle circT; - - @FXML - private Circle circR; - - @FXML - private Circle circE; - - @FXML - private Circle circW; - - @FXML - private Circle circQ; - - @FXML - private Label lblL; - - @FXML - private Label lblM; - - @FXML - private Label lblN; - - @FXML - private Label lblB; - - @FXML - private Label lblV; - - @FXML - private Label lblC; - - @FXML - private Label lblX; - - @FXML - private Label lblY; - - @FXML - private Label lblP; - - @FXML - private Label lblK; - - @FXML - private Label lblJ; - - @FXML - private Label lblH; - - @FXML - private Label lblG; - - @FXML - private Label lblF; - - @FXML - private Label lblD; - - @FXML - private Label lblS; - - @FXML - private Label lblA; - - @FXML - private Label lblQ; - - @FXML - private Label lblW; - - @FXML - private Label lblE; - - @FXML - private Label lblR; - - @FXML - private Label lblT; - - @FXML - private Label lblZ; - - @FXML - private Label lblU; - - @FXML - private Label lblI; - - @FXML - private Label lblO; - - @FXML - private TextField tfCodiert; - - @FXML - private TextField tfKlartext; - - @FXML - private ProgressBar pbLadeNachricht; - - @FXML - private MenuButton mBtnWalzPos1; - - @FXML - private MenuButton mBtnWalzPos2; - - @FXML - private MenuButton mBtnWalzPos3; - - @FXML - private MenuButton mBtnNotchPos1; - - @FXML - private MenuButton mBtnNotchPos2; - - @FXML - private MenuButton mBtnNotchPos3; - - @FXML - private MenuButton mBtnStartPos1; - - @FXML - private MenuButton mBtnStartPos2; - - @FXML - private MenuButton mBtnStartPos3; - - @FXML - private Label lblLadeNachricht; - - @FXML - void initialize() { - - // Variablen setzen - textEingabe = ""; - textCodiert = ""; - resetDisplay = true; - - //Einträge für Walzen - menu(mBtnWalzPos1, walzenNr); - menu(mBtnWalzPos2, walzenNr); - menu(mBtnWalzPos3, walzenNr); - - //Einträge für die Ringe - menu(mBtnNotchPos1, ringNr); - menu(mBtnNotchPos2, ringNr); - menu(mBtnNotchPos3, ringNr); - - //Einträge für die Startpositionen - menu(mBtnStartPos1, position); - menu(mBtnStartPos3, position); - menu(mBtnStartPos2, position); - - - //Setze Leucht Event bei Tastendruck - leuchten(btnA, circA); - leuchten(btnB, circB); - leuchten(btnC, circC); - leuchten(btnD, circD); - leuchten(btnE, circE); - leuchten(btnF, circF); - leuchten(btnG, circG); - leuchten(btnH, circH); - leuchten(btnI, circI); - leuchten(btnJ, circJ); - leuchten(btnK, circK); - leuchten(btnL, circL); - leuchten(btnM, circM); - leuchten(btnN, circN); - leuchten(btnO, circO); - leuchten(btnP, circP); - leuchten(btnQ, circQ); - leuchten(btnR, circR); - leuchten(btnS, circS); - leuchten(btnT, circT); - leuchten(btnU, circU); - leuchten(btnV, circV); - leuchten(btnW, circW); - leuchten(btnX, circX); - leuchten(btnY, circY); - leuchten(btnZ, circZ); - - this.codierer = new Codierer(); - this.codierer.setKenngruppe("enigma"); - - // Walzen auf ihre Position setzen. Der Spruchschlüssel ist hier bereits berücksichtigt. - mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0])); - mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1])); - mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2])); - } - - @FXML - private void loeschen() { - if (textEingabe.length()==0){ - tfKlartext.setText(""); - }else { - textEingabe = textEingabe.substring(0, textEingabe.length() - 1); - tfKlartext.setText(textEingabe); - } - } - - @FXML - void btnempfangen() { - String[] empfangeneNachricht = this.codierer.empfangeNachricht(); - if (empfangeneNachricht[0] != null) { - this.tfKlartext.setText(empfangeneNachricht[2]); - this.tfCodiert.setText(empfangeneNachricht[1]); - this.resetDisplay = true; - - mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0])); - mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1])); - mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2])); - } - } - - @FXML - void btnsenden() { - this.tfKlartext.setText(""); - this.tfCodiert.setText(""); - - try { - this.codierer.sendeNachricht(); - } catch (HttpException | IOException e) { - e.printStackTrace(); - } - - } - - /** - * Methode zum setzen des menuButton Textes auf das ausgewählte MenuItem - * - * @param mb : MenuButton der Walze - * @param mi : MenuItem - */ - private void listener(MenuButton mb, MenuItem mi) { - // mb.setText(mi.getText()); - - if(mb.getId().equals(mBtnStartPos1.getId()))setzePosition(1,mi.getText().charAt(0)); - if(mb.getId().equals(mBtnStartPos2.getId()))setzePosition(2,mi.getText().charAt(0)); - if(mb.getId().equals(mBtnStartPos3.getId()))setzePosition(3,mi.getText().charAt(0)); - if(mb.getId().equals(mBtnWalzPos1.getId()))setzeWalze(1,mi.getText()); - if(mb.getId().equals(mBtnWalzPos2.getId()))setzeWalze(2,mi.getText()); - if(mb.getId().equals(mBtnWalzPos3.getId()))setzeWalze(3,mi.getText()); - if(mb.getId().equals(mBtnNotchPos1.getId())) - setzeRing(1,Integer.parseInt(mi.getText())-1); - if(mb.getId().equals(mBtnNotchPos2.getId())) - setzeRing(2,Integer.parseInt(mi.getText())-1); - if(mb.getId().equals(mBtnNotchPos3.getId())) - setzeRing(3,Integer.parseInt(mi.getText())-1); - } - - /** - * Methode zur Erstellung der Einträge und Action Listener für die einzelnen Menüs - * - * @param button : Button für die die Einträge erstellt werden sollen - */ - private void menu(MenuButton button, String[] str) { - mItem = new ArrayList<>(); - for (int i = 0; i < str.length; i++) { - //Eintrag aus str der Arraylist mi hinzufügen - mItem.add(new MenuItem(str[i])); - //MenuItem mi dem Button button hinzufügen - button.getItems().add(mItem.get(i)); - int finalI = i; - //Listener für die einzelnen Einträge - ArrayList<MenuItem> finalMi = mItem; - mItem.get(i).setOnAction(e -> listener(button, finalMi.get(finalI))); - } - } - - /** - * Auswertung welcher Button gedrückt wurde - * - * @param e => ActionEvent des auslösenden Button - */ - @FXML - private void gedrueckteTaste(ActionEvent e) { - - //TODO Anbindung an Klasse Hardware - if (e.getSource() == btnA) setText(btnA); - if (e.getSource() == btnB) setText(btnB); - if (e.getSource() == btnC) setText(btnC); - if (e.getSource() == btnD) setText(btnD); - if (e.getSource() == btnE) setText(btnE); - if (e.getSource() == btnF) setText(btnF); - if (e.getSource() == btnG) setText(btnG); - if (e.getSource() == btnH) setText(btnH); - if (e.getSource() == btnI) setText(btnI); - if (e.getSource() == btnJ) setText(btnJ); - if (e.getSource() == btnK) setText(btnK); - if (e.getSource() == btnL) setText(btnL); - if (e.getSource() == btnM) setText(btnM); - if (e.getSource() == btnN) setText(btnN); - if (e.getSource() == btnO) setText(btnO); - if (e.getSource() == btnP) setText(btnP); - if (e.getSource() == btnQ) setText(btnQ); - if (e.getSource() == btnR) setText(btnR); - if (e.getSource() == btnS) setText(btnS); - if (e.getSource() == btnT) setText(btnT); - if (e.getSource() == btnU) setText(btnU); - if (e.getSource() == btnV) setText(btnV); - if (e.getSource() == btnW) setText(btnW); - if (e.getSource() == btnX) setText(btnX); - if (e.getSource() == btnY) setText(btnY); - if (e.getSource() == btnZ) setText(btnZ); - } - - /** - * schreibt Buchstaben des gedrückten Knopfes in Textfeld tfrein - * - * @param b : gedrückter Knopf - */ - private void setText(Button b) { - if (textEingabe.length() < 250) { - if(this.resetDisplay) { - this.tfCodiert.setText(""); - this.tfKlartext.setText(""); - this.resetDisplay = false; - this.codierer.resetHardware(); - textCodiert = ""; - textEingabe = ""; - // Spruchschlüssel generieren und codieren - this.codierer.generateSpruchschluessel(); - } - textEingabe += b.getText(); - textCodiert += this.codierer.codiere(b.getText().charAt(0), true); - - tfKlartext.setText(textEingabe); - tfCodiert.setText(textCodiert); - - mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0])); - mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1])); - mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2])); - } - } - - private void leuchten(Button taste, Circle leuchte) { - - taste.setOnMousePressed(mouseEvent -> leuchte.setStyle("-fx-fill: #FFA500")); - taste.setOnMouseReleased(mouseEvent -> { - leuchte.setStyle("-fx-background-color: " + taste.getBackground()); - leuchte.setStyle("-fx-border-color: #000000"); - }); - } - - /** - * Setzt die Anzeige des entsprechende Gui-Element auf die entsprechende Walze - * ->d.h. welche Walze sitzt auf welcher Position - * - * @param walzeRoemischNr => gibt die Walzennummer an - * @param walzenPosition => gibt die Position der Walze - */ - private void setzeWalze(int walzenPosition, String walzeRoemischNr) { - int walzeNr=0; - switch (walzeRoemischNr){ - case "I": - walzeNr=0; - break; - case "II": - walzeNr=1; - break; - case "III": - walzeNr=2; - break; - case "IV": - walzeNr=4; - break; - case "V": - walzeNr=4; - break; - default: - break; - } - - switch (walzenPosition) { - case 1: - mBtnWalzPos1.setText(walzenNr[walzeNr]); - //codierer.setWalze(walzeNr, walzenPosition) - break; - case 2: - mBtnWalzPos2.setText(walzenNr[walzeNr]); - - break; - case 3: - mBtnWalzPos3.setText(walzenNr[walzeNr]); - break; - default: - break; - } - } - - /** - * Setzt den Notch (position)=> die Mitnahmeposition der Walze (walze) fest - * Mitnahmeposition meint => die nächste Walze wird bei erreichen dieser Position (notch) - * um eine Stelle versetzt - * - * @param ringStellung => gibt die walze an - * @param walzenPosition => gibt den notch der Walze (walze) an - */ - private void setzeRing(int walzenPosition, int ringStellung) { - switch (walzenPosition) { - case 1: - mBtnNotchPos1.setText(ringNr[ringStellung]); - break; - case 2: - mBtnNotchPos2.setText(ringNr[ringStellung]); - break; - case 3: - mBtnNotchPos3.setText(ringNr[ringStellung]); - break; - default: - break; - } - } - - /** - * Setzt die Startposition/ aktuelle Position der Walze - * - * @param walze => gibt die walze an - * @param buchstabe gibt den Startwert bzw die aktuelle Position der Walze (walze) an - */ - private void setzePosition(int walze, char buchstabe) { - switch (walze) { - case 1: - mBtnStartPos1.setText(String.valueOf(buchstabe)); - break; - case 2: - mBtnStartPos2.setText(buchstabe + ""); - break; - case 3: - mBtnStartPos3.setText(buchstabe + ""); - break; - default: - break; - } - } - - /** - * Setzt den aktuellen TagesSchluessel - * - * @param tagesSchluessel => neuen Tagesschluessel übergeben - */ - public void setzeTagesSchluessel(String tagesSchluessel) { - /* - * TODO Benötige TestString aus der DB Codebuch - * - * Den Tagesschlüssel bekommst du wie folgt: - * <p> - * // Aktuelle Position der Walzen - * codierer.codebuch.getWalzenlage(); - * - * // Position der Ringe - * codierer.codebuch.getRingstellung(); - * - * //Position der Steckverbindungen - * codierer.codebuch.getSteckverbindung(); - * </p> - */ - - } + //region Klassenvariablen + private final static String[] walzenNr = {"I", "II", "III", "IV", "V"}; + private final static String[] ringNr = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26"}; + private final static String[] position = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"}; + private ArrayList<MenuItem> mItem; + private String textEingabe; + private String textCodiert; + private boolean resetDisplay; + private Codierer codierer; +//endregion + + //region GUI-Elemente + @FXML + private TextField tfStecker1, tfStecker2, tfStecker3, tfStecker4, tfStecker5, tfStecker6, tfStecker7, tfStecker8, + tfStecker9, tfStecker10, tfCodiert, tfKlartext; + + @FXML + private Button btnA, btnB, btnC, btnD, btnE, btnF, btnG, btnH, btnI, btnJ, btnK, btnL, btnM, btnN, btnO, btnP, btnQ, + btnR, btnS, btnT, btnU, btnV, btnW, btnX, btnY, btnZ, btnSenden, btnEmpfangen, btnDelete; + + @FXML + private Circle circA, circB, circC, circD, circE, circF, circG, circH, circI, circJ, circK, circL, circM, circN, + circO, circP, circQ, circR, circS, circT, circU, circV, circW, circX, circY, circZ; + + @FXML + private Label lblA, lblB, lblC, lblD, lblE, lblF, lblG, lblH, lblI, lblJ, lblK, lblL, lblM, lblN, lblO, lblP, lblQ, + lblR, lblS, lblT, lblU, lblV, lblW, lblX, lblY, lblZ, lblLadeNachricht, lblTagesschluessel, + lblSpruchschluessel; + + @FXML + private ProgressBar pbLadeNachricht; + + @FXML + private MenuButton mBtnWalzPos1, mBtnWalzPos2, mBtnWalzPos3, mBtnNotchPos1, mBtnNotchPos2, mBtnNotchPos3, + mBtnStartPos1, mBtnStartPos2, mBtnStartPos3; +//endregion + + //region Init + @FXML + void initialize() { + + // Variablen setzen + textEingabe = ""; + textCodiert = ""; + resetDisplay = true; + + //Einträge für Walzen + menu(mBtnWalzPos1, walzenNr); + menu(mBtnWalzPos2, walzenNr); + menu(mBtnWalzPos3, walzenNr); + + //Einträge für die Ringe + menu(mBtnNotchPos1, ringNr); + menu(mBtnNotchPos2, ringNr); + menu(mBtnNotchPos3, ringNr); + + //Einträge für die Startpositionen + menu(mBtnStartPos1, position); + menu(mBtnStartPos3, position); + menu(mBtnStartPos2, position); + + //Setze Leucht Event bei Tastendruck + leuchten(btnA, circA); + leuchten(btnB, circB); + leuchten(btnC, circC); + leuchten(btnD, circD); + leuchten(btnE, circE); + leuchten(btnF, circF); + leuchten(btnG, circG); + leuchten(btnH, circH); + leuchten(btnI, circI); + leuchten(btnJ, circJ); + leuchten(btnK, circK); + leuchten(btnL, circL); + leuchten(btnM, circM); + leuchten(btnN, circN); + leuchten(btnO, circO); + leuchten(btnP, circP); + leuchten(btnQ, circQ); + leuchten(btnR, circR); + leuchten(btnS, circS); + leuchten(btnT, circT); + leuchten(btnU, circU); + leuchten(btnV, circV); + leuchten(btnW, circW); + leuchten(btnX, circX); + leuchten(btnY, circY); + leuchten(btnZ, circZ); + + // Initialisieren des Codierers und setzen der Kenngruppe + this.codierer = new Codierer(); + this.codierer.setKenngruppe("enigma"); + + // Beim nächsten Tastendruck erstmal das Display löschen damit falschen Nachrichten geschickt werden. + this.resetDisplay = true; + + // Einstellungen aus dem Logbuch auslesen und setzen + this.setzeTagesSchluessel(); + this.setzeSteckverbindungen(); + } + + /** + * init Methode zur Erstellung der Einträge und Action Listener für die einzelnen Menüs + * + * @param button : Button für die die Einträge erstellt werden sollen + */ + private void menu(MenuButton button, String[] str) { + mItem = new ArrayList<>(); + for (int i = 0; i < str.length; i++) { + //Eintrag aus str der Arraylist mi hinzufügen + mItem.add(new MenuItem(str[i])); + //MenuItem mi dem Button button hinzufügen + button.getItems().add(mItem.get(i)); + int finalI = i; + //Listener für die einzelnen Einträge + ArrayList<MenuItem> finalMi = mItem; + mItem.get(i).setOnAction(e -> setMenuBtnText(button, finalMi.get(finalI))); + } + } +//endregion + + //region EventHandler/Listener + + /** + * //TODO DOKU + */ + private void leuchten(Button taste, Circle leuchte) { + + taste.setOnMousePressed(mouseEvent -> leuchte.setStyle("-fx-fill: #FFA500")); + taste.setOnMouseReleased(mouseEvent -> { + leuchte.setStyle("-fx-background-color: " + taste.getBackground()); + leuchte.setStyle("-fx-border-color: #000000"); + }); + } + + /** + * Auswertung welcher Button gedrückt wurde + * + * @param e => ActionEvent des auslösenden Button + */ + @FXML + private void gedrueckteTaste(ActionEvent e) { + + //TODO Anbindung an Klasse Hardware + if (e.getSource() == btnA) { + setText(btnA); + //leuchten(); + } + if (e.getSource() == btnB) setText(btnB); + if (e.getSource() == btnC) setText(btnC); + if (e.getSource() == btnD) setText(btnD); + if (e.getSource() == btnE) setText(btnE); + if (e.getSource() == btnF) setText(btnF); + if (e.getSource() == btnG) setText(btnG); + if (e.getSource() == btnH) setText(btnH); + if (e.getSource() == btnI) setText(btnI); + if (e.getSource() == btnJ) setText(btnJ); + if (e.getSource() == btnK) setText(btnK); + if (e.getSource() == btnL) setText(btnL); + if (e.getSource() == btnM) setText(btnM); + if (e.getSource() == btnN) setText(btnN); + if (e.getSource() == btnO) setText(btnO); + if (e.getSource() == btnP) setText(btnP); + if (e.getSource() == btnQ) setText(btnQ); + if (e.getSource() == btnR) setText(btnR); + if (e.getSource() == btnS) setText(btnS); + if (e.getSource() == btnT) setText(btnT); + if (e.getSource() == btnU) setText(btnU); + if (e.getSource() == btnV) setText(btnV); + if (e.getSource() == btnW) setText(btnW); + if (e.getSource() == btnX) setText(btnX); + if (e.getSource() == btnY) setText(btnY); + if (e.getSource() == btnZ) setText(btnZ); + if (e.getSource() == btnSenden) sendeFunkspruch(); + if (e.getSource() == btnEmpfangen) empfangeFunkspruch(); + if (e.getSource() == btnDelete) loeschen(); + } +//endregion + + //region Methoden + + /** + * Methode zum setzen des menuButton Textes auf das ausgewählte MenuItem + * + * @param mBtn : MenuButton der Walze + * @param mItm : MenuItem + */ + private void setMenuBtnText(MenuButton mBtn, MenuItem mItm) { + // mb.setText(mi.getText()); + + if (mBtn.getId().equals(mBtnStartPos1.getId())) setzePosition(1, mItm.getText().charAt(0)); + if (mBtn.getId().equals(mBtnStartPos2.getId())) setzePosition(2, mItm.getText().charAt(0)); + if (mBtn.getId().equals(mBtnStartPos3.getId())) setzePosition(3, mItm.getText().charAt(0)); + if (mBtn.getId().equals(mBtnWalzPos1.getId())) setzeWalze(1, mItm.getText()); + if (mBtn.getId().equals(mBtnWalzPos2.getId())) setzeWalze(2, mItm.getText()); + if (mBtn.getId().equals(mBtnWalzPos3.getId())) setzeWalze(3, mItm.getText()); + if (mBtn.getId().equals(mBtnNotchPos1.getId())) + setzeRing(1, Integer.parseInt(mItm.getText()) - 1); + if (mBtn.getId().equals(mBtnNotchPos2.getId())) + setzeRing(2, Integer.parseInt(mItm.getText()) - 1); + if (mBtn.getId().equals(mBtnNotchPos3.getId())) + setzeRing(3, Integer.parseInt(mItm.getText()) - 1); + } + + /** + * Hier werden die TextFelder, welche die Steckverbindungen darstellen, + * mit dem Werten die die Klasse Codierer zur Verfügung stellt gefüllt. + */ + private void setzeSteckverbindungen() { + tfStecker1.setText(codierer.fetchSteckverbindungen()[0][0] + "" + codierer.fetchSteckverbindungen()[0][1]); + tfStecker2.setText(codierer.fetchSteckverbindungen()[1][0] + "" + codierer.fetchSteckverbindungen()[1][1]); + tfStecker3.setText(codierer.fetchSteckverbindungen()[2][0] + "" + codierer.fetchSteckverbindungen()[2][1]); + tfStecker4.setText(codierer.fetchSteckverbindungen()[3][0] + "" + codierer.fetchSteckverbindungen()[3][1]); + tfStecker5.setText(codierer.fetchSteckverbindungen()[4][0] + "" + codierer.fetchSteckverbindungen()[4][1]); + tfStecker6.setText(codierer.fetchSteckverbindungen()[5][0] + "" + codierer.fetchSteckverbindungen()[5][1]); + tfStecker7.setText(codierer.fetchSteckverbindungen()[6][0] + "" + codierer.fetchSteckverbindungen()[6][1]); + tfStecker8.setText(codierer.fetchSteckverbindungen()[7][0] + "" + codierer.fetchSteckverbindungen()[7][1]); + tfStecker9.setText(codierer.fetchSteckverbindungen()[8][0] + "" + codierer.fetchSteckverbindungen()[8][1]); + tfStecker10.setText(codierer.fetchSteckverbindungen()[9][0] + "" + codierer.fetchSteckverbindungen()[9][1]); + } + + /** + * Die Löschen Funktion löscht das letzte Zeichen im Klartext sowie im Codiert Feld, + * der Codierer wird aufgerufen um ebenfalls das letzte Zeichen zu löschen + */ + private void loeschen() { + if (textEingabe.length() == 0) { + tfKlartext.setText(""); + tfCodiert.setText(""); + } else { + textEingabe = textEingabe.substring(0, textEingabe.length() - 1); + textCodiert = textCodiert.substring(0, textCodiert.length() - 1); + tfKlartext.setText(textEingabe); + tfCodiert.setText(textCodiert); + codierer.letztesZeichenLoeschen(); + mBtnStartPos1.setText(String.valueOf(this.codierer.fetchWalzen()[0])); + mBtnStartPos2.setText(String.valueOf(this.codierer.fetchWalzen()[1])); + mBtnStartPos3.setText(String.valueOf(this.codierer.fetchWalzen()[2])); + } + } + + /** + * //TODO DOKU + */ + void empfangeFunkspruch() { + String[] empfangeneNachricht = this.codierer.empfangeNachricht(); + if (empfangeneNachricht[0] != null) { + this.tfKlartext.setText(empfangeneNachricht[2]); + this.tfCodiert.setText(empfangeneNachricht[1]); + this.resetDisplay = true; + + // Spruchschluessel in das Feld lblSpruchschluessel schreiben + lblSpruchschluessel.setText(this.codierer.empfangenerSpruchschluessel(empfangeneNachricht[2])); + + this.setzeTagesSchluessel(); + } + } + + /** + * //TODO DOKU + */ + private void sendeFunkspruch() { + this.tfKlartext.setText(""); + this.tfCodiert.setText(""); + + try { + this.codierer.sendeNachricht(); + } catch (HttpException | IOException e) { + e.printStackTrace(); + } + + } + + /** + * schreibt Buchstaben des gedrückten Knopfes in Textfeld tfrein + * + * @param pressedButton : gedrückter Knopf + */ + private void setText(Button pressedButton) { + if (textEingabe.length() < 250) { + if (this.resetDisplay) { + this.tfCodiert.setText(""); + this.tfKlartext.setText(""); + this.resetDisplay = false; + this.codierer.resetHardware(); + textCodiert = ""; + textEingabe = ""; + // Spruchschlüssel generieren und codieren + this.codierer.generateSpruchschluessel(); + // Spruchschluessel in das Feld lblSpruchschluessel schreiben + lblSpruchschluessel.setText(this.codierer.getSpruchschluessel()); + } + textEingabe += pressedButton.getText(); + textCodiert += this.codierer.codiere(pressedButton.getText().charAt(0), true); + + tfKlartext.setText(textEingabe); + tfCodiert.setText(textCodiert); + + // Position der Walzen aktuallisieren + mBtnStartPos1.setText(String.valueOf(this.codierer.fetchWalzen()[0])); + mBtnStartPos2.setText(String.valueOf(this.codierer.fetchWalzen()[1])); + mBtnStartPos3.setText(String.valueOf(this.codierer.fetchWalzen()[2])); + } + } + + /** + * Setzt die Anzeige des entsprechende Gui-Element auf die entsprechende Walze + * ->d.h. welche Walze sitzt auf welcher Position + * + * @param walzeRoemischNr => gibt die Walzennummer an + * @param walzenPosition => gibt die Position der Walze + */ + private void setzeWalze(int walzenPosition, String walzeRoemischNr) { + int walzeNr = 0; + switch (walzeRoemischNr) { + case "I": + walzeNr = 0; + break; + case "II": + walzeNr = 1; + break; + case "III": + walzeNr = 2; + break; + case "IV": + walzeNr = 4; + break; + case "V": + walzeNr = 4; + break; + default: + break; + } + + switch (walzenPosition) { + case 1: + mBtnWalzPos1.setText(walzenNr[walzeNr]); + //codierer.setWalze(walzeNr, walzenPosition) + break; + case 2: + mBtnWalzPos2.setText(walzenNr[walzeNr]); + break; + case 3: + mBtnWalzPos3.setText(walzenNr[walzeNr]); + break; + default: + break; + } + } + + /** + * Setzt den Notch (position)=> die Mitnahmeposition der Walze (walze) fest + * Mitnahmeposition meint => die nächste Walze wird bei erreichen dieser Position (notch) + * um eine Stelle versetzt + * + * @param ringStellung => gibt die walze an + * @param walzenPosition => gibt den notch der Walze (walze) an + */ + private void setzeRing(int walzenPosition, int ringStellung) { + switch (walzenPosition) { + case 1: + mBtnNotchPos1.setText(ringNr[ringStellung]); + break; + case 2: + mBtnNotchPos2.setText(ringNr[ringStellung]); + break; + case 3: + mBtnNotchPos3.setText(ringNr[ringStellung]); + break; + default: + break; + } + } + + /** + * Setzt die Startposition/ aktuelle Position der Walze + * + * @param walze => gibt die walze an + * @param buchstabe gibt den Startwert bzw die aktuelle Position der Walze (walze) an + */ + private void setzePosition(int walze, char buchstabe) { + switch (walze) { + case 1: + mBtnStartPos1.setText(String.valueOf(buchstabe)); + break; + case 2: + mBtnStartPos2.setText(buchstabe + ""); + break; + case 3: + mBtnStartPos3.setText(buchstabe + ""); + break; + default: + break; + } + } + + /** + * Setzt den aktuellen TagesSchluessel + */ + public void setzeTagesSchluessel() { + + // Umsprungpunkte anzeigen + mBtnNotchPos1.setText(String.valueOf(this.codierer.fetchRingstellung()[0])); + mBtnNotchPos2.setText(String.valueOf(this.codierer.fetchRingstellung()[1])); + mBtnNotchPos3.setText(String.valueOf(this.codierer.fetchRingstellung()[2])); + // Walzennummern anzeigen + mBtnWalzPos1.setText(String.valueOf(this.codierer.fetchWalzenNr()[0])); + mBtnWalzPos2.setText(String.valueOf(this.codierer.fetchWalzenNr()[1])); + mBtnWalzPos3.setText(String.valueOf(this.codierer.fetchWalzenNr()[2])); + // Position der Walzen anzeigen + mBtnStartPos1.setText(String.valueOf(this.codierer.fetchWalzen()[0])); + mBtnStartPos2.setText(String.valueOf(this.codierer.fetchWalzen()[1])); + mBtnStartPos3.setText(String.valueOf(this.codierer.fetchWalzen()[2])); + // Steckbrett Felder setzen + tfStecker1.setText(this.codierer.fetchSteckverbindungen()[0][0] + "" + + this.codierer.fetchSteckverbindungen()[0][1]); + tfStecker2.setText(this.codierer.fetchSteckverbindungen()[1][0] + "" + + this.codierer.fetchSteckverbindungen()[1][1]); + tfStecker3.setText(this.codierer.fetchSteckverbindungen()[2][0] + "" + + this.codierer.fetchSteckverbindungen()[2][1]); + tfStecker4.setText(this.codierer.fetchSteckverbindungen()[3][0] + "" + + this.codierer.fetchSteckverbindungen()[3][1]); + tfStecker5.setText(this.codierer.fetchSteckverbindungen()[4][0] + "" + + this.codierer.fetchSteckverbindungen()[4][1]); + tfStecker6.setText(this.codierer.fetchSteckverbindungen()[5][0] + "" + + this.codierer.fetchSteckverbindungen()[5][1]); + tfStecker7.setText(this.codierer.fetchSteckverbindungen()[6][0] + "" + + this.codierer.fetchSteckverbindungen()[6][1]); + tfStecker8.setText(this.codierer.fetchSteckverbindungen()[7][0] + "" + + this.codierer.fetchSteckverbindungen()[7][1]); + tfStecker9.setText(this.codierer.fetchSteckverbindungen()[8][0] + "" + + this.codierer.fetchSteckverbindungen()[8][1]); + tfStecker10.setText(this.codierer.fetchSteckverbindungen()[9][0] + "" + + this.codierer.fetchSteckverbindungen()[9][1]); + } + //endregion } diff --git a/src/main/java/projekt/enigma/database/DatenbankSqlite.java b/src/main/java/projekt/enigma/database/DatenbankSqlite.java index 401af573f4c4c30bd1e8e04c18ca79f647348cb0..ac7c9024be694baff54f6573ac70dc695fc45081 100644 --- a/src/main/java/projekt/enigma/database/DatenbankSqlite.java +++ b/src/main/java/projekt/enigma/database/DatenbankSqlite.java @@ -22,7 +22,7 @@ public class DatenbankSqlite { */ private Connection connect() { - String url = "jdbc:sqlite::resource:enigma/codebuch.sqlite"; + String url = "jdbc:sqlite::resource:projekt/enigma/codebuch.sqlite"; Connection conn = null; try { diff --git a/src/main/java/projekt/enigma/model/Codebuch.java b/src/main/java/projekt/enigma/model/Codebuch.java index 9ded525e6d41617d76f148556b5c8f278bb88a63..8971dd7af85df192f23b32d3102710e6dc789b65 100644 --- a/src/main/java/projekt/enigma/model/Codebuch.java +++ b/src/main/java/projekt/enigma/model/Codebuch.java @@ -23,6 +23,7 @@ import java.time.ZoneId; */ public class Codebuch { + //region Variablen /** * TODO: Dokumentieren tag * tag : int : gibt den Tag an @@ -43,7 +44,9 @@ public class Codebuch { * steckverbindung : char[][] : stellt die Steckverbindungen im Steckbrett dar */ private char[][] steckverbindung; + //endregion + //region Konstruktor /** * Im Konstruktor werden die Standardwerte gesetzt * <p> @@ -64,7 +67,9 @@ public class Codebuch { this.steckverbindung[i][1] = 'A'; } } + //endregion + //region Funktionen & Methoden /** * TODO: Dokumentieren * Holt den Tagesschluessel aus dem Codebuch ab. Ist kein Tag angegeben, wird der aktuelle Tag genutzt. @@ -143,14 +148,46 @@ public class Codebuch { return sb.toString(); } + //endregion + //region Setter /** - * Gibt den Tag dieser Instanz zurück + * Setzt die Steckverbindung dieser Instanz * - * @return int : Tag + * @param kabel : String[] : Die Steckverbindungen die gesteckt werden sollen. + * Jeder Eintrag im Array ist ein String mit zwei Zeichen. + * Diese werden in zwei chars zerlegt und anschließend im globalen + * Array gespeichert. */ - public int getTag() { - return tag; + private void setSteckverbindung(String[] kabel) { + int counter = 0; + + for (String stecker : kabel) { + char[] verbindung = new char[2]; + verbindung[0] = stecker.charAt(0); + verbindung[1] = stecker.charAt(1); + this.steckverbindung[counter++] = verbindung; + } + } + + /** + * Setzt die Walzenlage dieser Instanz + * + * @param position : int : Position der Walze + * @param walzenlage : int : Welche Walze wurde eingesetzt + */ + private void setWalzenlage(int position, int walzenlage) { + this.walzenlage[position] = walzenlage; + } + + /** + * Setzt die Ringstellung dieser Instanz + * + * @param position : int : Auf welche Walze wird der Ring aufgesetzt? + * @param ringstellung : char : An dieser Position soll die nächste Walze weiter gedreht werden.TODO: String[] || int[]? + */ + private void setRingstellung(int position, int ringstellung) { + this.ringstellung[position] = ringstellung; } /** @@ -159,6 +196,17 @@ public class Codebuch { * @param tag : int : Tag */ void setTag(int tag) { this.tag = tag; } + //endregion + + //region Getter + /** + * Gibt den Tag dieser Instanz zurück + * + * @return int : Tag + */ + public int getTag() { + return tag; + } /** * Gibt die Walzenlage dieser Instanz zurück @@ -187,43 +235,5 @@ public class Codebuch { public char[][] getSteckverbindung() { return this.steckverbindung; } - - /** - * Setzt die Steckverbindung dieser Instanz - * - * @param kabel : String[] : Die Steckverbindungen die gesteckt werden sollen. - * Jeder Eintrag im Array ist ein String mit zwei Zeichen. - * Diese werden in zwei chars zerlegt und anschließend im globalen - * Array gespeichert. - */ - private void setSteckverbindung(String[] kabel) { - int counter = 0; - - for (String stecker : kabel) { - char[] verbindung = new char[2]; - verbindung[0] = stecker.charAt(0); - verbindung[1] = stecker.charAt(1); - this.steckverbindung[counter++] = verbindung; - } - } - - /** - * Setzt die Walzenlage dieser Instanz - * - * @param position : int : Position der Walze - * @param walzenlage : int : Welche Walze wurde eingesetzt - */ - private void setWalzenlage(int position, int walzenlage) { - this.walzenlage[position] = walzenlage; - } - - /** - * Setzt die Ringstellung dieser Instanz - * - * @param position : int : Auf welche Walze wird der Ring aufgesetzt? - * @param ringstellung : char : An dieser Position soll die nächste Walze weiter gedreht werden.TODO: String[] || int[]? - */ - private void setRingstellung(int position, int ringstellung) { - this.ringstellung[position] = ringstellung; - } + //endregion } diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java index 11ccd130aa1a551f84606f3e63822865386e25c5..aecf7f3f4d0c7e62cbf5b6df5548b9f91cf66c38 100644 --- a/src/main/java/projekt/enigma/model/Codierer.java +++ b/src/main/java/projekt/enigma/model/Codierer.java @@ -14,410 +14,512 @@ import java.util.Random; */ public class Codierer { - /** - * Der Klartext Spruchschlüssel zur codierung der Nachricht - */ - private String spruchschluessel; - /** - * Der Spruchschlüssel, mit den Tageswerten aus dem Codebuch, codiert - */ - private String spruchschluesselCodiert; - /** - * Die Kenngruppe für die versendeten Nachrichten gedacht sind. Diese ist relevant für den Webservice (Funkraum) - */ - private String kenngruppe; - /** - * Die Nachricht, welche der Benutzer eingibt, wird als String nachricht gespeichert - * und im laufe der Benutzung ergänzt - */ - private String nachricht; - /** - * Das Hardware Objekt. Hier werden alle Hardware relevanten Baugruppen gespeichert und verarbeitet. - */ - private Hardware hardware; - /** - * Im Codebuch sind die Tageswerte zu finden. Über dieses Objekt kann darauf zugegriffen werden. - */ - private Codebuch codebuch; - - /** - * Der Konstruktor des Codierers - * Hier werden die globalen Variablen auf ihre Standart Werte gesetzt sowie die Objekte Initialisiert. - */ - public Codierer() { - - this.nachricht = ""; - this.spruchschluessel = ""; - this.spruchschluesselCodiert = ""; - this.kenngruppe = ""; - this.codebuch = new Codebuch(); - this.codebuch.fetchTagesschluessel(); - } - - /** - * Hier lesen wir den heutigen Eintrag aus dem Codebuch aus und erstellen ein Codebuch Objekt - * Nach dem Codebuch werden dann die Ringe auf die Walzen gesteckt und die Walzen anschließend - * in die Hardware gebaut. - * <br> - * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und - * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben. - * <br> - * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen - * Codebuch Eintrag. - */ - private void initialisiereHardware() { - - // Das Steckbrett initialisieren - Steckbrett sb = new Steckbrett(); - char[][] verbinder = this.codebuch.getSteckverbindung(); - - // Für jedes Kabel eine Verbindung auf dem Steckbrett setzen - for (char[] kabel : verbinder) { - sb.setzeVertauschung(kabel[0], kabel[1]); - } - - // Die Hardware aus dem Koffer holen (initialisieren) - this.hardware = new Hardware(); - - // Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen - this.hardware.setWalzen(0, this.codebuch.getWalzenlage()[0], this.codebuch.getRingstellung()[0]); - this.hardware.setWalzen(1, this.codebuch.getWalzenlage()[1], this.codebuch.getRingstellung()[1]); - this.hardware.setWalzen(2, this.codebuch.getWalzenlage()[2], this.codebuch.getRingstellung()[2]); - - // Der Hardware das gesetzte Steckbrett zuweisen - this.hardware.setSteckbrett(sb); - - // Ein Reflektor Objekt erstellen und der Hardware bekannt geben - this.hardware.setReflektor(new Reflektor()); - - } - - /** - * Hier wird ein neuer Spruchschlüssel generiert. - * <p> - * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem - * Tagesschlüssel codiert, hinzugefügt. - * <br> - * Hierfür wird mittels der Funktion "randomBuchstabe" ein zufälliger Buchstabe generiert, - * und geschaut ob dieser bereits in der globalen Variable (this.spruchschluessel) vorhanden ist. - * Wenn nicht, wird der Buchstabe dem Spruchschlüssel hinzugefügt. - * <br> - * Dies wir nun so lange gemacht bis der Spruchschlüssel eine länge von drei Zeichen hat. - */ - public void generateSpruchschluessel() { - - String klartext = ""; - - while (klartext.length() < 3) { - String temp = this.randomBuchstabe(); - if (!klartext.contains(temp)) { - klartext += temp; - } - } - - this.spruchschluessel = klartext; - this.spruchschluesselCodiert = this.codiere(klartext + klartext, false); - - // Walzen auf den Spruchschlüssel stellen - this.hardware.setzePosition(0, this.spruchschluessel.charAt(0)); - this.hardware.setzePosition(1, this.spruchschluessel.charAt(1)); - this.hardware.setzePosition(2, this.spruchschluessel.charAt(2)); - - // Die Kenngruppe codieren und in der Nachricht speichern - this.codiere(this.kenngruppe, true); - } - - /** - * Der Spruchschlüssel wird, zur internen Verwendung, auch im Klartext gespeichert. - * Wir brauchen diesen dann zum codieren der eigentlichen Nachricht. - * - * @return String : Der klartext Spruchschlüssel - */ - public String getSpruchschluessel() { - return this.spruchschluessel; - } - - /** - * Erstellen des Nachrichten Kopfes. - * Hierfür wird die aktuelle Uhrzeit ausgelesen, die Länge der Nachricht sowie der, mit den - * Tagescodes codierte, Spruchschlüssel. - */ - private String generateKopf() { - Calendar cal = Calendar.getInstance(); - - // Uhrzeit an den Kopf hängen - return String.format("%02d%02d", cal.get(Calendar.HOUR), cal.get(Calendar.MINUTE)) + " " + - - // Zeichen Anzahl der Nachricht - this.nachricht.length() + " " + - - // Spruchschlüssel anhängen - this.spruchschluesselCodiert.substring(0, 3) + " " + this.spruchschluesselCodiert.substring(3, 6) + " "; - } - - /** - * Einen zufälligen Buchstaben aus dem Alphabet generieren. - * In der Funktion gibt es den String Alphabet, in welchem alle zulässigen Zeichen eingetragen sind. - * Aus diesem String wird nun zufällig ein Zeichen ausgewählt und zurück gegeben. - * - * @return String : ein zufällig generierter Buchstabe - */ - private String randomBuchstabe() { - return String.valueOf((char) ('A' + new Random().nextInt(26))); - } - - /** - * Befehl die Nachricht an den Funker zu übergeben - * - * @throws IOException : Die Antwort konnte nicht gelesen werden - * @throws HttpException : Die Nachricht konnte nicht abgesendet werden - */ - public void sendeNachricht() throws IOException, HttpException { - String kopf = this.generateKopf(); - new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(kopf + this.nachricht), this.kenngruppe); - this.nachricht = ""; - } - - /** - * Gibt die letzte empfangene Nachricht zurück - * <br> - * String[0] Tag wann die Nachricht gesendet wurde - * String[1] = Die verschlüsselte Nachricht - * String[2] = Nachricht im Klartext - */ - public String[] empfangeNachricht() { - - this.nachricht = ""; - Morsecode mc = new Morsecode(); - String[] nachricht = new String[3]; - String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe); - - if (codierteNachricht[1] != null) { - nachricht[0] = codierteNachricht[0]; - nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]); - nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0])); - StringBuilder sb = new StringBuilder(); - - sb.append(nachricht[1], 0, 16); - for (int i = 17; i <= nachricht[1].length(); ) { - if ((i + 5) < nachricht[1].length()) { - sb.append(nachricht[1], i, i + 5).append(" "); - i += 5; - } else { - sb.append(nachricht[1].substring(i)); - break; - } - } - nachricht[1] = sb.toString(); - } - - return nachricht; - } - - /** - * Liest die Kenngruppe aus welche die Maschine gerade besitzt. Früher war dies eine eindeutige Nummer - * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen. - * - * @return String : Kenngruppe - */ - public String getKenngruppe() { - return kenngruppe; - } + //region Variablen + /** + * Der Klartext Spruchschlüssel zur codierung der Nachricht + */ + private String spruchschluessel; + + /** + * Der Spruchschlüssel, mit den Tageswerten aus dem Codebuch, codiert + */ + private String spruchschluesselCodiert; + + /** + * Die Kenngruppe für die versendeten Nachrichten gedacht sind. Diese ist relevant für den Webservice (Funkraum) + */ + private String kenngruppe; + + /** + * Die Nachricht, welche der Benutzer eingibt, wird als String nachricht gespeichert + * und im laufe der Benutzung ergänzt + */ + private String nachricht; + + /** + * Das Hardware Objekt. Hier werden alle Hardware relevanten Baugruppen gespeichert und verarbeitet. + */ + private Hardware hardware; + + /** + * Im Codebuch sind die Tageswerte zu finden. Über dieses Objekt kann darauf zugegriffen werden. + */ + private Codebuch codebuch; + //endregion + + //region Konstruktor + /** + * Der Konstruktor des Codierers + * Hier werden die globalen Variablen auf ihre Standart Werte gesetzt sowie die Objekte Initialisiert. + */ + public Codierer() { + + this.nachricht = ""; + this.spruchschluessel = ""; + this.spruchschluesselCodiert = ""; + this.kenngruppe = ""; + this.codebuch = new Codebuch(); + this.codebuch.fetchTagesschluessel(); + } + //endregion + + //region Funktionen & Methoden + + //region Reset & Initialisieren + /** + * Hier lesen wir den heutigen Eintrag aus dem Codebuch aus und erstellen ein Codebuch Objekt + * Nach dem Codebuch werden dann die Ringe auf die Walzen gesteckt und die Walzen anschließend + * in die Hardware gebaut. + * <br> + * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und + * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben. + * <br> + * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen + * Codebuch Eintrag. + */ + private void initialisiereHardware() { + + // Das Steckbrett initialisieren + Steckbrett sb = new Steckbrett(); + char[][] verbinder = this.codebuch.getSteckverbindung(); + + // Für jedes Kabel eine Verbindung auf dem Steckbrett setzen + for (char[] kabel : verbinder) { + sb.setzeVertauschung(kabel[0], kabel[1]); + } + + // Die Hardware aus dem Koffer holen (initialisieren) + this.hardware = new Hardware(); + + // Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen + this.hardware.setWalzen(0, this.codebuch.getWalzenlage()[0], this.codebuch.getRingstellung()[0]); + this.hardware.setWalzen(1, this.codebuch.getWalzenlage()[1], this.codebuch.getRingstellung()[1]); + this.hardware.setWalzen(2, this.codebuch.getWalzenlage()[2], this.codebuch.getRingstellung()[2]); + + // Der Hardware das gesetzte Steckbrett zuweisen + this.hardware.setSteckbrett(sb); + + // Ein Reflektor Objekt erstellen und der Hardware bekannt geben + this.hardware.setReflektor(new Reflektor()); + } + + /** + * Setzt die Enigma auf die Einstellungen des aktuellen Tages, aus dem Codebuch zurück. + */ + public void resetHardware() { + this.initialisiereHardware(); + } /** - * Setzt die Kenngruppe welche die Enigma gerade benutzt. - * - * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt + * Leer das Nachrichten Objekt um eine neue Nachricht aufnehmen zu können */ - public void setKenngruppe(String kenngruppe) { - - this.kenngruppe = kenngruppe; - this.initialisiereHardware(); - - } - - /** - * Gibt die bisher erstellte Nachricht zurück - * - * @return String : Erstellte Nachricht - */ - public String getNachricht() { - return nachricht; - } - - /** - * Gibt die aktuellen Buchstaben auf den Walzen zurück - * - * @return char[] : Walzen Array mit der aktuellen Position - */ - public char[] getWalzen() { - char[] walzen = new char[3]; - walzen[0] = this.hardware.getWalzen()[0].getAnzeige(); - walzen[1] = this.hardware.getWalzen()[1].getAnzeige(); - walzen[2] = this.hardware.getWalzen()[2].getAnzeige(); - - return walzen; - } - - /** - * Hier wird ein einzelner Buchstabe verschlüsselt. - * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht. - * In der Regel ist dies der Fall. - * - * @param buchstabe : char : Der zu codierende Buchstabe - * @param save : boolean : Nachricht speichern oder nicht - * @return char : Der codierte Buchstabe - */ - public char codiere(char buchstabe, boolean save) { - char codiert = this.hardware.codiere(buchstabe); - if (save) { - this.nachricht += codiert; - } - - return codiert; - } - - /** - * Codiert den Übergebenen String. - * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht. - * In der Regel ist dies der Fall. - * - * @param klartext : String : Der zu codierende Text - * @param save : boolean : Nachricht speichern oder nicht - * @return String : Der codierte Text zusätzlich als Rückgabe - */ - public String codiere(String klartext, boolean save) { - - StringBuilder sb = new StringBuilder(); - - for (char buchstabe : klartext.toCharArray()) { - sb.append(this.codiere(buchstabe, save)); - } - - return sb.toString(); - } - - /** - * Diese Funktion erwartet als (codierteNachricht) eine korrekte Enigma Nachricht. - * Ihr muss auch der Tag der codierung mitgegeben werden. Dieser weiß dein Funker im Funkraum. - * In der Regel ist dies der Tag des Nachrichten empfangs. - * - * @param codierteNachricht : String : Enigma codierte Nachricht - * @param tag : int : Tag der Nachricht - * @return String : decodierte Nachricht - */ - private String decodiere(String codierteNachricht, int tag) { - - // Hardware reseten und Tageseinstellungen aus dem Codebuch laden - this.initialisiereHardware(); - this.codebuch.fetchTagesschluessel(tag); - - String[] nachricht = codierteNachricht.split(" "); - StringBuilder sb = new StringBuilder(); - - // Uhrzeit - sb.append(nachricht[0]).append(" "); - - // Zeichen Anzahl der Nachricht - sb.append(nachricht[1]).append(" "); - - // Spruchschlüssel - String spruchschluessel = this.decodiereString(nachricht[2]); - sb.append(spruchschluessel).append(" "); - sb.append(this.decodiereString(nachricht[3])).append(" "); - - // Walzen neu einstellen mit dem Spruchschlüssel - this.hardware.setzePosition(0, spruchschluessel.charAt(0)); - this.hardware.setzePosition(1, spruchschluessel.charAt(1)); - this.hardware.setzePosition(2, spruchschluessel.charAt(2)); - - // Nachricht decodieren - sb.append(this.decodiereString(nachricht[4])); - - return sb.toString(); - } - - /** - * Zerlegt den übergebenen String in einen char Array und decodiert jedes Zeichen. - * Der String wird dann decodiert zurück gegeben. - * - * @param nachricht : String : Der zu decodierende Text - * @return String : Der decodierte Text - */ - private String decodiereString(String nachricht) { - - StringBuilder sb = new StringBuilder(); - - for (char buchstabe : nachricht.toCharArray()) { - if (buchstabe > 0) { - sb.append(this.hardware.codiere(buchstabe)); - } - } - - return sb.toString(); - } - - /** - * Setzt die Enigma auf die Einstellungen des aktuellen Tages, aus dem Codebuch zurück. - */ - public void resetHardware() { - this.initialisiereHardware(); - } - - /** - * Setzt den anzuzeigenden Buchstaben (buchstabe) auf der Walze (wlazenPosition) - * TODO: Wenn die Walzen, Notches, Kabel, etc. verändert werden, muss die bisherige Nachricht (this.nachricht) gelöscht werden. - * - * @param walzenPosition : int : Nummer der Walze - * @param buchstabe : char : Buchstabe der zugewiesen soll - */ - public void setWalze(int walzenPosition, char buchstabe) { - this.hardware.setzePosition(walzenPosition, buchstabe); - } - - /** - * Setzt den Ring auf der Walze auf einen neuen Umstprungwert. - * - * @param walzenPosition : int : Walze auf die der Ring gesteckt wird - * @param umsprungPunkt : int : Buchstabe auf dem der Notch sitzt - */ - public void setRing(int walzenPosition, int umsprungPunkt) { - this.hardware.setzeRing(walzenPosition, umsprungPunkt); - } - - /** - * Setzt die Walze (walzeNr) in die Position (walzenPosition) der Enigma ein. - * Mit (ringstellung) gibt man die Position des Umsprungpunktes an. - * - * @param walzenPosition : int : Position der Walze in der Enigma (1-2-3) - * @param walzeNr : int : Nummer der Walze die eingesetzt wird - * @param ringstellung : int : Stellung des Ringes - */ - public void setWalzeNr(int walzenPosition, int walzeNr, int ringstellung) { - this.hardware.setzeWalzenNr(walzenPosition, walzeNr, ringstellung); - } - - /** - * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu. - * - * @param feldNr : int : Kabel Nummer welches am Steckbrett eingesteckt wird - * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt - */ - public void setSteckbrett(int feldNr, String verbindung) { - this.hardware.getSteckbrett().setzeVertauschung(verbindung.charAt(0), verbindung.charAt(1)); - } - - /** - * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist. - * <p> - * TODO: Prüfen ob im aktuellen Feld bereits zwei Buchstaben stehen, wenn ja, nach erfolg dieser Funktion, - * setSteckbrett ausführen mit beiden Buchstaben als String - * - * @param buchstabe : char : Der zuletzt eingegebene Buchstabe - * @return boolean : Wenn der Buchstabe nicht vorhanden ist, wird true zurückgegeben, ansonsten false - */ - public boolean pruefeSteckbrettPort(char buchstabe) { - return true; - } - + public void resetNachricht() { + this.nachricht = ""; + } + //endregion + + //region Nachrichten handler + /** + * Befehl die Nachricht an den Funker zu übergeben + * + * @throws IOException : Die Antwort konnte nicht gelesen werden + * @throws HttpException : Die Nachricht konnte nicht abgesendet werden + */ + public void sendeNachricht() throws IOException, HttpException { + String kopf = this.generateKopf(); + new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(kopf + this.nachricht), this.kenngruppe); + this.nachricht = ""; + this.resetHardware(); + } + + /** + * Gibt die letzte empfangene Nachricht zurück + * <br> + * String[0] Tag wann die Nachricht gesendet wurde + * String[1] = Die verschlüsselte Nachricht + * String[2] = Nachricht im Klartext + */ + public String[] empfangeNachricht() { + + // Alte Nachrichten Variable erstmal leeren + this.nachricht = ""; + // Morsecode Objekt initialisieren + Morsecode mc = new Morsecode(); + // Unser Nachrichten Array soll drei Einträge erhalten + String[] nachricht = new String[4]; + // Abrufen der letzten Nachricht, für unsere Kenngruppe, aus dem Funkraum + String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe); + + // Prüfen ob Nachrichtenlänge > 1 und die codierte Nachricht mehr als drei Felder (" ") hat + if (codierteNachricht.length > 1 && codierteNachricht[1].split(" ").length > 3) { + // Den Tag der Nachricht speichern + nachricht[0] = codierteNachricht[0]; + // Die Nachricht von Morsecode in Buchstaben konvertieren + nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]); + // Die Enigma Nachricht (nachricht[1]) mittels der Tageseinstellungen (nachricht[0]) decodieren + nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0])); + // StringBuilder initialisieren + StringBuilder sb = new StringBuilder(); + + sb.append(nachricht[1], 0, 16); + for (int i = 17; i <= nachricht[1].length(); ) { + if ((i + 5) < nachricht[1].length()) { + sb.append(nachricht[1], i, i + 5).append(" "); + i += 5; + } else { + sb.append(nachricht[1].substring(i)); + break; + } + } + nachricht[1] = sb.toString(); + } else { + nachricht[0] = ""; + nachricht[1] = ""; + nachricht[2] = "Es liegen keine neuen Nachrichten im Funkraum für Sie vor."; + } + + return nachricht; + } + //endregion + + //region Generatoren + /** + * Hier wird ein neuer Spruchschlüssel generiert. + * <p> + * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem + * Tagesschlüssel codiert, hinzugefügt. + * <br> + * Hierfür wird mittels der Funktion "randomBuchstabe" ein zufälliger Buchstabe generiert, + * und geschaut ob dieser bereits in der globalen Variable (this.spruchschluessel) vorhanden ist. + * Wenn nicht, wird der Buchstabe dem Spruchschlüssel hinzugefügt. + * <br> + * Dies wir nun so lange gemacht bis der Spruchschlüssel eine länge von drei Zeichen hat. + */ + public void generateSpruchschluessel() { + + String klartext = ""; + + while (klartext.length() < 3) { + String temp = this.randomBuchstabe(); + if (!klartext.contains(temp)) { + klartext += temp; + } + } + + this.spruchschluessel = klartext; + this.spruchschluesselCodiert = this.codiere(klartext + klartext, false); + + // Walzen auf den Spruchschlüssel stellen + this.hardware.setzePosition(0, this.spruchschluessel.charAt(0)); + this.hardware.setzePosition(1, this.spruchschluessel.charAt(1)); + this.hardware.setzePosition(2, this.spruchschluessel.charAt(2)); + + // Die Kenngruppe codieren und in der Nachricht speichern + this.codiere(this.kenngruppe, true); + } + + /** + * Erstellen des Nachrichten Kopfes. + * Hierfür wird die aktuelle Uhrzeit ausgelesen, die Länge der Nachricht sowie der, mit den + * Tagescodes codierte, Spruchschlüssel. + */ + private String generateKopf() { + Calendar cal = Calendar.getInstance(); + + // Uhrzeit an den Kopf hängen + return String.format("%02d%02d", cal.get(Calendar.HOUR), cal.get(Calendar.MINUTE)) + " " + + // Zeichen Anzahl der Nachricht + this.nachricht.length() + " " + + // Spruchschlüssel anhängen + this.spruchschluesselCodiert.substring(0, 3) + " " + this.spruchschluesselCodiert.substring(3, 6) + " "; + } + + /** + * Einen zufälligen Buchstaben aus dem Alphabet generieren. + * In der Funktion gibt es den String Alphabet, in welchem alle zulässigen Zeichen eingetragen sind. + * Aus diesem String wird nun zufällig ein Zeichen ausgewählt und zurück gegeben. + * + * @return String : ein zufällig generierter Buchstabe + */ + private String randomBuchstabe() { + return String.valueOf((char) ('A' + new Random().nextInt(26))); + } + //endregion + + //region setzte Funktionen + /** + * Setzt den anzuzeigenden Buchstaben (buchstabe) auf der Walze (walzenPosition) und resetet anschließen das + * Nachrichten Objekt + * + * @param walzenPosition : int : Nummer der Walze + * @param buchstabe : char : Buchstabe der zugewiesen soll + */ + public void setzeWalze(int walzenPosition, char buchstabe) { + this.resetNachricht(); + this.hardware.setzePosition(walzenPosition, buchstabe); + } + + /** + * Setzt den Ring auf der Walze auf einen neuen Umstprungwert. + * + * @param walzenPosition : int : Walze auf die der Ring gesteckt wird + * @param umsprungPunkt : int : Buchstabe auf dem der Notch sitzt + */ + public void setzeRing(int walzenPosition, int umsprungPunkt) { + this.hardware.setzeRing(walzenPosition, umsprungPunkt); + } + + /** + * Setzt die Walze (walzeNr) in die Position (walzenPosition) der Enigma ein. + * Mit (ringstellung) gibt man die Position des Umsprungpunktes an. + * + * @param walzenPosition : int : Position der Walze in der Enigma (1-2-3) + * @param walzeNr : int : Nummer der Walze die eingesetzt wird + * @param ringstellung : int : Stellung des Ringes + */ + public void setzeWalzeNr(int walzenPosition, int walzeNr, int ringstellung) { + this.hardware.setzeWalzenNr(walzenPosition, walzeNr, ringstellung); + } + + /** + * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu. + * + * @param port : int : Kabel Nummer welches am Steckbrett eingesteckt wird + * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt + * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines + */ + public boolean setzeSteckbrett(int port, String verbindung) { + return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1)); + } + //endregion + + //region fetch Funktionen + + /** + * Gibt die Ringstellungen aus dem Codebuch zurück + * + * @return int[] : Array mit den Ringstellungen der drei eingesetzten Walzen + */ + public int[] fetchRingstellung() { + return this.codebuch.getRingstellung(); + } + + /** + * Gibt die Walzennummer aus dem Codebuch zurück + * + * @return int[] : Array mit den Nummern der drei eingesetzten Walzen + */ + public int[] fetchWalzenNr() { + return this.codebuch.getWalzenlage(); + } + + /** + * Gibt die Steckverbindungen aus dem Codebuch zurück + * + * @return char[][] : Array mit den gesteckten Verbindungen im Steckbrett + */ + public char[][] fetchSteckverbindungen() { + return this.codebuch.getSteckverbindung(); + } + + /** + * Gibt die aktuellen Buchstaben auf den Walzen zurück + * + * @return char[] : Walzen Array mit der aktuellen Position + */ + public char[] fetchWalzen() { + char[] walzen = new char[3]; + walzen[0] = this.hardware.getWalzen()[0].getPosition(); + walzen[1] = this.hardware.getWalzen()[1].getPosition(); + walzen[2] = this.hardware.getWalzen()[2].getPosition(); + + return walzen; + } + //endregion + + //region codierer + /** + * Hier wird ein einzelner Buchstabe verschlüsselt. + * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht. + * In der Regel ist dies der Fall. + * + * @param buchstabe : char : Der zu codierende Buchstabe + * @param save : boolean : Nachricht speichern oder nicht + * @return char : Der codierte Buchstabe + */ + public char codiere(char buchstabe, boolean save) { + + char codiert = this.hardware.codiere(buchstabe); + + if (save) { + this.nachricht += codiert; + } + + return codiert; + } + + /** + * Codiert den Übergebenen String. + * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht. + * In der Regel ist dies der Fall. + * + * @param klartext : String : Der zu codierende Text + * @param save : boolean : Nachricht speichern oder nicht + * @return String : Der codierte Text zusätzlich als Rückgabe + */ + public String codiere(String klartext, boolean save) { + + StringBuilder sb = new StringBuilder(); + + for (char buchstabe : klartext.toCharArray()) { + sb.append(this.codiere(buchstabe, save)); + } + + return sb.toString(); + } + + /** + * Diese Funktion erwartet als (codierteNachricht) eine korrekte Enigma Nachricht. + * Ihr muss auch der Tag der codierung mitgegeben werden. Dieser weiß dein Funker im Funkraum. + * In der Regel ist dies der Tag des Nachrichten empfangs. + * + * @param codierteNachricht : String : Enigma codierte Nachricht + * @param tag : int : Tag der Nachricht + * @return String : decodierte Nachricht + */ + private String decodiere(String codierteNachricht, int tag) { + + // Hardware reseten und Tageseinstellungen aus dem Codebuch laden + this.initialisiereHardware(); + this.codebuch.fetchTagesschluessel(tag); + + // Nachricht splitten mit whitespace als delimiter + String[] nachricht = codierteNachricht.split(" "); + StringBuilder sb = new StringBuilder(); + + // Uhrzeit + sb.append(nachricht[0]).append(" "); + + // Zeichen Anzahl der Nachricht + sb.append(nachricht[1]).append(" "); + + // Spruchschlüssel + String spruchschluessel = this.decodiereString(nachricht[2]); + + sb.append(spruchschluessel).append(" "); + sb.append(this.decodiereString(nachricht[3])).append(" "); + + // Walzen neu einstellen mit dem Spruchschlüssel + this.hardware.setzePosition(0, spruchschluessel.charAt(0)); + this.hardware.setzePosition(1, spruchschluessel.charAt(1)); + this.hardware.setzePosition(2, spruchschluessel.charAt(2)); + + // Nachricht decodieren + sb.append(this.decodiereString(nachricht[4])); + + return sb.toString(); + } + + /** + * Zerlegt den übergebenen String in einen char Array und decodiert jedes Zeichen. + * Der String wird dann decodiert zurück gegeben. + * + * @param nachricht : String : Der zu decodierende Text + * @return String : Der decodierte Text + */ + private String decodiereString(String nachricht) { + + StringBuilder sb = new StringBuilder(); + + for (char buchstabe : nachricht.toCharArray()) { + if (buchstabe > 0) { + sb.append(this.hardware.codiere(buchstabe)); + } + } + + return sb.toString(); + } + //endregion + + //region Sonstige + + /** + * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist. + * <p> + * setSteckbrett ausführen mit beiden Buchstaben als String + * + * @param buchstabe : char : Der zuletzt eingegebene Buchstabe + * @return boolean : Wenn der Buchstabe nicht vorhanden ist, wird true zurückgegeben, ansonsten false + */ + public boolean pruefeSteckbrettPort(char buchstabe) { + return this.hardware.getSteckbrett().ueberpruefeVertauschungen(buchstabe); + } + + /** + * Ließt aus der empfangenen Nachricht den Spruchschlüssel aus und gibt ihn zurück. + * + * @param empfangeneNachricht : String : Die empfangene Nachricht als String + * @return String : Der Spruchschlüssel mit welcher die Nachricht codiert wurde. + */ + public String empfangenerSpruchschluessel(String empfangeneNachricht) { + String[] nachricht = empfangeneNachricht.split(" "); + + return nachricht[2]; + } + + /** + * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück. + */ + public void letztesZeichenLoeschen() { + this.hardware.dreheWalzen(-1); + } + //endregion + //endregion + + //region Setter + + /** + * Setzt die Kenngruppe welche die Enigma gerade benutzt. + * + * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt + */ + public void setKenngruppe(String kenngruppe) { + + this.kenngruppe = kenngruppe; + this.initialisiereHardware(); + + } + //endregion + + //region Getter + + /** + * Gibt die bisher erstellte Nachricht zurück + * + * @return String : Erstellte Nachricht + */ + public String getNachricht() { + return nachricht; + } + + /** + * Liest die Kenngruppe aus welche die Maschine gerade besitzt. Früher war dies eine eindeutige Nummer + * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen. + * + * @return String : Kenngruppe + */ + public String getKenngruppe() { + return kenngruppe; + } + + /** + * Der Spruchschlüssel wird, zur internen Verwendung, auch im Klartext gespeichert. + * Wir brauchen diesen dann zum codieren der eigentlichen Nachricht. + * + * @return String : Der klartext Spruchschlüssel + */ + public String getSpruchschluessel() { + return this.spruchschluessel; + } + //endregion } diff --git a/src/main/java/projekt/enigma/model/Hardware.java b/src/main/java/projekt/enigma/model/Hardware.java index b37ddd166c98d2274e0722e401418c81d354bc16..4fc0c5ba2b22eac34592a1ea65f32105ff53dec9 100644 --- a/src/main/java/projekt/enigma/model/Hardware.java +++ b/src/main/java/projekt/enigma/model/Hardware.java @@ -15,153 +15,174 @@ package projekt.enigma.model; */ public class Hardware { - /** - * TODO: Dokumentieren - */ - private Walze[] walzen; - private Steckbrett steckbrett; - private Reflektor reflektor; - - /** - * Im Konstruktor legen wir die Anzahl der Walzen fest welche die Hardware aufnehmen kann. - * Die Enigma I welche hier nachgebildet werden soll, konnte drei Walzen aufnehmen. - */ - public Hardware() { - this.walzen = new Walze[3]; - } - - /** - * Setzt eine Walze ein - * - * @param walze : int : Setzt die Walze mit der angegebenen Nummer ein - * @param walzenNr : int : Die Nummer der einzusetzenden Walze - */ - public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) { - this.walzen[walze] = new Walze(walzenNr, ringstellung); - } - - /** - * Setzt den Notch der Walze - * - * @param walze : int : Position der Walze - * @param position : int : Umspringpunkt auf der Walze - */ - public void setzeRing(int walze, int position) { - this.walzen[walze].setRingstellung(position); - } - - /** - * Setzt den Startwert (position) der Walze (walze) - * - * @param walze : int : Nummer der Walze - * @param buchstabe : char : Buchstabe der zugewiesen soll - */ - public void setzePosition(int walze, char buchstabe) { - this.walzen[walze].setPosition(buchstabe); - } - - /** - * Verschlüsselt den übergebenen Buchstaben und fügt ihn der Nachricht hinzu - * - * @param buchstabe char : Der zu ver/entschlüsselnde Buchstabe - * @return char : Der ver/entschlüsselte Buchstabe - */ - public char codiere(char buchstabe) { - this.dreheWalzen(); - - buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe)); - buchstabe = this.walzen[2].codiere(buchstabe); - buchstabe = this.walzen[1].codiere(buchstabe); - buchstabe = this.walzen[0].codiere(buchstabe); - buchstabe = this.reflektor.codiere(buchstabe); - buchstabe = this.walzen[0].codiere2(buchstabe); - buchstabe = this.walzen[1].codiere2(buchstabe); - buchstabe = this.walzen[2].codiere2(buchstabe); - buchstabe = this.steckbrett.codiere(buchstabe); - - return buchstabe; - } - - /** - * Nach jeder codierung eines Buchstabens müssen die Walzen gedreht werden. - * Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an. - */ - private void dreheWalzen() { - if (this.walzen[2].dreheWalze()) { - if (this.walzen[1].dreheWalze()) { - this.walzen[0].dreheWalze(); - } - } - } - - /** - * Gibt die verbauten Walzen Objekte zurück - * - * @return Walze[] : Array mit den Walzen Objekten - */ - public Walze[] getWalzen() { - return this.walzen; - } - - /** - * Setzt eine Walze ein und speichert das Objekt im Walzen Array - * - * @param position : int : Position der Walze - * @param walze : int : Die Nummer der Walze - * @param ringstellung : int : Umsprung Punkt der Walze - */ - public void setWalzen(int position, int walze, int ringstellung) { - this.walzen[position] = new Walze(walze, ringstellung); - } - - /** - * Gibt das Objekt des Steckbretts zurück - * - * @return Steckbrett : Das eingesetzte Steckbrett mit seinen Kabeln wenn eingesteckt - */ - public Steckbrett getSteckbrett() { - return steckbrett; - } - - /** - * Setzt das übergebene Steckbrett Objekt in die Hardware ein - * - * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln - */ - public void setSteckbrett(Steckbrett steckbrett) { - this.steckbrett = steckbrett; - } - - /** - * Liest den Reflektor aus und gibt ihn zurück - * - * @return Reflektor : Objekt des Reflektors - */ - public Reflektor getReflektor() { - return reflektor; - } - - /** - * Setzt den Reflektor ein. - * In der Enigma I welche hier nachgebaut wird, gab es nur einen Reflektor. - * Spätere Versionen haten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafür erstellt, - * welches ausgetauscht werden kann. - * - * @param reflektor : Reflektor : Das Obejtk des Reflektors - */ - public void setReflektor(Reflektor reflektor) { - this.reflektor = reflektor; - } - - /** - * Diese Funktion setzt die Walzen auf ihren Anfangswert zurück. - * Hierfür ist der Buchstabe "A" festgelegt. - * Dies wird benötigt um zB einen neuen Spruchschlüssel einzustellen oder eine neue Nachricht zu verfassen. - */ - public void resetWalzen() { - this.getWalzen()[0].setPosition('A'); - this.getWalzen()[1].setPosition('A'); - this.getWalzen()[2].setPosition('A'); - } + //region Variablen + /** + * TODO: Dokumentieren + */ + private Walze[] walzen; + private Steckbrett steckbrett; + private Reflektor reflektor; + //endregion + + //region Konstruktor + /** + * Im Konstruktor legen wir die Anzahl der Walzen fest welche die Hardware aufnehmen kann. + * Die Enigma I welche hier nachgebildet werden soll, konnte drei Walzen aufnehmen. + */ + public Hardware() { + this.walzen = new Walze[3]; + } + //endregion + + //region Funktionen & Methoden + /** + * Setzt eine Walze ein + * + * @param walze : int : Setzt die Walze mit der angegebenen Nummer ein + * @param walzenNr : int : Die Nummer der einzusetzenden Walze + */ + public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) { + this.walzen[walze] = new Walze(walzenNr, ringstellung); + } + + /** + * Setzt den Notch der Walze + * + * @param walze : int : Position der Walze + * @param position : int : Umspringpunkt auf der Walze + */ + public void setzeRing(int walze, int position) { + this.walzen[walze].setRingstellung(position); + } + + /** + * Setzt den Startwert (position) der Walze (walze) + * + * @param walze : int : Nummer der Walze + * @param buchstabe : char : Buchstabe der zugewiesen soll + */ + public void setzePosition(int walze, char buchstabe) { + this.walzen[walze].setPosition(buchstabe); + } + + /** + * Verschlüsselt den übergebenen Buchstaben und fügt ihn der Nachricht hinzu + * + * @param buchstabe char : Der zu ver/entschlüsselnde Buchstabe + * @return char : Der ver/entschlüsselte Buchstabe + */ + public char codiere(char buchstabe) { + + buchstabe = Character.toUpperCase(buchstabe); + this.dreheWalzen(1); + + buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe)); + buchstabe = this.walzen[2].codiere(buchstabe); + buchstabe = this.walzen[1].codiere(buchstabe); + buchstabe = this.walzen[0].codiere(buchstabe); + buchstabe = this.reflektor.codiere(buchstabe); + buchstabe = this.walzen[0].codiere2(buchstabe); + buchstabe = this.walzen[1].codiere2(buchstabe); + buchstabe = this.walzen[2].codiere2(buchstabe); + buchstabe = this.steckbrett.codiere(buchstabe); + + return buchstabe; + } + + /** + * Nach jeder codierung eines Buchstabens müssen die Walzen gedreht werden. + * Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an. + */ + public void dreheWalzen(int richtung) { + if (richtung > 0) { + for (int i = 0; i < richtung; i++) { + if (this.walzen[2].dreheWalze(1) && this.walzen[1].dreheWalze(1)) { + this.walzen[0].dreheWalze(1); + } + } + } else { + for (int i = 0; i > richtung; richtung++) { + if (this.walzen[2].dreheWalze(-1) && this.walzen[1].dreheWalze(-1)) { + this.walzen[0].dreheWalze(-1); + } + } + } + } + + /** + * Diese Funktion setzt die Walzen auf ihren Anfangswert zurück. + * Hierfür ist der Buchstabe "A" festgelegt. + * Dies wird benötigt um zB einen neuen Spruchschlüssel einzustellen oder eine neue Nachricht zu verfassen. + */ + public void resetWalzen() { + this.getWalzen()[0].setPosition('A'); + this.getWalzen()[1].setPosition('A'); + this.getWalzen()[2].setPosition('A'); + } + //endregion + + //region Setter + /** + * Setzt eine Walze ein und speichert das Objekt im Walzen Array + * + * @param position : int : Position der Walze + * @param walze : int : Die Nummer der Walze + * @param ringstellung : int : Umsprung Punkt der Walze + */ + public void setWalzen(int position, int walze, int ringstellung) { + this.walzen[position] = new Walze(walze, ringstellung); + } + + /** + * Setzt den Reflektor ein. + * In der Enigma I welche hier nachgebaut wird, gab es nur einen Reflektor. + * Spätere Versionen haten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafür erstellt, + * welches ausgetauscht werden kann. + * + * @param reflektor : Reflektor : Das Obejtk des Reflektors + */ + public void setReflektor(Reflektor reflektor) { + this.reflektor = reflektor; + } + + /** + * Setzt das übergebene Steckbrett Objekt in die Hardware ein + * + * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln + */ + public void setSteckbrett(Steckbrett steckbrett) { + this.steckbrett = steckbrett; + } + //endregion + + //region Getter + + /** + * Gibt das Objekt des Steckbretts zurück + * + * @return Steckbrett : Das eingesetzte Steckbrett mit seinen Kabeln wenn eingesteckt + */ + public Steckbrett getSteckbrett() { + return steckbrett; + } + + /** + * Liest den Reflektor aus und gibt ihn zurück + * + * @return Reflektor : Objekt des Reflektors + */ + public Reflektor getReflektor() { + return reflektor; + } + + /** + * Gibt die verbauten Walzen Objekte zurück + * + * @return Walze[] : Array mit den Walzen Objekten + */ + public Walze[] getWalzen() { + return this.walzen; + } + //endregion } diff --git a/src/main/java/projekt/enigma/model/Reflektor.java b/src/main/java/projekt/enigma/model/Reflektor.java index 9e5e6b1424852c8ee063179f8a8d216aac9c969a..dca62412c87722b6660ae8118899662c636aee04 100644 --- a/src/main/java/projekt/enigma/model/Reflektor.java +++ b/src/main/java/projekt/enigma/model/Reflektor.java @@ -1,6 +1,7 @@ package projekt.enigma.model; /** + * TODO: Dokumentation aktuallisieren * Klasse Reflektor * <br> * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und und kodiert diesen. @@ -12,17 +13,6 @@ package projekt.enigma.model; */ public class Reflektor { - /** - * WALZE_ALPHABET : konstanter Char-Array mit den Werten des Alphabeths (26 Werte) - */ - private final Character[] WALZE_ALPHABET = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}; - - /** - * WALZE_REFLEKTOR : konstanter Char-Array mit den Werten des Reflektors (26 Werte) - */ - private final Character[] WALZE_REFLEKTOR = {'E', 'J', 'M', 'Z', 'A', 'L', 'Y', 'X', 'V', 'B', 'W', 'F', 'C', 'R', 'Q', 'U', 'O', 'N', 'T', 'S', 'P', 'I', 'K', 'H', 'G', 'D'}; - - /** * Funktion codiere * <br> @@ -33,16 +23,11 @@ public class Reflektor { * @return WALZE_REFLEKTOR[iPositionReflektor]: Character: Der kodierte Buchstabe aus dem Reflektor */ public char codiere(Character buchstabe) { - int iPositionReflektor = 0; - - //Ermittelt die Position des Buchstaben "buchstabe" auf der Alphabetswalze - for (int index = 0; index < WALZE_ALPHABET.length; index++) { - if (buchstabe.equals(WALZE_ALPHABET[index])) { - iPositionReflektor = index; - break; - } - } + // alphabet : String mit den Werten des Alphabeths (26 Werte) + String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + // reflektor : String mit den Werten des Reflektors (26 Werte) + String reflektor = "EJMZALYXVBWFCRQUONTSPIKHGD"; - return WALZE_REFLEKTOR[iPositionReflektor]; + return reflektor.charAt(alphabet.indexOf(buchstabe)); } } diff --git a/src/main/java/projekt/enigma/model/Steckbrett.java b/src/main/java/projekt/enigma/model/Steckbrett.java index b0ad4f4cb212d07e6bc2398ac5275142bbe8d756..b2d698f7b576b685230f97dd524b8e7767e60147 100644 --- a/src/main/java/projekt/enigma/model/Steckbrett.java +++ b/src/main/java/projekt/enigma/model/Steckbrett.java @@ -1,6 +1,8 @@ package projekt.enigma.model; /** + * TODO: Dokumentation aktuallisieren + * <p> * Klasse Steckbrett * <br> * Das Steckbrett diente dazu Buchstaben paarweise zu vertauschen noch bevor diese durch die Walzen codiert werden. @@ -9,20 +11,15 @@ package projekt.enigma.model; */ public class Steckbrett { - /** - * zaehler: Int, der als Laufvariable genutzt wird - */ - private int zaehler; - /** * orginalBuchstaben: Character-Array, der jeweils den ersten zu vertauschenden Buchstaben enthält */ - private Character[] orginalBuchstaben; + private String originalBuchstaben; /** * getauschteBuchstaben: Character-Array, der jeweils den zweiten zu vertauschenden Buchstaben enthält */ - private Character[] getauschteBuchstaben; + private String getauschteBuchstaben; /** @@ -32,62 +29,85 @@ public class Steckbrett { */ public Steckbrett() { - orginalBuchstaben = new Character[10]; - getauschteBuchstaben = new Character[10]; + originalBuchstaben = ""; + getauschteBuchstaben = ""; } /** - * TODO: Fehlerfall kommentieren, bzw. Exceptions werfen ????? - * TODO: Überprüfe Vertauschungen für jeden Buchstaben aufrufen * Funktion setzeVertauschung * <br> * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) übergeben. - * buchstabe1 wird in das Character-Array orginalBuchstaben geschrieben. - * buchstabe2 wird in das Character-Array getauschteBuchstaben geschrieben. - * Anschließend wird die Funktion ueberpruefeVertauschungen aufgerufen. + * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre. + * <br> + * Anschließend wird: + * <p> + * buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben + * buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index geschrieben. + * </p> * * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll. * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll. - * @return ueberpruefeVertauschungen(): Ueberprueft ob die Vertauschungen zulaessig sind. + * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false */ public boolean setzeVertauschung(char buchstabe1, char buchstabe2) { - if (zaehler < orginalBuchstaben.length) { - orginalBuchstaben[zaehler] = buchstabe1; - getauschteBuchstaben[zaehler++] = buchstabe2; + + if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2) && originalBuchstaben.length() <= 20) { + originalBuchstaben += buchstabe1; + getauschteBuchstaben += buchstabe2; + + return true; + } else { + return false; + } + } + + /** + * Funktion setzeVertauschung mit angabe eines Ports von 1 - 10 + * <br> + * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) sowie der Port übergeben. + * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre. + * <br> + * Anschließend wird: + * <p> + * buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben + * buchstabe2 in das Array getauschteBuchstaben auf den Index (steckbrettPort) geschrieben. + * </p> + * + * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll. + * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll. + * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false + */ + public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) { + + if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) { + originalBuchstaben.replace(originalBuchstaben.charAt(steckbrettPort), buchstabe1); + getauschteBuchstaben.replace(getauschteBuchstaben.charAt(steckbrettPort), buchstabe2); + + return true; } else { - System.err.println("Zu viele Vertauschungen angegeben!"); + return false; } - return ueberpruefeVertauschungen(); } /** - * TODO: Fehlerfall kommentieren, bzw. Exceptions werfen ????? - * TODO: Buchstabe zum überpüfen übergeben * Funktion ueberpruefeVertauschungen * <br> - * Die Funktion ueberpruefeVertauschungen prueft ob die Buchstabenvertauschung zulaessig ist. + * Die Funktion ueberpruefeVertauschungen prueft ob der übergebene Buchstabe bereits in den beiden Arrays + * (orginalBuchstaben) und (getauschteBuchstaben) vorhanden ist. * Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt * (ein Buchstabe nicht mehrmals vertauscht wird). * - * @return boolean : result : Flag, der die Zulassigkeit der Vertauschungen zurueckgibt. + * @return boolean : Wenn false, dann darf der Buchstabe genutzt werden. + * Wenn er schon vorhanden ist, wird true zurück gegeben */ - public boolean ueberpruefeVertauschungen() { - boolean result = true; - - /*Es wird geprüft: - 1. Ob im Array originalBuchstaben Dopplungen enthalten sind. - 2. Ob im Array originalBuchstaben Buchstaben im Array getauschteBuchstaben enthalten sind. - 3. Ob im Array getauschteBuchstaben Dopplungen enthalten sind. - Tritt einer der Fälle ein, erfolgt eine Konsolenausgabe und der Flag wird auf false gesetzt. - */ - for (int n = 0; n < orginalBuchstaben.length; n++) { - if (orginalBuchstaben.equals(orginalBuchstaben[n]) || - getauschteBuchstaben.equals(orginalBuchstaben[n]) || - getauschteBuchstaben.equals(getauschteBuchstaben[n])) { - System.err.println("Vertauschungen enthalten unzulässige Dopplungen"); - result = false; - } + public boolean ueberpruefeVertauschungen(Character buchstabe) { + + boolean result = false; + + if (originalBuchstaben.contains(String.valueOf(buchstabe)) || + getauschteBuchstaben.contains(String.valueOf(buchstabe))) { + result = true; } return result; @@ -102,15 +122,14 @@ public class Steckbrett { * @return buchstabe : Character : Codierter Buchstabe. */ public char codiere(Character buchstabe) { - for (int index = 0; index < getauschteBuchstaben.length; index++) { - if (buchstabe.equals(getauschteBuchstaben[index])) { - buchstabe = orginalBuchstaben[index]; - } else if (buchstabe.equals(orginalBuchstaben[index])) { - buchstabe = getauschteBuchstaben[index]; - } - } - return buchstabe; + if (originalBuchstaben.contains(String.valueOf(buchstabe))) { + return getauschteBuchstaben.charAt(originalBuchstaben.indexOf(buchstabe)); + } else if(getauschteBuchstaben.contains(String.valueOf(buchstabe))) { + return originalBuchstaben.charAt(getauschteBuchstaben.indexOf(buchstabe)); + } else { + return buchstabe; + } } -} +} \ No newline at end of file diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java index 51bf3a8b377e37edaa1e303a21409f0dea83c87f..118ad4f6245b3c8ebd42e5baaf480b18d4808392 100644 --- a/src/main/java/projekt/enigma/model/Walze.java +++ b/src/main/java/projekt/enigma/model/Walze.java @@ -1,6 +1,8 @@ package projekt.enigma.model; /** + * TODO: Dokumentation aktuallisieren + * <p> * Klasse Walze * <br> * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften: @@ -14,255 +16,174 @@ package projekt.enigma.model; */ public class Walze { + //region Variablen /** - * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt + * Das String Array aller bekannter aktuellen Walzen */ - private Character[] alphabet; - - /** - * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt - */ - private char ringstellung; - - /** - * walzennr : int : Bestimmt, welche Walze genutzt wird - */ - private int walzennr; - - /** - * alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes - * aber immer wieder ueberschrieben. - */ - private Character[] walzeAlpha; + String[] walzen; /** - * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt - * - * @param walzennr : int : Nummer der gewaehlten Walze - * @param ringstellung : int : Einstellung des Umsprungpunktes + * alphabet : String dass die Buchstaben des Alphabets enthaelt */ - public Walze(int walzennr, int ringstellung) { - this.alphabet = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', - 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}; - this.walzeAlpha = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', - 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}; - - this.setWalzennr(walzennr); - this.setRingstellung(ringstellung); - } + private String alphabet; /** - * Sortiert der Walzennummer das passende Character-Array mittels switch zu. - * - * @return walze : Character[] : gibt die gewaehlte Walze zurueck + * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt */ - private Character[] walzenNummer() { - Character[] walze = new Character[26]; + private char ringstellung; - // Character-Arrays fuer die Codierung jeder Walze - Character[] walzeEins = {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', - 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'}; - Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', - 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'}; - Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', - 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'}; - Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X', - 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'}; - Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L', - 'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'}; - - switch (this.walzennr) { - case 1: - walze = walzeEins; - break; - case 2: - walze = walzeZwei; - break; - case 3: - walze = walzeDrei; - break; - case 4: - walze = walzeVier; - break; - case 5: - walze = walzeFuenf; - break; - } - - return walze; - } + /** + * walzennr : int : Bestimmt, welche Walze genutzt wird + */ + private int walzenNr; /** - * TODO: Dokumentieren - * - * @return ringstellung : char : gibt die neue Ringstellung als char zurueck + * Die Anzahl der getätigten Walzen Drehungen */ - public char getRingstellung() { - return ringstellung; - } + private int turns; + //endregion + //region Konstruktor /** - * Setzt die Initiale Ringstellung der Walze. - * Es sind nur Zahlen von 1 - 26 zugelassen. - * - * Die Ringstellung wird zum char umgewandelt. - * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt. + * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt * - * @param ringstellung : int : Punkt an dem die Walze umspringt + * @param walzenNr : int : Nummer der gewaehlten Walze + * @param ringstellung : int : Einstellung des Umsprungpunktes */ - //TODO ??? Setter Ringstellung - public void setRingstellung(int ringstellung) { - if ((ringstellung > 0) && (ringstellung <= 26)) { - this.ringstellung = this.alphabet[ringstellung - 1]; - } else { - this.ringstellung = 'Z'; - } + public Walze(int walzenNr, int ringstellung) { + + this.walzen = new String[5]; + this.walzen[0] = "EKMFLGDQVZNTOWYHXUSPAIBRCJ"; + this.walzen[1] = "AJDKSIRUXBLHWTMCQGZNPYFVOE"; + this.walzen[2] = "BDFHJLCPRTXVZNYEIWGAKMUSQO"; + this.walzen[3] = "ESOVPZJAYQUIRHXLNFTGKDCMWB"; + this.walzen[4] = "VZBRGITYUPSDNHLXAWMJQOFECK"; + this.alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + this.turns = 0; + + this.setWalzenNr(walzenNr); + this.setRingstellung(ringstellung); } + //endregion + //region Funktionen & Methoden /** - * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt - * das Array alphabet mit der neuen Anordnung. - * - * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde. - * - * @param drehung : int[] : Anzahl der Drehungen - * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde + * Dreht die Walze: Zählt die Umdrehungen (Turns) um eines hoch oder runter, je nach Drehrichtung. + * <p> + * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde. + * + * @param richtung : int : 1 dreht die Walze weiter und -1 dreht sie einen Schritt zurück + * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde * TODO: Doku */ - public boolean dreheWalze(int... drehung) { - boolean checkRing = false; + public boolean dreheWalze(int richtung) { - // fuehrt die Verschiebung des Alphabets um eine Stelle durch - verschiebung(); + boolean checkRing = false; - // fuehrt die Verschiebung mehrfach aus, wenn mehrere Drehungen ausgefuehrt werden sollen - if (drehung.length > 0) { - for (int i = 1; i < drehung[0]; i++) { - verschiebung(); + if (richtung == -1 || richtung == 1) { + if (richtung == 1) { + this.turns++; + } else if (richtung == -1) { + this.turns--; } - } - // gleicht die Ringstellung mit der aktuellen Position ab - if (this.getPosition().equals(this.ringstellung)) { - checkRing = true; + // gleicht die Ringstellung mit der aktuellen Position ab + if (this.getPosition() + richtung == this.ringstellung) { + checkRing = true; + } } return checkRing; } - /** - * Ueberschreibt die Alphabetswalze mit dem, durch die Drehung, verschobenen Alphabet. - * TODO: Dokumentieren - */ - private void verschiebung() { - Character[] neueWalze = new Character[26]; - - for (int index = 0; index < neueWalze.length; index++) { - neueWalze[(index + 1) % neueWalze.length] = this.walzeAlpha[index]; - } - - this.walzeAlpha = neueWalze; - } - - /** - * TODO: Dokumentieren // dass selbe wie getPosition - * Gibt den Buchstaben zurueck der in der Walze aktuell eingestellt ist. - * - * @return char an der Stelle temp des Alphabets - */ - public char getAnzeige() { - int temp = this.fetchArrayIndex('A', this.walzeAlpha); - return this.alphabet[temp]; - } - /** * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze. * - * @param buchstabe : char : Buchstabe, der verschluesselt werden soll + * @param buchstabe : char : Buchstabe, der verschluesselt werden soll * @return buchstabe : char : verschluesselter Buchstabe */ public char codiere(char buchstabe) { - /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und - uebertraegt den Index auf die gewaehlte Codierwalze*/ - buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)]; - - return buchstabe; + return this.fetchWalze().charAt((this.alphabet.indexOf(buchstabe) + this.turns) % 26); } /** - * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze + * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Walze * - * @param buchstabe : char : Buchstabe, der decodiert werden soll + * @param buchstabe : char : Buchstabe, der decodiert werden soll * @return buchstabe : char : decodierter Buchstabe */ public char codiere2(char buchstabe) { - /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und - uebertraegt den Index auf die (verschobene) Alphabetswalze*/ - buchstabe = walzeAlpha[fetchArrayIndex(buchstabe, walzenNummer())]; - return buchstabe; + int zwischensumme = this.fetchWalze().indexOf(buchstabe) - this.turns; + if (zwischensumme < 0) { + zwischensumme = this.fetchWalze().indexOf(buchstabe) - this.turns + 26; + } + return this.alphabet.charAt(zwischensumme % 26); } /** - * TODO: Dokumentieren - * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife - * - * @param buchstabe : Character : Buchstabe, dessen Index benoetigt wird - * @param array : Character[] : Array, in dem der Buchstabe vorkommen soll - * @return result : int : index des Buchstaben + * Holt den korrekten String zu der Walze + * + * @return walze : Character[] : gibt die gewaehlte Walze zurueck */ - private int fetchArrayIndex(Character buchstabe, Character[] array) { - // wird mit ungueltigem Wert initialisiert - int result = -1; + private String fetchWalze() { - for (int i = 0; i < array.length; i++) { - if (array[i].equals(buchstabe)) { - result = i; - break; - } - } + return walzen[walzenNr]; + } + //endregion - return result; + //region Setter + /** + * * TODO: Funktionsname hat sich geändert + * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen. + * Buchstaben werden automatisch in Grossbuchstaben umgewandelt. + * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen. + * + * @param buchstabe : Character : Einstellung der Walze + */ + public void setPosition(Character buchstabe) { + this.turns = alphabet.indexOf(buchstabe); } /** * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl. * - * @param walzennr : int : Walzennummer + * @param walzenNr : int : Walzennummer */ - public void setWalzennr(int walzennr) { - if ((walzennr > 0) && (walzennr < 6)) { - this.walzennr = walzennr; + public void setWalzenNr(int walzenNr) { + if ((walzenNr > 0) && (walzenNr < 6)) { + this.walzenNr = walzenNr - 1; } else { System.err.println("Keine gültige Walzennummer"); } } /** - * TODO: Dokumentieren // das selbe wie getAnzeig? - * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist + * Setzt die Initiale Ringstellung der Walze. + * Es sind nur Zahlen von 1 - 26 zugelassen. + * <p> + * Die Ringstellung wird zum char umgewandelt. + * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt. * - * @return Character am Index 0 des (verschobenen) Alphabets zurueck + * @param ringstellung : int : Punkt an dem die Walze umspringt */ - public Character getPosition() { - return walzeAlpha[0]; + public void setRingstellung(int ringstellung) { + if ((ringstellung > 0) && (ringstellung <= 26)) { + this.ringstellung = this.alphabet.charAt(ringstellung - 1); + } else { + this.ringstellung = 'Z'; + } } + //endregion + //region Getter /** - * * TODO: Funktionsname hat sich geändert - * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen. - * Buchstaben werden automatisch in Grossbuchstaben umgewandelt. - * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen. + * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist * - * @param buchstabe : Character : Einstellung der Walze + * @return Character am Index 0 des (verschobenen) Alphabets zurueck */ - public void setPosition(Character buchstabe) { - if (Character.isLetter(buchstabe)) { - buchstabe = Character.toUpperCase(buchstabe); - System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length); - if (buchstabe > 'A') { - dreheWalze(this.fetchArrayIndex(buchstabe, this.walzeAlpha)); - } - } + public Character getPosition() { + return this.alphabet.charAt(turns % 26); } -} + //endregion +} \ No newline at end of file diff --git a/src/main/resources/projekt/enigma/gui.fxml b/src/main/resources/projekt/enigma/gui.fxml index 4c75cd670c3ea1b526fb67c89e0adc9bfae8579d..8630069413fb732ad0ed6f81fbe7b28ce2efa52f 100644 --- a/src/main/resources/projekt/enigma/gui.fxml +++ b/src/main/resources/projekt/enigma/gui.fxml @@ -5,20 +5,18 @@ <?import javafx.scene.control.Label?> <?import javafx.scene.control.MenuButton?> <?import javafx.scene.control.ProgressBar?> -<?import javafx.scene.control.Separator?> <?import javafx.scene.control.TextField?> <?import javafx.scene.layout.AnchorPane?> <?import javafx.scene.layout.ColumnConstraints?> <?import javafx.scene.layout.FlowPane?> <?import javafx.scene.layout.GridPane?> -<?import javafx.scene.layout.Pane?> <?import javafx.scene.layout.RowConstraints?> <?import javafx.scene.layout.TilePane?> <?import javafx.scene.layout.VBox?> <?import javafx.scene.shape.Circle?> <?import javafx.scene.text.Font?> -<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="677.0" prefWidth="967.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="projekt.enigma.GuiController"> +<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="677.0" prefWidth="967.0" xmlns="http://javafx.com/javafx/8.0.999-ea" xmlns:fx="http://javafx.com/fxml/1" fx:controller="projekt.enigma.GuiController"> <children> <GridPane layoutY="313.0" prefHeight="393.0" prefWidth="968.0" AnchorPane.bottomAnchor="-7.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="313.0"> <columnConstraints> @@ -41,8 +39,8 @@ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" /> <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" /> <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" /> - <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" /> - <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" /> + <RowConstraints maxHeight="63.0" minHeight="10.0" prefHeight="63.0" vgrow="SOMETIMES" /> + <RowConstraints maxHeight="41.0" minHeight="10.0" prefHeight="29.0" vgrow="SOMETIMES" /> <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" /> <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" /> </rowConstraints> @@ -198,14 +196,6 @@ <Insets left="28.0" /> </GridPane.margin> </Button> - <Button fx:id="btnA" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="A" textFill="#fffdfd" GridPane.columnIndex="2" GridPane.rowIndex="5"> - <font> - <Font name="System Bold" size="18.0" /> - </font> - <GridPane.margin> - <Insets left="28.0" /> - </GridPane.margin> - </Button> <Button fx:id="btnO" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="O" textFill="#fffdfd" GridPane.columnIndex="10" GridPane.rowIndex="4"> <font> <Font name="System Bold" size="18.0" /> @@ -251,7 +241,7 @@ <Font name="System Bold" size="18.0" /> </font> </Button> - <Button minHeight="44.0" mnemonicParsing="false" onAction="#loeschen" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="<" textFill="#fffdfd" GridPane.columnIndex="10" GridPane.rowIndex="5"> + <Button fx:id="btnDelete" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="<" textFill="#fffdfd" GridPane.columnIndex="10" GridPane.rowIndex="5"> <font> <Font size="18.0" /> </font> @@ -527,21 +517,26 @@ </Label> <TilePane prefHeight="200.0" prefWidth="200.0" GridPane.columnIndex="1" GridPane.rowIndex="4" /> <VBox prefHeight="200.0" prefWidth="152.0" GridPane.columnIndex="11" /> + <Button fx:id="btnA" minHeight="35.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="35.0" prefWidth="42.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="A" textFill="#fffdfd" GridPane.columnIndex="2" GridPane.rowIndex="5"> + <font> + <Font name="System Bold" size="18.0" /> + </font> + </Button> </children> </GridPane> <AnchorPane layoutX="241.0" layoutY="130.0" prefHeight="111.0" prefWidth="487.0" AnchorPane.leftAnchor="241.0" AnchorPane.rightAnchor="240.0"> <children> - <VBox layoutX="72.0" layoutY="-89.0" prefHeight="200.0" prefWidth="378.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="72.0" AnchorPane.rightAnchor="37.0" AnchorPane.topAnchor="-89.0"> + <VBox layoutX="72.0" layoutY="-89.0" prefHeight="210.0" prefWidth="377.0" AnchorPane.bottomAnchor="-10.0" AnchorPane.leftAnchor="72.0" AnchorPane.rightAnchor="37.0" AnchorPane.topAnchor="-89.0"> <children> - <TextField fx:id="tfCodiert" editable="false" prefHeight="99.0" prefWidth="377.0" /> - <Separator prefWidth="200.0" /> - <TextField fx:id="tfKlartext" editable="false" prefHeight="100.0" prefWidth="378.0" /> + <TextField fx:id="tfKlartext" editable="false" prefHeight="80.0" prefWidth="377.0" /> + <Label prefHeight="17.0" prefWidth="385.0" /> + <TextField fx:id="tfCodiert" editable="false" prefHeight="79.0" prefWidth="377.0" /> + <Label prefHeight="17.0" prefWidth="385.0" /> + <Label fx:id="lblLadeNachricht" alignment="BASELINE_CENTER" contentDisplay="CENTER" prefHeight="5.0" prefWidth="377.0" text="Neue Nachricht wird vom Funkraum abgerufen!" /> + <ProgressBar fx:id="pbLadeNachricht" prefHeight="10.0" prefWidth="377.0" progress="0.0" /> </children> </VBox> </children></AnchorPane> - <Label layoutX="40.0" layoutY="233.0" prefHeight="17.0" prefWidth="172.0" text="Spruchschlüssel" /> - <Label layoutX="34.0" layoutY="259.0" prefHeight="17.0" prefWidth="172.0" text="Tagesschlüssel" /> - <ProgressBar fx:id="pbLadeNachricht" layoutX="313.0" layoutY="273.0" prefHeight="18.0" prefWidth="378.0" progress="0.0" /> <GridPane layoutX="23.0" layoutY="60.0" prefHeight="158.0" prefWidth="237.0" AnchorPane.leftAnchor="23.0" AnchorPane.topAnchor="60.0"> <columnConstraints> <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" /> @@ -607,16 +602,28 @@ </MenuButton> </children> </GridPane> - <Label fx:id="lblLadeNachricht" alignment="CENTER" layoutX="313.0" layoutY="250.0" prefHeight="17.0" prefWidth="378.0" text="Neue Nachricht wird vom Funkraum abgerufen!" /> - <FlowPane layoutX="735.0" layoutY="27.0" prefHeight="158.0" prefWidth="152.0" AnchorPane.leftAnchor="735.0" AnchorPane.rightAnchor="38.0" AnchorPane.topAnchor="27.0"> + <FlowPane layoutX="736.0" layoutY="51.0" prefHeight="173.0" prefWidth="195.0" AnchorPane.rightAnchor="36.0" AnchorPane.topAnchor="51.0"> <children> - <Button mnemonicParsing="false" onAction="#btnsenden" prefHeight="80.0" prefWidth="152.0" text="An Funker senden" /> - <Pane> - <children> - <Button mnemonicParsing="false" onAction="#btnempfangen" prefHeight="101.0" prefWidth="195.0" text="Funkspruch empfangen" /> - </children> - </Pane> + <Button fx:id="btnEmpfangen" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="80.0" prefWidth="195.0" text="Funkspruch empfangen" /> + <Label prefHeight="17.0" prefWidth="195.0" /> + <Button fx:id="btnSenden" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="80.0" prefWidth="195.0" text="An Funker senden" /> </children> </FlowPane> + <GridPane layoutX="23.0" layoutY="222.0" prefHeight="60.0" prefWidth="270.0" AnchorPane.leftAnchor="23.0" AnchorPane.topAnchor="222.0"> + <columnConstraints> + <ColumnConstraints hgrow="SOMETIMES" maxWidth="130.0" minWidth="10.0" prefWidth="100.0" /> + <ColumnConstraints hgrow="SOMETIMES" maxWidth="224.0" minWidth="10.0" prefWidth="170.0" /> + </columnConstraints> + <rowConstraints> + <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" /> + <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" /> + </rowConstraints> + <children> + <Label alignment="CENTER_RIGHT" text="Tagesschlüssel:" /> + <Label text="Spruchschlüssel:" GridPane.rowIndex="1" /> + <Label fx:id="lblTagesschluessel" prefHeight="17.0" prefWidth="181.0" GridPane.columnIndex="1" /> + <Label fx:id="lblSpruchschluessel" prefHeight="17.0" prefWidth="181.0" GridPane.columnIndex="1" GridPane.rowIndex="1" /> + </children> + </GridPane> </children> </AnchorPane> diff --git a/src/main/resources/projekt/enigma/kenngruppe.fxml b/src/main/resources/projekt/enigma/kenngruppe.fxml index 237b3ed092c45e0f47661d7827503bee95b79ea7..2cedf3644a5b65ea0c8f53751137ac55e051acd3 100644 --- a/src/main/resources/projekt/enigma/kenngruppe.fxml +++ b/src/main/resources/projekt/enigma/kenngruppe.fxml @@ -4,8 +4,9 @@ <?import javafx.scene.control.Label?> <?import javafx.scene.layout.AnchorPane?> <?import javafx.scene.layout.HBox?> +<?import javafx.scene.shape.Circle?> -<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="411.0" prefWidth="512.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="enigma.KenngruppeController"> +<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="411.0" prefWidth="512.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="projekt.enigma.KenngruppeController"> <children> <Label layoutX="81.0" layoutY="29.0" text="Bitte Kenngruppe eingeben!" AnchorPane.leftAnchor="81.0" AnchorPane.rightAnchor="70.0" AnchorPane.topAnchor="29.0" /> <HBox layoutX="107.0" layoutY="141.0" prefHeight="26.0" prefWidth="276.0" AnchorPane.leftAnchor="107.0" AnchorPane.rightAnchor="129.0" AnchorPane.topAnchor="141.0"> @@ -15,5 +16,7 @@ <Button mnemonicParsing="false" prefHeight="25.0" prefWidth="150.0" text="Button" /> </children> </HBox> + <Circle fill="DODGERBLUE" layoutX="226.0" layoutY="267.0" radius="100.0" stroke="BLACK" strokeType="INSIDE" AnchorPane.leftAnchor="126.0" AnchorPane.rightAnchor="186.0" AnchorPane.topAnchor="167.0" /> + <Button fx:id="secondaryButton" layoutX="40.0" layoutY="85.0" onAction="#switchToPrimary" prefHeight="25.0" prefWidth="241.0" text="Kenngruppe bestätigen!" /> </children> </AnchorPane> diff --git a/src/test/java/projekt/enigma/model/HardwareTest.java b/src/test/java/projekt/enigma/model/HardwareTest.java index 742e6aba1b8679f81f8729a183fc7dd377616aa9..d0be7f035f829af0eb6defdb7356440510017587 100644 --- a/src/test/java/projekt/enigma/model/HardwareTest.java +++ b/src/test/java/projekt/enigma/model/HardwareTest.java @@ -17,13 +17,14 @@ public class HardwareTest { /* Walze nach der Chiffrierung - Alphabet {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}; - Steckbrett {'B', 'G', 'D', 'F'} - Steckbrett {'G', 'B', 'F', 'F'} - Walze 3 {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'}; - Walze 2 {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'}; - Walze 1 {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'}; - Reflektor {'E', 'J', 'M', 'Z', 'A', 'L', 'Y', 'X', 'V', 'B', 'W', 'F', 'C', 'R', 'Q', 'U', 'O', 'N', 'T', 'S', 'P', 'I', 'K', 'H', 'G', 'D'}; + Alphabet "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z" + Steckbrett "W S L V H Y G I X A" + Steckbrett "J E F B K P M Q U C" + + Walze 3 "E K M F L G D Q V Z N T O W Y H X U S P A I B R C J" + Walze 2 "V Z B R G I T Y U P S D N H L X A W M J Q O F E C K" + Walze 1 "A J D K S I R U X B L H W T M C Q G Z N P Y F V O E" + Reflektor "E J M Z A L Y X V B W F C R Q U O N T S P I K H G D" */ char result; @@ -52,13 +53,17 @@ public class HardwareTest { h.getSteckbrett().setzeVertauschung('D', 'F'); h.getSteckbrett().setzeVertauschung('I', 'L'); h.getSteckbrett().setzeVertauschung('M', 'Q'); - h.getSteckbrett().setzeVertauschung('T', 'X'); + h.getSteckbrett().setzeVertauschung('N', 'X'); + h.getSteckbrett().setzeVertauschung('K', 'Y'); + h.getSteckbrett().setzeVertauschung('U', 'Z'); + h.getSteckbrett().setzeVertauschung('A', 'O'); + h.getSteckbrett().setzeVertauschung('E', 'S'); result = h.codiere('I'); - Assert.assertEquals("Codiere: Erwartet F, erhalten " + result, 'D', result); + Assert.assertEquals("Codiere: I Erwartet F, erhalten " + result, 'D', result); h.resetWalzen(); result = h.codiere('D'); - Assert.assertEquals("Codiere: Erwartet I, erhalten " + result, 'I', result); + Assert.assertEquals("Codiere: D Erwartet I, erhalten " + result, 'I', result); } } \ No newline at end of file diff --git a/src/test/java/projekt/enigma/model/WalzeTest.java b/src/test/java/projekt/enigma/model/WalzeTest.java index 7a898dd9c28224efe22df8d49726af786ed9e3db..ce8cdbc4fd5a5c59769e260244e149001d410def 100644 --- a/src/test/java/projekt/enigma/model/WalzeTest.java +++ b/src/test/java/projekt/enigma/model/WalzeTest.java @@ -10,22 +10,22 @@ public class WalzeTest { @Test public void setRingstellung() { Walze w = new Walze(1, 1); - char temp = w.getAnzeige(); + char temp = w.getPosition(); Assert.assertEquals('A', temp); } @Test public void dreheWalze() { - Walze w = new Walze(1, 3); - assertFalse("false erwartet, true geliefert", w.dreheWalze(2)); - char temp = w.getAnzeige(); - Assert.assertEquals("C erwartet, " + temp + " zurück gegeben", 'C', temp); + Walze w = new Walze(1, 4); + assertFalse("false erwartet, true geliefert", w.dreheWalze(1)); + char temp = w.getPosition(); + Assert.assertEquals("B erwartet, " + temp + " zurück gegeben", 'B', temp); } @Test - public void getAnzeige() { + public void getPosition() { Walze w = new Walze(1, 1); - char temp = w.getAnzeige(); + char temp = w.getPosition(); Assert.assertEquals('A', temp); }