Funktionen Implementiert, Tests angepasst, Java Doc added

src/main/java/Card.java

@@ -1,37 +1,118 @@
+/**
+ * Object einer Card
+ */
 public class Card {
+    private String name;
+    private double damage;
+    private ElementTyp elementTyp;
+    private CardType cardType;
+
+    /**
+     * Erstellt eine neue Card mit gegebenen Eigenschaften
+     * @param name Name der Card
+     * @param damage Damage den die Card macht
+     * @param elementTyp ElementType der Card
+     * @param cardType CardType der Card
+     */
     public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) {
-
+        this.name = name;
+        this.damage = damage;
+        this.elementTyp = elementTyp;
+        this.cardType = cardType;
     }
 
+    /**
+     * Holt den Namen der Card
+     * @return Name der Card
+     */
     public String getName() {
-        return "";
+        return this.name;
     }
 
-    public int getDamage() {
-        return 0;
+    /**
+     * Holt den Damage der Card
+     * @return Damage der Card
+     */
+    public double getDamage() {
+        return this.damage;
     }
 
+    /**
+     * Holt den ElementType der Card
+     * @return ElementType der Card
+     */
     public ElementTyp getElementTyp() {
-        return null;
+        return this.elementTyp;
     }
 
+    /**
+     * Holt den CardType der Card
+     * @return CardType der Card
+     */
     public CardType getCardType() {
-        return null;
+        return this.cardType;
     }
 
-    public EffectivnessType getEffectivenessAgainst() {
-        return null;
+    /**
+     * Berechnet die Wirksamkeit gegen eine Andere card. Die Card im Parameter wird angegriffen
+     * @param toCeck Card gegen welche die Wirksamkeit geprüft werden soll
+     * @return Gibt die Wirksamkeit zurück
+     * @throws InternalError Wenn die Effectifeness von den 2 Cards nicht berechnet werden kann
+     */
+    public EffectivnessType getEffectivenessAgainst(Card toCeck) {
+        if(toCeck.getCardType() == CardType.MONSTER){
+            if(this.cardType == CardType.MONSTER){
+                return EffectivnessType.NOEFFECT;
+            }else if (this.cardType == CardType.SPELL){
+
+            }
+        }else if (toCeck.getCardType() == CardType.SPELL){
+            if ((toCeck.getElementTyp() == ElementTyp.FIRE && this.elementTyp == ElementTyp.WATER) || (toCeck.getElementTyp() == ElementTyp.NORMAL && this.elementTyp == ElementTyp.FIRE) || (toCeck.getElementTyp() == ElementTyp.WATER && this.elementTyp == ElementTyp.NORMAL)){
+                return EffectivnessType.EFFECTIVE;
+            }else if (this.elementTyp == ElementTyp.FIRE && toCeck.getElementTyp() == ElementTyp.WATER){
+                return EffectivnessType.NOTEFFECTIVE;
+            }else if ((toCeck.getElementTyp() == ElementTyp.NORMAL && this.cardType == CardType.MONSTER && this.elementTyp == ElementTyp.NORMAL)){
+                return EffectivnessType.NOEFFECT;
+            }
+        }
+        throw new InternalError("Konnte die Effectiveness von den Cards nicht berechnen");
     }
 
-    public boolean setName(String neuerName) {
-        return false;
+    /**
+     * Setztden namen der Card
+     * @param neuerName Name der Card
+     */
+    public void setName(String neuerName) {
+        this.name = name;
     }
 
-    public boolean setDamage(int damage) {
-        return false;
+    /**
+     * Setzt den Damage der Card
+     * @param damage Der Damage
+     */
+    public void setDamage(int damage) {
+        this.damage = damage;
     }
 
-    public boolean setElementType(ElementTyp elementTyp) {
-        return false;
+    /**
+     * Setzt den ElementType der Card
+     * @param elementTyp Der ElementType
+     */
+    public void setElementType(ElementTyp elementTyp) {
+        this.elementTyp = elementTyp;
+    }
+
+    /**
+     * Testet ob die beiden Karten gleich sind
+     * @param card Card die geprüft werden soll
+     * @return True wenn die Karten übereinstimmen
+     */
+    public boolean equals(Card card){
+        if(card == null) return false;
+        if(this.name == card.getName() && this.cardType == card.getCardType() && this.elementTyp == card.getElementTyp() && this.damage == card.getDamage()){
+            return true;
+        }else {
+            return false;
+        }
     }
 }

src/main/java/Cards.java

@@ -1,23 +1,78 @@
 import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
 
+/**
+ * Verwaltet eine Liste vo Cards
+ */
 public class Cards {
-    public Cards(ArrayList<Card> cardsArrayList) {
+    private ArrayList<Card> cards;
 
+    /**
+     * Erstellt ein nues obj mit gegebenen Karten
+     * @param cardsArrayList Die Cards zum erstellen des Obj
+     */
+    public Cards(ArrayList<Card> cardsArrayList) {
+        this.cards = cardsArrayList;
     }
 
+    /**
+     * Erstellt ein neues Obj ohne Cards
+     */
     public Cards() {
 
     }
 
+    /**
+     * Fügt eine neue Card hinzu
+     * @param newCard neue Card
+     */
     public void addCard(Card newCard) {
-
+        this.cards.add(newCard);
     }
 
+    /**
+     * Holt alle Cards
+     * @return Alle Cards
+     */
     public ArrayList<Card> getCards() {
-        return null;
+        return this.cards;
     }
 
-    public boolean delCard(Card delCard) {
-        return false;
+    /**
+     * Löscht die gegebene Card
+     * @param delCard Card zum löschen
+     */
+    public void delCard(Card delCard) {
+        this.cards.removeIf(obj -> obj.equals(delCard));
+    }
+
+    /**
+     * Prüft ob eine Card in den Cards vorhanden ist
+     * @param toCeck Card nach der in den Cards gesucht werden soll
+     * @return True wenn die Card in den Cards ist
+     */
+    public boolean containsCard(Card toCeck){
+        AtomicBoolean returnval = new AtomicBoolean(false);
+        this.cards.forEach(item -> {
+            if(item.getElementTyp().equals(toCeck.getElementTyp()) && item.getCardType().equals(toCeck.getCardType()) && item.getName().equals(toCeck.getName()) && item.getDamage() == toCeck.getDamage()){
+                returnval.set(true);
+            }
+        });
+        return returnval.get();
+    }
+
+    /**
+     * Vergleicht 2 Cards Obj miteinander
+     * @param toCompare Cards zum vergleichen
+     * @return True wenn es aus den selben Cards besteht
+     */
+    public boolean equals(Cards toCompare){
+        AtomicBoolean returnval = new AtomicBoolean(false);
+        this.cards.forEach(item -> {
+            if(toCompare.containsCard(item)){
+                returnval.set(true);
+            }
+        });
+        return returnval.get();
     }
 }

src/main/java/Coins.java

@@ -1,21 +1,65 @@
+/**
+ * Alle coins eines Users
+ */
 public class Coins {
+    private int amount;
+
+    /**
+     * Erstellt ein neues Münzen Obj
+     * @param coins Alle münzen des Users
+     */
     public Coins(int coins) {
-
+        this.amount = coins;
     }
 
+    /**
+     * Holt alle münzen
+     * @return Alle münzen
+     */
     public int getCoinAmount() {
-        return 0;
+        return this.amount;
     }
 
+    /**
+     * Fügt münzen hinzu
+     * @param coins Münzen die hinzugefügt werden -> Positiv
+     * @throws NegativAmountException Wenn negative münzen hinzugefüght werden
+     */
     public void addCoin(int coins) throws NegativAmountException{
-        throw new NegativAmountException();
+        if(coins < 0) {
+            throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden");
+        }else {
+            this.amount += coins;
+        }
     }
 
+    /**
+     * Entfernt münzen
+     * @param coins Münzen die entfernt werden sollen, muss positiv sein
+     * @return True wenn erfolgreich
+     * @throws NegativAmountException Wenn ein negativer betrag abgezogen werden soll
+     */
     public boolean removeCoin(int coins) throws NegativAmountException{
-        throw new NegativAmountException();
+        if(coins < 0) {
+            throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden");
+        }else {
+            this.amount -= coins;
+            return true;
+        }
     }
 
-    public boolean changeCoinAmmount(int coins) {
-        return false;
+    /**
+     * Ändert den Absoluten Coin amount
+     * @param coins Neue Coin anzahl, muss positiv sein
+     * @return true wenn erfolgreich
+     * @throws NegativAmountException Wenn ein negativer wert eingegeben wird
+     */
+    public boolean changeCoinAmmount(int coins) throws NegativAmountException{
+        if(coins < 0) {
+            throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden");
+        }else {
+            this.amount = coins;
+            return true;
+        }
     }
 }

src/main/java/Credentials.java

@@ -1,2 +1,48 @@
+/**
+ * User Login Daten
+ */
 public class Credentials {
+    private String passwort, username;
+
+    /**
+     * Startet einen neuen User mit folgenden Daten
+     * @param username Diesem Usernamen
+     * @param passwort Diesem Passwort
+     */
+    public Credentials(String username, String passwort){
+        this.username = username;
+        this.passwort = passwort;
+    }
+
+    /**
+     * Holt das Passwort des users
+     * @return PW des Users
+     */
+    public String getPasswort() {
+        return passwort;
+    }
+
+    /**
+     * Setzt das User Passwort
+     * @param passwort Neues Passwort
+     */
+    public void setPasswort(String passwort) {
+        this.passwort = passwort;
+    }
+
+    /**
+     * Holt den Usernamen des Users
+     * @return Username
+     */
+    public String getUsername() {
+        return username;
+    }
+
+    /**
+     * Setzt einen neuen Usernamen
+     * @param username Neuer Username
+     */
+    public void setUsername(String username) {
+        this.username = username;
+    }
 }

src/main/java/DBConnection.java

@@ -1,2 +1,64 @@
+import java.util.ArrayList;
+
+/**
+ * Stellt die Verbindung zur "Datenbank" her
+ * Die "Datenbank" sind hier nur beispieldaten.
+ */
 public class DBConnection {
+    private ArrayList<TradingDeal> tradingDeals;
+    private ArrayList<Package> packages;
+
+    /**
+     * Erstellt alle Beispieldaten und simuliert somit den
+     * Verbindungsaufbau zu einer DB
+     */
+    public DBConnection(){
+        Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER);
+        Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL);
+        Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER);
+        Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL);
+        Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER);
+        Cards deck = new Cards();
+        Cards stack = new Cards();
+        deck.addCard(c1);
+        deck.addCard(c2);
+        stack.addCard(c3);
+        stack.addCard(c4);
+        stack.addCard(c5);
+        User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000));
+        this.tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.SPELL));
+        this.packages.add(new Package(stack, "Test Package", 100));
+    }
+
+    /**
+     * Holt alle verfügbaren TradingDeals
+     * @return Alle Trading Deals
+     */
+    public ArrayList<TradingDeal> getAllTradingDeals(){
+        return this.tradingDeals;
+    }
+
+    /**
+     * Holt alle verfügbaren Packages
+     * @return Alle Packages
+     */
+    public ArrayList<Package> getAllPackages(){
+        return this.packages;
+    }
+
+    /**
+     * Fügt einen neuen Tradingdeal zum Store hinzu
+     * @param tradingDeal Der neue Deal
+     */
+    public void addTradingDeal(TradingDeal tradingDeal){
+        this.tradingDeals.add(tradingDeal);
+    }
+
+    /**
+     * Fügt ein neues Package zu dem Store hinzu
+     * @param packageDeal Das neue Package
+     */
+    public void addPackage(Package packageDeal){
+        this.packages.add(packageDeal);
+    }
 }

