Test added for playCard and wonTrick(). wonTrick() test fails. Also removed firstCard from Constructor.

src/main/scala/Worksheet.sc

@@ -1,12 +1,3 @@
-import de.knockoutwhist.cards.CardManager
-
-val eol = sys.props("line.separator") // String =
-def bar(cellwidth: Int = 3, cellNum: Int = 3) = (("+" + "-" * cellwidth)*cellNum) + "+" + eol
-def cells(cellwidth: Int = 3, cellNum: Int = 3) = ("|" + " " * cellwidth) *cellNum + "|" + eol
-def mesh(cellwidth: Int = 3, cellNum: Int = 3) = (bar(cellwidth, cellNum) + cells(cellwidth, cellNum)) * cellNum + eol
-
-bar(8,6)
-cells()
-mesh()
+
 
 

src/main/scala/de/knockoutwhist/KnockOutWhist.scala

@@ -8,38 +8,9 @@ object KnockOutWhist {
   class KnockOutWhist {
 
   }
-
-  val eol: String = sys.props("line.separator")
-
-  def bar(cellWidth: Int = 9, cellNum: Int = 1): String =
-    ("-" * cellWidth) * cellNum
-
-  def cells(cellWidth: Int = 7, cellNum: Int = 1): String =
-    ("|" + " " * cellWidth) * cellNum + "|"
-
-  def meshk: String =
-    bar() + cells() + eol + "|Karten | " + eol + (cells()+ eol) * 2 + bar() + eol
-
-  def mesha: String =
-    bar() + cells() + eol + "|Ablage | " + eol + (cells()+ eol) * 2 + bar() + eol
-
-  private def mesht1 =
-    bar() + eol + cells() + eol + "|Trumpfe| " + eol + "|s1     |\n" + cells() + eol + bar() + eol
-
-  private def mesht2 =
-    bar() + eol + cells() + eol + "|Trumpfe|" + eol + "|s2     |\n" + cells() + eol + bar() + eol
-  private def meshTable = {
-    bar() + "\t" + bar() + eol + cells() + "\t" + cells() + eol +
-      "|Karten |" + "\t" + "|Ablage |" + eol + (cells() + "\t" + cells() + eol) * 2 +
-      bar() + "\t" + bar() + eol
-  }
-
   def main(args: Array[String]): Unit = {
     println("Welcome to Knock out Whist")
-
-    print(meshTable)
-    print(mesht1)
-    print(mesht2)
+    
 
 
   }

src/main/scala/de/knockoutwhist/rounds/Round.scala

@@ -1,7 +1,15 @@
 package de.knockoutwhist.rounds
-
+import de.knockoutwhist.rounds.Trick
 import de.knockoutwhist.cards.Suit
+import de.knockoutwhist.cards.Player
+import scala.collection.mutable.ListBuffer
 
-case class Round(trumpSuit: Suit, cardAmount: Int) {
+case class Round(trumpSuit: Suit, cardAmount: Int, tricklist: ListBuffer[Trick], players_in: List[Player]) {
+  def create_trick(trumpSuit: Suit, players_in: List[Player]): Unit = 
+  {
+    
+  }  
+  
+  
   
 }

src/main/scala/de/knockoutwhist/rounds/Trick.scala

@@ -1,26 +1,30 @@
 package de.knockoutwhist.rounds
 
 import de.knockoutwhist.cards.{Card, Player}
+import de.knockoutwhist.cards.Suit
 
 import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
 
-case class Trick private(round: Round, firstCard: Card, cards: mutable.HashMap[Card, Player], winner: Player = null, finished: Boolean = false) {
-  
-  def this(round: Round, firstCard: Card) = this(round, firstCard, mutable.HashMap[Card, Player]())
 
+case class Trick private(round: Round, cards: mutable.HashMap[Card, Player], winner: Player = null, finished: Boolean = false) {
+  
+  def this(round: Round) = this(round, mutable.HashMap[Card, Player]())
+  var first_card: Option[Suit] = None // statt als Parameter im Konstruktor
   /**
    * Play a card in the trick
    * @param card The card to play
    * @return True if the card has a chance of winning the trick, false otherwise
    */
   def playCard(card: Card, player: Player): Boolean = {
-    if (cards.isEmpty) {
-      throw new IllegalStateException("Cannot play a card in an empty trick")
-    } else if (trickFinished()) {
+    if (finished) {
       throw new IllegalStateException("This trick is already finished")
     } else {
-      if (card.suit == firstCard.suit) {
+      if (cards.isEmpty) {
+        first_card = Some(card.suit)
+        cards += (card -> player)
+        true
+      } else if (card.suit == first_card) {
         cards += (card -> player)
         true
       } else if (card.suit == round.trumpSuit) {
@@ -33,24 +37,17 @@ case class Trick private(round: Round, firstCard: Card, cards: mutable.HashMap[C
     }
   }
   
-  def trickFinished(): Boolean = {
-    cards.size == round.cardAmount
-  }
-  
   def wonTrick(): (Player, Trick) = {
-    if (!trickFinished()) {
-      throw new IllegalStateException("Cannot determine winner of unfinished trick")
-    } else {
-      val winningCard = {
-        if (cards.keys.exists(_.suit == round.trumpSuit)) {
-          cards.keys.filter(_.suit == round.trumpSuit).maxBy(_.cardValue.ordinal)
-        } else {
-          cards.keys.filter(_.suit == firstCard.suit).maxBy(_.cardValue.ordinal)
-        }
+    val winningCard = {
+      if (cards.keys.exists(_.suit == round.trumpSuit)) {
+        cards.keys.filter(_.suit == round.trumpSuit).maxBy(_.cardValue.ordinal) //stream
+      } else {
+        cards.keys.filter(_.suit == first_card).maxBy(_.cardValue.ordinal) //stream
       }
-      val winningPlayer = cards(winningCard)
-      (winningPlayer, Trick(round, firstCard, cards, winningPlayer, true))
+    } 
+    val winningPlayer = cards(winningCard)
+    (winningPlayer, Trick(round, cards, winningPlayer, true))
     }
   }
-  
-}
+
+

src/test/scala/de/knockoutwhist/cards/DeckTests.scala

@@ -3,7 +3,11 @@ package de.knockoutwhist.cards
 import org.scalatest.matchers.must.Matchers
 import org.scalatest.matchers.should.Matchers.{should, shouldBe}
 import org.scalatest.wordspec.AnyWordSpec
+import de.knockoutwhist.rounds.Trick
+import de.knockoutwhist.rounds.Round
+import de.knockoutwhist.cards.Player
 
+import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
 
 class DeckTests extends AnyWordSpec with Matchers{
@@ -113,5 +117,30 @@ class DeckTests extends AnyWordSpec with Matchers{
       hand.renderAsString() shouldBe expectedResult
     }
   }
+  "A trick" should {
+    "be able to place a card in the HashMap" in {
+      val playerlist = List(Player("Gunter"))
+      val player = Player("Gunter")
+      val tricks_played: ListBuffer[Trick] = ListBuffer.empty[Trick]
+      val round = Round(Suit.Spades, 7, tricks_played, playerlist)
+      val card = Card(CardValue.Ace, Suit.Spades)
+      val trick = new Trick(round)
+      trick.playCard(card, player) shouldBe true
+    }
+    "be able to tell who won the trick" in {
+      val playerlist = List(Player("Gunter"))
+      val player = Player("Gunter")
+      val tricks_played: ListBuffer[Trick] = ListBuffer.empty[Trick]
+      val round = Round(Suit.Spades, 7, tricks_played, playerlist)
+      val card = Card(CardValue.Ace, Suit.Spades)
+      val trick = new Trick(round)
+      // val hashMap: mutable.HashMap[Card, Player] = mutable.HashMap.empty[Card, Player]
+      // hashMap += (card, player)
+
+      trick.playCard(card, player)
+      trick.wonTrick() shouldBe (player,trick)
+
+    }
+  }
 
 }