implement card organisation and movement between decks

- extension of ArrayList for Deck class to provide methods for movement between
e.g. handcards, playarea, discard-pile …
- basic Market + purchase functionality
- Singleton for market as only one per game-session is allowed

closes #24, closes #21, relates to #28, relates to #55, #54, #53,
relates to #80

app/src/main/java/at/vunfer/openrealms/model/Deck.java

@@ -0,0 +1,29 @@
+/* Licensed under GNU GPL v3.0 (C) 2023 */
+package at.vunfer.openrealms.model;
+
+import java.util.ArrayList;
+import java.util.Random;
+
+public class Deck<T> extends ArrayList<T> {
+    private static final Random rand = new Random();
+
+    public T drawRandom() throws IllegalStateException {
+        if (super.isEmpty()) {
+            throw new IllegalStateException("Cannot draw from empty source.");
+        }
+
+        int index = rand.nextInt(super.size());
+        T drawn = super.get(index);
+        super.remove(drawn);
+
+        return drawn;
+    }
+
+    public T draw(T item) throws IllegalArgumentException {
+        if (!super.contains(item)) {
+            throw new IllegalArgumentException("Item not in deck.");
+        }
+        super.remove(item);
+        return item;
+    }
+}

app/src/main/java/at/vunfer/openrealms/model/Market.java

@@ -1,4 +1,47 @@
 /* Licensed under GNU GPL v3.0 (C) 2023 */
 package at.vunfer.openrealms.model;
 
-public class Market {}
+import android.util.Log;
+import java.util.ArrayList;
+
+public class Market {
+    private static Market INSTANCE;
+    private static final int TOTAL_PURCHASABLE = 5;
+    private static final String TAG = "PlayerCards";
+    Deck<Card> marketDeck;
+    Deck<Card> forPurchase;
+
+    private Market() {}
+
+    public static Market getInstance() {
+        if (INSTANCE == null) {
+            INSTANCE = new Market();
+        }
+        return INSTANCE;
+    }
+
+    public ArrayList<Card> getForPurchase() {
+        return forPurchase;
+    }
+
+    public int restock() {
+        int restocked = 0;
+        while (forPurchase.size() < TOTAL_PURCHASABLE) {
+            try {
+                forPurchase.add(marketDeck.drawRandom());
+                restocked++;
+            } catch (Exception e) {
+                Log.v(TAG, "You have no more cards to draw for the market.");
+            }
+        }
+        return restocked;
+    }
+
+    public Card purchase(Card card) {
+        if (card == null || !forPurchase.contains(card)) {
+            throw new IllegalArgumentException("Card is not to purchase.");
+        }
+        forPurchase.remove(card);
+        return card;
+    }
+}

app/src/main/java/at/vunfer/openrealms/model/PlayArea.java

@@ -1,98 +1,61 @@
 /* Licensed under GNU GPL v3.0 (C) 2023 */
 package at.vunfer.openrealms.model;
 
