3 create cheat game model

.github/workflows/github.yml

@@ -42,7 +42,7 @@ jobs:
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
       - name: Unit test with Gradle
-        run: ./gradlew jacocoTestReport
+        run: ./gradlew koverXmlReport
 
       - name: Publish Test Results
         uses: EnricoMi/publish-unit-test-result-action@v2
@@ -53,9 +53,15 @@ jobs:
             **/test-results/**/*.trx
             **/test-results/**/*.json
       - name: Add coverage to PR
+        id: kover
+        uses: mi-kas/kover-report@v1
         if: always()
-        uses: madrapps/jacoco-report@v1.6.1
         with:
-          paths: |
-            ${{ github.workspace }}/**/build/reports/jacoco/**/*.xml
-          token: ${{github.token}}
+          path: |
+            ${{ github.workspace }}/model/build/reports/kover/report.xml
+          token: ${{secrets.token}}
+          title: Code Coverage
+          update-comment: false
+          min-coverage-overall: 80
+          min-coverage-changed-files: 80
+          coverage-counter-type: LINE

build.gradle.kts

@@ -3,8 +3,7 @@ plugins {
     alias(libs.plugins.kotlin.qa)
     alias(libs.plugins.taskTree)
     alias(libs.plugins.dokka)
-    jacoco
-    alias(libs.plugins.multiJvmTesting)
+    alias(libs.plugins.kover)
 }
 
 allprojects {
@@ -15,21 +14,9 @@ allprojects {
 subprojects {
     apply(plugin = "kotlin")
     apply(plugin = "java")
-    apply(plugin = "org.danilopianini.multi-jvm-test-plugin")
-    apply(plugin = "jacoco")
-
-    tasks.jacocoTestReport {
-        dependsOn(tasks.test)
-        reports {
-            xml.required.set(true)
-        }
-    }
+    apply(plugin = "org.jetbrains.kotlinx.kover")
 
     tasks.test {
         useJUnitPlatform()
     }
-
-    multiJvm {
-        maximumSupportedJvmVersion.set(latestJavaSupportedByGradle)
-    }
 }

gradle/libs.versions.toml

@@ -36,4 +36,4 @@ dokka = "org.jetbrains.dokka:1.9.0"
 kotlin-qa = { id = "org.danilopianini.gradle-kotlin-qa", version = "0.49.1" }
 taskTree = { id = "com.dorongold.task-tree", version = "2.1.1" }
 gitSemVer = { id = "org.danilopianini.git-sensitive-semantic-versioning-gradle-plugin", version.ref = "gitSemVer" }
-multiJvmTesting = { id = "org.danilopianini.multi-jvm-test-plugin", version = "0.5.5" }
+kover = { id = "org.jetbrains.kotlinx.kover", version = "0.7.3" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

model/src/main/kotlin/it/unibo/ds/model/game/Game.kt

@@ -0,0 +1,26 @@
+package it.unibo.ds.model.game
+
+import it.unibo.ds.model.cards.Card
+import it.unibo.ds.model.cards.Rank
+import it.unibo.ds.model.cards.italian.ItalianRanks
+import it.unibo.ds.model.game.cards.DiscardPile
+import it.unibo.ds.model.game.cards.FieldPile
+import it.unibo.ds.model.game.event.EventConsumer
+import it.unibo.ds.model.game.event.EventSource
+
+interface Game : EventSource, EventConsumer {
+
+    val discardPile: DiscardPile<Card>
+
+    val fieldPile: FieldPile<Card>
+
+    val declaredRank: Rank?
+
+    val lastDeclaredCardNumber: Int?
+
+    val players: List<String>
+
+    val currentPlayer: String
+
+    fun startGame()
+}

model/src/main/kotlin/it/unibo/ds/model/game/GameFactory.kt

@@ -0,0 +1,30 @@
+package it.unibo.ds.model.game
+
+import it.unibo.ds.model.cards.italian.ItalianSuitsDeckFactory
+import it.unibo.ds.model.game.cards.CheatAccumulatorFactory
+
+object GameFactory {
+
+    fun createGame(playersName: List<String>): Pair<Game, List<Player>> {
+        val (hands, _) = ItalianSuitsDeckFactory()
+            .getFullDeck()
+            .shuffle()
+            .divideCardsFairly(playersName.size)
+        val factory = CheatAccumulatorFactory()
+        val players = playersName
+            .mapIndexed { index, name ->
+                PlayerImpl(
+                    name,
+                    factory.createPlayerHand(hands[index])
+                )
+            }
+        val game = GameImpl(
+            factory.createDiscardPile(),
+            factory.createFieldPile(),
+            playersName
+        )
+        players.forEach { it.register(game) }
+        players.forEach(game::register)
+        return game to players
+    }
+}

model/src/main/kotlin/it/unibo/ds/model/game/GameImpl.kt

@@ -0,0 +1,96 @@
+package it.unibo.ds.model.game
+
+import it.unibo.ds.model.cards.Card
+import it.unibo.ds.model.cards.Rank
+import it.unibo.ds.model.game.cards.DiscardPile
+import it.unibo.ds.model.game.cards.FieldPile
+import it.unibo.ds.model.game.event.*
+
+class GameImpl(
+    private var discardPileImpl: DiscardPile<Card>,
+    private var fieldPileImpl: FieldPile<Card>,
+    override val players: List<String>,
+) : Game {
+
+    override val discardPile: DiscardPile<Card>
+        get() = discardPileImpl
+
+    override val fieldPile: FieldPile<Card>
+        get() = fieldPileImpl
+    override val declaredRank: Rank?
+        get() = declaredRankImpl
+    override val lastDeclaredCardNumber: Int?
+        get() = lastDeclaredCardNumberImpl
+
+    override val currentPlayer: String
+        get() = players[turn % players.size]
+
+    override fun startGame() {
+        notify(StartGameEvent(currentPlayer))
+    }
+
+    private var eventConsumers: Set<EventConsumer> = emptySet()
+
+    private var declaredRankImpl: Rank? = null
+
+    private var lastDeclaredCardNumberImpl: Int? = null
+
+    private var turn = 0
+
+    override fun register(eventConsumer: EventConsumer) {
+        eventConsumers = eventConsumers + eventConsumer
+    }
+
+    override fun unregister(eventConsumer: EventConsumer) {
+        eventConsumers = eventConsumers - eventConsumer
+    }
+
+    override fun notify(event: Event) {
+        eventConsumers.forEach { it.consume(event) }
+    }
+
+    private fun previousPlayer(): String {
+        return players[(turn - 1) % players.size]
+    }
+
+    private fun doubtCorrectly(): Boolean =
+        lastDeclaredCardNumber != fieldPileImpl.lastCardsPlayed.size ||
+                fieldPileImpl.lastCardsPlayed.any { it.rank != declaredRank }
+
+    override fun consume(event: Event) {
+        when (event) {
+
+            is PlayerDeclareRankEvent -> {
+                declaredRankImpl = event.rank
+                fieldPileImpl = fieldPileImpl.addCards(event.cardsPlayed)
+                lastDeclaredCardNumberImpl = event.declaredCardNumber
+                turn = (turn + 1) % players.size
+                notify(PlayerTurnEvent(currentPlayer))
+            }
+
+            is DoubtEvent -> {
+                if (previousPlayer() == event.lastPlayerWhoPlayed) {
+                    turn = if (doubtCorrectly()) {
+                        notify(DrawCardsEvent(previousPlayer(), fieldPileImpl.allCards))
+                        players.indexOf(event.player)
+                    } else {
+                        notify(DrawCardsEvent(event.player, fieldPileImpl.allCards))
+                        players.indexOf(previousPlayer())
+                    }
+                    notify(PlayerCanChooseRankEvent(currentPlayer))
+                }
+            }
+
+            is DiscardCardEvent -> {
+                discardPileImpl.areCardsToDiscard(event.cardDiscarded)
+            }
+
+            is PlayCardsEvent -> {
+                fieldPileImpl = fieldPileImpl.addCards(event.cardsPlayed)
+                lastDeclaredCardNumberImpl = event.declaredCardNumber
+                turn = (turn + 1) % players.size
+                notify(PlayerTurnEvent(currentPlayer))
+            }
+        }
+    }
+}

model/src/main/kotlin/it/unibo/ds/model/game/Player.kt

@@ -0,0 +1,28 @@
+package it.unibo.ds.model.game
+
+import it.unibo.ds.model.cards.Card
+import it.unibo.ds.model.cards.Rank
+import it.unibo.ds.model.game.cards.PlayerHand
+import it.unibo.ds.model.game.event.EventConsumer
+import it.unibo.ds.model.game.event.EventSource
+
+interface Player : EventConsumer, EventSource {
+
+    val name: String
+
+    val hand: PlayerHand<Card>
+
+    val isTurn: Boolean
+
+    val canDoubt: Boolean
+
+    val canDeclareRank: Boolean
+
+    fun playCards(cards: Set<Card>, declaredCardNumber: Int)
+
+    fun doubt()
+
+    fun discardCards()
+
+    fun declareRank(cards: Set<Card>, declaredCardNumber: Int, rank: Rank)
+}