From b9c1a5f612995c106a926558729b22a5aee7f54b Mon Sep 17 00:00:00 2001 From: Asecave <39377667+Asecave@users.noreply.github.com> Date: Fri, 2 Oct 2020 17:54:08 +0200 Subject: [PATCH] Created box selection --- Vokabeltrainer/.classpath | 1 + Vokabeltrainer/src/main/BoxMaker.java | 54 +++++ Vokabeltrainer/src/main/BoxQuery.java | 10 + Vokabeltrainer/src/main/Card.java | 26 +++ Vokabeltrainer/src/main/CardBox.java | 31 +++ Vokabeltrainer/src/main/Launcher.java | 22 ++ Vokabeltrainer/src/main/List.java | 317 ++++++++++++++++++++++++++ Vokabeltrainer/src/main/Trainer.java | 100 ++++++++ 8 files changed, 561 insertions(+) create mode 100644 Vokabeltrainer/src/main/BoxMaker.java create mode 100644 Vokabeltrainer/src/main/BoxQuery.java create mode 100644 Vokabeltrainer/src/main/Card.java create mode 100644 Vokabeltrainer/src/main/CardBox.java create mode 100644 Vokabeltrainer/src/main/Launcher.java create mode 100644 Vokabeltrainer/src/main/List.java create mode 100644 Vokabeltrainer/src/main/Trainer.java diff --git a/Vokabeltrainer/.classpath b/Vokabeltrainer/.classpath index 51a8bba..1879f19 100644 --- a/Vokabeltrainer/.classpath +++ b/Vokabeltrainer/.classpath @@ -2,5 +2,6 @@ + diff --git a/Vokabeltrainer/src/main/BoxMaker.java b/Vokabeltrainer/src/main/BoxMaker.java new file mode 100644 index 0000000..61f63b9 --- /dev/null +++ b/Vokabeltrainer/src/main/BoxMaker.java @@ -0,0 +1,54 @@ +package main; + +import com.asecave.Console.Color; + +public class BoxMaker { + + public CardBox createBox() { + Trainer.con.setBGColor(Color.BLACK); + Trainer.con.fill(' '); + + Trainer.con.setCursor(5, 3); + Trainer.con.setFGColor(Color.WHITE); + Trainer.con.print("Boxname:"); + CardBox box = new CardBox(requestString(5, 5)); + + return null; + } + + private String requestString(int x, int y) { + String in = ""; + boolean writing = true; + while (writing) { + char inputChar = Trainer.con.getInputChar(); + switch (inputChar) { + case 13: + writing = false; + break; + case 0: + break; + case 8: + if (in.length() > 0) { + Trainer.con.setCursor(x, y); + Trainer.con.print(" "); + in = in.substring(0, in.length() - 1); + } + break; + default: + in += inputChar; + break; + } + if (inputChar != 0) { + Trainer.con.setCursor(x, y); + Trainer.con.print(in); + } + try { + Thread.sleep(16); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + return in; + } + +} diff --git a/Vokabeltrainer/src/main/BoxQuery.java b/Vokabeltrainer/src/main/BoxQuery.java new file mode 100644 index 0000000..9e3c045 --- /dev/null +++ b/Vokabeltrainer/src/main/BoxQuery.java @@ -0,0 +1,10 @@ +package main; + +public class BoxQuery { + + public BoxQuery(List vocabulary) { + while (!vocabulary.isEmpty()) { + + } + } +} diff --git a/Vokabeltrainer/src/main/Card.java b/Vokabeltrainer/src/main/Card.java new file mode 100644 index 0000000..bbfd772 --- /dev/null +++ b/Vokabeltrainer/src/main/Card.java @@ -0,0 +1,26 @@ +package main; + +public class Card { + + private String translation; + private String word; + + public Card(String word, String translation) { + this.word = word; + this.translation = translation; + } + + public String getWord() { + return word; + } + + public int isCorrect(String input) { + if (input.equals(translation)) { + return 1; + } + if (input.toLowerCase().equals(translation.toLowerCase())) { + return 2; + } + return 0; + } +} diff --git a/Vokabeltrainer/src/main/CardBox.java b/Vokabeltrainer/src/main/CardBox.java new file mode 100644 index 0000000..7a3c865 --- /dev/null +++ b/Vokabeltrainer/src/main/CardBox.java @@ -0,0 +1,31 @@ +package main; + +public class CardBox { + + private List cards; + + private String name; + + public CardBox(String name) { + this.name = name; + cards = new List<>(); + } + + public void addCard(Card card) { + cards.append(card); + } + + public List getCopy() { + List copy = new List<>(); + cards.toFirst(); + while(cards.hasAccess()) { + copy.append(cards.getContent()); + cards.next(); + } + return copy; + } + + public String getName() { + return name; + } +} diff --git a/Vokabeltrainer/src/main/Launcher.java b/Vokabeltrainer/src/main/Launcher.java new file mode 100644 index 0000000..7353a36 --- /dev/null +++ b/Vokabeltrainer/src/main/Launcher.java @@ -0,0 +1,22 @@ +package main; + +public class Launcher { + + public static void main(String[] args) { + try { + new Trainer(); + } catch (Exception e) { + Trainer.con.print("An Exception occured.\n"); + Trainer.con.print(e + ": " + e.getMessage() + "\n"); + for (StackTraceElement ste : e.getStackTrace()) { + Trainer.con.print(ste.toString() + "\n"); + } + Trainer.con.print("Exiting in 10 seconds..."); + try { + Thread.sleep(10000); + } catch (InterruptedException e1) { + e1.printStackTrace(); + } + } + } +} diff --git a/Vokabeltrainer/src/main/List.java b/Vokabeltrainer/src/main/List.java new file mode 100644 index 0000000..ed98b63 --- /dev/null +++ b/Vokabeltrainer/src/main/List.java @@ -0,0 +1,317 @@ +package main; + +public class List { + + /* --------- Anfang der privaten inneren Klasse -------------- */ + + private class ListNode { + + private ContentType contentObject; + private ListNode next; + + /** + * Ein neues Objekt wird erschaffen. Der Verweis ist leer. + * + * @param pContent das Inhaltsobjekt vom Typ ContentType + */ + private ListNode(ContentType pContent) { + contentObject = pContent; + next = null; + } + + /** + * Der Inhalt des Knotens wird zurueckgeliefert. + * + * @return das Inhaltsobjekt des Knotens + */ + public ContentType getContentObject() { + return contentObject; + } + + /** + * Der Inhalt dieses Kontens wird gesetzt. + * + * @param pContent das Inhaltsobjekt vom Typ ContentType + */ + public void setContentObject(ContentType pContent) { + contentObject = pContent; + } + + /** + * Der Nachfolgeknoten wird zurueckgeliefert. + * + * @return das Objekt, auf das der aktuelle Verweis zeigt + */ + public ListNode getNextNode() { + return this.next; + } + + /** + * Der Verweis wird auf das Objekt, das als Parameter uebergeben wird, gesetzt. + * + * @param pNext der Nachfolger des Knotens + */ + public void setNextNode(ListNode pNext) { + this.next = pNext; + } + + } + + /* ----------- Ende der privaten inneren Klasse -------------- */ + + // erstes Element der Liste + ListNode first; + + // letztes Element der Liste + ListNode last; + + // aktuelles Element der Liste + ListNode current; + + /** + * Eine leere Liste wird erzeugt. + */ + public List() { + first = null; + last = null; + current = null; + } + + /** + * Die Anfrage liefert den Wert true, wenn die Liste keine Objekte enthaelt, + * sonst liefert sie den Wert false. + * + * @return true, wenn die Liste leer ist, sonst false + */ + public boolean isEmpty() { + // Die Liste ist leer, wenn es kein erstes Element gibt. + return first == null; + } + + /** + * Die Anfrage liefert den Wert true, wenn es ein aktuelles Objekt gibt, sonst + * liefert sie den Wert false. + * + * @return true, falls Zugriff moeglich, sonst false + */ + public boolean hasAccess() { + // Es gibt keinen Zugriff, wenn current auf kein Element verweist. + return current != null; + } + + /** + * Falls die Liste nicht leer ist, es ein aktuelles Objekt gibt und dieses nicht + * das letzte Objekt der Liste ist, wird das dem aktuellen Objekt in der Liste + * folgende Objekt zum aktuellen Objekt, andernfalls gibt es nach Ausfuehrung + * des Auftrags kein aktuelles Objekt, d.h. hasAccess() liefert den Wert false. + */ + public void next() { + if (this.hasAccess()) { + current = current.getNextNode(); + } + } + + /** + * Falls die Liste nicht leer ist, wird das erste Objekt der Liste aktuelles + * Objekt. Ist die Liste leer, geschieht nichts. + */ + public void toFirst() { + if (!isEmpty()) { + current = first; + } + } + + /** + * Falls die Liste nicht leer ist, wird das letzte Objekt der Liste aktuelles + * Objekt. Ist die Liste leer, geschieht nichts. + */ + public void toLast() { + if (!isEmpty()) { + current = last; + } + } + + /** + * Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das aktuelle + * Objekt zurueckgegeben, andernfalls (hasAccess() == false) gibt die Anfrage + * den Wert null zurueck. + * + * @return das aktuelle Objekt (vom Typ ContentType) oder null, wenn es kein + * aktuelles Objekt gibt + */ + public ContentType getContent() { + if (this.hasAccess()) { + return current.getContentObject(); + } else { + return null; + } + } + + /** + * Falls es ein aktuelles Objekt gibt (hasAccess() == true) und pContent + * ungleich null ist, wird das aktuelle Objekt durch pContent ersetzt. Sonst + * geschieht nichts. + * + * @param pContent das zu schreibende Objekt vom Typ ContentType + */ + public void setContent(ContentType pContent) { + // Nichts tun, wenn es keinen Inhalt oder kein aktuelles Element gibt. + if (pContent != null && this.hasAccess()) { + current.setContentObject(pContent); + } + } + + /** + * Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird ein neues + * Objekt vor dem aktuellen Objekt in die Liste eingefuegt. Das aktuelle Objekt + * bleibt unveraendert.
+ * Wenn die Liste leer ist, wird pContent in die Liste eingefuegt und es gibt + * weiterhin kein aktuelles Objekt (hasAccess() == false).
+ * Falls es kein aktuelles Objekt gibt (hasAccess() == false) und die Liste + * nicht leer ist oder pContent gleich null ist, geschieht nichts. + * + * @param pContent das einzufuegende Objekt vom Typ ContentType + */ + public void insert(ContentType pContent) { + if (pContent != null) { // Nichts tun, wenn es keinen Inhalt gibt. + if (this.hasAccess()) { // Fall: Es gibt ein aktuelles Element. + + // Neuen Knoten erstellen. + ListNode newNode = new ListNode(pContent); + + if (current != first) { // Fall: Nicht an erster Stelle einfuegen. + ListNode previous = this.getPrevious(current); + newNode.setNextNode(previous.getNextNode()); + previous.setNextNode(newNode); + } else { // Fall: An erster Stelle einfuegen. + newNode.setNextNode(first); + first = newNode; + } + + } else { // Fall: Es gibt kein aktuelles Element. + + if (this.isEmpty()) { // Fall: In leere Liste einfuegen. + + // Neuen Knoten erstellen. + ListNode newNode = new ListNode(pContent); + + first = newNode; + last = newNode; + } + + } + } + } + + /** + * Falls pContent gleich null ist, geschieht nichts.
+ * Ansonsten wird ein neues Objekt pContent am Ende der Liste eingefuegt. Das + * aktuelle Objekt bleibt unveraendert.
+ * Wenn die Liste leer ist, wird das Objekt pContent in die Liste eingefuegt und + * es gibt weiterhin kein aktuelles Objekt (hasAccess() == false). + * + * @param pContent das anzuhaengende Objekt vom Typ ContentType + */ + public void append(ContentType pContent) { + if (pContent != null) { // Nichts tun, wenn es keine Inhalt gibt. + + if (this.isEmpty()) { // Fall: An leere Liste anfuegen. + this.insert(pContent); + } else { // Fall: An nicht-leere Liste anfuegen. + + // Neuen Knoten erstellen. + ListNode newNode = new ListNode(pContent); + + last.setNextNode(newNode); + last = newNode; // Letzten Knoten aktualisieren. + } + + } + } + + /** + * Falls es sich bei der Liste und pList um dasselbe Objekt handelt, pList null + * oder eine leere Liste ist, geschieht nichts.
+ * Ansonsten wird die Liste pList an die aktuelle Liste angehaengt. + * Anschliessend wird pList eine leere Liste. Das aktuelle Objekt bleibt + * unveraendert. Insbesondere bleibt hasAccess identisch. + * + * @param pList die am Ende anzuhaengende Liste vom Typ List + */ + public void concat(List pList) { + if (pList != this && pList != null && !pList.isEmpty()) { // Nichts tun, + // wenn pList und this identisch, pList leer oder nicht existent. + + if (this.isEmpty()) { // Fall: An leere Liste anfuegen. + this.first = pList.first; + this.last = pList.last; + } else { // Fall: An nicht-leere Liste anfuegen. + this.last.setNextNode(pList.first); + this.last = pList.last; + } + + // Liste pList loeschen. + pList.first = null; + pList.last = null; + pList.current = null; + } + } + + /** + * Wenn die Liste leer ist oder es kein aktuelles Objekt gibt (hasAccess() == + * false), geschieht nichts.
+ * Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das aktuelle + * Objekt geloescht und das Objekt hinter dem geloeschten Objekt wird zum + * aktuellen Objekt.
+ * Wird das Objekt, das am Ende der Liste steht, geloescht, gibt es kein + * aktuelles Objekt mehr. + */ + public void remove() { + // Nichts tun, wenn es kein aktuelle Element gibt oder die Liste leer ist. + if (this.hasAccess() && !this.isEmpty()) { + + if (current == first) { + first = first.getNextNode(); + } else { + ListNode previous = this.getPrevious(current); + if (current == last) { + last = previous; + } + previous.setNextNode(current.getNextNode()); + } + + ListNode temp = current.getNextNode(); + current.setContentObject(null); + current.setNextNode(null); + current = temp; + + // Beim loeschen des letzten Elements last auf null setzen. + if (this.isEmpty()) { + last = null; + } + } + } + + /** + * Liefert den Vorgaengerknoten des Knotens pNode. Ist die Liste leer, pNode == + * null, pNode nicht in der Liste oder pNode der erste Knoten der Liste, wird + * null zurueckgegeben. + * + * @param pNode der Knoten, dessen Vorgaenger zurueckgegeben werden soll + * @return der Vorgaenger des Knotens pNode oder null, falls die Liste leer ist, + * pNode == null ist, pNode nicht in der Liste ist oder pNode der erste + * Knoten der Liste ist + */ + private ListNode getPrevious(ListNode pNode) { + if (pNode != null && pNode != first && !this.isEmpty()) { + ListNode temp = first; + while (temp != null && temp.getNextNode() != pNode) { + temp = temp.getNextNode(); + } + return temp; + } else { + return null; + } + } + +} \ No newline at end of file diff --git a/Vokabeltrainer/src/main/Trainer.java b/Vokabeltrainer/src/main/Trainer.java new file mode 100644 index 0000000..b18e1e9 --- /dev/null +++ b/Vokabeltrainer/src/main/Trainer.java @@ -0,0 +1,100 @@ +package main; + +import com.asecave.Console; +import com.asecave.Console.Color; +import com.asecave.Console.FontSize; + +public class Trainer { + + private List boxes; + static Console con; + private boolean running; + private int cursor = 0; + private int boxCount = 0; + private BoxMaker maker; + + public Trainer() { + boxes = new List<>(); + + maker = new BoxMaker(); + + con = new Console(); + con.setTitle("Vokabeltrainer"); + con.setFontSize(FontSize.NORMAL); + + con.setBGColor(Color.BLACK); + con.fill(' '); + print(); + + running = true; + while (running) { + loop(); + } + } + + private void loop() { + + char in = con.getInputChar(); + if (in != 0) { + switch (in) { + case 'H': // Arrow up + if (cursor > 0) { + cursor--; + } + break; + case 'P': // Arrow down + if (cursor < boxCount) { + cursor++; + } + break; + case 13: // Enter + if (cursor == 0) { + boxes.append(maker.createBox()); + } + break; + } + print(); + } + + try { + Thread.sleep(16); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + private void print() { + con.setCursor(5, 2); + con.setFGColor(Color.GOLD); + con.setBGColor(Color.BLACK); + con.print("--== V O K A B E L T R A I N E R ==--"); + con.setCursor(5, 4); + if (cursor == 0) { + con.setFGColor(Color.BLACK); + con.setBGColor(Color.GREEN); + } else { + con.setFGColor(Color.WHITE); + con.setBGColor(Color.BLACK); + } + con.print(""); + + boxCount = 0; + int y = 0; + boxes.toFirst(); + while (boxes.hasAccess()) { + con.setCursor(5, 5 + y); + y++; + if (cursor == y) { + con.setFGColor(Color.BLACK); + con.setBGColor(Color.GREEN); + } else { + con.setFGColor(Color.WHITE); + con.setBGColor(Color.BLACK); + } + con.print(boxes.getContent().getName()); + boxCount++; + boxes.next(); + } + con.setCursorVisible(false); + } +}