Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • d.eisold/enigma
  • Janschubi1993/enigma
  • TsunamiKlaus/enigma
  • alfatrainingkurse/java/enigma
  • FloriN/enigma
  • PaoloPinkel/enigma
6 results
Show changes
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 1489 additions and 272 deletions
src/main/java/projekt/enigma/model/Morsecode.java 0 → 100644
View file @ 6cfa05da
package projekt.enigma.model;
import java.util.Map.Entry;
import java.util.TreeMap;
/**
* Diese Klasse definiert die Zugehoerigkeit zwischen den Buchstaben A-Z und dem Morsecode.
* Die Funktionen sollen Texte von und zu Morsecode konvertieren.
*/
public class Morsecode {
/**
* Anlegen der codeMap als TreeMap.
*/
private TreeMap<String, String> codeMap;
/**
* Im Konstruktor werden alle verfuegbaren Buchstaben (A-Z) und deren zugehoerigen
* Morsecodes, der codeMap hinzugefuegt.
*/
public Morsecode() {
codeMap = new TreeMap<>();
this.codeMap.put("A", ".-");
this.codeMap.put("B", "-...");
this.codeMap.put("C", "-.-.");
this.codeMap.put("D", "-..");
this.codeMap.put("E", ".");
this.codeMap.put("F", "..-.");
this.codeMap.put("G", "--.");
this.codeMap.put("H", "....");
this.codeMap.put("I", "..");
this.codeMap.put("J", ".---");
this.codeMap.put("K", "-.-");
this.codeMap.put("L", ".-..");
this.codeMap.put("M", "--");
this.codeMap.put("N", "-.");
this.codeMap.put("O", "---");
this.codeMap.put("P", ".--.");
this.codeMap.put("Q", "--.-");
this.codeMap.put("R", ".-.");
this.codeMap.put("S", "...");
this.codeMap.put("T", "-");
this.codeMap.put("U", "..-");
this.codeMap.put("V", "...-");
this.codeMap.put("W", ".--");
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", "-----");
}
/**
* Diese Funktion ueberprueft ob der uebergebene Buchstabe in der codeMap enthalten ist.
* Wenn er enthalten ist, wird der zugehoerige Morsecode zurueck gegeben, ansonsten null.
*
* @param buchstabe : char : Zu uebersetzender Buchstabe.
* @return String : Der zugehoerige Morsecode aus der codeMap.
*/
private String getMorsecode(char buchstabe) {
return this.codeMap.getOrDefault(String.valueOf(buchstabe).toUpperCase(), null);
}
/**
* Der uebergebene String wird in seine einzelnen Zeichen (char) zerlegt und an die Funktion getMorsecode
* uebergeben und der zugehoerige Morsecode rausgesucht.
* Mittels eines StringBuilders werden die Ergebnisse zu einem Rueckgabe-String zusammengesetzt.
* Wenn kein zugehoeriger Code in der codeMap gefunden wurde, wird das Zeichen ignoriert da es bei der
* Enigma nicht vorhanden war.
*
* @param input : String : Zu konvertierender Text.
* @return String : Der in Morsecode konvertierte Text.
*/
public String convertBuchstabeToMorsecode(String input) {
StringBuilder sb = new StringBuilder();
String morsecode;
// Durch alle char im uebergebenen String loopen
for (int i = 0; i < input.length(); i++) {
morsecode = this.getMorsecode(input.charAt(i));
if (morsecode != null) {
sb.append(morsecode).append(' ');
}
}
return sb.toString();
}
/**
* Diese Funktion ueberprueft ob der uebergebene Morsecode in der codeMap enthalten ist.
* Wenn er enthalten ist, wird der zugehoerige Buchstabe zurueckgegeben, ansonsten null.
*
* @param morsecode : String : Der zu uebersetzende Morsecode.
* @return : String : Der zugehoerige Buchstabe aus der codeMap.
*/
private String getBuchstabe(String morsecode) {
String result = null;
// Loopt duch die codeMap und erstellt daraus ein Set
for (Entry<String, String> entry : this.codeMap.entrySet()) {
if (entry.getValue().equals(morsecode)) {
result = entry.getKey();
}
}
return result;
}
/**
* Der uebergebene String wird in ein String-Array zerlegt. Als Trennzeichen wird das Leerzeichen genutzt.
* Anschließend wird das Array durchlaufen und die Elemente an die Funktion getBuchstabe uebergeben um den
* zugehoerigen Buchstaben zu erhalten.
* Mittels eines StringBuilders werden die Ergebnisse zu einem Rueckgabe String zusammengesetzt.
* Wenn kein zugehoeriger Buchstabe in der codeMap gefunden wurde, wird das Zeichen ignoriert, da es bei der
* Enigma nicht vorhanden war.
*
* @param input : String : Zu konvertierender Morsecode.
* @return String : Der in Text konvertierte Morsecode.
*/
public String convertMorsecodeToBuchstabe(String input) {
StringBuilder sb = new StringBuilder();
String buchstabe;
String[] morsecodes = input.split(" ");
// Durch alle char im uebergebenen String loopen
for (String morsecode : morsecodes) {
buchstabe = this.getBuchstabe(morsecode);
if (buchstabe != null) {
sb.append(buchstabe);
}
}
return sb.toString();
}
}
src/main/java/projekt/enigma/model/Reflektor.java 0 → 100644
View file @ 6cfa05da
package projekt.enigma.model;
/**
* Klasse Reflektor
* <br>
* Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und codiert diesen.
* Der codierte Buchstabe wird an die Klasse Walze wieder zurueckgegeben.
* <br>
* Prinzipiell verhaelt sich die Klasse Reflektor wie die Klasse Walze, ausser das sie sich
* nach Betaetigung einer Taste nicht dreht (quasi starr montiert ist) und sie gibt keine Signale
* an andere Walzen zum Drehen.
*/
public class Reflektor {
/**
* Funktion codiere
* <br>
* Durchsucht den String alphabet nach der Position des mitgegebenen Buchstabens und
* gibt den Character an der entsprechenden Position im String reflektor zurueck.
*
* @param buchstabe : Character : der zu codierende Buchstabe.
* @return char : Der codierte Buchstabe aus dem Reflektor.
*/
public char codiere(Character buchstabe) {
String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
String reflektor = "EJMZALYXVBWFCRQUONTSPIKHGD";
return reflektor.charAt(alphabet.indexOf(buchstabe));
}
}
src/main/java/projekt/enigma/model/Steckbrett.java 0 → 100644
View file @ 6cfa05da
package projekt.enigma.model;
/**
* <p>
* Klasse Steckbrett
* <br>
* Das Steckbrett diente dazu, Buchstaben paarweise zu vertauschen noch bevor diese durch die Walzen codiert werden.
* Die Klasse Steckbrett nimmt bis zu 10 paarweise zu vertauschende Buchstabenpaare entgegen, prueft diese auf
* Zulaessigkeit und tauscht diese dann paarweise aus.
*/
public class Steckbrett {
/**
* orginalBuchstaben: String : der jeweils den ersten zu vertauschenden Buchstaben enthaelt.
*/
private String originalBuchstaben;
/**
* getauschteBuchstaben: String : der jeweils den zweiten zu vertauschenden Buchstaben enthaelt.
*/
private String getauschteBuchstaben;
/**
* Konstruktor Steckbrett
* <br>
* Erzeugt zwei Strings und initialisiert diese.
*/
public Steckbrett() {
originalBuchstaben = "";
getauschteBuchstaben = "";
}
/**
* Funktion setzeVertauschung
* <br>
* Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) uebergeben.
* Zuerst wird ueberprueft ob einer der beiden Buchstaben bereits enthalten ist, was unzulaessig waere.
* <br>
* Anschliessend wird:
* <p>
* buchstabe1 dem String orginalBuchstaben angehaengt.
* buchstabe2 dem String getauschteBuchstaben angehaengt.
* </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 zulaessig ist, true, ansonsten false.
*/
public boolean setzeVertauschung(char buchstabe1, char 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 uebergeben.
* Zuerst wird ueberprueft ob einer der beiden Buchstaben bereits enthalten ist, was unzulaessig waere.
* <br>
* Anschliessend wird:
* <p>
* buchstabe1 in den String orginalBuchstaben auf die Position (steckbrettPort) geschrieben.
* buchstabe2 in den String getauschteBuchstaben auf die Position (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 zulaessig ist, true, ansonsten false.
*/
public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
char[] original;
char[] getauscht;
new Fehler().debug("setzeVertauschung(int " + steckbrettPort + ", char |" + buchstabe1 + "|, char |" + buchstabe2 + "|)", false);
if ((!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) ||
(buchstabe1 == ' ' && buchstabe2 == ' ')) {
new Fehler().debug("-> Original:\t" + originalBuchstaben, false);
new Fehler().debug("-> Getauscht:\t" + getauschteBuchstaben, false);
original = originalBuchstaben.toCharArray();
getauscht = getauschteBuchstaben.toCharArray();
original[steckbrettPort] = buchstabe1;
getauscht[steckbrettPort] = buchstabe2;
originalBuchstaben = String.valueOf(original);
getauschteBuchstaben = String.valueOf(getauscht);
new Fehler().debug("<- Original:\t" + originalBuchstaben, false);
new Fehler().debug("<- Getauscht:\t" + getauschteBuchstaben, false);
new Fehler().debug("true\tOS: |" + originalBuchstaben + "| GS: |" + getauschteBuchstaben + "|", false);
return true;
} else {
new Fehler().debug("false\tOS: |" + originalBuchstaben + "| GS: |" + getauschteBuchstaben + "|", false);
return false;
}
}
/**
* Funktion ueberpruefeVertauschungen
* <br>
* Die Funktion ueberpruefeVertauschungen prueft, ob der uebergebene Buchstabe bereits in den beiden Strings
* orginalBuchstaben und getauschteBuchstaben vorhanden ist.
* Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt
* (ein Buchstabe nicht mehrmals vertauscht wird).
*
* @param buchstabe : Character: zu pruefender Buchstabe.
* @return result : boolean : Wenn false, dann darf der Buchstabe genutzt werden. Wenn er schon vorhanden ist,
* wird true zurueckgegeben.
*/
public boolean ueberpruefeVertauschungen(Character buchstabe) {
boolean result = false;
if (originalBuchstaben.contains(String.valueOf(buchstabe)) ||
getauschteBuchstaben.contains(String.valueOf(buchstabe))) {
result = true;
}
return result;
}
/**
* Funktion codiere
* <br>
* Die Funktion codiere tauscht den uebergebenen Character buchstabe mit dem zu tauschenden Character aus.
*
* @param buchstabe : Character : Buchstabe der codiert werden soll.
* @return buchstabe : Character : Codierter Buchstabe.
*/
public char codiere(Character 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;
}
}
/**
* Tauscht die Buchstaben im Alphabet aus und gibt ein modifiziertes Alphabet zurueck.
*
* @param port : int : Platz der getauschten Buchstaben.
* @return alphabet : String : Alphabet mit getauschtem Buchstabenpaar.
*/
public String fetchVerfuegbareBuchstaben(int port) {
String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (char c : this.originalBuchstaben.toCharArray()) {
alphabet = alphabet.replace(String.valueOf(c), "");
}
for (char c : this.getauschteBuchstaben.toCharArray()) {
alphabet = alphabet.replace(String.valueOf(c), "");
}
alphabet += originalBuchstaben.charAt(port);
alphabet += getauschteBuchstaben.charAt(port);
return alphabet;
}
}
\ No newline at end of file
src/main/java/projekt/enigma/model/Walze.java 0 → 100644
View file @ 6cfa05da
package projekt.enigma.model;
/**
* Klasse Walze
* <br>
* Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
* <br>
* 1. Walzennummer (Die Walze enthaelt die 26 Buchstaben des Alphabets und codiert diese.
* Fuenf verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabets
* vertauschen).
* <br>
* 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
* den Drehzeitpunkt der linken Nachbarwalze).
*/
public class Walze {
//region Variablen
/**
* Die Anzahl der getaetigten Walzendrehungen.
*/
private int turns;
/**
* Das String-Array aller bekannter aktueller Walzen.
*/
private String[] walzen;
/**
* alphabet : String : enthaelt die Buchstaben des Alphabets.
*/
private String alphabet;
/**
* ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt.
*/
private char ringstellung;
/**
* walzenNr : int : Bestimmt, welche Walze genutzt wird.
*/
private int walzenNr;
//endregion
//region Konstruktor
/**
* Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt.
*
* @param walzenNr : int : Nummer der gewaehlten Walze.
* @param ringstellung : int : Einstellung des Umsprungpunktes.
*/
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: Zaehlt die Umdrehungen (turns) um eins 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 zurueck.
* @return checkRing : boolean : gibt true zurueck, wenn der Umspringpunkt erreicht wurde.
*/
boolean dreheWalze(int richtung) {
boolean checkRing = false;
int korrekturFaktor = 0;
if ((richtung == -1) || (richtung == 1)) {
if (richtung == 1) {
this.turns++;
} else {
korrekturFaktor = 1;
this.turns--;
}
// gleicht die Ringstellung mit der aktuellen Position ab
if ((this.alphabet.indexOf(this.getPosition()) + korrekturFaktor) % 26
== this.alphabet.indexOf(this.ringstellung)) {
checkRing = true;
}
}
return checkRing;
}
/**
* Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
*
* @param buchstabe : char : Buchstabe, der verschluesselt werden soll.
* @return char : verschluesselter Buchstabe.
*/
public char codiere(char buchstabe) {
return this.fetchWalze().charAt((this.alphabet.indexOf(buchstabe) + this.turns) % 26);
}
/**
* Decodiert den mitgegebenen Buchstaben anhand des Alphabets.
*
* @param buchstabe : char : Buchstabe, der decodiert werden soll.
* @return char : decodierter Buchstabe.
*/
char codiere2(char buchstabe) {
return this.alphabet.charAt((this.fetchWalze().indexOf(buchstabe) - this.turns + 520) % 26);
}
/**
* @return String : Gibt den Verschluesselungs-String der ausgewaehlten Walze zurueck.
*/
private String fetchWalze() {
return walzen[walzenNr];
}
//endregion
//region Setter
/**
* Setzt die Walzennummer. Es stehen fuenf Walzen zur Auswahl.
*
* @param walzenNr : int : Walzennummer.
*/
private void setWalzenNr(int walzenNr) {
if ((walzenNr > 0) && (walzenNr < 6)) {
this.walzenNr = walzenNr - 1;
} else {
System.err.println("Keine gültige Walzennummer");
}
}
/**
* Setzt die Initiale Ringstellung der Walze.
* Es sind nur Zahlen von 1 - 26 zugelassen.
* <br>
* Die Ringstellung wird zum char umgewandelt.
* Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
*
* @param ringstellung : int : Punkt an dem die Nachbarwalze umspringt.
*/
void setRingstellung(int ringstellung) {
if ((ringstellung > 0) && (ringstellung <= 26)) {
this.ringstellung = this.alphabet.charAt(ringstellung - 1);
} else {
this.ringstellung = 'Z';
}
}
/**
* Stellt die Grundeinstellung der Walze ein.
* Ermittelt, wie oft die Walze gedreht werden muss, bis die Grundeinstellung erreicht ist.
*
* @param buchstabe : Character : Einstellung der Walze.
*/
void setPosition(Character buchstabe) {
this.turns = alphabet.indexOf(buchstabe);
}
//endregion
//region Getter
/**
* Gibt den Buchstaben zurueck, der aktuell in der Walze eingestellt ist.
*
* @return char : Ermittelte Stelle im Alphabet, anhand der aktuellen Anzahl der Drehungen.
*/
Character getPosition() {
return this.alphabet.charAt(turns % 26);
}
/**
* Getter der Walzennummer.
* @return walzenNr : int : gibt Walzennummer zurueck.
*/
int getWalzenNr() {
return this.walzenNr;
}
//endregion
}
\ No newline at end of file
src/main/java/projekt/enigma/view/ChkBoxGridPane.java 0 → 100644
View file @ 6cfa05da
package projekt.enigma.view;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.control.CheckBox;
import javafx.scene.control.ToggleButton;
import javafx.scene.layout.GridPane;
import projekt.enigma.model.Codierer;
import java.util.Arrays;
/**
* Die Klasse ChkBoxGripPane erweitert das GridPane Objekt.
* Wir erstellen ein GridPane in welches Checkboxen gelegt werden.
* Die Anzahl der Checkboxen wird durch die verfuegbarenBuchstaben festgelegt.
* Für jeden Buchstaben in diesem char Array, wird eine Checkbox erstellt und auf das Gridpane gelegt.
*/
public class ChkBoxGridPane extends GridPane {
// Der globale Checkbox Array
private CheckBox[] checkbox;
// Die Buchstaben die für das jeweilige Pane selectiert werden sollen
private String checkedBuchstaben;
// Die Anzahl der möglichen Checkboxen
private int charSize;
// Das Codierer Objekt. Dieses wird benötigt um auf die Funktionen für das Steckbrett zuzugreifen
private Codierer codierer;
// Der Steckbrett Port für welchen das Pane und die Checkboxen erstellt werden sollen
private int port;
// Die verfügbaren Buchstaben für den jeweiligen Port
private char[] verfuegbareBuchstaben;
// Das Button Objekt des Ports über den dieses Pane gesteuert wird
private ToggleButton tBtnPort;
/**
* Hier werfen wir die Checkboxen auf das Gridpane und weißen ihnen die Propertys zu.
* Außerdem wird hier auch der Listener generiert womit wir prüfen ob die maximale Auswahlmöglichkeit
* erreicht ist.
* Es können maximal zwei Checkboxen ausgewählt werden. Wenn zwei erreicht sind, werden die restlichen Checkboxen
* deaktiviert. Wenn nur noch eine oder keine Box ausgewählt ist, werden die restlichen wieder aktiviert.
* Bei null und zwei Boxen, werden die Buchstaben in das Steckbrett geschrieben.
* Andere Auswahlmöglchkeiten stehen nicht zur Verfügung, da ein Kabel nur zwei Enden hat in der Regel.
*
* @param codierer : Codierer Objekt
* @param port : int
* @param tBtnPort : ToogleButton
*/
public ChkBoxGridPane(Codierer codierer, int port, ToggleButton tBtnPort) {
this.codierer = codierer;
this.port = port;
this.tBtnPort = tBtnPort;
this.verfuegbareBuchstaben = this.codierer.fetchVerfuegbareBuchstaben(this.port).toCharArray();
Arrays.sort(this.verfuegbareBuchstaben);
charSize = this.verfuegbareBuchstaben.length;
this.checkedBuchstaben = tBtnPort.getText();
initializeComponents();
}
/**
* Es wird ein GridPane erzeugt, das zwei Spalten und abhängig von der Länge des
* Arrays (Character[] alphabet) Reihen hat. Das Label der CheckBoxen soll
* abhängig von deren Index links bzw. recht erzeugt werden
*/
private void initializeComponents() {
checkbox = new CheckBox[charSize];
this.setAlignment(Pos.CENTER);
// Für jeden verfügbaren Buchstaben einen Durchlauf
for (int i = 0; i < this.verfuegbareBuchstaben.length; i++) {
if (this.verfuegbareBuchstaben[i] != 20 && this.verfuegbareBuchstaben[i] != ' ') {
checkbox[i] = new CheckBox(this.verfuegbareBuchstaben[i] + "");
checkbox[i].setPadding(new Insets(1, 1, 1, 1));
if (!checkedBuchstaben.equals("")) {
if (!checkedBuchstaben.contains(String.valueOf(this.verfuegbareBuchstaben[i]))) {
checkbox[i].setDisable(true);
} else {
checkbox[i].setSelected(true);
}
} else {
checkbox[i].setSelected(false);
checkbox[i].setDisable(false);
}
// Der Listener für die jeweilige Checkbox
checkbox[i].selectedProperty().addListener((observable, oldValue, newValue) -> {
String portSelection = "";
int zaehler = 0;
// Die selektierten Chechkboxen zählen
for (CheckBox cb : checkbox) {
if (cb != null && cb.isSelected()) {
zaehler++;
}
}
// Wenn nur eine oder keine Checkbox ausgewählt ist
if (zaehler == 1 || zaehler == 0) {
for (CheckBox cb : checkbox) {
if (cb != null && cb.isDisabled()) {
cb.setDisable(false);
}
}
}
// Es ist keine Checkbox ausgewählt
if (zaehler == 0) {
// Daten ins Steckbrett schreiben
this.codierer.setzeSteckbrett(this.port, "");
// Und den Button neu beschreiben
tBtnPort.setText(portSelection);
}
// Das Maximum an selektierten Checkboxen (2) ist erreicht
if (zaehler == 2) {
for (CheckBox cb : checkbox) {
if (cb != null && !cb.isSelected()) {
cb.setDisable(true);
} else {
if (cb != null) {
portSelection += cb.getText();
}
}
}
// Daten ins Steckbrett schreiben
this.codierer.setzeSteckbrett(this.port, "");
this.codierer.setzeSteckbrett(this.port, portSelection);
// Und den Button neu beschreiben
tBtnPort.setText(portSelection);
}
});
// Eine neue Row im Gridpane anlegen für den nächsten Button
this.addRow(i + 1);
this.add(checkbox[i], 2, i + 1, 1, 1);
}
}
// Das Pane anzeigen
this.setVisible(true);
}
/**
* Gibt den Anzahl der zur Verfügung stehenden Buchstaben zurück.
* Anhang dieses Wertes, wird die Anzahl der Checkboxen festgelegt.
*
* @return int : Anzahl der möglcihen chars
*/
public int getCharSize() {
return charSize;
}
}
src/main/resources/Enigma/gui.fxml deleted 100644 → 0
View file @ a14a7e2e
<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.control.Button?>
<?import javafx.scene.control.ButtonBar?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.control.MenuButton?>
<?import javafx.scene.control.MenuItem?>
<?import javafx.scene.control.TextField?>
<?import javafx.scene.layout.AnchorPane?>
<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="Enigma.GuiController">
<children>
<TextField layoutX="43.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
<TextField layoutX="112.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
<TextField layoutX="187.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
<TextField layoutX="272.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
<TextField layoutX="346.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
<TextField layoutX="413.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
<TextField layoutX="476.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
<TextField layoutX="544.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
<TextField layoutX="617.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
<TextField layoutX="693.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
<ButtonBar layoutX="31.0" layoutY="570.0" prefHeight="36.0" prefWidth="860.0">
<buttons>
<Button mnemonicParsing="false" text="L" />
<Button mnemonicParsing="false" text="P" />
<Button mnemonicParsing="false" text="Y" />
<Button mnemonicParsing="false" text="X" />
<Button mnemonicParsing="false" text="C" />
<Button mnemonicParsing="false" text="V" />
<Button mnemonicParsing="false" text="B" />
<Button mnemonicParsing="false" text="N" />
<Button mnemonicParsing="false" text="M" />
</buttons>
</ButtonBar>
<ButtonBar layoutX="15.0" layoutY="534.0" prefHeight="36.0" prefWidth="860.0">
<buttons>
<Button mnemonicParsing="false" text="A" />
<Button mnemonicParsing="false" text="S" />
<Button mnemonicParsing="false" text="D" />
<Button mnemonicParsing="false" text="F" />
<Button mnemonicParsing="false" text="G" />
<Button mnemonicParsing="false" text="H" />
<Button mnemonicParsing="false" text="J" />
<Button mnemonicParsing="false" text="K" />
</buttons>
</ButtonBar>
<ButtonBar layoutX="22.0" layoutY="491.0" prefHeight="25.0" prefWidth="583.0">
<buttons>
<Button minWidth="13.0" mnemonicParsing="false" prefHeight="25.0" text="Q" />
<Button mnemonicParsing="false" text="W" />
<Button mnemonicParsing="false" text="E" />
<Button mnemonicParsing="false" text="R" />
<Button mnemonicParsing="false" text="T" />
<Button mnemonicParsing="false" text="Z" />
<Button mnemonicParsing="false" text="U" />
<Button mnemonicParsing="false" text="I" />
<Button mnemonicParsing="false" text="O" />
<Button mnemonicParsing="false" text="Löschen" />
</buttons>
</ButtonBar>
<ButtonBar layoutX="39.0" layoutY="418.0" prefHeight="36.0" prefWidth="860.0">
<buttons>
<Button mnemonicParsing="false" text="L" />
<Button mnemonicParsing="false" text="P" />
<Button mnemonicParsing="false" text="Y" />
<Button mnemonicParsing="false" text="X" />
<Button mnemonicParsing="false" text="C" />
<Button mnemonicParsing="false" text="V" />
<Button mnemonicParsing="false" text="B" />
<Button mnemonicParsing="false" text="N" />
<Button mnemonicParsing="false" text="M" />
</buttons>
</ButtonBar>
<ButtonBar layoutX="23.0" layoutY="382.0" prefHeight="36.0" prefWidth="860.0">
<buttons>
<Button mnemonicParsing="false" text="A" />
<Button mnemonicParsing="false" text="S" />
<Button mnemonicParsing="false" text="D" />
<Button mnemonicParsing="false" text="F" />
<Button mnemonicParsing="false" text="G" />
<Button mnemonicParsing="false" text="H" />
<Button mnemonicParsing="false" text="J" />
<Button mnemonicParsing="false" text="K" />
</buttons>
</ButtonBar>
<ButtonBar layoutX="30.0" layoutY="339.0" prefHeight="25.0" prefWidth="583.0">
<buttons>
<Button minWidth="13.0" mnemonicParsing="false" prefHeight="25.0" text="Q" />
<Button mnemonicParsing="false" text="W" />
<Button mnemonicParsing="false" text="E" />
<Button mnemonicParsing="false" text="R" />
<Button mnemonicParsing="false" text="T" />
<Button mnemonicParsing="false" text="Z" />
<Button mnemonicParsing="false" text="U" />
<Button mnemonicParsing="false" text="I" />
<Button mnemonicParsing="false" text="O" />
</buttons>
</ButtonBar>
<MenuButton fx:id="w1" layoutX="91.0" layoutY="76.0" mnemonicParsing="false" text="I">
<!-- <items>-->
<!-- <MenuItem fx:id="w1I" mnemonicParsing="false" onAction="#w1I" text="I" />-->
<!-- <MenuItem fx:id="w1II" mnemonicParsing="false" onAction="#w1II" text="II" />-->
<!-- <MenuItem fx:id="w1III" mnemonicParsing="false" onAction="#w1III" text="III" />-->
<!-- <MenuItem fx:id="w1IV" mnemonicParsing="false" onAction="#w1IV" text="IV" />-->
<!-- <MenuItem fx:id="w1V" mnemonicParsing="false" onAction="#w1V" text="V" />-->
<!-- </items>-->
</MenuButton>
<MenuButton fx:id="w3" layoutX="171.0" layoutY="76.0" mnemonicParsing="false" text="I">
<items>
<MenuItem fx:id="w3I" mnemonicParsing="false" onAction="#w3I" text="I" />
<MenuItem fx:id="w3II" mnemonicParsing="false" onAction="#w3II" text="II" />
<MenuItem fx:id="w3III" mnemonicParsing="false" onAction="#w3III" text="III" />
<MenuItem fx:id="w3IV" mnemonicParsing="false" onAction="#w3IV" text="IV" />
<MenuItem fx:id="w3V" mnemonicParsing="false" onAction="#w3V" text="V" />
</items>
</MenuButton>
<MenuButton fx:id="w2" layoutX="133.0" layoutY="76.0" mnemonicParsing="false" text="I">
<items>
<MenuItem fx:id="w2I" mnemonicParsing="false" onAction="#w2I" text="I" />
<MenuItem fx:id="w2II" mnemonicParsing="false" onAction="#w2II" text="II" />
<MenuItem fx:id="w2III" mnemonicParsing="false" onAction="#w2III" text="III" />
<MenuItem fx:id="w2IV" mnemonicParsing="false" onAction="#w2IV" text="IV" />
<MenuItem fx:id="w2V" mnemonicParsing="false" onAction="#w2V" text="V" />
</items>
</MenuButton>
<!-- <MenuButton layoutX="93.0" layoutY="114.0" mnemonicParsing="false">-->
<!-- <items>-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z1" text="1" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z2" text="2" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z3" text="3" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z4" text="4" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z5" text="5" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z6" text="6" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z7" text="7" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z8" text="8" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z9" text="9" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z10" text="10" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z11" text="11" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z12" text="12" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z13" text="13" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z14" text="14" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z15" text="15" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z16" text="16" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z17" text="17" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z18" text="18" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z19" text="19" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z20" text="20" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z21" text="21" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z22" text="22" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z23" text="23" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z24" text="24" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z25" text="25" />-->
<!-- <MenuItem mnemonicParsing="false" onAction="#z26" text="26" />-->
<!-- </items>-->
<!-- </MenuButton>-->
<MenuButton layoutX="173.0" layoutY="114.0" mnemonicParsing="false">
<items>
<MenuItem mnemonicParsing="false" text="Action 1" />
<MenuItem mnemonicParsing="false" text="Action 2" />
</items>
</MenuButton>
<MenuButton layoutX="135.0" layoutY="114.0" mnemonicParsing="false">
<items>
<MenuItem mnemonicParsing="false" text="Action 1" />
<MenuItem mnemonicParsing="false" text="Action 2" />
</items>
</MenuButton>
<MenuButton layoutX="95.0" layoutY="157.0" mnemonicParsing="false">
<items>
<MenuItem mnemonicParsing="false" text="Action 1" />
<MenuItem mnemonicParsing="false" text="Action 2" />
</items>
</MenuButton>
<MenuButton layoutX="175.0" layoutY="157.0" mnemonicParsing="false">
<items>
<MenuItem mnemonicParsing="false" text="Action 1" />
<MenuItem mnemonicParsing="false" text="Action 2" />
</items>
</MenuButton>
<MenuButton layoutX="137.0" layoutY="157.0" mnemonicParsing="false">
<items>
<MenuItem mnemonicParsing="false" text="Action 1" />
<MenuItem mnemonicParsing="false" text="Action 2" />
</items>
</MenuButton>
<TextField layoutX="246.0" layoutY="76.0" prefHeight="77.0" prefWidth="410.0" />
<TextField layoutX="248.0" layoutY="182.0" prefHeight="77.0" prefWidth="410.0" />
<Button layoutX="717.0" layoutY="221.0" mnemonicParsing="false" onAction="#btnsenden" prefHeight="69.0" prefWidth="164.0" text="An Funker senden" />
<Button layoutX="717.0" layoutY="135.0" mnemonicParsing="false" prefHeight="69.0" prefWidth="164.0" text="Funkspruch empfangen" />
<TextField layoutX="725.0" layoutY="76.0" />
<Label layoutX="727.0" layoutY="51.0" prefHeight="17.0" prefWidth="149.0" text="Kenngruppe" />
<MenuButton layoutX="93.0" layoutY="114.0" mnemonicParsing="false">
<items>
<MenuItem mnemonicParsing="false" text="Action 1" />
<MenuItem mnemonicParsing="false" text="Action 2" />
</items>
</MenuButton>
</children>
</AnchorPane>
src/main/resources/Enigma/secondary.fxml deleted 100644 → 0
View file @ a14a7e2e
<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.layout.VBox?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.control.Button?>
<?import javafx.geometry.Insets?>
<VBox alignment="CENTER" spacing="20.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="Enigma.SecondaryController">
<children>
<Label text="Secondary View" />
<Button fx:id="secondaryButton" text="Switch to Primary View" onAction="#switchToPrimary" />
</children>
<padding>
<Insets bottom="20.0" left="20.0" right="20.0" top="20.0" />
</padding>
</VBox>
src/main/resources/projekt/enigma/gui.fxml 0 → 100644
View file @ 6cfa05da
This diff is collapsed.
src/test/java/Enigma/model/WalzeTest.java deleted 100644 → 0
View file @ a14a7e2e
package Enigma.model;
import org.junit.Assert;
import org.junit.Test;
import static org.junit.Assert.*;
public class WalzeTest {
@Test
public void setzeNotch() {
/*Walze w = new Walze(1);
w.setzeNotch('G');
Assert.assertEquals('G', w.wlazenPosition());*/
}
@Test
public void dreheWalze() {
/*Walze w = new Walze(1);
w.setzeNotch('G');
w.dreheWalze();
Assert.assertEquals('H', w.wlazenPosition());*/
}
@Test
public void walzenPoition() {
/*Walze w = new Walze(1);
w.setzeNotch('G');
Assert.assertEquals('G', w.wlazenPosition());*/
}
@Test
public void codiere() {
/*Walze w = new Walze(1);
w.setzeNotch('A');
Assert.assertEquals('E', w.codiere('A'));*/
}
@Test
public void codiere2() {
/*Walze w = new Walze(1);
w.setzeNotch('A');
Assert.assertEquals('A', w.codiere('E'));*/
}
}
\ No newline at end of file
src/test/java/Enigma/model/CodebuchTest.java → src/test/java/projekt/enigma/model/CodebuchTest.java
View file @ 6cfa05da
package Enigma.model;
package projekt.enigma.model;
import org.junit.Assert;
import org.junit.Test;
import java.sql.SQLException;
public class CodebuchTest {
......@@ -11,17 +10,13 @@ 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 {
// Codebuch abrufen
Codebuch cb = new DatenbankSqlite().getCodebuch(1);
// Ausgabe auf der Konsole
String result = new DatenbankSqlite().getCodebuch(1).toString();
Assert.assertEquals(expected, result);
} catch (SQLException e) {
e.printStackTrace();
}
// Ausgabe auf der Konsole
Codebuch cb = new Codebuch();
cb.fetchTagesschluessel(1);
String result = cb.toString();
Assert.assertEquals(result, expected, result);
}
@Test
......
src/test/java/projekt/enigma/model/HardwareTest.java 0 → 100644
View file @ 6cfa05da
package projekt.enigma.model;
import org.junit.Assert;
import org.junit.Test;
public class HardwareTest {
@Test
public void tippeBuchstabe() {
Hardware h = new Hardware();
h.setReflektor(new Reflektor());
h.setSteckbrett(new Steckbrett());
/*
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 "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;
h.setWalzen(0, 2, 25);
h.setWalzen(1, 5, 25);
h.setWalzen(2, 1, 25);
result = h.codiere('A');
Assert.assertEquals("Codiere: A Erwartet N, erhalten " + result, 'N', result);
result = h.codiere('B');
Assert.assertEquals("Codiere: B Erwartet K, erhalten " + result, 'K', result);
result = h.codiere('I');
Assert.assertEquals("Codiere: I Erwartet V, erhalten " + result, 'V', result);
result = h.codiere('F');
Assert.assertEquals("Codiere: F Erwartet T, erhalten " + result, 'T', result);
h.setWalzen(0, 2, 25);
h.setWalzen(1, 5, 25);
h.setWalzen(2, 1, 25);
result = h.codiere('N');
Assert.assertEquals("Decodiere: N Erwartet A, erhalten " + result, 'A', result);
result = h.codiere('K');
Assert.assertEquals("Decodiere: K Erwartet B, erhalten " + result, 'B', result);
result = h.codiere('V');
Assert.assertEquals("Decodiere: V Erwartet I, erhalten " + result, 'I', result);
result = h.codiere('T');
Assert.assertEquals("Decodiere: T Erwartet F, erhalten " + result, 'F', result);
h.setWalzen(0, 2, 25);
h.setWalzen(1, 5, 25);
h.setWalzen(2, 1, 25);
h.getSteckbrett().setzeVertauschung('B', 'G');
h.getSteckbrett().setzeVertauschung('D', 'F');
h.getSteckbrett().setzeVertauschung('I', 'L');
h.getSteckbrett().setzeVertauschung('M', 'Q');
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: I Erwartet C, erhalten " + result, 'C', result);
h.setWalzen(0, 2, 25);
h.setWalzen(1, 5, 25);
h.setWalzen(2, 1, 25);
result = h.codiere('C');
Assert.assertEquals("Codiere: C Erwartet I, erhalten " + result, 'I', result);
h.setWalzen(0, 2, 25);
h.setWalzen(1, 5, 25);
h.setWalzen(2, 1, 25);
h.getSteckbrett().setzeVertauschung('A', 'B');
h.getSteckbrett().setzeVertauschung('C', 'D');
result = h.codiere('A');
Assert.assertEquals("Codiere: A Erwartet M, erhalten " + result, 'M', result);
}
}
\ No newline at end of file
src/test/java/Enigma/model/ReflektorTest.java → src/test/java/projekt/enigma/model/ReflektorTest.java
View file @ 6cfa05da
package Enigma.model;
package projekt.enigma.model;
import org.junit.Assert;
import org.junit.Test;
......@@ -7,7 +7,6 @@ public class ReflektorTest {
@Test
public void codiere() {
/*
Reflektor r = new Reflektor();
Assert.assertEquals('E', r.codiere('A'));
......@@ -15,19 +14,10 @@ public class ReflektorTest {
Assert.assertEquals('X', r.codiere('H'));
Assert.assertEquals('O', r.codiere('Q'));
Assert.assertEquals('I', r.codiere('V'));
//Assert.assertNull(null, r.codiere(null));
*/
}
@Test
public void codiere2() {
/*
Reflektor r = new Reflektor();
Assert.assertEquals('A', r.codiere('E'));
Assert.assertEquals('D', r.codiere('Z'));
Assert.assertEquals('H', r.codiere('X'));
Assert.assertEquals('Q', r.codiere('O'));
Assert.assertEquals('V', r.codiere('I'));
*/
}
}
\ No newline at end of file
src/test/java/Enigma/model/SteckbrettTest.java → src/test/java/projekt/enigma/model/SteckbrettTest.java
View file @ 6cfa05da
package Enigma.model;
package projekt.enigma.model;
import org.junit.Assert;
import org.junit.Test;
import static org.junit.Assert.*;
public class SteckbrettTest {
@Test
public void setzeVertauschung() {
/*Steckbrett sb = new Steckbrett();
Steckbrett sb = new Steckbrett();
sb.setzeVertauschung('A', 'G');
sb.setzeVertauschung('C', 'H');
Assert.assertEquals('H', sb.codiere('C'));
Assert.assertEquals('G', sb.codiere('A'));*/
Assert.assertEquals('G', sb.codiere('A'));
}
@Test
public void codiere() {
/*Steckbrett sb = new Steckbrett();
Steckbrett sb = new Steckbrett();
sb.setzeVertauschung('A', 'G');
sb.setzeVertauschung('C', 'H');
Assert.assertEquals('H', sb.codiere('C'));
Assert.assertEquals('G', sb.codiere('A'));*/
}
@Test
public void codiere2() {
/*Steckbrett sb = new Steckbrett();
sb.setzeVertauschung('A', 'G');
sb.setzeVertauschung('C', 'H');
Assert.assertEquals('C', sb.codiere2('H'));
Assert.assertEquals('A', sb.codiere2('G'));*/
Assert.assertEquals('G', sb.codiere('A'));
}
}
\ No newline at end of file
src/test/java/projekt/enigma/model/WalzeTest.java 0 → 100644
View file @ 6cfa05da
package projekt.enigma.model;
import org.junit.Assert;
import org.junit.Test;
import static org.junit.Assert.*;
public class WalzeTest {
@Test
public void setRingstellung() {
Walze w = new Walze(1, 1);
char temp = w.getPosition();
Assert.assertEquals('A', temp);
}
@Test
public void dreheWalze() {
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 getPosition() {
Walze w = new Walze(1, 1);
char temp = w.getPosition();
Assert.assertEquals('A', temp);
}
@Test
public void codiere() {
Walze w = new Walze(1, 1);
char result = w.codiere('G');
Assert.assertEquals("Erwartet D erhalten " + result, 'D', result);
}
@Test
public void codiere2() {
Walze w = new Walze(1, 1);
char result = w.codiere2('E');
Assert.assertEquals("Erwartet A erhalten " + result, 'A', result);
}
}
\ No newline at end of file