Skip to content
Snippets Groups Projects
Commit 750a36bf authored by Dennis Eisold's avatar Dennis Eisold
Browse files

Merge branch 'master' into 'master'

Das drehen funktioniert, nur der Notch macht noch Probleme #12

See merge request alfatrainingkurse/java/enigma!64
parents eb040c96 501a48c4
No related branches found
No related tags found
No related merge requests found
...@@ -406,8 +406,9 @@ public class Codierer { ...@@ -406,8 +406,9 @@ public class Codierer {
/** /**
* Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu. * 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 * @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 * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
*/ */
public boolean setSteckbrett(int port, String verbindung) { public boolean setSteckbrett(int port, String verbindung) {
...@@ -469,6 +470,12 @@ public class Codierer { ...@@ -469,6 +470,12 @@ public class Codierer {
* Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück. * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
*/ */
public void letztesZeichenLoeschen() { public void letztesZeichenLoeschen() {
if (this.hardware.getWalzen()[2].dreheWalze(-1)) {
System.out.println("Drehe W2");
if (this.hardware.getWalzen()[1].dreheWalze(-1)) {
System.out.println("Drehe W1");
this.hardware.getWalzen()[0].dreheWalze(-1);
}
}
} }
} }
package projekt.enigma.model; package projekt.enigma.model;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
/** /**
* Klasse Walze * Klasse Walze
* <br> * <br>
...@@ -14,10 +20,10 @@ package projekt.enigma.model; ...@@ -14,10 +20,10 @@ package projekt.enigma.model;
*/ */
public class Walze { public class Walze {
/** /**
* walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
*/ */
private Character[] alphabet; private Character[] alphabet;
/** /**
* ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
...@@ -25,244 +31,250 @@ public class Walze { ...@@ -25,244 +31,250 @@ public class Walze {
private char ringstellung; private char ringstellung;
/** /**
* walzennr : int : Bestimmt, welche Walze genutzt wird * walzennr : int : Bestimmt, welche Walze genutzt wird
*/ */
private int walzennr; private int walzennr;
/** /**
* alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes * alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
* aber immer wieder ueberschrieben. * aber immer wieder ueberschrieben.
*/ */
private Character[] walzeAlpha; private Character[] walzeAlpha;
/**
* Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
*
* @param walzennr : int : Nummer der gewaehlten Walze
* @param ringstellung : int : Einstellung des Umsprungpunktes
*/
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);
}
/**
* Sortiert der Walzennummer das passende Character-Array mittels switch zu.
*
* @return walze : Character[] : gibt die gewaehlte Walze zurueck
*/
private Character[] walzenNummer() {
Character[] walze = new Character[26];
// 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; /**
} * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
/**
* TODO: Dokumentieren
*
* @return ringstellung : char : gibt die neue Ringstellung als char zurueck
*/
public char getRingstellung() {
return ringstellung;
}
/**
* Setzt die Initiale Ringstellung der Walze.
* Es sind nur Zahlen von 1 - 26 zugelassen.
* *
* @param walzennr : int : Nummer der gewaehlten Walze
* @param ringstellung : int : Einstellung des Umsprungpunktes
*/
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);
}
/**
* Sortiert der Walzennummer das passende Character-Array mittels switch zu.
*
* @return walze : Character[] : gibt die gewaehlte Walze zurueck
*/
private Character[] walzenNummer() {
Character[] walze = new Character[26];
// 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;
}
/**
* TODO: Dokumentieren
*
* @return ringstellung : char : gibt die neue Ringstellung als char zurueck
*/
public char getRingstellung() {
return ringstellung;
}
/**
* Setzt die Initiale Ringstellung der Walze.
* Es sind nur Zahlen von 1 - 26 zugelassen.
* <p>
* Die Ringstellung wird zum char umgewandelt. * Die Ringstellung wird zum char umgewandelt.
* Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt. * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
* *
* @param ringstellung : int : Punkt an dem die Walze umspringt * @param ringstellung : int : Punkt an dem die Walze umspringt
*/ */
//TODO ??? Setter Ringstellung //TODO ??? Setter Ringstellung
public void setRingstellung(int ringstellung) { public void setRingstellung(int ringstellung) {
if ((ringstellung > 0) && (ringstellung <= 26)) { if ((ringstellung > 0) && (ringstellung <= 26)) {
this.ringstellung = this.alphabet[ringstellung - 1]; this.ringstellung = this.alphabet[ringstellung - 1];
} else { } else {
this.ringstellung = 'Z'; this.ringstellung = 'Z';
} }
} }
/** /**
* Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
* das Array alphabet mit der neuen Anordnung. * das Array alphabet mit der neuen Anordnung.
* * <p>
* Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde. * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
* *
* @param drehung : int[] : Anzahl der Drehungen * @param drehung : int[] : Anzahl der Drehungen
* @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
* TODO: Doku * TODO: Doku
*/ */
public boolean dreheWalze(int... drehung) { public boolean dreheWalze(int... drehung) {
boolean checkRing = false; boolean checkRing = false;
int richtung = 1;
// fuehrt die Verschiebung des Alphabets um eine Stelle durch
verschiebung();
// fuehrt die Verschiebung mehrfach aus, wenn mehrere Drehungen ausgefuehrt werden sollen
if (drehung.length > 0) {
for (int i = 1; i < drehung[0]; i++) {
verschiebung();
}
}
// gleicht die Ringstellung mit der aktuellen Position ab if (drehung.length > 0 && drehung[0] < 0) {
if (this.getPosition().equals(this.ringstellung)) { richtung = -1;
checkRing = true; }
}
// fuehrt die Verschiebung des Alphabets um eine Stelle durch
verschiebung(richtung);
return checkRing; // fuehrt die Verschiebung mehrfach aus, wenn mehrere Drehungen ausgefuehrt werden sollen
} if (drehung.length > 0) {
for (int i = 1; i < drehung[0]; i++) {
verschiebung(richtung);
}
}
/** // gleicht die Ringstellung mit der aktuellen Position ab
if (this.getPosition().equals(this.ringstellung)) {
checkRing = true;
}
return checkRing;
}
/**
* Ueberschreibt die Alphabetswalze mit dem, durch die Drehung, verschobenen Alphabet. * Ueberschreibt die Alphabetswalze mit dem, durch die Drehung, verschobenen Alphabet.
* TODO: Dokumentieren *
*/ * @param richtung : int : Wenn "normal" gedreht werden soll, wird 1 übergeben, reverse entspricht dann -1
private void verschiebung() { * TODO: Dokumentieren
Character[] neueWalze = new Character[26]; */
private void verschiebung(int richtung) {
for (int index = 0; index < neueWalze.length; index++) { if (richtung > 0) {
neueWalze[(index + 1) % neueWalze.length] = this.walzeAlpha[index]; Collections.rotate(Arrays.asList(this.walzeAlpha), 1);
} else {
Collections.rotate(Arrays.asList(this.walzeAlpha), -1);
} }
}
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];
}
/** /**
* TODO: Dokumentieren // dass selbe wie getPosition * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
* 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 * @return buchstabe : char : verschluesselter Buchstabe
*/ */
public char codiere(char buchstabe) { public char codiere(char buchstabe) {
/* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und
uebertraegt den Index auf die gewaehlte Codierwalze*/ uebertraegt den Index auf die gewaehlte Codierwalze*/
buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)]; buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)];
return buchstabe; return buchstabe;
} }
/** /**
* Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
* *
* @param buchstabe : char : Buchstabe, der decodiert werden soll * @param buchstabe : char : Buchstabe, der decodiert werden soll
* @return buchstabe : char : decodierter Buchstabe * @return buchstabe : char : decodierter Buchstabe
*/ */
public char codiere2(char buchstabe) { public char codiere2(char buchstabe) {
/* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und
uebertraegt den Index auf die (verschobene) Alphabetswalze*/ uebertraegt den Index auf die (verschobene) Alphabetswalze*/
buchstabe = walzeAlpha[fetchArrayIndex(buchstabe, walzenNummer())]; buchstabe = walzeAlpha[fetchArrayIndex(buchstabe, walzenNummer())];
return buchstabe; return buchstabe;
} }
/** /**
* TODO: Dokumentieren * TODO: Dokumentieren
* Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife
* *
* @param buchstabe : Character : Buchstabe, dessen Index benoetigt wird * @param buchstabe : Character : Buchstabe, dessen Index benoetigt wird
* @param array : Character[] : Array, in dem der Buchstabe vorkommen soll * @param array : Character[] : Array, in dem der Buchstabe vorkommen soll
* @return result : int : index des Buchstaben * @return result : int : index des Buchstaben
*/ */
private int fetchArrayIndex(Character buchstabe, Character[] array) { private int fetchArrayIndex(Character buchstabe, Character[] array) {
// wird mit ungueltigem Wert initialisiert // wird mit ungueltigem Wert initialisiert
int result = -1; int result = -1;
for (int i = 0; i < array.length; i++) {
if (array[i].equals(buchstabe)) {
result = i;
break;
}
}
return result; for (int i = 0; i < array.length; i++) {
} if (array[i].equals(buchstabe)) {
result = i;
/** break;
* Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl. }
* }
* @param walzennr : int : Walzennummer
*/ return result;
public void setWalzennr(int walzennr) { }
if ((walzennr > 0) && (walzennr < 6)) {
this.walzennr = walzennr;
} else {
System.err.println("Keine gültige Walzennummer");
}
}
/** /**
* TODO: Dokumentieren // das selbe wie getAnzeig? * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
*
* @param walzennr : int : Walzennummer
*/
public void setWalzennr(int walzennr) {
if ((walzennr > 0) && (walzennr < 6)) {
this.walzennr = walzennr;
} 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 * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
* *
* @return Character am Index 0 des (verschobenen) Alphabets zurueck * @return Character am Index 0 des (verschobenen) Alphabets zurueck
*/ */
public Character getPosition() { public Character getPosition() {
return walzeAlpha[0]; return walzeAlpha[0];
} }
/** /**
* * TODO: Funktionsname hat sich geändert * * TODO: Funktionsname hat sich geändert
* Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen. * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
* Buchstaben werden automatisch in Grossbuchstaben umgewandelt. * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
* Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen. * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
* *
* @param buchstabe : Character : Einstellung der Walze * @param buchstabe : Character : Einstellung der Walze
*/ */
public void setPosition(Character buchstabe) { public void setPosition(Character buchstabe) {
if (Character.isLetter(buchstabe)) { if (Character.isLetter(buchstabe)) {
buchstabe = Character.toUpperCase(buchstabe); buchstabe = Character.toUpperCase(buchstabe);
System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length); System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
if (buchstabe > 'A') { if (buchstabe > 'A') {
dreheWalze(this.fetchArrayIndex(buchstabe, this.walzeAlpha)); dreheWalze(this.fetchArrayIndex(buchstabe, this.walzeAlpha));
} }
} }
} }
} }
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment