diff --git a/pom.xml b/pom.xml
index ccec90007b7180a0e5217dd1c67323f132d5f920..b89e09f4aa5adf8ff897397c06d63c055cb4c5f9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -25,6 +25,12 @@
<artifactId>javafx-fxml</artifactId>
<version>${use.javafx.version}</version>
</dependency>
+ <!-- https://mvnrepository.com/artifact/net.sourceforge.plantuml/plantuml -->
+ <dependency>
+ <groupId>net.sourceforge.plantuml</groupId>
+ <artifactId>plantuml</artifactId>
+ <version>8059</version>
+ </dependency>
<!-- https://mvnrepository.com/artifact/org.xerial/sqlite-jdbc -->
<dependency>
<groupId>org.xerial</groupId>
diff --git a/src/main/java/Enigma/App.java b/src/main/java/Enigma/App.java
index d166be1527024b2dbcf6c3d3c7442fd8e6cc3dc4..005c44a50e3583b6839306fbc21aeb640ebbb8e9 100644
--- a/src/main/java/Enigma/App.java
+++ b/src/main/java/Enigma/App.java
@@ -7,11 +7,7 @@ import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;
import org.apache.http.HttpException;
-
import java.io.IOException;
-import java.sql.SQLException;
-import java.time.LocalDate;
-import java.time.ZoneId;
/**
* JavaFX App
@@ -19,8 +15,7 @@ import java.time.ZoneId;
public class App extends Application {
private static Scene scene;
- private Codebuch cb;
- private Hardware h;
+ private Codierer c;
static void setRoot(String fxml) throws IOException {
scene.setRoot(loadFXML(fxml));
@@ -41,72 +36,29 @@ public class App extends Application {
stage.setScene(scene);
stage.show();
- initialisiereHardware();
+ this.c = new Codierer();
/**
* TODO: Nur zum Testen muss später wieder gelöscht werden.
*/
//region Test
- h.setKenngruppe("deisold");
+ c.setKenngruppe("deisold");
String nachricht = "Hello world.";
for (char buchstabe : nachricht.toCharArray()) {
- System.out.print(buchstabe + ":");
- System.out.print(h.codiere(buchstabe));
- System.out.println(" W1:" + h.getWalzen()[0].getBuchstabe() + " W2:" + h.getWalzen()[1].getBuchstabe() + " W3:" + h.getWalzen()[2].getBuchstabe());
+ if(buchstabe > 0) {
+ System.out.print(buchstabe + ":");
+ System.out.print(c.getHardware().codiere(buchstabe));
+ System.out.println(" W1:" + c.getHardware().getWalzen()[0].getBuchstabe() + " W2:" + c.getHardware().getWalzen()[1].getBuchstabe() + " W3:" + c.getHardware().getWalzen()[2].getBuchstabe());
+ }
}
try {
- System.out.println(h.getNachricht());
- h.sendeNachricht();
+ System.out.println(c.getNachricht());
+ c.sendeNachricht();
} catch (HttpException e) {
e.printStackTrace();
}
//endregion
}
- /**
- * 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.
- * <p>
- * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und
- * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben.
- * <p>
- * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen
- * Codebuch Eintrag.
- */
- private void initialisiereHardware() {
-
- // Hole den heutigen Eintrag aus der SQLite Datenbank und erstelle daraus ein Codebuch Objekt
- try {
- this.cb = new DatenbankSqlite().getCodebuch(LocalDate.now(ZoneId.of("Europe/Berlin")).getDayOfMonth());
- } catch (SQLException ignored) {
- }
-
- // TODO: Was zum Henker macht der hier????!?
- System.out.println(this.cb.toString());
-
- // Das Steckbrett initialisieren
- Steckbrett sb = new Steckbrett();
- char[][] verbinder = cb.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.h = new Hardware();
-
- // Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen
- h.setWalzen(0, cb.getWalzenlage()[0], cb.getRingstellung()[0]);
- h.setWalzen(1, cb.getWalzenlage()[1], cb.getRingstellung()[1]);
- h.setWalzen(2, cb.getWalzenlage()[2], cb.getRingstellung()[2]);
-
- // Der Hardware das gesetzte Steckbrett zuweisen
- h.setSteckbrett(sb);
-
- // Ein Reflektor Objekt erstellen und der Hardware bekannt geben
- h.setReflektor(new Reflektor());
- }
-
}
\ No newline at end of file
diff --git a/src/main/java/Enigma/GuiController.java b/src/main/java/Enigma/GuiController.java
index 3bfb5056ad2d8ed737f883004b0f7747c0ed5dea..c5bb75c83804ac83e6f39aeebc35bbdcded0f63c 100644
--- a/src/main/java/Enigma/GuiController.java
+++ b/src/main/java/Enigma/GuiController.java
@@ -5,6 +5,7 @@ import javafx.scene.control.*;
import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
import java.util.ArrayList;
public class GuiController {
@@ -133,6 +134,7 @@ public class GuiController {
@FXML
void gedrueckteTaste() {
+
}
@FXML
@@ -226,25 +228,142 @@ public class GuiController {
assert tfKenngruppe != null : "fx:id=\"tfKenngruppe\" was not injected: check your FXML file 'gui.fxml'.";
assert mBtnNotchPos1 != null : "fx:id=\"mBtnNotchPos1\" was not injected: check your FXML file 'gui.fxml'.";
+ // ActionListener den Butten hinzufügen
+ btnA.setOnAction(e -> {gedrueckteTaste(e);});
+ btnB.setOnAction(e -> {gedrueckteTaste(e);});
+ btnC.setOnAction(e -> {gedrueckteTaste(e);});
+ btnD.setOnAction(e -> {gedrueckteTaste(e);});
+ btnE.setOnAction(e -> {gedrueckteTaste(e);});
+ btnF.setOnAction(e -> {gedrueckteTaste(e);});
+ btnG.setOnAction(e -> {gedrueckteTaste(e);});
+ btnH.setOnAction(e -> {gedrueckteTaste(e);});
+ btnI.setOnAction(e -> {gedrueckteTaste(e);});
+ btnJ.setOnAction(e -> {gedrueckteTaste(e);});
+ btnK.setOnAction(e -> {gedrueckteTaste(e);});
+ btnL.setOnAction(e -> {gedrueckteTaste(e);});
+ btnM.setOnAction(e -> {gedrueckteTaste(e);});
+ btnN.setOnAction(e -> {gedrueckteTaste(e);});
+ btnO.setOnAction(e -> {gedrueckteTaste(e);});
+ btnP.setOnAction(e -> {gedrueckteTaste(e);});
+ btnQ.setOnAction(e -> {gedrueckteTaste(e);});
+ btnR.setOnAction(e -> {gedrueckteTaste(e);});
+ btnS.setOnAction(e -> {gedrueckteTaste(e);});
+ btnT.setOnAction(e -> {gedrueckteTaste(e);});
+ btnU.setOnAction(e -> {gedrueckteTaste(e);});
+ btnV.setOnAction(e -> {gedrueckteTaste(e);});
+ btnW.setOnAction(e -> {gedrueckteTaste(e);});
+ btnX.setOnAction(e -> {gedrueckteTaste(e);});
+ btnY.setOnAction(e -> {gedrueckteTaste(e);});
+ btnZ.setOnAction(e -> {gedrueckteTaste(e);});
+ }
+
+ /**
+ * Auswertung welcher Button gedrückt wurde
+ * @param e => ActionEvent des auslösenden Button
+ */
+ private void gedrueckteTaste(javafx.event.ActionEvent e) {
+ //TODO Anbindung an Klasse Hardware
+ if (e.getSource() == btnA) System.out.println("Taste A gedrückt");
+ if (e.getSource() == btnB) System.out.println("Taste B gedrückt");
+ if (e.getSource() == btnC) System.out.println("Taste C gedrückt");
+ if (e.getSource() == btnD) System.out.println("Taste D gedrückt");
+ if (e.getSource() == btnE) System.out.println("Taste E gedrückt");
+ if (e.getSource() == btnF) System.out.println("Taste F gedrückt");
+ if (e.getSource() == btnG) System.out.println("Taste G gedrückt");
+ if (e.getSource() == btnH) System.out.println("Taste H gedrückt");
+ if (e.getSource() == btnI) System.out.println("Taste I gedrückt");
+ if (e.getSource() == btnJ) System.out.println("Taste J gedrückt");
+ if (e.getSource() == btnK) System.out.println("Taste K gedrückt");
+ if (e.getSource() == btnL) System.out.println("Taste L gedrückt");
+ if (e.getSource() == btnM) System.out.println("Taste M gedrückt");
+ if (e.getSource() == btnN) System.out.println("Taste N gedrückt");
+ if (e.getSource() == btnO) System.out.println("Taste O gedrückt");
+ if (e.getSource() == btnP) System.out.println("Taste P gedrückt");
+ if (e.getSource() == btnQ) System.out.println("Taste Q gedrückt");
+ if (e.getSource() == btnR) System.out.println("Taste R gedrückt");
+ if (e.getSource() == btnS) System.out.println("Taste S gedrückt");
+ if (e.getSource() == btnT) System.out.println("Taste T gedrückt");
+ if (e.getSource() == btnU) System.out.println("Taste U gedrückt");
+ if (e.getSource() == btnV) System.out.println("Taste V gedrückt");
+ if (e.getSource() == btnW) System.out.println("Taste W gedrückt");
+ if (e.getSource() == btnX) System.out.println("Taste X gedrückt");
+ if (e.getSource() == btnY) System.out.println("Taste Y gedrückt");
+ if (e.getSource() == btnZ) System.out.println("Taste Z gedrückt");
+ }
+
+ /**
+ * Setzt die Anzeige des entsprechende Gui-Element auf die entsprechende Walze
+ * ->d.h. welche Walze sitzt auf welcher Position
+ *
+ * @param walze => gibt die Walzennummer an (entspricht
+ * @param position => gibt die Position der Walze (entspricht
+ */
+ public void setzeWalze(int walze, int position){
+ switch (position){
+ case 1:
+ mBtnWalzPos1.setText(str[position]);
+ break;
+ case 2:
+ mBtnWalzPos2.setText(str[position]);
+ break;
+ case 3:
+ mBtnWalzPos3.setText(str[position]);
+ break;
+ default:
+ break;
+ }
}
-// /**
-// * Setzt die Anzeige des entsprechende Gui-Element auf die entsprechende Walze
-// *
-// * @param walze => gibt die Walzennummer an (entspricht
-// * @param position => gibt die Position der Walze (entspricht
-// */
-// public void setzeWalze(int walze, int position){
-// switch (position){
-// case 1:
-// // mBtnWalzPos1.setText();
-// break;
-// case 2:
-// break;
-// case 3:
-// 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 walze => gibt die walze an
+ * @param position => gibt den notch der Walze (walze) an
+ */
+ public void setzeRing(int walze, int position){
+ switch (walze){
+ case 1:
+ mBtnNotchPos1.setText(num[position]);
+ break;
+ case 2:
+ mBtnNotchPos2.setText(num[position]);
+ break;
+ case 3:
+ mBtnNotchPos3.setText(num[position]);
+ 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
+ */
+ public 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
+ */
+ public void setzeTagesSchluessel(String tagesSchluessel){
+ //TODO Benötige TestString aus der DB Codebuch
+ }
}
diff --git a/src/main/java/Enigma/model/Codebuch.java b/src/main/java/Enigma/model/Codebuch.java
index 60f699eb693909af145a24a1d2d376a7446807d5..ee7b96e0aa0af4d2e3a48a12f88631c039944a2c 100644
--- a/src/main/java/Enigma/model/Codebuch.java
+++ b/src/main/java/Enigma/model/Codebuch.java
@@ -19,7 +19,7 @@ package Enigma.model;
public class Codebuch {
private int tag;
private int[] walzenlage;
- private char[] ringstellung;
+ private int[] ringstellung;
private char[][] steckverbindung;
/**
@@ -33,10 +33,10 @@ public class Codebuch {
*/
public Codebuch() {
this.walzenlage = new int[3];
- this.ringstellung = new char[3];
+ this.ringstellung = new int[3];
this.steckverbindung = new char[10][];
- for(int i = 0; i < 10; i++) {
+ for (int i = 0; i < 10; i++) {
this.steckverbindung[i] = new char[2];
this.steckverbindung[i][0] = 'A';
this.steckverbindung[i][1] = 'A';
@@ -69,7 +69,7 @@ public class Codebuch {
sb.append("\n");
sb.append("Ringstellung: ");
- for (char rs : this.getRingstellung()) {
+ for (int rs : this.getRingstellung()) {
sb.append(rs).append(",");
rsLoop = true;
}
@@ -79,11 +79,9 @@ public class Codebuch {
sb.append("\n");
sb.append("Steckverbindung: ");
- for (char[] s : this.getSteckverbindung()) {
- if (Character.isLetter(s[0])) {
- sb.append(s[0]).append(":").append(s[1]).append(",");
- svLoop = true;
- }
+ for (char[] verbindung : this.getSteckverbindung()) {
+ sb.append(verbindung[0]).append(":").append(verbindung[1]).append(",");
+ svLoop = true;
}
if (svLoop) {
sb.setLength(sb.length() - 1);
@@ -125,7 +123,7 @@ public class Codebuch {
*
* @return String[] : Ringstellung
*/
- public char[] getRingstellung() {
+ public int[] getRingstellung() {
return ringstellung;
}
@@ -141,15 +139,16 @@ public class Codebuch {
/**
* Setzt die Steckverbindung dieser Instanz
*
- * @param steckverbindung : String[] : Die Steckverbindungen die gesteckt werden sollen.
+ * @param kabel : String[] : Die Steckverbindungen die gesteckt werden sollen.
* Jeder Eintrag im Array ist ein String mit zwei Zeichen.
* Diese werden in zwei char zerlegt und anschließend im globalen
* Array gespeichert.
*/
- public void setSteckverbindung(String[] steckverbindung) {
+ public void setSteckverbindung(String[] kabel) {
int counter = 0;
- char[] verbindung = new char[2];
- for (String stecker : steckverbindung) {
+
+ for (String stecker : kabel) {
+ char[] verbindung = new char[2];
verbindung[0] = stecker.charAt(0);
verbindung[1] = stecker.charAt(1);
this.steckverbindung[counter++] = verbindung;
@@ -172,7 +171,7 @@ public class Codebuch {
* @param position : int : Auf welche Walze wird der Ring aufgesetzt?
* @param ringstellung : char : An dieser Position soll die nächste Walze weiter gedreht werden.
*/
- public void setRingstellung(int position, char ringstellung) {
+ public void setRingstellung(int position, int ringstellung) {
this.ringstellung[position] = ringstellung;
}
}
diff --git a/src/main/java/Enigma/model/Codierer.java b/src/main/java/Enigma/model/Codierer.java
new file mode 100644
index 0000000000000000000000000000000000000000..dfc7d673e2c8d659177a968a1b1f9576bbc33823
--- /dev/null
+++ b/src/main/java/Enigma/model/Codierer.java
@@ -0,0 +1,188 @@
+package Enigma.model;
+
+import org.apache.http.HttpException;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.util.Random;
+
+public class Codierer {
+
+ private String spruchschluessel;
+ private String kenngruppe;
+ private String nachricht;
+ private Hardware hardware;
+ private Codebuch codebuch;
+
+ public Codierer() {
+ this.nachricht = "";
+ initialisiereHardware();
+ }
+
+ /**
+ * 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.
+ * <p>
+ * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und
+ * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben.
+ * <p>
+ * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen
+ * Codebuch Eintrag.
+ */
+ private void initialisiereHardware() {
+
+ // Hole den heutigen Eintrag aus der SQLite Datenbank und erstelle daraus ein Codebuch Objekt
+ try {
+ this.codebuch = new DatenbankSqlite().getCodebuch(LocalDate.now(ZoneId.of("Europe/Berlin")).getDayOfMonth());
+ } catch (SQLException ignored) {
+ }
+
+ // Das Steckbrett initialisieren
+ Steckbrett sb = new Steckbrett();
+ char[][] verbinder = 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
+ hardware.setWalzen(0, codebuch.getWalzenlage()[0], codebuch.getRingstellung()[0]);
+ hardware.setWalzen(1, codebuch.getWalzenlage()[1], codebuch.getRingstellung()[1]);
+ hardware.setWalzen(2, codebuch.getWalzenlage()[2], codebuch.getRingstellung()[2]);
+
+ // Der Hardware das gesetzte Steckbrett zuweisen
+ hardware.setSteckbrett(sb);
+
+ // Ein Reflektor Objekt erstellen und der Hardware bekannt geben
+ hardware.setReflektor(new Reflektor());
+ }
+
+ /**
+ * Hier wird ein neuer Spruchschlüssel generiert.
+ * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem
+ * Tagesschlüssel codiert, hinzugefügt.
+ *
+ * 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.
+ *
+ * Dies wir nun so lange gemacht bis der Spruchschlüssel eine länge von drei Zeichen hat.
+ */
+ public void spruchSchluessel() {
+ while(this.spruchschluessel.length() < 3) {
+ String temp = this.randomBuchstabe();
+ if(!this.spruchschluessel.contains(temp)) {
+ this.spruchschluessel += temp;
+ }
+ }
+ }
+
+ /**
+ * 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() {
+ Random r = new Random();
+ String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ char buchstabe = 'X';
+
+ for (int i = 0; i < alphabet.length(); i++) {
+ buchstabe = alphabet.charAt(r.nextInt(alphabet.length()));
+ }
+
+ return String.valueOf(buchstabe);
+ }
+
+ /**
+ * 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 {
+ new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(this.nachricht), this.kenngruppe);
+ }
+
+ /**
+ * Gibt die letzte empfangene Nachricht zurück
+ * <p>
+ * String[0} Tag wann die Nachricht gesendet wurde
+ * String[1] = Die verschlüsselte Nachricht
+ * String[2] = Nachricht im Klartext
+ */
+ public String[] empfangeNachricht() {
+ String[] codierteNachricht = new String[3];
+ Morsecode mc = new Morsecode();
+
+ try {
+ codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
+ String morsecode = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
+ String decodiert = "";
+
+ for (char buchstabe : morsecode.toCharArray()) {
+ decodiert += this.hardware.codiere(buchstabe);
+ }
+
+ codierteNachricht[2] = decodiert;
+
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ return codierteNachricht;
+ }
+
+ /**
+ * 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;
+ }
+
+ /**
+ * 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;
+ }
+
+ /**
+ * Gibt die bisher erstellte Nachricht zurück
+ *
+ * @return String : Erstellte Nachricht
+ */
+ public String getNachricht() {
+ return nachricht;
+ }
+
+ /**
+ * Gibt das Hardware Objekt zurück
+ *
+ * @return Hardware
+ */
+ public Hardware getHardware() {
+ return hardware;
+ }
+
+ /**
+ * Setzt ein neues Hardware Objekt
+ *
+ * @param hardware : Hardware
+ */
+ public void setHardware(Hardware hardware) {
+ this.hardware = hardware;
+ }
+}
diff --git a/src/main/java/Enigma/model/DatenbankSqlite.java b/src/main/java/Enigma/model/DatenbankSqlite.java
index 51f34c1bf1c59f343bb5ef7ea9123133995defdb..236b2bbeb90acf80cf2f127a627c5236e3757867 100644
--- a/src/main/java/Enigma/model/DatenbankSqlite.java
+++ b/src/main/java/Enigma/model/DatenbankSqlite.java
@@ -57,13 +57,13 @@ public class DatenbankSqlite {
cb.setTag(rs.getInt("Tag"));
walzenlage = rs.getString("Walzenlage").split(",");
- for(int i = 0; i < 3; i++) {
+ for (int i = 0; i < 3; i++) {
cb.setWalzenlage(i, Integer.parseInt(walzenlage[i]));
}
ringstellung = rs.getString("Ringstellung").split(",");
- for(int i = 0; i < 3; i++) {
- cb.setRingstellung(i, ringstellung[i].charAt(0));
+ for (int i = 0; i < 3; i++) {
+ cb.setRingstellung(i, Integer.parseInt(ringstellung[i]));
}
cb.setSteckverbindung(rs.getString("Steckverbindung").split(","));
@@ -137,26 +137,30 @@ public class DatenbankSqlite {
/**
* Generiert einen String aus 10 * 2 unterschiedlichen Großbuchstaben
* @return String => 10 Buchstabenkombinationen mit Komma getrennt
- */
- /*
- private static String steckverbindung(){
- Random rnd = new Random();
- String steckverbindung="";
- char[] c = new char[2];
- for (int i = 0; i < 10; i++) {
- for (int j = 0; j < 2; j++) {
- c[j]= (char) (rnd.nextInt(26) + 'A');
- if (j==1) {
- while (c[0] == c[j]) {
- c[j] = (char) (rnd.nextInt(26) + 'A');
- }
- }
- }
- System.out.println(c[0]+" / "+c[1]);
- steckverbindung+= ((""+c[0]) + (""+c[1]) +",");
- }
- steckverbindung= (String) steckverbindung.subSequence(0,steckverbindung.lastIndexOf(","));
- return steckverbindung;
- }*/
+ *//*
+ private static String steckverbindung(){
+ Random rnd = new Random();
+ String steckverbindung="";
+
+
+ char[] c = new char[20];
+ for (int i = 0; i < 20; i++) {
+ c[i] = (char) (rnd.nextInt(26) + 'A');
+ for (int j = i; j >= 0; j--) {
+ if (i>j) {
+ while (c[i]==c[j]) {
+ c[i] = (char) (rnd.nextInt(26) + 'A');
+ j= i-1;
+ }
+ }
+ }
+ }
+ steckverbindung = ((""+c[0]) + (""+c[1]) +"," +(""+c[2]) +(""+c[3]) + ","+(""+c[4]) +(""+c[5]) + ","+(""+c[6]) +(""+c[7]) + ","
+ +(""+c[8]) +(""+c[9]) + ","+(""+c[10]) +(""+c[11]) + ","+(""+c[12]) +(""+c[13]) + ","+(""+c[14]) +(""+c[15]) + ","+(""+c[16]) +(""+c[17]) + ","
+ +(""+c[18]) +(""+c[19]));
+ // System.out.println(steckverbindung);
+ // steckverbindung= (String) steckverbindung.subSequence(0,steckverbindung.lastIndexOf(","));
+ return steckverbindung;
+ }*/
//endregion
}
diff --git a/src/main/java/Enigma/model/Hardware.java b/src/main/java/Enigma/model/Hardware.java
index efb0517db59ec4ed9e56a381b05d623aa4fd6004..8b1674a30fab0fa501d21942d83e330619d5f0db 100644
--- a/src/main/java/Enigma/model/Hardware.java
+++ b/src/main/java/Enigma/model/Hardware.java
@@ -3,6 +3,7 @@ package Enigma.model;
import org.apache.http.HttpException;
import java.io.IOException;
+import java.util.Random;
/**
* In dieser Klasse wird die Hardware zusammen gefasst.
@@ -22,8 +23,6 @@ public class Hardware {
private Walze[] walzen;
private Steckbrett steckbrett;
private Reflektor reflektor;
- private String nachricht;
- private String kenngruppe;
/**
* Im Konstruktor legen wir die Anzahl der Walzen fest welche die Hardware aufnehmen kann.
@@ -39,7 +38,8 @@ public class Hardware {
* @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) {
+ public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) {
+ this.walzen[walze] = new Walze(walzenNr, ringstellung);
}
/**
@@ -49,6 +49,7 @@ public class Hardware {
* @param position : int : Umspringpunkt auf der Walze
*/
public void setzeRing(int walze, int position) {
+ this.walzen[walze].setRingstellung(position);
}
/**
@@ -58,27 +59,7 @@ public class Hardware {
* @param buchstabe : char : Buchstabe der zugewiesen soll
*/
public void setzePosition(int walze, char buchstabe) {
- }
-
- /**
- * 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 {
- new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(this.nachricht), this.kenngruppe);
- }
-
- /**
- * Gibt die letzte empfangene Nachricht zurück
- * <p>
- * String[0] = Die verschlüsselte Nachricht
- * String[1] = Nachricht im Klartext
- */
- public String[] empfangeNachricht() {
-
- return new String[2];
+ this.walzen[walze].setBuchstabe(buchstabe);
}
/**
@@ -88,6 +69,8 @@ public class Hardware {
* @return char : Der ver/entschlüsselte Buchstabe
*/
public char codiere(char buchstabe) {
+ this.dreheWalzen();
+
buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
buchstabe = this.walzen[0].codiere(buchstabe);
buchstabe = this.walzen[1].codiere(buchstabe);
@@ -98,10 +81,6 @@ public class Hardware {
buchstabe = this.walzen[0].codiere2(buchstabe);
buchstabe = this.steckbrett.codiere(buchstabe);
- this.dreheWalzen();
-
- this.nachricht += buchstabe;
-
return buchstabe;
}
@@ -176,31 +155,5 @@ public class Hardware {
this.reflektor = reflektor;
}
- /**
- * 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;
- }
-
- /**
- * 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;
- }
- /**
- * Gibt die bisher erstellte Nachricht zurück
- *
- * @return String : Erstellte Nachricht
- */
- public String getNachricht() {
- return nachricht;
- }
}
diff --git a/src/main/java/Enigma/model/Morsecode.java b/src/main/java/Enigma/model/Morsecode.java
index 38e2b1febd8d01994fd91365184f0d6c420ffe2c..67284f5d4103ff37ddbaa2fdb48ff40b4c63de61 100644
--- a/src/main/java/Enigma/model/Morsecode.java
+++ b/src/main/java/Enigma/model/Morsecode.java
@@ -42,6 +42,17 @@ public class Morsecode {
this.codeMap.put("X", "-..-");
this.codeMap.put("Y", "-.--");
this.codeMap.put("Z", "--..");
+ this.codeMap.put(" ", "-...-");
+ this.codeMap.put("1", ".----");
+ this.codeMap.put("2", ".----");
+ this.codeMap.put("3", "...--");
+ this.codeMap.put("4", "....-");
+ this.codeMap.put("5", ".....");
+ this.codeMap.put("6", "-....");
+ this.codeMap.put("7", "--...");
+ this.codeMap.put("8", "---..");
+ this.codeMap.put("9", "----.");
+ this.codeMap.put("0", "-----");
}
/**
diff --git a/src/main/resources/Enigma/codebuch.sqlite b/src/main/resources/Enigma/codebuch.sqlite
index 78be5227db85283c0c20e3719303cb77e48e8cbf..018731d4221da62ff7e8702ce5f52833bccbea05 100644
Binary files a/src/main/resources/Enigma/codebuch.sqlite and b/src/main/resources/Enigma/codebuch.sqlite differ
diff --git a/src/test/java/Enigma/model/CodebuchTest.java b/src/test/java/Enigma/model/CodebuchTest.java
index aa64deaa3f9c17f57767b284a452cf00149c923d..ce6a4f75f740e9ac93b1bd2b160444047bab133a 100644
--- a/src/test/java/Enigma/model/CodebuchTest.java
+++ b/src/test/java/Enigma/model/CodebuchTest.java
@@ -11,7 +11,7 @@ public class CodebuchTest {
String expected = "Tag: 1\n" +
"Walzenlage: 1,3,2\n" +
"Ringstellung: 16,11,13\n" +
- "Steckverbindung: CO,DI,FR,HU,JW,LS,TX\n";
+ "Steckverbindung: E:U,O:H,T:Z,A:S,M:R,I:V,C:G,F:Q,B:X,Y:K\n";
try {
// Ausgabe auf der Konsole