src/main/java/EffectivnessType.java

@@ -1,5 +1,5 @@
 public enum EffectivnessType {
-    EFFEKTIVE,
-    NOTEFFEKTIVE,
-    NOEFFEKT
+    EFFECTIVE,
+    NOTEFFECTIVE,
+    NOEFFECT
 }

src/main/java/ElementTyp.java

@@ -1,3 +1,3 @@
 public enum ElementTyp {
-    WATER, FIRE
+    WATER, FIRE, NORMAL
 }

src/main/java/NegativAmountException.java

@@ -1,2 +1,15 @@
+/**
+ * Wenn ein negativer wert eingegeben wird aber ein Positiver erwartet wird, dann kann diese Exception geworfen werden
+ */
 public class NegativAmountException extends Exception {
+
+    /**
+     * Aufruf des Constructors der Super class Exception
+     * @param message Fehler Nachrichgt
+     * @param cause Fehler Ursache
+     */
+    public NegativAmountException(String message){
+        super(message);
+    }
+
 }

src/main/java/Package.java

@@ -1,17 +1,43 @@
+/**
+ * Package besteht aus 4 Karten. Ist eine Erweiterung der Cards, zeigt für 4 Cards den Preis und einen Packagenamen an
+ */
 public class Package extends Cards{
-    public Package(Cards stack, Cards deck, String name, int price) {
+    private String name;
+    private int price;
 
+    /**
+     * Erstellt ein neues Package mit den gegebenen Stats
+     * @param stack Cards des Packages
+     * @param name Name des Packages
+     * @param price Price des Packages
+     */
+    public Package(Cards stack, String name, int price) {
+        super(stack.getCards());
+        this.name = name;
+        this.price = price;
     }
 
+    /**
+     * Holt den namen des Packages
+     * @return Name des Packages
+     */
     public String getName() {
-        return null;
+        return this.name;
     }
 
+    /**
+     * Holt den Preis des Packages
+     * @return Preis des Packages
+     */
     public int getPrice() {
-        return 0;
+        return this.price;
     }
 
+    /**
+     * Setzt den Namen des Packages
+     * @param neuName Neuer name des Packages
+     */
     public void setName(String neuName) {
-
+        this.name = neuName;
     }
 }

src/main/java/Stack.java

@@ -1,17 +1,48 @@
+/**
+ * Erweitert Cards insofern, dass es im Stack auch ein Deck gibt
+ */
 public class Stack extends Cards{
-    public Stack(Cards cards, Cards nochNewCards) {
+    private Cards deck;
 
+    /**
+     * Erstellt einen neuen Stack aus den User Cards und seinem Deck
+     * @param cards Alle Cards des Users
+     * @param deck Sein Deck
+     */
+    public Stack(Cards cards, Cards deck) {
+        super(cards.getCards());
+        this.deck = deck;
     }
 
+    /**
+     * Fügt ein neues Deck in den Stack ein
+     * @param newCards Gesamtes Deck
+     */
     public void addDeck(Cards newCards) {
-
+        this.deck = newCards;
     }
 
+    /**
+     * Holt das gesamte Deck
+     * @return Gesamtes Deck
+     */
     public Cards getDeck() {
-        return null;
+        return this.deck;
     }
 
-    public boolean delDeck(Cards delCards) {
-        return false;
+    /**
+     * Löscht eine Card aus dem Deck
+     * @param toDel Card zum löschen
+     */
+    public void delDeck(Card toDel) {
+        this.deck.delCard(toDel);
+    }
+
+    /**
+     * Fügt dem deck eine neue Card ein
+     * @param toAdd Neue Card
+     */
+    public void addDeckCard(Card toAdd){
+        this.deck.addCard(toAdd);
     }
 }

src/main/java/Store.java

@@ -9,7 +9,5 @@ public interface Store {
 
     boolean doTrading(TradingDeal tradingDeal1, TradingDeal tradingDeal2);
 
-    ArrayList<TradingDeal> getPossibleTradingDeals();
-
-    ArrayList<TradingDeal> getPossibleAvailableTradingDeals();
+    ArrayList<TradingDeal> getPossibleTradingDeals(Card toTrade);
 }

src/main/java/TradingDeal.java

@@ -1,43 +1,128 @@
+/**
+ * Ein einzelner Trading deal wird hier verwaltet.
+ */
 public class TradingDeal {
+    private User tradingUser;
+    private Card cardToTrade;
+    private ElementTyp requiredElementType;
+    private double requiredMinDamage;
+    private CardType requiredCardType;
+
+    /**
+     * Ein TradingDeal wird  erstellt
+     * @param user User des Deals
+     * @param cardToTrade Card die getauscht werden soll
+     * @param requiredElementType Req ElementType für den Tausch
+     * @param requiredMinDamage Req min damage für den Tausch
+     * @param requiredCardType Req Card Type für den Tausch
+     */
     public TradingDeal(User user, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType) {
+        this.tradingUser = user;
+        this.cardToTrade = cardToTrade;
+        this.requiredElementType = requiredElementType;
+        this.requiredMinDamage = requiredMinDamage;
+        this.requiredCardType = requiredCardType;
     }
 
+    /**
+     * Holt den Trading User
+     * @return User der den Trade erstellt hat
+     */
     public User getTradingUser() {
-        return null;
+        return this.tradingUser;
     }
 
+    /**
+     * Card die getraded werden soll
+     * @return Card die getradet werden soll
+     */
     public Card getCardToTrade() {
-        return null;
+        return this.cardToTrade;
     }
 
+    /**
+     * Req Element type holen
+     * @return Req Element Type
+     */
     public ElementTyp getRequiredElementType() {
-        return null;
+        return this.requiredElementType;
     }
 
-    public int getRequiredMinDamage() {
-        return 0;
+    /**
+     * Req min damage holen
+     * @return Req min damage
+     */
+    public double getRequiredMinDamage() {
+        return this.requiredMinDamage;
     }
 
+    /**
+     * Hole req cardtype
+     * @return Req CardType
+     */
     public CardType getRequiredCardType() {
-        return null;
+        return this.requiredCardType;
     }
 
-    public void setTradingUser(User user) {
-
+    /**
+     * Setzt den User des Trades
+     * @param tradingUser User der Traded
+     */
+    public void setTradingUser(User tradingUser) {
+        this.tradingUser = tradingUser;
     }
 
-    public void setCardToTrade(Card card) {
-
+    /**
+     * Setzt die Karte die Getradet werden soll
+     * @param cardToTrade Card zum tauschen
+     */
+    public void setCardToTrade(Card cardToTrade) {
+        this.cardToTrade = cardToTrade;
     }
 
-    public void setRequiredElementType(ElementTyp elementTyp) {
+    /**
+     * Setzt req elementType
+     * @param requiredElementType Der Req elementType
+     */
+    public void setRequiredElementType(ElementTyp requiredElementType) {
+        this.requiredElementType = requiredElementType;
     }
 
-    public void setRequiredMinDamage(int damage) {
-
+    /**
+     * Setzt die req Min damage
+     * @param requiredMinDamage Die req min gamage
+     */
+    public void setRequiredMinDamage(double requiredMinDamage) {
+        this.requiredMinDamage = requiredMinDamage;
     }
 
-    public void setRequiredCardType(CardType cardType) {
+    /**
+     * Setzt req cardType
+     * @param requiredCardType Der Req CardType
+     */
+    public void setRequiredCardType(CardType requiredCardType) {
+        this.requiredCardType = requiredCardType;
+    }
 
+    /**
+     * Vom deal im Parameter wird die Card mit den Requirements von THIS verglichen
+     * @param checkDeal Von diesem Deal wird die CardToTrade geprüft
+     * @return True wenn der Deal passt
+     */
+    public boolean dealOk(TradingDeal checkDeal){
+        return this.cardOk(checkDeal.getCardToTrade());
+    }
+
+    /**
+     * Von der Card im Parameter wird die Card mit den Requirements von THIS verglichen
+     * @param checkCard Card die mit dem Deal verglichen wird
+     * @return True wenn der Deal passt
+     */
+    public boolean cardOk(Card checkCard){
+        if(checkCard.getCardType().equals(this.requiredCardType) && checkCard.getElementTyp().equals(this.requiredElementType) && checkCard.getDamage() >= this.requiredMinDamage){
+            return true;
+        }else {
+            return false;
+        }
     }
 }

src/main/java/User.java

@@ -1,55 +1,218 @@
 import java.util.ArrayList;
 
+/**
+ * User & Store Logik
+ */
 public class User implements Store{
+    private String name, nachname, email;
+    private Stack stack;
+    private DBConnection db;
+    private Credentials credentials;
+    private Coins coins;
+
+    /**
+     * Erstellt einen neuen User
+     * @param credentials Zugangsdaten des Users
+     * @param name Name des Users
+     * @param nachname Nachname des Users
+     * @param email Email des Users
+     * @param stack Alle Karten des Users
+     * @param coins Alle Münzen des Users
+     */
     public User(Credentials credentials, String name, String nachname, String email, Stack stack, Coins coins) {
-
+        this.credentials = credentials;
+        this.name = name;
+        this.nachname = nachname;
+        this.email = email;
+        this.stack = stack;
+        this.coins = coins;
+        this.db = new DBConnection();
     }
 
+    /**
+     * Holt den Stack des Users
+     * @return Stack des Users
+     */
+    public Stack getStack() {
+        return stack;
+    }
+
+    /**
+     * Setzt den Stack eines Users
+     * @param stack Der neue Stack des Users
+     */
+    public void setStack(Stack stack) {
+        this.stack = stack;
+    }
+
+    /**
+     * Holt das DB Obj
+     * @return Das DB Obj
+     */
+    public DBConnection getDb() {
+        return db;
+    }
+
+    /**
+     * Setzt ein neues DB Obj
+     * @param db Das neue DB Obj
+     */
+    public void setDb(DBConnection db) {
+        this.db = db;
+    }
+
+    /**
+     * Holt die eindeutigen Logindaten des Users
+     * @return Eindeutige Logindaten
+     */
+    public Credentials getCredentials() {
+        return credentials;
+    }
+
+    /**
+     * Setzt die eindeutigen Logindaten
+     * @param credentials Die neuen Credentials des Users
+     */
+    public void setCredentials(Credentials credentials) {
+        this.credentials = credentials;
+    }
+
+    /**
+     * Holt alle Coins des Users
+     * @return Coins des Users
+     */
+    public Coins getCoins() {
+        return coins;
+    }
+
+    /**
+     * Setzt alle Coins des Users
+     * @param coins Neue Coins des Users
+     */
+    public void setCoins(Coins coins) {
+        this.coins = coins;
+    }
+
+    /**
+     * Get Name of User
+     * @return Name of User
+     */
     public String getName() {
-        return null;
+        return this.name;
     }
 
+    /**
+     * Get Nachname of User
+     * @return Nachname of User
+     */
     public String getNachname() {
-        return null;
+        return this.nachname;
     }
 
+    /**
+     * Email of User
+     * @return Email of User
+     */
     public String getEmail() {
-        return null;
+        return this.email;
     }
 
-    public String setName(String name) {
-        return null;
+    /**
+     * Setzt den Namen des Users
+     * @param name Neuer Name des Users
+     */
+    public void setName(String name) {
+        this.name = name;
     }
 
-    public String setNachname(String nachname) {
-        return null;
+    /**
+     * Setzt den Nachnamen
+     * @param nachname Neuer Nachname
+     */
+    public void setNachname(String nachname) {
+        this.nachname = nachname;
     }
 
-    public String setEmail(String email) {
-        return null;
+    /**
+     * Setzt die Email des Users
+     * @param email Neue Email des Users
+     */
+    public void setEmail(String email) {
+        this.email = email;
     }
 
-    public Cards buyPackage(Package mypackage) {
-        return null;
+    //Store Methoden
+
+    /**
+     * Kauft ein Package
+     * @param mypackage Package welches gekauft werden soll
+     * @return Alle Karten des neuen Package
+     * @throws NegativAmountException Wenn ein negativer Preis im Package gesetzt wird.
+     */
+    public ArrayList<Card> buyPackage(Package mypackage) throws NegativAmountException {
+        ArrayList<Package> availablePackages = db.getAllPackages();
+        availablePackages.removeIf(obj -> obj.equals(mypackage));
+        this.coins.removeCoin(mypackage.getPrice());
+        return mypackage.getCards();
     }
 
+    /**
+     * Fügt dem Store einen neuen Tradingdeal hinzu
+     * @param tradingDeal Der neue Tradingdeal
+     */
     public void addTradingDeal(TradingDeal tradingDeal) {
-
+        db.addTradingDeal(tradingDeal);
     }
 
+    /**
+     * Holt alle verfügbaren Tradingdeals
+     * @return Alle verfügbaren Deals
+     */
     public ArrayList<TradingDeal> getTradingDeals() {
-        return null;
+        return db.getAllTradingDeals();
     }
 
-    public boolean doTrading(TradingDeal tradingDeal1, TradingDeal tradingDeal2) {
+    /**
+     * Startet ein Trading zw 2 TradingDeals
+     * @param myTradingDeal Wenn der Deal passt, wird diese Karte aus dem Stack entfernt
+     * @param storeTradingDeal Wenn der Deal passt, wird diese Karte dem Stack hinzugefügt
+     * @return True wenn erfolgreich, False wenn die Deals nicht zusammenpassen
+     */
+    public boolean doTrading(TradingDeal myTradingDeal, TradingDeal storeTradingDeal) {
+        if (storeTradingDeal.dealOk(myTradingDeal)){
+            stack.delCard(myTradingDeal.getCardToTrade());
+            stack.addCard(storeTradingDeal.getCardToTrade());
+        }
         return false;
     }
 
-    public ArrayList<TradingDeal> getPossibleTradingDeals() {
-        return null;
+    /**
+     * Gibt alle Möglichen Trading Deals zurück
+     * @param toTrade Prüft nach diesem Deal
+     * @return
+     */
+    @Override
+    public ArrayList<TradingDeal> getPossibleTradingDeals(Card toTrade) {
+        ArrayList<TradingDeal> storeList = db.getAllTradingDeals();
+        ArrayList<TradingDeal> possible = new ArrayList<TradingDeal>();
+        storeList.forEach(item -> {
+            if(item.cardOk(toTrade)){
+                possible.add(item);
+            }
+        });
+        return possible;
     }
 
-    public ArrayList<TradingDeal> getPossibleAvailableTradingDeals() {
-        return null;
+    /**
+     * Checkt ob es sich um den selben User handelt
+     * @param toCheck Mit diesem User wird verglichen
+     * @return True wenn es der selbe User ist
+     */
+    public boolean equals(User toCheck){
+        if (toCheck.getCredentials().getUsername() == this.credentials.getUsername() && toCheck.getCredentials().getPasswort() == this.credentials.getPasswort()){
+            return true;
+        }else {
+            return false;
+        }
     }
 }