feat(user-sessions): enhance game lobby management with user session handling and game full exception (#51)

Reviewed-on: #51
Co-authored-by: Janis <janis.e.20@gmx.de>
Co-committed-by: Janis <janis.e.20@gmx.de>

.idea/copilot.data.migration.agent.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AgentMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/copilot.data.migration.ask.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AskMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/copilot.data.migration.ask2agent.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Ask2AgentMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/copilot.data.migration.edit.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="EditMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

DOCKER-COMMANDS

@@ -0,0 +1 @@
+docker run -it --rm -e DISPLAY=host.docker.internal:0 -v /tmp/.X11-unix:/tmp/.X11-unix knockout:v1

Dockerfile

@@ -0,0 +1,35 @@
+FROM sbtscala/scala-sbt:eclipse-temurin-jammy-22_36_1.10.0_3.4.2
+
+WORKDIR /knockout
+
+ENV DEBIAN_FRONTEND=noninterface
+
+RUN apt-get update && apt-get install -y curl gnupg2 x11-apps
+RUN apt-get update && apt-get install -y \
+    libxext6 \
+    libxrender1 \
+    libxtst6 \
+    libxi6 \
+    libxrandr2 \
+    libgtk-3-0 \
+    xorg
+
+RUN curl -sL https://dlcdn.apache.org/sbt/debian/sbt-1.9.4.deb -o sbt.deb
+
+RUN dpkg -i sbt.deb || apt-get install -f -y
+
+ENV DEBIAN_FRONTEND=dialog
+
+RUN sbt update
+
+ENV DISPLAY=:99
+ENV SBT_OPTS="-Xms512M -Xmx1536M -Xss2M -XX:MaxMetaspaceSize=512M"
+ENV _JAVA_OPTIONS="-Djava.security.policy=applet.policy -Dprism.order=sw"
+
+VOLUME /tmp/.X11-unix
+
+COPY . /knockout
+
+RUN sbt compile
+
+CMD ["sh", "-c", "sbt run"]

README.md

@@ -1,4 +1,4 @@
-# Knock-out Whist
+# Knock-out Whist [![Coverage Status](https://coveralls.io/repos/github/16Janis12/KnockOutWhist/badge.svg?branch=master)](https://coveralls.io/github/16Janis12/KnockOutWhist?branch=master) [![Build-Status-Master](https://teamcity.janis-eccarius.de/guestAuth/app/rest/builds/buildType:(id:KnockOutWhist_BuildAndTest),branch:master/statusIcon.png)](https://teamcity.janis-eccarius.de/viewType.html?buildTypeId=KnockOutWhist_BuildAndTest&branch=master) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=16Janis12_KnockOutWhist&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=16Janis12_KnockOutWhist)
 ## About the Game
 Knock-out Whist is a trick-taking card game designed for 2 to 7 players. It uses a standard 52-card deck.
 The objective is to win tricks. Players who fail to win at least one trick in a round are eliminated.
@@ -29,14 +29,17 @@ If they win a trick, they re-enter the game in the following round. When this ha
 ## About the project
 This project is a Scala implementation of the Knock-out Whist card game. It is maintained by 2 students of the HTWG Konstanz.
 
-Last stable build: [![Build-Status-Master](https://teamcity.janis-eccarius.de/guestAuth/app/rest/builds/buildType:(id:KnockOutWhist_BuildAndTest),branch:master/statusIcon.png)](https://teamcity.janis-eccarius.de/viewType.html?buildTypeId=KnockOutWhist_BuildAndTest&branch=master)
+Last stable build: [![Build-Status-Master](https://teamcity.janis-eccarius.de/app/rest/builds/buildType:id:KnockOutWhist_BuildAndTest/statusIcon.svg)](https://teamcity.janis-eccarius.de/viewType.html?buildTypeId=KnockOutWhist_BuildAndTest&branch=master)
 
-Last development build: [![Build-Status-Dev](https://teamcity.janis-eccarius.de/guestAuth/app/rest/builds/buildType:(id:KnockOutWhist_BuildAndTest),branch:development/statusIcon.png)](https://teamcity.janis-eccarius.de/viewType.html?buildTypeId=KnockOutWhist_BuildAndTest&branch=development)
+Last development build: [![Build-Status-Dev](https://teamcity.janis-eccarius.de/app/rest/builds/buildType:id:KnockOutWhist_BuildAndTest,branch:name:development/statusIcon.svg)](https://teamcity.janis-eccarius.de/viewType.html?buildTypeId=KnockOutWhist_BuildAndTest&branch=development)
 
 Gitea: [https://git.janis-eccarius.de/KnockOutWhist/KnockOutWhist](https://git.janis-eccarius.de/KnockOutWhist/KnockOutWhist)
 
 GitHub (Mirror): [https://github.com/16Janis12/KnockOutWhist](https://github.com/16Janis12/KnockOutWhist)
 
+SonarQube: [https://sonarcloud.io/project/overview?id=16Janis12_KnockOutWhist](https://sonarcloud.io/project/overview?id=16Janis12_KnockOutWhist)
+
+Coveralls: [https://coveralls.io/github/16Janis12/KnockOutWhist](https://coveralls.io/github/16Janis12/KnockOutWhist)
 
 ## Licence
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

build.sbt

@@ -1,30 +0,0 @@
-ThisBuild / version := "0.1.0-SNAPSHOT"
-ThisBuild / scalaVersion := "3.5.1"
-
-Compile/mainClass := Some("de.knockoutwhist.KnockOutWhist")
-
-name := "KnockOutWhist"
-version := {
-  val major = sys.env.getOrElse("MAJOR_VERSION", "0")
-  val minor = sys.env.getOrElse("MINOR_VERSION", "0")
-  val buildNR = sys.env.getOrElse("BUI_COUNTER", "1")
-  s"$major.$minor.$buildNR"
-}
-organization := "de.knockoutwhist"
-
-lazy val root = (project in file("."))
-  .settings(
-    name := "Projekt-zu-SE"
-  )
-
-
-
-libraryDependencies += "org.scalactic" %% "scalactic" % "3.2.18"
-libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.18" % "test"
-
-Test / testOptions += Tests.Filter(_.equals("de.knockoutwhist.TestSequence"))
-
-coverageEnabled := true
-coverageFailOnMinimum := true
-coverageMinimumStmtTotal := 85
-coverageMinimumBranchTotal := 100

project/build.properties

@@ -1 +0,0 @@
-sbt.version = 1.10.2

project/plugins.sbt

@@ -1 +0,0 @@
-addSbtPlugin("org.scoverage" % "sbt-scoverage" % "2.2.1")

src/main/scala/Worksheet.sc

@@ -1,5 +0,0 @@
-import de.knockoutwhist.cards.CardManager
-
-val originalDeck = List(CardManager.cardContainer)
-CardManager.shuffleAndReset()
-val shuffledDeck = CardManager.cardContainer

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

@@ -1,24 +1,45 @@
 package de.knockoutwhist
 
 
-import de.knockoutwhist.control.MatchControl
-import de.knockoutwhist.control.text.TextMatchControl
+import com.google.inject.{Guice, Injector}
+import de.knockoutwhist.components.Configuration
+import de.knockoutwhist.control.ControlThread
+import de.knockoutwhist.control.controllerBaseImpl.BaseGameLogic
+import de.knockoutwhist.di.KnockOutConfigurationModule
+import de.knockoutwhist.utils.events.EventListener
 
 
 object KnockOutWhist {
-
-  val matchControl: MatchControl = TextMatchControl
+  
   /*
-  Debug mode:
-
+  Debug mode
   - Disables the random shuffle of the cards
    */
-  private[knockoutwhist] var DEBUG_MODE_VAR: Boolean = true
+  private[knockoutwhist] var DEBUG_MODE_VAR: Boolean = false
+  
+  private var _config: Option[Configuration] = None
+  
+  def config: Configuration = _config.get
 
-  def DEBUG_MODE = DEBUG_MODE_VAR
+  def debugmode: Boolean = DEBUG_MODE_VAR
 
   def main(args: Array[String]): Unit = {
-    if(!matchControl.initial()) throw new IllegalStateException("Game could not be started.")
+    val injector: Injector = Guice.createInjector(KnockOutConfigurationModule())
+    val config: Configuration = injector.getInstance(classOf[Configuration])
+    entry(config)
+  }
+  
+  def entry(configuration: Configuration): Unit = {
+    _config = Some(configuration)
+    val baseLogic = BaseGameLogic(configuration)
+    for (handler <- configuration.listener) baseLogic.addListener(handler)
+    for (ui <- configuration.uis) {
+      if (!ui.initial(baseLogic)) throw new IllegalStateException(s"${ui.getClass.getName} could not be started.")
+      ui match {
+        case eventListener: EventListener => baseLogic.addListener(eventListener)
+        case _ =>
+      }
+    }
   }
   
 }

src/main/scala/de/knockoutwhist/Worksheet.sc

@@ -0,0 +1,9 @@
+//start from 0, stop at 9 inclusive
+for (i <- 0 until 10){
+  println("Hi " + i)
+}
+
+//or start from 0, stop at 9 inclusive
+for (i <- 0 to 9){
+  println("Hi " + i)
+}

src/main/scala/de/knockoutwhist/cards/Card.scala

@@ -1,8 +1,5 @@
 package de.knockoutwhist.cards
 
-import de.knockoutwhist.cards.CardValue.Ten
-import de.knockoutwhist.cards.Suit
-
 enum Suit(identifier: String):
 
   def cardType(): String = identifier
@@ -34,34 +31,15 @@ enum CardValue(identifier: String):
 end CardValue
 
 case class Card(cardValue: CardValue, suit: Suit) {
+  
+  override def toString: String = s"$cardValue of $suit"
 
-  def cardColour(suit: Suit): String = suit match {
-    case Suit.Hearts | Suit.Diamonds => Console.RED
-    case Suit.Clubs | Suit.Spades => Console.BLACK
+  override def canEqual(that: Any): Boolean = that.isInstanceOf[Card]
+  
+  override def equals(obj: Any): Boolean = obj match {
+    case that: Card =>
+      this.cardValue == that.cardValue &&
+      this.suit == that.suit
+    case _ => false
   }
-
-  def renderAsString(): Vector[String] = {
-    if (cardValue == Ten) {
-      return Vector(
-        s"┌─────────┐",
-        s"│${cardColour(suit)}${Console.BOLD}${cardValue.cardType()}${Console.RESET}       │",
-        "│         │",
-        s"│    ${cardColour(suit)}${Console.BOLD}${suit.cardType()}${Console.RESET}    │",
-        "│         │",
-        s"│       ${cardColour(suit)}${Console.BOLD}${cardValue.cardType()}${Console.RESET}│",
-        s"└─────────┘"
-      )
-    }
-    Vector(
-      s"┌─────────┐",
-      s"│${cardColour(suit)}${Console.BOLD}${cardValue.cardType()}${Console.RESET}        │",
-      "│         │",
-      s"│    ${cardColour(suit)}${Console.BOLD}${suit.cardType()}${Console.RESET}    │",
-      "│         │",
-      s"│        ${cardColour(suit)}${Console.BOLD}${cardValue.cardType()}${Console.RESET}│",
-      s"└─────────┘"
-    )
-  }
-      override def toString: String = s"$cardValue of $suit"
-   //Combined String
 }

src/main/scala/de/knockoutwhist/cards/CardManager.scala

@@ -1,50 +1,25 @@
 package de.knockoutwhist.cards
 
-import de.knockoutwhist.KnockOutWhist
+trait CardManager {
 
-import scala.collection.mutable.ListBuffer
-import scala.util.Random
+  def cardContainer: List[Card]
 
-object CardManager {
+  def shuffleAndReset(): Unit
 
+  def resetOrder(): Unit
 
-  var cardContainer: List[Card] = {
-    val cc = ListBuffer[Card]()
-    for (suit <- Suit.values) {
-      for (cardValue <- CardValue.values) {
-        cc += Card(cardValue, suit)
-      }
-    }
-    cc.toList
-  }
-  private var currentIdx = 0
-
-  def shuffleAndReset(): Unit = {
-    cardContainer = Random.shuffle(cardContainer)
-    currentIdx = 0
-  }
+  def nextCard(): Card
   
-  def resetOrder(): Unit = {
-    cardContainer = cardContainer.sortBy(c => (c.suit.ordinal, c.cardValue.ordinal))
-    currentIdx = 0
-  }
+  def remainingCards: Int = cardContainer.size - currentIndx
 
-  def nextCard(): Card = {
-    val card = cardContainer(currentIdx)
-    if (currentIdx + 1 > 51) {
-      throw new IndexOutOfBoundsException("Trying to access card 53(out of bounds)")
-    } else {
-      currentIdx += 1
-      card
-    }
-  }
+  def removeCards(amount: Int): List[Card]
   
-  def createHand(amount: Int = 7): Hand = {
-    val hand = ListBuffer[Card]()
-    for (_ <- 1 to amount) {
-      hand += nextCard()
-    }
-    Hand(hand.toList)
-  }
+  def createHand(amount: Int = 7): Hand
+  
+  def grabSpecificCard(card: Card): Card
+  
+  def currentIndx: Int
 
+  def setState(cc: List[Card], currentIndex: Int): Unit
+  
 }

src/main/scala/de/knockoutwhist/cards/Hand.scala

@@ -1,7 +1,5 @@
 package de.knockoutwhist.cards
 
-import scala.collection.mutable.ListBuffer
-
 case class Hand(cards: List[Card]) {
 
   def removeCard(card: Card): Hand = {
@@ -19,11 +17,5 @@ case class Hand(cards: List[Card]) {
   def hasTrumpSuit(trumpSuit: Suit): Boolean = {
     cards.exists(_.suit == trumpSuit)
   }
-  
-  def renderAsString() : List[String] = {
-    val cardStrings = cards.map(_.renderAsString())
-    val zipped = cardStrings.transpose
-    zipped.map(_.mkString(" "))
-  }
 
 }

src/main/scala/de/knockoutwhist/cards/base/CardBaseManager.scala

@@ -0,0 +1,68 @@
+package de.knockoutwhist.cards.base
+
+import de.knockoutwhist.cards.*
+
+import scala.collection.mutable.ListBuffer
+import scala.util.Random
+
+class CardBaseManager extends CardManager {
+
+  override def setState(cc: List[Card], currentIndex: Int): Unit = {
+    this.cc = cc
+    this.currentIdx = currentIndex
+  }
+  
+  override def cardContainer: List[Card] = cc
+  private var cc: List[Card] = {
+    val cc = ListBuffer[Card]()
+    for (suit <- Suit.values) {
+      for (cardValue <- CardValue.values) {
+        cc += Card(cardValue, suit)
+      }
+    }
+    cc.toList
+  }
+  private var currentIdx = 0
+
+  override def currentIndx: Int = currentIdx
+
+  override def shuffleAndReset(): Unit = {
+    cc = Random.shuffle(cc)
+    currentIdx = 0
+  }
+  
+  override def resetOrder(): Unit = {
+    cc = cc.sortBy(c => (c.suit.ordinal, c.cardValue.ordinal))
+    currentIdx = 0
+  }
+
+  override def nextCard(): Card = {
+    val card = cc(currentIdx)
+    if (currentIdx + 1 > 51) {
+      throw new IndexOutOfBoundsException("Trying to access card 53(out of bounds)")
+    } else {
+      currentIdx += 1
+      card
+    }
+  }
+  
+  override def removeCards(amount: Int): List[Card] = {
+    val removedCards = ListBuffer[Card]()
+    for (_ <- 0 to amount) {
+      removedCards += nextCard()
+    }
+    removedCards.toList
+  }
+  
+  override def createHand(amount: Int = 7): Hand = {
+    val hand = ListBuffer[Card]()
+    for (_ <- 1 to amount) {
+      hand += nextCard()
+    }
+    Hand(hand.toList)
+  }
+
+  override def grabSpecificCard(card: Card): Card = {
+    cc.filter(c => c.suit == card.suit && c.cardValue == card.cardValue).head
+  }
+}

src/main/scala/de/knockoutwhist/cards/stub/StubCardManager.scala

@@ -0,0 +1,23 @@
+package de.knockoutwhist.cards.stub
+
+import de.knockoutwhist.cards.*
+
+object StubCardManager extends CardManager {
+  override def cardContainer: List[Card] = List()
+
+  override def shuffleAndReset(): Unit = {}
+
+  override def resetOrder(): Unit = {}
+
+  override def nextCard(): Card = Card(CardValue.Ace, Suit.Clubs)
+  
+  override def removeCards(amount: Int): List[Card] = List(Card(CardValue.Ace, Suit.Clubs))
+
+  override def createHand(amount: Int): Hand = Hand(List(Card(CardValue.Ace, Suit.Clubs)))
+
+  override def grabSpecificCard(card: Card): Card = card
+
+  override def currentIndx: Int = -1
+
+  override def setState(cc: List[Card], currentIndex: Int): Unit = {}
+}

src/main/scala/de/knockoutwhist/components/Configuration.scala

@@ -0,0 +1,18 @@
+package de.knockoutwhist.components
+
+import de.knockoutwhist.cards.CardManager
+import de.knockoutwhist.persistence.formats.FileFormatter
+import de.knockoutwhist.player.AbstractPlayer
+import de.knockoutwhist.ui.UI
+import de.knockoutwhist.utils.CustomPlayerQueue
+import de.knockoutwhist.utils.events.EventListener
+
+trait Configuration {
+  def cardManager: CardManager
+  def fileFormatter: FileFormatter
+  def uis: Set[UI]
+  def listener: Set[EventListener]
+  
+  def createRightQueue(players: Array[AbstractPlayer], start: Int = 0): CustomPlayerQueue[AbstractPlayer]
+  
+}

src/main/scala/de/knockoutwhist/components/DefaultConfiguration.scala

@@ -0,0 +1,38 @@
+package de.knockoutwhist.components
+
+import com.google.inject.Guice
+import de.knockoutwhist.cards.CardManager
+import de.knockoutwhist.di.{KnockOutConfigurationModule, KnockOutLogicModule}
+import de.knockoutwhist.persistence.formats.FileFormatter
+import de.knockoutwhist.player.AbstractPlayer
+import de.knockoutwhist.ui.UI
+import de.knockoutwhist.ui.gui.GUIMain
+import de.knockoutwhist.ui.tui.TUIMain
+import de.knockoutwhist.utils
+import de.knockoutwhist.utils.CustomPlayerQueue
+import de.knockoutwhist.utils.baseQueue.QueueBuilder
+import de.knockoutwhist.utils.events.EventListener
+
+import scala.language.postfixOps
+
+class DefaultConfiguration extends Configuration {
+
+  private val injector = Guice.createInjector(KnockOutLogicModule(), KnockOutConfigurationModule())
+  
+  override def cardManager: CardManager = injector.getInstance(classOf[CardManager])
+  override def fileFormatter: FileFormatter = injector.getInstance(classOf[FileFormatter])
+  override def uis: Set[UI] = Set[UI](
+    TUIMain(),
+    GUIMain()
+  )
+  override def listener: Set[EventListener] = Set[EventListener](
+    utils.DelayHandler
+  )
+
+  override def createRightQueue(players: Array[AbstractPlayer], start: Int): CustomPlayerQueue[AbstractPlayer] = {
+    val builder = injector.getInstance(classOf[QueueBuilder])
+    builder.setStart(start)
+    builder.setPlayer(players)
+    builder.build()
+  }
+}

src/main/scala/de/knockoutwhist/control/ControlThread.scala

@@ -0,0 +1,9 @@
+package de.knockoutwhist.control
+
+object ControlThread {
+
+  def runLater[R](op: => R): Unit = {
+    op
+  }
+  
+}

src/main/scala/de/knockoutwhist/control/GameLogic.scala

@@ -0,0 +1,39 @@
+package de.knockoutwhist.control
+
+import de.knockoutwhist.control.controllerBaseImpl.sublogic.util.RoundResult
+import de.knockoutwhist.control.sublogic.{PersistenceManager, PlayerInputLogic, PlayerTieLogic, UndoManager}
+import de.knockoutwhist.player.AbstractPlayer
+import de.knockoutwhist.rounds.{Match, Round, Trick}
+import de.knockoutwhist.utils.CustomPlayerQueue
+import de.knockoutwhist.utils.events.EventHandler
+
+trait GameLogic extends EventHandler with SnapshottingGameLogic  {
+
+  def createSession(): Unit
+  def endSession(): Unit
+  def createMatch(players: List[AbstractPlayer]): Match
+  def controlMatch(): Unit
+  def controlPreRound(): Unit
+  def controlRound(): Unit
+  def endRound(winner: AbstractPlayer, roundResult: RoundResult): Match
+  def controlTrick(): Unit
+  def endTrick(): Round
+  def controlPlayerPlay(): Unit
+  def providePlayersWithCards(): Unit
+  
+  def isWaitingForInput: Boolean
+  
+  def playerInputLogic: PlayerInputLogic
+  def playerTieLogic: PlayerTieLogic
+  def undoManager: UndoManager
+  def persistenceManager: PersistenceManager
+
+  def getCurrentState: GameState
+  def getCurrentMatch: Option[Match]
+  def getCurrentRound: Option[Round]
+  def getCurrentTrick: Option[Trick]
+  def getCurrentPlayer: Option[AbstractPlayer]
+  def getTrumpPlayer: Option[AbstractPlayer]
+  def getPlayerQueue: Option[CustomPlayerQueue[AbstractPlayer]]
+  
+}

src/main/scala/de/knockoutwhist/control/GameState.scala

@@ -0,0 +1,12 @@
+package de.knockoutwhist.control
+
+enum GameState {
+  
+  case MainMenu
+  case Lobby
+  case InGame
+  case SelectTrump
+  case TieBreak
+  case FinishedMatch
+
+}

src/main/scala/de/knockoutwhist/control/MatchControl.scala

@@ -1,24 +0,0 @@
-package de.knockoutwhist.control
-
-import de.knockoutwhist.rounds.{Match, Round, Trick}
-
-trait MatchControl {
-  
-  def initial(): Boolean
-  def start(): Unit
-  def playerControl: PlayerControl
-  
-  /**
-   * Start the next round
-   * @return the next round or null if the match is over
-   */
-  def nextRound(matchImpl: Match): Round
-
-  /**
-   * Start the next trick
-   * @return the last trick or null if the round is over
-   */
-  def nextTrick(roundImpl: Round): Trick
-  
-
-}

src/main/scala/de/knockoutwhist/control/PlayerControl.scala

@@ -1,16 +0,0 @@
-package de.knockoutwhist.control
-
-import de.knockoutwhist.cards.{Card, Suit}
-import de.knockoutwhist.player.Player
-import de.knockoutwhist.rounds.Round
-
-trait PlayerControl {
-
-  def playCard(player: Player): Card
-  def dogplayCard(player: Player, round: Round): Option[Card]
-  def determineWinnerTie(players: List[Player]): Player
-  def pickNextTrumpsuit(player: Player): Suit
-  def showCards(player: Player): Boolean
-  def showWon(player: Player, round: Round): String
-  
-}

src/main/scala/de/knockoutwhist/control/SnapshottingLogic.scala

@@ -0,0 +1,13 @@
+package de.knockoutwhist.control
+
+trait SnapshottingGameLogic {
+  
+  def createSnapshot(): LogicSnapshot[this.type]
+
+}
+
+trait LogicSnapshot[T <: SnapshottingGameLogic] {
+
+  def restore(logic: T): Unit
+
+}

src/main/scala/de/knockoutwhist/control/controllerBaseImpl/BaseGameLogic.scala

@@ -0,0 +1,426 @@
+package de.knockoutwhist.control.controllerBaseImpl
+
+import de.knockoutwhist.cards.{Card, CardManager}
+import de.knockoutwhist.components.Configuration
+import de.knockoutwhist.control.GameState.*
+import de.knockoutwhist.control.controllerBaseImpl.sublogic.util.{MatchUtil, RoundResult, RoundUtil, TrickUtil}
+import de.knockoutwhist.control.controllerBaseImpl.sublogic.{BasePersistenceManager, BasePlayerInputLogic, BasePlayerTieLogic, BaseUndoManager}
+import de.knockoutwhist.control.sublogic.{PersistenceManager, PlayerInputLogic, PlayerTieLogic}
+import de.knockoutwhist.control.{GameLogic, GameState, LogicSnapshot}
+import de.knockoutwhist.events.global.*
+import de.knockoutwhist.events.global.tie.TieEvent
+import de.knockoutwhist.events.player.ReceivedHandEvent
+import de.knockoutwhist.events.util.DelayEvent
+import de.knockoutwhist.persistence.MethodEntryPoint.{ControlMatch, ControlRound}
+import de.knockoutwhist.player.{AbstractPlayer, PlayerData}
+import de.knockoutwhist.rounds.{Match, Round, Trick}
+import de.knockoutwhist.utils.CustomPlayerQueue
+import de.knockoutwhist.utils.events.EventHandler
+
+import java.util.UUID
+import scala.util.Random
+
+/*
+  Main game logic controller
+*/
+final class BaseGameLogic(val config: Configuration) extends EventHandler with GameLogic {
+  //Constants
+  val ID: UUID = UUID.randomUUID()
+
+  //Logics
+  val playerTieLogic: PlayerTieLogic = BasePlayerTieLogic(this)
+  val playerInputLogic: PlayerInputLogic = BasePlayerInputLogic(this)
+  val undoManager: BaseUndoManager = BaseUndoManager(this)
+  val persistenceManager: PersistenceManager = BasePersistenceManager(this)
+  
+  //Game State
+  private[control] var state: GameState = GameState.MainMenu
+
+  //Variables
+  private[control] var cardManager: Option[CardManager] = Some(config.cardManager)
+  
+  private[control] var currentMatch: Option[Match] = None
+  private[control] var currentRound: Option[Round] = None
+  private[control] var currentTrick: Option[Trick] = None
+  private[control] var currentPlayer: Option[AbstractPlayer] = None
+  private[control] var playerQueue: Option[CustomPlayerQueue[AbstractPlayer]] = None
+
+  override def createSession(): Unit = {
+    cardManager = Some(config.cardManager)
+
+    currentMatch = None
+    currentRound = None
+    currentTrick = None
+    currentPlayer = None
+    playerQueue = None
+    invoke(GameStateChangeEvent(state, Lobby))
+    state = Lobby
+  }
+
+  override def createMatch(players: List[AbstractPlayer]): Match = {
+    val matchImpl = Match(totalplayers = players, playersIn = players)
+    currentMatch = Some(matchImpl)
+    matchImpl
+  }
+
+  override def controlMatch(): Unit = {
+    if (currentMatch.isEmpty) throw new IllegalStateException("No current match set")
+    val matchImpl = currentMatch.get
+
+    persistenceManager.update(ControlMatch)
+
+    if (matchImpl.isOver) {
+      //Winner is the last person in the playersIn list
+      val winner = matchImpl.playersIn.head
+      
+      invoke(GameStateChangeEvent(state, FinishedMatch))
+      state = FinishedMatch
+      invoke(MatchEndEvent(winner))
+    } else {
+      if (matchImpl.roundlist.isEmpty) {
+        if (cardManager.isEmpty) throw new IllegalStateException("No card manager set")
+        val cardManagerImpl = cardManager.get
+        val firstCard = cardManagerImpl.nextCard()
+        val newRound = RoundUtil.createRound(firstCard.suit, true)
+
+        providePlayersWithCards()
+        
+        val randomPlayer: Int = 1//Random.nextInt(matchImpl.playersIn.size)
+        playerQueue = Some(config.createRightQueue(matchImpl.playersIn.toArray, randomPlayer))
+        
+        matchImpl.playersIn.foreach(player => {invoke(ReceivedHandEvent(player))})
+
+        currentRound = Some(newRound)
+
+        invoke(NewRoundEvent())
+        invoke(DelayEvent(500))
+        
+        controlRound()
+        return
+      }
+      currentMatch = Some(matchImpl.setNumberOfCards(matchImpl.numberofcards - 1))
+      providePlayersWithCards()
+
+      matchImpl.playersIn.foreach(player => {invoke(ReceivedHandEvent(player))})
+
+      controlPreRound()
+    }
+  }
+  
+  //
+  override def controlPreRound(): Unit = {
+    if (currentMatch.isEmpty) throw new IllegalStateException("No current match set")
+    val matchImpl = currentMatch.get
+    //Check if the last round had a winner
+    val lastWinner = getTrumpPlayer
+    if (lastWinner.isEmpty) throw new IllegalStateException("No last round winner found")
+
+    //Create new player queue starting with last round winner
+
+    playerQueue = Some(config.createRightQueue(
+      matchImpl.playersIn.toArray,
+      matchImpl.playersIn.indexOf(lastWinner.get)
+    ))
+
+    invoke(GameStateChangeEvent(state, SelectTrump))
+    state = SelectTrump
+
+    invoke(TrumpSelectEvent(lastWinner.get))
+
+    playerInputLogic.requestTrumpSuit(lastWinner.get)
+  }
+  
+  override def controlRound(): Unit = {
+    if (state != InGame)
+      invoke(GameStateChangeEvent(state, InGame))
+    state = InGame
+    if (currentMatch.isEmpty) throw new IllegalStateException("No current match set")
+    val matchImpl = currentMatch.get
+    if (currentRound.isEmpty) throw new IllegalStateException("No current round set")
+    val roundImpl = currentRound.get
+
+    persistenceManager.update(ControlRound)
+
+    if (MatchUtil.isRoundOver(matchImpl, roundImpl)) {
+      val roundResult: RoundResult = RoundUtil.finishRound(roundImpl, matchImpl)
+      if (roundResult.isTie) {
+        invoke(GameStateChangeEvent(state, TieBreak))
+        state = TieBreak
+
+        invoke(TieEvent(roundResult.winners))
+        invoke(DelayEvent(2000))
+
+        playerTieLogic.handleTie(roundResult)
+        return
+      }
+      val newMatch = endRound(roundResult.winners.head, roundResult)
+      currentMatch = Some(newMatch)
+      controlMatch()
+    } else {
+      
+      invoke(NewTrickEvent())
+      invoke(DelayEvent(1000))
+
+      val trick = Trick()
+      currentTrick = Some(trick)
+      controlTrick()
+    }
+  }
+
+  override def endRound(winner: AbstractPlayer, roundResult: RoundResult): Match = {
+    if (currentMatch.isEmpty) throw new IllegalStateException("No current match set")
+    var matchImpl = currentMatch.get
+    if (currentRound.isEmpty) throw new IllegalStateException("No current round set")
+    val roundImpl = currentRound.get
+    //Create final round snapshot
+    val resultingRound = Round(
+      trumpSuit = roundImpl.trumpSuit,
+      firstRound = roundImpl.firstRound,
+      tricklist = roundImpl.tricklist,
+      winner = Some(winner)
+    )
+    
+    invoke(RoundEndEvent(winner, roundResult.tricked.filter(
+      rp => rp.player == winner
+    ).map(rp => rp.amountOfTricks).sum))
+    invoke(DelayEvent(2000))
+
+    if (roundResult.notTricked.nonEmpty && !roundImpl.firstRound) {
+      if (matchImpl.dogLife) {
+        invoke(ShowPlayersOutEvent(roundResult.notTricked))
+        invoke(DelayEvent(2000))
+        matchImpl = matchImpl.updatePlayersIn(matchImpl.playersIn.filterNot(roundResult.notTricked.contains(_)))
+      } else {
+        invoke(ShowDogsEvent(roundResult.notTricked))
+        invoke(DelayEvent(2000))
+        matchImpl = matchImpl.setDogLife()
+        // Make players dogs
+        roundResult.notTricked.foreach(player => {
+          player.setDogLife()
+        })
+      }
+    }
+    roundResult.tricked.foreach(player => {
+      player.player.resetDogLife()
+    })
+    matchImpl.addRound(resultingRound)
+  }
+  
+  override def controlTrick(): Unit = {
+    if (currentMatch.isEmpty) throw new IllegalStateException("No current match set")
+    val matchImpl = currentMatch.get
+    if (playerQueue.isEmpty) throw new IllegalStateException("No player queue set")
+    val queueImpl = playerQueue.get
+    if (currentTrick.isEmpty) throw new IllegalStateException("No current trick set")
+    val trickImpl = currentTrick.get
+
+    persistenceManager.update(ControlRound)
+
+    if (TrickUtil.isOver(matchImpl, queueImpl)) {
+      val newRound = endTrick()
+      if (newRound.tricklist.isEmpty || newRound.tricklist.last.winner.isEmpty) throw new IllegalStateException("Trick has no winner after ending trick")
+      val winner = newRound.tricklist.last.winner.get
+      currentRound = Some(newRound)
+      
+      invoke(TrickEndEvent(winner))
+      invoke(DelayEvent(2000))
+      
+      queueImpl.resetAndSetStart(winner)
+      controlRound()
+    } else {
+      val playerImpl = queueImpl.nextPlayer()
+      currentPlayer = Some(playerImpl)
+      controlPlayerPlay()
+    }
+  }
+
+  override def endTrick(): Round = {
+    if (currentTrick.isEmpty) throw new IllegalStateException("No current trick set")
+    val trickImpl = currentTrick.get
+    if (currentRound.isEmpty) throw new IllegalStateException("No current round set")
+    val roundImpl = currentRound.get
+    val resultTrick = TrickUtil.finishTrick(trickImpl, roundImpl)
+    val resultingTrick = Trick(
+      cards = trickImpl.cards,
+      winner = Some(resultTrick.winner),
+      firstCard = trickImpl.firstCard
+    )
+    roundImpl.addTrick(resultingTrick)
+  }
+  
+  override def controlPlayerPlay(): Unit = {
+    if (currentPlayer.isEmpty) throw new IllegalStateException("No current player set")
+    val playerImpl = currentPlayer.get
+    if (playerImpl.currentHand().isEmpty) {
+      controlTrick()
+      return
+    }
+    val handImpl = playerImpl.currentHand().get
+    if (handImpl.cards.isEmpty) {
+      controlTrick()
+      return
+    }
+    invoke(TurnEvent(playerImpl))
+    playerInputLogic.requestCard(playerImpl)
+  }
+
+  override def isWaitingForInput: Boolean = {
+    if (state == InGame || state == SelectTrump) {
+      playerInputLogic.isWaitingForInput
+    } else if (state == TieBreak) {
+      playerTieLogic.isWaitingForInput
+    } else {
+      false
+    }
+  }
+
+  //
+  override def providePlayersWithCards(): Unit = {
+    if (currentMatch.isEmpty) throw new IllegalStateException("No current match set")
+    val matchImpl = currentMatch.get
+    if (cardManager.isEmpty) throw new IllegalStateException("No card manager set")
+    val cardManagerImpl = cardManager.get
+
+    cardManagerImpl.shuffleAndReset()
+
+    val handSize = matchImpl.numberofcards
+
+    matchImpl.playersIn.foreach(player => {
+      val hand = if (!player.isInDogLife) {
+        cardManagerImpl.createHand(handSize)
+      } else {
+        cardManagerImpl.createHand(1)
+      }
+      player.provideHand(hand)
+    })
+  }
+  
+  
+  
+  // Getters
+  
+  override def getCurrentState: GameState = state
+  override def getCurrentMatch: Option[Match] = currentMatch
+  override def getCurrentRound: Option[Round] = currentRound
+  override def getCurrentTrick: Option[Trick] = currentTrick
+  override def getCurrentPlayer: Option[AbstractPlayer] = currentPlayer
+  override def getPlayerQueue: Option[CustomPlayerQueue[AbstractPlayer]] = playerQueue
+
+  override def getTrumpPlayer: Option[AbstractPlayer] = {
+    if (currentMatch.isEmpty) throw new IllegalStateException("No current match set")
+    val matchImpl = currentMatch.get
+    if (matchImpl.roundlist.isEmpty) return None
+    val roundImpl = matchImpl.roundlist.last
+    if (roundImpl.winner.isEmpty) return None
+    Some(roundImpl.winner.get)
+  }
+  //Snapshotting
+
+  override def createSnapshot(): LogicSnapshot[BaseGameLogic.this.type] = {
+    BaseGameLogicSnapshot(this).asInstanceOf[LogicSnapshot[BaseGameLogic.this.type]]
+  }
+
+  override def endSession(): Unit = {
+    cardManager = None
+    currentMatch = None
+    currentRound = None
+    currentTrick = None
+    currentPlayer = None
+    playerQueue = None
+    invoke(SessionClosed())
+    invoke(GameStateChangeEvent(state, MainMenu))
+    state = MainMenu
+  }
+}
+
+class BaseGameLogicSnapshot(
+                           val savedState: GameState,
+                           //Card Manager
+                           val cardContainer: Option[List[Card]],
+                           val cardIndex: Option[Int],
+
+                           val currentMatch: Option[Match],
+                           val currentRound: Option[Round],
+                           val currentTrick: Option[Trick],
+                           val currentPlayer: Option[AbstractPlayer],
+                           
+                           //Custom Player Queue
+                           val playerIndex: Option[Int],
+                           val players: Option[List[AbstractPlayer]],
+
+                           val playerStates: Map[UUID, PlayerData]
+                           
+                           ) extends LogicSnapshot[BaseGameLogic] {
+  
+  def this(gameLogic: BaseGameLogic) = {
+    this(
+      gameLogic.state,
+      
+      gameLogic.cardManager.map(cm => cm.cardContainer),
+      gameLogic.cardManager.map(cm => cm.currentIndx),
+      
+      gameLogic.currentMatch,
+      gameLogic.currentRound,
+      gameLogic.currentTrick,
+      gameLogic.currentPlayer,
+      
+      gameLogic.playerQueue.map(pq => pq.currentIndex),
+      gameLogic.playerQueue.map(pq => pq.duplicate().toList),
+      
+      gameLogic.currentMatch match {
+        case Some(m) => m.totalplayers.map(p => (p.id, p.generatePlayerData())).toMap
+        case None => Map.empty[UUID, PlayerData]
+      }
+    )
+  }
+  
+
+  override def restore(logic: BaseGameLogic): Unit = {
+    logic.state = savedState
+
+    //Card Manager
+    if (logic.cardManager.isDefined) {
+      val cardManagerImpl = logic.cardManager.get
+      if (cardContainer.isDefined && cardIndex.isDefined)
+        cardManagerImpl.setState(cardContainer.get, cardIndex.get)
+    } else {
+      if (cardContainer.isDefined && cardIndex.isDefined) {
+        val newCardManager = logic.config.cardManager
+        newCardManager.setState(cardContainer.get, cardIndex.get)
+        logic.cardManager = Some(newCardManager)
+      }
+    }
+    
+
+    logic.currentMatch = currentMatch
+    logic.currentRound = currentRound
+    logic.currentTrick = currentTrick
+    logic.currentPlayer = currentPlayer
+
+    //Custom Player Queue
+    if (logic.playerQueue.isDefined) {
+      if (players.isDefined && playerIndex.isDefined)
+        logic.playerQueue = Some(logic.config.createRightQueue(
+          players.get.toArray,
+          playerIndex.get
+        ))
+    } else {
+      if (players.isDefined && playerIndex.isDefined)
+        logic.playerQueue = Some(logic.config.createRightQueue(
+          players.get.toArray,
+          playerIndex.get
+        ))
+    }
+
+    //Player States
+    logic.currentMatch match {
+      case Some(m) =>
+        m.totalplayers.foreach(player => {
+          val dataOpt = playerStates.get(player.id)
+          if (dataOpt.isDefined)
+            player.receivePlayerData(dataOpt.get)
+        })
+      case None => //Do nothing
+    }
+  }
+}

src/main/scala/de/knockoutwhist/control/controllerBaseImpl/sublogic/BasePersistenceManager.scala

@@ -0,0 +1,41 @@
+package de.knockoutwhist.control.controllerBaseImpl.sublogic
+
+import de.knockoutwhist.KnockOutWhist
+import de.knockoutwhist.control.controllerBaseImpl.BaseGameLogic
+import de.knockoutwhist.control.sublogic.PersistenceManager
+import de.knockoutwhist.control.{GameLogic, LogicSnapshot}
+import de.knockoutwhist.events.util.ReloadAllEvent
+import de.knockoutwhist.persistence.{MatchSnapshot, MethodEntryPoint}
+
+class BasePersistenceManager(val gameLogic: BaseGameLogic) extends PersistenceManager {
+
+  private var currentSnapshot: MatchSnapshot = MatchSnapshot()
+
+  override def update(methodEntryPoint: MethodEntryPoint): MatchSnapshot = {
+    currentSnapshot = currentSnapshot
+      .withMethodEntryPoint(methodEntryPoint)
+      .withGameLogicSnapShot(gameLogic.createSnapshot().asInstanceOf[LogicSnapshot[GameLogic]])
+    currentSnapshot
+  }
+
+  override def saveFile(path: String): Unit = {
+    KnockOutWhist.config.fileFormatter.writeToFile(currentSnapshot, path + "." + KnockOutWhist.config.fileFormatter.fileEnding)
+  }
+
+  override def loadFile(path: String): Unit = {
+    currentSnapshot = KnockOutWhist.config.fileFormatter.readFromFile(path + "." + KnockOutWhist.config.fileFormatter.fileEnding)
+    if currentSnapshot.entryPoint.isEmpty then
+      throw new IllegalStateException("Loaded snapshot does not contain an entry point!")
+    currentSnapshot.gameLogicSnapShot.foreach(_.restore(gameLogic))
+    gameLogic.invoke(ReloadAllEvent())
+    currentSnapshot.entryPoint.get match {
+      case MethodEntryPoint.ControlMatch =>
+        gameLogic.controlMatch()
+      case MethodEntryPoint.ControlRound =>
+        gameLogic.controlRound()
+      case MethodEntryPoint.ControlTrick =>
+        gameLogic.controlTrick()
+    }
+  }
+
+}

src/main/scala/de/knockoutwhist/control/controllerBaseImpl/sublogic/BasePlayerInputLogic.scala

@@ -0,0 +1,89 @@
+package de.knockoutwhist.control.controllerBaseImpl.sublogic
+
+import de.knockoutwhist.cards.{Card, Suit}
+import de.knockoutwhist.control.controllerBaseImpl.BaseGameLogic
+import de.knockoutwhist.control.controllerBaseImpl.sublogic.util.RoundUtil
+import de.knockoutwhist.control.sublogic.PlayerInputLogic
+import de.knockoutwhist.events.global.{CardPlayedEvent, TrumpSelectedEvent}
+import de.knockoutwhist.events.player.{RequestCardEvent, RequestTrumpSuitEvent}
+import de.knockoutwhist.player.AbstractPlayer
+
+final class BasePlayerInputLogic(gameLogic: BaseGameLogic) extends PlayerInputLogic {
+
+  val TIME_TO_RESPOND: Int = 30 // seconds
+
+  private var _waitingForInput: Boolean = false
+  
+  
+  override def requestTrumpSuit(player: AbstractPlayer): Unit = {
+    _waitingForInput = true
+    gameLogic.invoke(RequestTrumpSuitEvent(player))
+  }
+  
+  override def receivedTrumpSuit(suit: Suit): Unit = {
+    if (!_waitingForInput) throw new IllegalStateException("Not waiting for input")
+    _waitingForInput = false
+    val newRound = RoundUtil.createRound(suit)
+    gameLogic.currentRound = Some(newRound)
+    gameLogic.invoke(TrumpSelectedEvent(suit))
+    gameLogic.controlRound()
+  }
+  
+  override def requestCard(player: AbstractPlayer): Unit = {
+    _waitingForInput = true
+    gameLogic.invoke(RequestCardEvent(player))
+  }
+  
+  override def receivedCard(card: Card): Unit = {
+    if (!_waitingForInput) throw new IllegalStateException("Not waiting for input")
+    _waitingForInput = false
+    
+    if (gameLogic.currentTrick.isEmpty) throw new IllegalStateException("No current trick set")
+    val trickImpl = gameLogic.currentTrick.get
+    if (gameLogic.currentPlayer.isEmpty) throw new IllegalStateException("No current player set")
+    val player = gameLogic.currentPlayer.get
+    
+
+    val newTrick = if (trickImpl.firstCard.isEmpty) {
+       trickImpl
+        .setfirstcard(card)
+        .addCard(card, player)
+    } else {
+       trickImpl
+        .addCard(card, player)
+    }
+    player.removeCard(card)
+    
+    gameLogic.currentTrick = Some(newTrick)
+    
+    gameLogic.invoke(CardPlayedEvent(player, newTrick))
+    
+    gameLogic.controlTrick()
+  }
+  
+  override def receivedDog(dog: Option[Card]): Unit = {
+    if (!_waitingForInput) throw new IllegalStateException("Not waiting for input")
+    _waitingForInput = false
+    
+    if (gameLogic.currentTrick.isEmpty) throw new IllegalStateException("No current trick set")
+    val trickImpl = gameLogic.currentTrick.get
+    if (gameLogic.currentPlayer.isEmpty) throw new IllegalStateException("No current player set")
+    val player = gameLogic.currentPlayer.get
+    
+    if (dog.isDefined) {
+      val newTrick = if (trickImpl.firstCard.isEmpty) {
+        trickImpl
+          .setfirstcard(dog.get)
+          .addCard(dog.get, player)
+      } else {
+        trickImpl
+          .addCard(dog.get, player)
+      }
+      player.removeCard(dog.get)
+      gameLogic.currentTrick = Some(newTrick)
+    }
+    gameLogic.controlTrick()
+  }
+
+  override def isWaitingForInput: Boolean = _waitingForInput
+}

src/main/scala/de/knockoutwhist/control/controllerBaseImpl/sublogic/BasePlayerTieLogic.scala

@@ -0,0 +1,167 @@
+package de.knockoutwhist.control.controllerBaseImpl.sublogic
+
+import de.knockoutwhist.cards.Card
+import de.knockoutwhist.control.LogicSnapshot
+import de.knockoutwhist.control.controllerBaseImpl.BaseGameLogic
+import de.knockoutwhist.control.controllerBaseImpl.sublogic.util.{ResultPlayer, RoundResult}
+import de.knockoutwhist.control.sublogic.PlayerTieLogic
+import de.knockoutwhist.events.global.tie.*
+import de.knockoutwhist.events.player.RequestTieChoiceEvent
+import de.knockoutwhist.events.util.DelayEvent
+import de.knockoutwhist.player.AbstractPlayer
+
+final class BasePlayerTieLogic(gameLogic: BaseGameLogic) extends PlayerTieLogic {
+  
+  private[control] var roundResult: Option[RoundResult] = None
+  private[control] var tiedPlayers: List[AbstractPlayer] = Nil
+  private[control] var tieBreakerIndex: Int = -1
+  private[control] var lastNumber = -1
+  private[control] var selectedCard: Map[AbstractPlayer, Card] = Map.empty
+  private var _waitingForInput: Boolean = false
+
+  override def handleTie(roundResult: RoundResult): Unit = {
+    this.roundResult = Some(roundResult)
+    tiedPlayers = roundResult.winners
+    tieBreakerIndex = -1
+    lastNumber = 0
+    selectedCard = Map.empty
+    if (gameLogic.cardManager.isEmpty) throw new IllegalStateException("No card manager set")
+    gameLogic.cardManager.get.shuffleAndReset()
+    handleNextTieBreakerPlayer()
+  }
+  
+  override def handleNextTieBreakerPlayer(): Unit = {
+    tieBreakerIndex += 1
+    if(tieBreakerIndex >= 0 && tieBreakerIndex < tiedPlayers.size) {
+      requestTieChoice(currentTiePlayer())
+    } else {
+      // All players have selected their tie-breaker cards
+      // Find the highest card among selected cards
+      
+      gameLogic.invoke(TieAllPlayersSelectedEvent())
+      gameLogic.invoke(DelayEvent(2000))
+      gameLogic.invoke(TieShowPlayerCardsEvent())
+      
+      val winningEntry = selectedCard.values.maxBy(_.cardValue.ordinal)
+      val winners = selectedCard.filter((_, card) => card == winningEntry).keySet.toList
+
+      gameLogic.invoke(TieWinningPlayersEvent(winners))
+      gameLogic.invoke(DelayEvent(2000))
+      if (winners.size > 1) {
+        gameLogic.invoke(TieTieEvent(winners))
+        
+        // Still a tie, handle again
+        tiedPlayers = winners
+        tieBreakerIndex = -1
+        lastNumber = 0
+        selectedCard = Map.empty
+        gameLogic.cardManager.get.shuffleAndReset()
+        handleNextTieBreakerPlayer()
+        return 
+      }
+      
+      
+      // Tie-breaker resolved
+      roundResult = None
+      tiedPlayers = Nil
+      lastNumber = -1
+      tieBreakerIndex = -1
+      selectedCard = Map.empty
+      
+      val winner = winners.head
+      // Inform game logic about the winner
+      
+    }
+  }
+
+  override def currentTiePlayer(): AbstractPlayer = {
+    tiedPlayers(tieBreakerIndex)
+  }
+
+  override def requestTieChoice(player: AbstractPlayer): Unit = {
+    _waitingForInput = true
+    gameLogic.invoke(TieTurnEvent(player))
+    gameLogic.invoke(RequestTieChoiceEvent(player, highestAllowedNumber()))
+  }
+
+  /**
+   * Called when a player has selected a tie-breaker card
+   * @param number the index of the selected card
+   */
+  override def receivedTieBreakerCard(number: Int): Unit = {
+    if (!_waitingForInput) throw new IllegalStateException("Not waiting for input")
+    _waitingForInput = false
+
+    val player = tiedPlayers(tieBreakerIndex)
+    val highestNumber = highestAllowedNumber()
+    if (number < 0 || number > highestNumber)
+      throw new IllegalArgumentException(s"Selected number $number is out of allowed range (0 to $highestNumber)")
+
+    if (gameLogic.cardManager.isEmpty) throw new IllegalStateException("No card manager set")
+    
+    val cardManager = gameLogic.cardManager.get
+    val card = cardManager.removeCards(number).last
+    selectedCard += (player -> card)
+    handleNextTieBreakerPlayer()
+  }
+  
+  override def highestAllowedNumber(): Int = {
+    if (gameLogic.cardManager.isEmpty) throw new IllegalStateException("No card manager set")
+    val remainingCards = gameLogic.cardManager.get.remainingCards
+    
+    // The highest allowed number is total cards minus the number of tied players already selected
+    // This ensures that each tied player can select a unique card
+    remainingCards - (tiedPlayers.size - selectedCard.size - 1)
+  }
+
+  override def isWaitingForInput: Boolean = _waitingForInput
+  
+  
+
+  override def createSnapshot(): LogicSnapshot[BasePlayerTieLogic.this.type] = BasePlayerTieLogicSnapshot(this).asInstanceOf[LogicSnapshot[BasePlayerTieLogic.this.type]]
+
+  // Getter
+  override def getRoundResult: Option[RoundResult] = roundResult
+  override def getTiedPlayers: List[AbstractPlayer] = tiedPlayers
+  override def getTieBreakerIndex: Int = tieBreakerIndex
+  override def getLastNumber: Int = lastNumber
+  override def getSelectedCard: Map[AbstractPlayer, Card] = selectedCard
+
+}
+
+class BasePlayerTieLogicSnapshot(
+                                  //Round result
+                                  val winners: List[AbstractPlayer],
+                                  val tricked: List[ResultPlayer],
+                                  val notTricked: List[AbstractPlayer],
+
+                                  val tiedPlayers: List[AbstractPlayer],
+                                  val tieBreakerIndex: Int,
+                                  val lastNumber: Int,
+                                  val selectedCard: Map[AbstractPlayer, Card]
+                                ) extends LogicSnapshot[BasePlayerTieLogic] {
+
+  def this(logic: BasePlayerTieLogic) = {
+    this(
+      logic.roundResult.map(_.winners).getOrElse(Nil),
+      logic.roundResult.map(_.tricked).getOrElse(Nil),
+      logic.roundResult.map(_.notTricked).getOrElse(Nil),
+      logic.tiedPlayers,
+      logic.tieBreakerIndex,
+      logic.lastNumber,
+      logic.selectedCard
+    )
+  }
+
+  override def restore(logic: BasePlayerTieLogic): Unit = {
+    if (winners.nonEmpty || tricked.nonEmpty || notTricked.nonEmpty) {
+      logic.roundResult = Some(RoundResult(winners, tricked, notTricked))
+    } else {
+      logic.roundResult = None
+    }
+    logic.tiedPlayers = tiedPlayers
+    logic.tieBreakerIndex = tieBreakerIndex
+    logic.lastNumber = lastNumber
+    logic.selectedCard = selectedCard
+  }
+}

src/main/scala/de/knockoutwhist/control/controllerBaseImpl/sublogic/BaseUndoManager.scala

@@ -0,0 +1,51 @@
+package de.knockoutwhist.control.controllerBaseImpl.sublogic
+
+import de.knockoutwhist.control.ControlThread
+import de.knockoutwhist.control.controllerBaseImpl.BaseGameLogic
+import de.knockoutwhist.control.sublogic.UndoManager
+import de.knockoutwhist.undo.{Command, UndoneException}
+
+class BaseUndoManager(gameLogic: BaseGameLogic) extends UndoManager {
+
+  private var undoStack: List[Command] = Nil
+  private var redoStack: List[Command] = Nil
+
+  override def doStep(command: Command): Unit = {
+    redoStack = Nil
+    undoStack = command :: undoStack
+    command.doStep(gameLogic)
+  }
+
+  override def undoStep(): Unit = {
+    ControlThread.runLater {
+      undoStack match {
+        case Nil => false
+        case head :: stack =>
+          undoStack = stack
+          redoStack = head :: redoStack
+          try {
+            head.undoStep(gameLogic)
+          } catch {
+            case _: UndoneException =>
+          }
+      }
+    }
+  }
+
+  override def redoStep(): Unit = {
+    ControlThread.runLater {
+      redoStack match {
+        case Nil => false
+        case head :: stack =>
+          redoStack = stack
+          undoStack = head :: undoStack
+          try {
+            head.doStep(gameLogic)
+          } catch {
+            case _: UndoneException =>
+          }
+      }
+    }
+  }
+
+}

src/main/scala/de/knockoutwhist/control/controllerBaseImpl/sublogic/util/MatchUtil.scala

@@ -0,0 +1,23 @@
+package de.knockoutwhist.control.controllerBaseImpl.sublogic.util
+
+import de.knockoutwhist.rounds.{Match, Round}
+
+object MatchUtil {
+
+  private def remainingRounds(matchImpl: Match, roundImpl: Round): Int = {
+    // If no player has any cards left, there are no rounds remaining
+    if !matchImpl.playersIn
+      .map(player => player.currentHand()).exists(hand => hand.isDefined && hand.get.cards.nonEmpty) then return 0
+    // Otherwise, calculate remaining rounds based on number of cards and tricks played
+    matchImpl.numberofcards - roundImpl.tricklist.size
+  }
+  
+  def isRoundOver(matchImpl: Match, roundImpl: Round): Boolean = {
+    remainingRounds(matchImpl, roundImpl) == 0
+  }
+
+  def dogNeedsToPlay(matchImpl: Match, roundImpl: Round): Boolean = {
+    remainingRounds(matchImpl, roundImpl) == 1
+  }
+  
+}

src/main/scala/de/knockoutwhist/control/controllerBaseImpl/sublogic/util/PlayerUtil.scala

@@ -0,0 +1,52 @@
+package de.knockoutwhist.control.controllerBaseImpl.sublogic.util
+
+import de.knockoutwhist.cards.Card
+import de.knockoutwhist.player.AbstractPlayer
+import de.knockoutwhist.rounds.{Round, Trick}
+
+object PlayerUtil {
+  
+  def canPlayCard(card: Card, round: Round, trick: Trick, player: AbstractPlayer): Boolean = {
+    if (trick.firstCard.isEmpty)
+      return true
+    val alternatives = alternativeCards(card, round, trick, player)
+    if (alternatives.nonEmpty) {
+      return false
+    }
+    true
+  }
+
+  def alternativeCards(card: Card, round: Round, trick: Trick, player: AbstractPlayer): List[Card] = {
+    if (trick.firstCard.isDefined) {
+      val firstCard = trick.firstCard.get
+      if (firstCard.suit != card.suit) {
+        val alternatives: List[Card] = for cardInHand <- player.currentHand().get.cards
+                                           if cardInHand.suit == firstCard.suit
+        yield cardInHand
+        if (round.trumpSuit == card.suit && alternatives.isEmpty) {
+          return Nil
+        }
+        if (alternatives.nonEmpty) {
+          return alternatives
+        }
+      }
+    }
+    Nil
+  }
+
+  def playableCards(round: Round, trick: Trick, player: AbstractPlayer): List[Card] = {
+    val handOption = player.currentHand()
+    if (handOption.isEmpty) {
+      throw new IllegalStateException("You have no cards!")
+    }
+    val hand = handOption.get
+    if (trick.firstCard.isEmpty) {
+      return hand.cards
+    }
+    val playableCards: List[Card] = for cardInHand <- hand.cards
+                                        if canPlayCard(cardInHand, round, trick, player)
+    yield cardInHand
+    playableCards
+  }
+
+}

src/main/scala/de/knockoutwhist/control/controllerBaseImpl/sublogic/util/RoundUtil.scala

@@ -0,0 +1,43 @@
+package de.knockoutwhist.control.controllerBaseImpl.sublogic.util
+
+import de.knockoutwhist.cards.Suit
+import de.knockoutwhist.player.AbstractPlayer
+import de.knockoutwhist.rounds.{Match, Round}
+
+object RoundUtil {
+  
+  def createRound(trumpSuit: Suit, firstRound: Boolean = false): Round = {
+    Round(trumpSuit, firstRound)
+  }
+
+  def finishRound(round: Round, matchImpl: Match): RoundResult = {
+    val tricksMapped = round.tricklist
+      .map(t => t.winner)
+      .filter(t => t.isDefined)
+      .map(t => t.get)
+      .groupBy(identity).map((p, l) => (p, l.size))
+    val maxTricks = if (tricksMapped.isEmpty) 0 else tricksMapped.values.max
+    val winners = tricksMapped
+      .filter((p, i) => i == maxTricks)
+      .keys.toList
+    val trickedPlayers = tricksMapped.map((p, i) => ResultPlayer(p, i)).toList
+    val notTrickedPlayers = matchImpl.playersIn.filterNot(p => tricksMapped.keySet.contains(p))
+    RoundResult(winners, trickedPlayers, notTrickedPlayers)
+  }
+  
+  def roundEndSnapshot(winner: AbstractPlayer, round: Round): Round = {
+    Round(
+      round.trumpSuit,
+      round.firstRound,
+      round.tricklist,
+      Some(winner)
+    )
+  }
+
+}
+
+case class RoundResult(winners: List[AbstractPlayer], tricked: List[ResultPlayer], notTricked: List[AbstractPlayer]) {
+  def isTie: Boolean = winners.size > 1
+}
+
+case class ResultPlayer(player: AbstractPlayer, amountOfTricks: Int)

src/main/scala/de/knockoutwhist/control/controllerBaseImpl/sublogic/util/SnapshotUtil.scala

@@ -0,0 +1,13 @@
+package de.knockoutwhist.control.controllerBaseImpl.sublogic.util
+
+import de.knockoutwhist.control.{GameLogic, LogicSnapshot}
+
+object SnapshotUtil {
+  
+  def generateSnapshots(gameLogic: GameLogic): (LogicSnapshot[? <: GameLogic], LogicSnapshot[? <: GameLogic]) = {
+    val gameLogicSnapshot = gameLogic.createSnapshot()
+    val playerTieLogicSnapshot = gameLogic.playerTieLogic.createSnapshot()
+    (gameLogicSnapshot, playerTieLogicSnapshot.asInstanceOf[LogicSnapshot[? <: GameLogic]])
+  }
+
+}