-import java.util.ArrayList;
 import java.util.List;
 
 public class PlayArea {
     private int health;
     private int turnDamage;
     private int turnHealing;
     private int turnCoins;
-    private List<Card> playedCards;
-    private List<Card> playedChampions;
+
+    private Market market;
+    private Deck<Card> playedCards;
+    private Deck<Card> playedChampions;
     private PlayerCards playerCards;
 
-    public PlayArea(
-            int health,
-            PlayerCards playerCards) {
+    public PlayArea(int health, PlayerCards playerCards) {
 
         this.health = health;
         this.turnDamage = 0;
         this.turnHealing = 0;
         this.turnCoins = 0;
-        this.playedCards = new ArrayList<Card>();
-        this.playedChampions = new ArrayList<Card>();
+        this.playedCards = new Deck<Card>();
+        this.playedChampions = new Deck<Card>();
         this.playerCards = playerCards;
+        this.market = Market.getInstance();
     }
 
     public int getHealth() {
         return health;
     }
 
-    public void setHealth(int health) {
-        this.health = health;
-    }
-
     public int getTurnDamage() {
         return turnDamage;
     }
 
-    public void setTurnDamage(int turnDamage) {
-        this.turnDamage = turnDamage;
-    }
-
     public int getTurnHealing() {
         return turnHealing;
     }
 
-    public void setTurnHealing(int turnHealing) {
-        this.turnHealing = turnHealing;
+    public PlayerCards getPlayerCards() {
+        return playerCards;
     }
 
     public int getTurnCoins() {
         return turnCoins;
     }
 
-    public void setTurnCoins(int turnCoins) {
-        this.turnCoins = turnCoins;
-    }
-
     public List<Card> getPlayedCards() {
         return playedCards;
     }
 
-    public void setPlayedCards(List<Card> playedCards) {
-        this.playedCards = playedCards;
-    }
-
     public List<Card> getPlayedChampions() {
         return playedChampions;
     }
 
-    public void setPlayedChampions(List<Card> playedChampions) {
-        this.playedChampions = playedChampions;
-    }
-
-    public PlayerCards getPlayerCards() {
-        return playerCards;
-    }
-
-    public void setPlayerCards(PlayerCards playerCards) {
-        this.playerCards = playerCards;
-    }
-
-    public Card playCard(Card card) {
-        if (playerCards.playCard(card) != null) {
-            playedCards.add(card);
-            useCardEffect(card);
-            return card;
-        }
-        return null;
-    }
-
-    public void useCardEffect(Card card) {
-        card.getAbility().resolveAbility(this);
+    public void playCard(Card card) {
+        playedCards.add(playerCards.popFromHand(card));
     }
 
     public Card useCardAllyEffect(Card card) {
@@ -129,4 +92,25 @@ public void heal(int value) {
     public void takeDamage(int value) {
         health -= value;
     }
+
+    public void visitDamage(int damage) {
+        turnDamage += damage;
+    }
+
+    public void visitCoin(int coin) {
+        turnCoins += coin;
+    }
+
+    public void visitHealing(int healing) {
+        turnHealing += healing;
+    }
+
+    public void buyCard(Card card) throws IllegalArgumentException {
+        if (this.turnCoins < card.getCost()) {
+            throw new IllegalArgumentException("Not enough coins this turn");
+        }
+        turnCoins -= card.getCost();
+        market.purchase(card);
+        playerCards.addBoughtCard(card);
+    }
 }

app/src/main/java/at/vunfer/openrealms/model/PlayerCards.java

@@ -4,70 +4,57 @@
 import java.util.List;
 
 public class PlayerCards {
-    private List<Card> handCards;
-    private List<Card> deckCards;
-    private List<Card> discardedCards;
-    private Market market;
-
-    public PlayerCards(
-            List<Card> handCards,
-            List<Card> deckCards,
-            List<Card> discardedCards,
-            Market market) {
-        this.handCards = handCards;
-        this.deckCards = deckCards;
-        this.discardedCards = discardedCards;
-        this.market = market;
+    private static final String TAG = "PlayerCards";
+    private Deck<Card> handCards;
+    private Deck<Card> deckCards;
+    private Deck<Card> discardedCards;
+
+    private static final int HANDSIZE = 5;
+
+    public PlayerCards() {
+        List<Effect> effects = List.of(new DamageEffect(3), new CoinEffect(4));
+
+        this.handCards = new Deck<Card>();
+        this.deckCards = new Deck<Card>();
+        this.discardedCards = new Deck<Card>();
+        this.deckCards.add(new Card("Dagger", 0, List.of(new DamageEffect(1))));
+        this.deckCards.add(new Card("Shortsword", 0, List.of(new HealingEffect(2))));
+        this.deckCards.add(new Card("Ruby ", 0, List.of(new CoinEffect(2))));
+        for (int i = 0; i < 7; i++){
+            this.deckCards.add(new Card("Coin", 0, List.of(new CoinEffect(1))));
+        }
+        while (handCards.size() < HANDSIZE) {
+            handCards.add(deckCards.drawRandom());
+        }
     }
 
-    public List<Card> getHandCards() {
+    public Deck<Card> getHandCards() {
         return handCards;
     }
 
-    public void setHandCards(List<Card> handCards) {
-        this.handCards = handCards;
-    }
-
-    public List<Card> getDeckCards() {
-        return deckCards;
-    }
-
-    public void setDeckCards(List<Card> deckCards) {
-        this.deckCards = deckCards;
-    }
-
-    public List<Card> getDiscardedCards() {
-        return discardedCards;
-    }
-
-    public void setDiscardedCards(List<Card> discardedCards) {
-        this.discardedCards = discardedCards;
-    }
-
-    public Market getMarket() {
-        return market;
+    public void discard(Card card) throws IllegalArgumentException {
+        discardedCards.add(handCards.draw(card));
     }
 
-    public void setMarket(Market market) {
-        this.market = market;
+    public void addBoughtCard(Card card){
+        discardedCards.add(card);
     }
 
-    public Card draw() {
-        return null;
+    public Card popFromHand(Card card) {
+        return handCards.draw(card);
     }
 
-    public Card discard() {
-        return null;
-    }
+    public void restockHand() {
+        if (deckCards.size() < HANDSIZE) {
+            handCards.addAll(deckCards);
+            deckCards.clear();
 
-    public Card playCard(Card card) {
-        if (handCards.contains(card)) {
-            return card;
+            deckCards.addAll(discardedCards);
+            discardedCards.clear();
         }
-        return null;
-    }
 
-    public Card buyCard(Card card) {
-        return null;
+        while (handCards.size() < HANDSIZE) {
+            handCards.add(deckCards.drawRandom());
+        }
     }
 }