Improve hand playability calculations and API output

12 files changed, 299 insertions, 136 deletions

diff --git a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/Game.kt b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/Game.kt
index b535bb96..f92177c8 100644
--- a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/Game.kt
+++ b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/Game.kt
@@ -48,7 +48,7 @@ class Game internal constructor(
     private fun createPlayerTurnInfo(player: Player): PlayerTurnInfo {
         val hand = hands.createHand(player)
         val action = determineAction(hand, player.board)
-        val neighbourGuildCards = table.getNeighbourGuildCards(player.index).map { it.toTableCard() }
+        val neighbourGuildCards = table.getNeighbourGuildCards(player.index).map { it.toTableCard(null) }
 
         return PlayerTurnInfo(player.index, table.toApiTable(), action, hand, neighbourGuildCards)
     }
diff --git a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Boards.kt b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Boards.kt
index 01b840c6..e1b9c4e9 100644
--- a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Boards.kt
+++ b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Boards.kt
@@ -4,6 +4,8 @@ import org.luxons.sevenwonders.game.boards.Military
 import org.luxons.sevenwonders.game.boards.Science
 import org.luxons.sevenwonders.game.boards.ScienceType
 import org.luxons.sevenwonders.game.cards.CardBack
+import org.luxons.sevenwonders.game.moves.Move
+import org.luxons.sevenwonders.game.moves.MoveType
 import org.luxons.sevenwonders.game.resources.Production
 import org.luxons.sevenwonders.game.resources.ResourceType
 import org.luxons.sevenwonders.game.resources.Resources
@@ -22,14 +24,14 @@ data class Board(
     val gold: Int
 )
 
-internal fun InternalBoard.toApiBoard(): Board = Board(
+internal fun InternalBoard.toApiBoard(lastMove: Move?): Board = Board(
     playerIndex = playerIndex,
-    wonder = wonder.toApiWonder(),
+    wonder = wonder.toApiWonder(lastMove),
     production = production.toApiProduction(),
     publicProduction = publicProduction.toApiProduction(),
     science = science.toApiScience(),
     military = military.toApiMilitary(),
-    playedCards = getPlayedCards().map { it.toTableCard() },
+    playedCards = getPlayedCards().map { it.toTableCard(lastMove) },
     gold = gold
 )
 
@@ -41,23 +43,26 @@ data class Wonder(
     val nbBuiltStages: Int
 )
 
-internal fun InternalWonder.toApiWonder(): Wonder = Wonder(
+internal fun InternalWonder.toApiWonder(lastMove: Move?): Wonder = Wonder(
     name = name,
     initialResource = initialResource,
-    stages = stages.map { it.toApiWonderStage() },
+    stages = stages.map { it.toApiWonderStage(lastBuiltStage == it, lastMove) },
     image = image,
     nbBuiltStages = nbBuiltStages
 )
 
 data class WonderStage(
     val cardBack: CardBack?,
-    val isBuilt: Boolean
+    val isBuilt: Boolean,
+    val builtDuringLastMove: Boolean
 )
 
-internal fun InternalWonderStage.toApiWonderStage(): WonderStage = WonderStage(
-    cardBack = cardBack,
-    isBuilt = isBuilt
-)
+internal fun InternalWonderStage.toApiWonderStage(isLastBuiltStage: Boolean, lastMove: Move?): WonderStage =
+    WonderStage(
+        cardBack = cardBack,
+        isBuilt = isBuilt,
+        builtDuringLastMove = lastMove?.type == MoveType.UPGRADE_WONDER && isLastBuiltStage
+    )
 
 data class ApiProduction(
     val fixedResources: Resources,
diff --git a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Cards.kt b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Cards.kt
index b49c6ab0..d238ab77 100644
--- a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Cards.kt
+++ b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Cards.kt
@@ -3,9 +3,11 @@ package org.luxons.sevenwonders.game.api
 import org.luxons.sevenwonders.game.Player
 import org.luxons.sevenwonders.game.cards.Card
 import org.luxons.sevenwonders.game.cards.CardBack
+import org.luxons.sevenwonders.game.cards.CardPlayability
 import org.luxons.sevenwonders.game.cards.Color
 import org.luxons.sevenwonders.game.cards.Requirements
-import org.luxons.sevenwonders.game.resources.TransactionPlan
+import org.luxons.sevenwonders.game.moves.Move
+import org.luxons.sevenwonders.game.resources.ResourceTransactions
 import org.luxons.sevenwonders.game.resources.bestSolution
 
 data class TableCard(
@@ -15,17 +17,19 @@ data class TableCard(
     val chainParent: String?,
     val chainChildren: List<String>,
     val image: String,
-    val back: CardBack
+    val back: CardBack,
+    val playedDuringLastMove: Boolean
 )
 
-internal fun Card.toTableCard(): TableCard = TableCard(
+internal fun Card.toTableCard(lastMove: Move? = null): TableCard = TableCard(
     name = name,
     color = color,
     requirements = requirements,
     chainParent = chainParent,
     chainChildren = chainChildren,
     image = image,
-    back = back
+    back = back,
+    playedDuringLastMove = lastMove != null && this.name == lastMove.card.name
 )
 
 /**
@@ -43,19 +47,24 @@ data class HandCard(
     val isChainable: Boolean,
     val isFree: Boolean,
     val isPlayable: Boolean,
-    val cheapestTransactions: TransactionPlan
+    val minPrice: Int,
+    val cheapestTransactions: Set<ResourceTransactions>
 )
 
-internal fun Card.toHandCard(player: Player): HandCard = HandCard(
-    name = name,
-    color = color,
-    requirements = requirements,
-    chainParent = chainParent,
-    chainChildren = chainChildren,
-    image = image,
-    back = back,
-    isChainable = isChainableOn(player.board),
-    isFree = isFreeFor(player.board),
-    isPlayable = isPlayableBy(player),
-    cheapestTransactions = bestSolution(requirements.resources, player)
-)
+internal fun Card.toHandCard(player: Player): HandCard {
+    val playability: CardPlayability = computePlayabilityBy(player)
+    return HandCard(
+        name = name,
+        color = color,
+        requirements = requirements,
+        chainParent = chainParent,
+        chainChildren = chainChildren,
+        image = image,
+        back = back,
+        isChainable = playability.isChainable,
+        isFree = playability.isFree,
+        isPlayable = playability.isPlayable,
+        minPrice = playability.minPrice,
+        cheapestTransactions = playability.cheapestTransactions
+    )
+}
diff --git a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Table.kt b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Table.kt
index 05242f00..4be897db 100644
--- a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Table.kt
+++ b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/api/Table.kt
@@ -17,7 +17,7 @@ data class Table(
 }
 
 internal fun InternalTable.toApiTable(): Table = Table(
-    boards = boards.map { it.toApiBoard() },
+    boards = boards.mapIndexed { i, b -> b.toApiBoard(lastPlayedMoves.getOrNull(i)) },
     currentAge = currentAge,
     handRotationDirection = handRotationDirection,
     lastPlayedMoves = lastPlayedMoves.map { it.toPlayedMove() }
@@ -33,6 +33,6 @@ data class PlayedMove(
 internal fun Move.toPlayedMove(): PlayedMove = PlayedMove(
     playerIndex = playerContext.index,
     type = type,
-    card = card.toTableCard(),
+    card = card.toTableCard(this),
     transactions = transactions
 )
diff --git a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/cards/Cards.kt b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/cards/Cards.kt
index df0e06cc..94c1a81a 100644
--- a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/cards/Cards.kt
+++ b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/cards/Cards.kt
@@ -4,9 +4,18 @@ import org.luxons.sevenwonders.game.Player
 import org.luxons.sevenwonders.game.boards.Board
 import org.luxons.sevenwonders.game.effects.Effect
 import org.luxons.sevenwonders.game.resources.ResourceTransactions
+import org.luxons.sevenwonders.game.resources.noTransactions
 
 data class CardBack(val image: String)
 
+data class CardPlayability(
+    val isPlayable: Boolean,
+    val isFree: Boolean = false,
+    val isChainable: Boolean = false,
+    val minPrice: Int = Int.MAX_VALUE,
+    val cheapestTransactions: Set<ResourceTransactions> = emptySet()
+)
+
 internal data class Card(
     val name: String,
     val color: Color,
@@ -17,21 +26,43 @@ internal data class Card(
     val image: String,
     val back: CardBack
 ) {
-    private fun isAllowedOnBoard(board: Board): Boolean = !board.isPlayed(name) // cannot play twice the same card
-
-    fun isFreeFor(board: Board): Boolean = isChainableOn(board) || isFreeWithoutChainingOn(board)
+    fun computePlayabilityBy(player: Player): CardPlayability {
+        if (!isAllowedOnBoard(player.board)) {
+            return nonPlayable()
+        }
+        if (isParentOnBoard(player.board)) {
+            return chainablePlayability()
+        }
+        return requirementsPlayability(player)
+    }
 
-    fun isChainableOn(board: Board): Boolean =
-        isAllowedOnBoard(board) && chainParent != null && board.isPlayed(chainParent)
+    private fun nonPlayable() = CardPlayability(isPlayable = false)
 
-    private fun isFreeWithoutChainingOn(board: Board) =
-        isAllowedOnBoard(board) && requirements.areMetWithoutNeighboursBy(board) && requirements.gold == 0
+    private fun chainablePlayability(): CardPlayability = CardPlayability(
+        isPlayable = true,
+        isFree = true,
+        isChainable = true,
+        minPrice = 0,
+        cheapestTransactions = setOf(noTransactions())
+    )
 
-    fun isPlayableBy(player: Player): Boolean {
-        val board = player.board
-        return isAllowedOnBoard(board) && (isChainableOn(board) || requirements.areMetBy(player))
+    private fun requirementsPlayability(player: Player): CardPlayability {
+        val satisfaction = requirements.computeSatisfaction(player)
+        return CardPlayability(
+            isPlayable = satisfaction is RequirementsSatisfaction.Acceptable,
+            isFree = satisfaction.minPrice == 0,
+            isChainable = false,
+            minPrice = satisfaction.minPrice,
+            cheapestTransactions = satisfaction.cheapestTransactions
+        )
     }
 
+    fun isChainableOn(board: Board): Boolean = isAllowedOnBoard(board) && isParentOnBoard(board)
+
+    private fun isAllowedOnBoard(board: Board): Boolean = !board.isPlayed(name) // cannot play twice the same card
+
+    private fun isParentOnBoard(board: Board): Boolean = chainParent != null && board.isPlayed(chainParent)
+
     fun applyTo(player: Player, transactions: ResourceTransactions) {
         if (!isChainableOn(player.board)) {
             requirements.pay(player, transactions)
diff --git a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/cards/Requirements.kt b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/cards/Requirements.kt
index 69fb5d61..30c67683 100644
--- a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/cards/Requirements.kt
+++ b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/cards/Requirements.kt
@@ -14,14 +14,39 @@ data class Requirements internal constructor(
     val resources: Resources = emptyResources()
 ) {
     /**
-     * Returns whether the given [board] meets these requirements on its own.
-     *
-     * @param board the board to check
-     *
-     * @return true if the given board meets these requirements without any transaction with its neighbours
+     * Returns information about the extent to which the given [player] meets these requirements, either on its own or
+     * by buying resources to neighbours.
      */
-    internal fun areMetWithoutNeighboursBy(board: Board): Boolean =
-        hasRequiredGold(board) && producesRequiredResources(board)
+    internal fun computeSatisfaction(player: Player): RequirementsSatisfaction {
+        if (player.board.gold < gold) {
+            return RequirementsSatisfaction.missingRequiredGold(gold)
+        }
+        if (resources.isEmpty()) {
+            if (gold > 0) {
+                return RequirementsSatisfaction.enoughGold(gold)
+            }
+            return RequirementsSatisfaction.noRequirements()
+        }
+        if (producesRequiredResources(player.board)) {
+            if (gold > 0) {
+                return RequirementsSatisfaction.enoughResourcesAndGold(gold)
+            }
+            return RequirementsSatisfaction.enoughResources()
+        }
+        return satisfactionWithPotentialHelp(player)
+    }
+
+    private fun satisfactionWithPotentialHelp(player: Player): RequirementsSatisfaction {
+        val (minPriceForResources, possibleTransactions) = bestSolution(resources, player)
+        val minPrice = minPriceForResources + gold
+        if (possibleTransactions.isEmpty()) {
+            return RequirementsSatisfaction.resourcesUnavailable()
+        }
+        if (player.board.gold < minPrice) {
+            return RequirementsSatisfaction.missingGoldForResources(minPrice, possibleTransactions)
+        }
+        return RequirementsSatisfaction.metWithHelp(minPrice, possibleTransactions)
+    }
 
     /**
      * Returns whether the given board meets these requirements, if the specified resources are bought from neighbours.
@@ -38,28 +63,6 @@ data class Requirements internal constructor(
         return producesRequiredResources(board) || producesRequiredResourcesWithHelp(board, boughtResources)
     }
 
-    /**
-     * Returns whether the given player meets these requirements, either on its own or by buying resources to
-     * neighbours.
-     *
-     * @param player the player to check
-     *
-     * @return true if the given player's board could meet these requirements
-     */
-    internal fun areMetBy(player: Player): Boolean {
-        val board = player.board
-        if (!hasRequiredGold(board)) {
-            return false
-        }
-        if (producesRequiredResources(board)) {
-            return true
-        }
-        val solution = bestSolution(resources, player)
-        return !solution.possibleTransactions.isEmpty() && solution.price <= board.gold - gold
-    }
-
-    private fun hasRequiredGold(board: Board): Boolean = board.gold >= gold
-
     private fun hasRequiredGold(board: Board, resourceTransactions: ResourceTransactions): Boolean {
         val resourcesPrice = board.tradingRules.computeCost(resourceTransactions)
         return board.gold >= gold + resourcesPrice
diff --git a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/cards/RequirementsSatisfaction.kt b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/cards/RequirementsSatisfaction.kt
new file mode 100644
index 00000000..de78abad
--- /dev/null
+++ b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/cards/RequirementsSatisfaction.kt
@@ -0,0 +1,84 @@
+package org.luxons.sevenwonders.game.cards
+
+import org.luxons.sevenwonders.game.resources.ResourceTransactions
+import org.luxons.sevenwonders.game.resources.noTransactions
+
+internal sealed class RequirementsSatisfaction(
+    val satisfied: Boolean,
+    val minPrice: Int,
+    val cheapestTransactions: Set<ResourceTransactions>
+) {
+    sealed class Acceptable(minPrice: Int, cheapestTransactions: Set<ResourceTransactions>) :
+        RequirementsSatisfaction(true, minPrice, cheapestTransactions) {
+
+        sealed class WithoutHelp(minPrice: Int) : Acceptable(minPrice, setOf(noTransactions())) {
+
+            sealed class Free : WithoutHelp(0) {
+
+                object NoRequirement : Free()
+
+                object EnoughResources : Free()
+            }
+
+            class EnoughGold(minPrice: Int) : WithoutHelp(minPrice)
+
+            class EnoughResourcesAndGold(minPrice: Int) : WithoutHelp(minPrice)
+        }
+
+        class WithHelp(minPrice: Int, cheapestTransactions: Set<ResourceTransactions>) :
+            Acceptable(minPrice, cheapestTransactions)
+    }
+
+    sealed class Insufficient(minPrice: Int, cheapestTransactions: Set<ResourceTransactions>) :
+        RequirementsSatisfaction(false, minPrice, cheapestTransactions) {
+
+        class MissingRequiredGold(minPrice: Int) : Insufficient(minPrice, emptySet())
+
+        class MissingGoldForResources(minPrice: Int, cheapestTransactions: Set<ResourceTransactions>) :
+            Insufficient(minPrice, cheapestTransactions)
+
+        object UnavailableResources : Insufficient(Int.MAX_VALUE, emptySet())
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as RequirementsSatisfaction
+
+        if (satisfied != other.satisfied) return false
+        if (minPrice != other.minPrice) return false
+        if (cheapestTransactions != other.cheapestTransactions) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = satisfied.hashCode()
+        result = 31 * result + minPrice
+        result = 31 * result + cheapestTransactions.hashCode()
+        return result
+    }
+
+    companion object {
+
+        internal fun noRequirements() = RequirementsSatisfaction.Acceptable.WithoutHelp.Free.NoRequirement
+
+        internal fun enoughResources() = RequirementsSatisfaction.Acceptable.WithoutHelp.Free.EnoughResources
+
+        internal fun enoughGold(minPrice: Int) = RequirementsSatisfaction.Acceptable.WithoutHelp.EnoughGold(minPrice)
+
+        internal fun enoughResourcesAndGold(minPrice: Int) =
+            RequirementsSatisfaction.Acceptable.WithoutHelp.EnoughResourcesAndGold(minPrice)
+
+        internal fun metWithHelp(minPrice: Int, cheapestTransactions: Set<ResourceTransactions>) =
+            RequirementsSatisfaction.Acceptable.WithHelp(minPrice, cheapestTransactions)
+
+        internal fun missingRequiredGold(minPrice: Int) = RequirementsSatisfaction.Insufficient.MissingRequiredGold(minPrice)
+
+        internal fun missingGoldForResources(minPrice: Int, cheapestTransactions: Set<ResourceTransactions>) =
+            RequirementsSatisfaction.Insufficient.MissingGoldForResources(minPrice, cheapestTransactions)
+
+        internal fun resourcesUnavailable() = RequirementsSatisfaction.Insufficient.UnavailableResources
+    }
+}
diff --git a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/moves/MoveType.kt b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/moves/MoveType.kt
index ae00f23f..8062e212 100644
--- a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/moves/MoveType.kt
+++ b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/moves/MoveType.kt
@@ -11,7 +11,5 @@ enum class MoveType(private val create: (move: PlayerMove, card: Card, context:
     DISCARD(::DiscardMove),
     COPY_GUILD(::CopyGuildMove);
 
-    internal fun resolve(move: PlayerMove, card: Card, context: PlayerContext): Move {
-        return create(move, card, context)
-    }
+    internal fun resolve(move: PlayerMove, card: Card, context: PlayerContext): Move = create(move, card, context)
 }
diff --git a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/wonders/Wonder.kt b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/wonders/Wonder.kt
index 46e09d40..4910c51f 100644
--- a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/wonders/Wonder.kt
+++ b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/wonders/Wonder.kt
@@ -13,22 +13,18 @@ internal class Wonder(
     val image: String
 ) {
     val nbBuiltStages: Int
-        get() = stages.filter { it.isBuilt }.count()
+        get() = stages.count { it.isBuilt }
 
     private val nextStage: WonderStage
         get() {
-            val nextLevel = nbBuiltStages
-            if (nextLevel == stages.size) {
+            if (nbBuiltStages == stages.size) {
                 throw IllegalStateException("This wonder has already reached its maximum level")
             }
-            return stages[nextLevel]
+            return stages[nbBuiltStages]
         }
 
-    private val lastBuiltStage: WonderStage
-        get() {
-            val lastLevel = nbBuiltStages - 1
-            return stages[lastLevel]
-        }
+    val lastBuiltStage: WonderStage?
+        get() = stages.getOrNull(nbBuiltStages - 1)
 
     fun isNextStageBuildable(board: Board, boughtResources: ResourceTransactions): Boolean =
         nbBuiltStages < stages.size && nextStage.isBuildable(board, boughtResources)
@@ -36,11 +32,8 @@ internal class Wonder(
     fun placeCard(cardBack: CardBack) = nextStage.placeCard(cardBack)
 
     fun activateLastBuiltStage(player: Player, boughtResources: ResourceTransactions) =
-        lastBuiltStage.activate(player, boughtResources)
+        lastBuiltStage!!.activate(player, boughtResources)
 
     fun computePoints(player: Player): Int =
-        stages.filter { it.isBuilt }
-            .flatMap { it.effects }
-            .map { it.computePoints(player) }
-            .sum()
+        stages.filter { it.isBuilt }.flatMap { it.effects }.sumBy { it.computePoints(player) }
 }
diff --git a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/wonders/WonderStage.kt b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/wonders/WonderStage.kt
index 39aca254..311e589e 100644
--- a/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/wonders/WonderStage.kt
+++ b/game-engine/src/main/kotlin/org/luxons/sevenwonders/game/wonders/WonderStage.kt
@@ -7,17 +7,18 @@ import org.luxons.sevenwonders.game.cards.Requirements
 import org.luxons.sevenwonders.game.effects.Effect
 import org.luxons.sevenwonders.game.resources.ResourceTransactions
 
-internal class WonderStage(val requirements: Requirements, val effects: List<Effect>) {
-
+internal class WonderStage(
+    val requirements: Requirements,
+    val effects: List<Effect>
+) {
     var cardBack: CardBack? = null
         private set
 
     val isBuilt: Boolean
         get() = cardBack != null
 
-    fun isBuildable(board: Board, boughtResources: ResourceTransactions): Boolean {
-        return requirements.areMetWithHelpBy(board, boughtResources)
-    }
+    fun isBuildable(board: Board, boughtResources: ResourceTransactions): Boolean =
+        requirements.areMetWithHelpBy(board, boughtResources)
 
     fun placeCard(cardBack: CardBack) {
         this.cardBack = cardBack
diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/GameTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/GameTest.kt
index 3736ddc0..5b9d36d0 100644
--- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/GameTest.kt
+++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/GameTest.kt
@@ -2,15 +2,14 @@ package org.luxons.sevenwonders.game
 
 import org.junit.Test
 import org.luxons.sevenwonders.game.api.Action
-import org.luxons.sevenwonders.game.api.HandCard
+import org.luxons.sevenwonders.game.api.Board
+import org.luxons.sevenwonders.game.api.PlayedMove
 import org.luxons.sevenwonders.game.api.PlayerMove
 import org.luxons.sevenwonders.game.api.PlayerTurnInfo
 import org.luxons.sevenwonders.game.api.Table
 import org.luxons.sevenwonders.game.data.GameDefinition
 import org.luxons.sevenwonders.game.data.LAST_AGE
 import org.luxons.sevenwonders.game.moves.MoveType
-import org.luxons.sevenwonders.game.resources.ResourceTransactions
-import org.luxons.sevenwonders.game.resources.noTransactions
 import org.luxons.sevenwonders.game.test.testCustomizableSettings
 import java.util.HashMap
 import kotlin.test.assertEquals
@@ -21,13 +20,25 @@ import kotlin.test.assertTrue
 class GameTest {
 
     @Test
-    fun testFullGame() {
-        val nbPlayers = 5
+    fun testFullGame3Players() {
+        playGame(nbPlayers = 3)
+    }
+
+    @Test
+    fun testFullGame5Players() {
+        playGame(nbPlayers = 6)
+    }
+
+    @Test
+    fun testFullGame7Players() {
+        playGame(nbPlayers = 7)
+    }
+
+    private fun playGame(nbPlayers: Int) {
         val game = createGame(nbPlayers)
 
-        for (age in 1..LAST_AGE) {
-            playAge(nbPlayers, game, age)
-        }
+        (1..LAST_AGE).forEach { playAge(nbPlayers, game, it) }
+
         game.computeScore()
     }
 
@@ -59,36 +70,24 @@ class GameTest {
         checkLastPlayedMoves(sentMoves, table)
     }
 
-    private fun getFirstAvailableMove(turnInfo: PlayerTurnInfo): PlayerMove? {
-        return when (turnInfo.action) {
-            Action.PLAY, Action.PLAY_2, Action.PLAY_LAST -> createPlayCardMove(turnInfo)
-            Action.PICK_NEIGHBOR_GUILD -> createPickGuildMove(turnInfo)
-            Action.WAIT -> null
-            else -> null
-        }
+    private fun getFirstAvailableMove(turnInfo: PlayerTurnInfo): PlayerMove? = when (turnInfo.action) {
+        Action.PLAY, Action.PLAY_2, Action.PLAY_LAST -> createPlayCardMove(turnInfo)
+        Action.PICK_NEIGHBOR_GUILD -> createPickGuildMove(turnInfo)
+        Action.WAIT -> null
     }
 
     private fun createPlayCardMove(turnInfo: PlayerTurnInfo): PlayerMove {
-        for (handCard in turnInfo.hand) {
-            if (handCard.isPlayable) {
-                val transactions = findResourcesToBuyFor(handCard)
-                return PlayerMove(MoveType.PLAY, handCard.name, transactions)
-            }
-        }
-        val firstCardInHand = turnInfo.hand[0]
-        return PlayerMove(MoveType.DISCARD, firstCardInHand.name)
-    }
+        val playableCard = turnInfo.hand.firstOrNull { it.isPlayable }
 
-    private fun findResourcesToBuyFor(handCard: HandCard): ResourceTransactions {
-        if (handCard.isFree) {
-            return noTransactions()
+        return if (playableCard != null) {
+            PlayerMove(MoveType.PLAY, playableCard.name, playableCard.cheapestTransactions.first())
+        } else {
+            PlayerMove(MoveType.DISCARD, turnInfo.hand.first().name)
         }
-        return handCard.cheapestTransactions.possibleTransactions.first()
     }
 
     private fun createPickGuildMove(turnInfo: PlayerTurnInfo): PlayerMove {
         val neighbourGuilds = turnInfo.neighbourGuildCards
-        assertNotNull(neighbourGuilds)
         assertFalse(neighbourGuilds.isEmpty())
         val cardName = neighbourGuilds[0].name
         return PlayerMove(MoveType.COPY_GUILD, cardName)
@@ -100,6 +99,30 @@ class GameTest {
             assertNotNull(sentMove)
             assertNotNull(move.card)
             assertEquals(sentMove.cardName, move.card.name)
+            assertEquals(sentMove.type, move.type)
+            assertEquals(sentMove.transactions, move.transactions)
+
+            val board = table.boards[move.playerIndex]
+            when (sentMove.type) {
+                MoveType.PLAY, MoveType.PLAY_FREE -> checkLastPlayedCard(move, board)
+                MoveType.UPGRADE_WONDER -> checkWonderUpgraded(move, board)
+                else -> Unit
+            }
         }
     }
+
+    private fun checkLastPlayedCard(move: PlayedMove, board: Board) {
+        val card = board.playedCards.first { it.name == move.card.name }
+        assertTrue(card.playedDuringLastMove)
+    }
+
+    private fun checkWonderUpgraded(move: PlayedMove, board: Board) {
+        val stages = board.wonder.stages
+
+        val lastBuiltStage = stages.last { it.isBuilt }
+        val otherStages = stages - lastBuiltStage
+
+        assertEquals(move.type == MoveType.UPGRADE_WONDER, lastBuiltStage.builtDuringLastMove)
+        assertFalse(otherStages.any { it.builtDuringLastMove })
+    }
 }
diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/RequirementsTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/RequirementsTest.kt
index 5abbba6e..4ed244b6 100644
--- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/RequirementsTest.kt
+++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/RequirementsTest.kt
@@ -16,9 +16,7 @@ import org.luxons.sevenwonders.game.test.createRequirements
 import org.luxons.sevenwonders.game.test.createTransactions
 import org.luxons.sevenwonders.game.test.singleBoardPlayer
 import org.luxons.sevenwonders.game.test.testBoard
-import java.util.Arrays
 import kotlin.test.assertEquals
-import kotlin.test.assertFalse
 import kotlin.test.assertSame
 import kotlin.test.assertTrue
 
@@ -45,9 +43,18 @@ class RequirementsTest {
         val board = testBoard(ResourceType.CLAY, boardGold)
         val player = singleBoardPlayer(board)
 
-        assertEquals(boardGold >= requiredGold, requirements.areMetWithoutNeighboursBy(board))
         assertEquals(boardGold >= requiredGold, requirements.areMetWithHelpBy(board, noTransactions()))
-        assertEquals(boardGold >= requiredGold, requirements.areMetBy(player))
+
+        val satisfaction = requirements.computeSatisfaction(player)
+        if (boardGold >= requiredGold) {
+            if (requiredGold == 0) {
+                assertEquals(RequirementsSatisfaction.noRequirements(), satisfaction)
+            } else {
+                assertEquals(RequirementsSatisfaction.enoughGold(requiredGold), satisfaction)
+            }
+        } else {
+            assertEquals(RequirementsSatisfaction.missingRequiredGold(requiredGold), satisfaction)
+        }
     }
 
     @Theory
@@ -57,11 +64,11 @@ class RequirementsTest {
         val board = testBoard(initialResource, 0)
         val player = singleBoardPlayer(board)
 
-        assertEquals(initialResource == requiredResource, requirements.areMetWithoutNeighboursBy(board))
         assertEquals(initialResource == requiredResource, requirements.areMetWithHelpBy(board, noTransactions()))
 
         if (initialResource == requiredResource) {
-            assertTrue(requirements.areMetBy(player))
+            val satisfaction = requirements.computeSatisfaction(player)
+            assertEquals(RequirementsSatisfaction.enoughResources(), satisfaction)
         }
     }
 
@@ -79,11 +86,11 @@ class RequirementsTest {
         board.production.addFixedResource(producedResource, 1)
         val player = singleBoardPlayer(board)
 
-        assertEquals(producedResource == requiredResource, requirements.areMetWithoutNeighboursBy(board))
         assertEquals(producedResource == requiredResource, requirements.areMetWithHelpBy(board, noTransactions()))
 
         if (producedResource == requiredResource) {
-            assertTrue(requirements.areMetBy(player))
+            val satisfaction = requirements.computeSatisfaction(player)
+            assertEquals(RequirementsSatisfaction.enoughResources(), satisfaction)
         }
     }
 
@@ -100,14 +107,24 @@ class RequirementsTest {
         val board = testBoard(initialResource, 2)
         val neighbourBoard = testBoard(initialResource, 0)
         neighbourBoard.publicProduction.addFixedResource(boughtResource, 1)
-        val table = Table(Arrays.asList(board, neighbourBoard))
+        val table = Table(listOf(board, neighbourBoard))
         val player = SimplePlayer(0, table)
 
         val resources = createTransactions(Provider.RIGHT_PLAYER, boughtResource)
 
-        assertFalse(requirements.areMetWithoutNeighboursBy(board))
-        assertEquals(boughtResource == requiredResource, requirements.areMetWithHelpBy(board, resources))
-        assertEquals(boughtResource == requiredResource, requirements.areMetBy(player))
+        val neighbourHasResource = boughtResource == requiredResource
+        assertEquals(neighbourHasResource, requirements.areMetWithHelpBy(board, resources))
+
+        val satisfaction = requirements.computeSatisfaction(player)
+        if (neighbourHasResource) {
+            val transactions = setOf(
+                createTransactions(Provider.LEFT_PLAYER, requiredResource),
+                createTransactions(Provider.RIGHT_PLAYER, requiredResource)
+            )
+            assertEquals(RequirementsSatisfaction.metWithHelp(2, transactions), satisfaction)
+        } else {
+            assertEquals(RequirementsSatisfaction.resourcesUnavailable(), satisfaction)
+        }
     }
 
     @Theory
@@ -118,14 +135,13 @@ class RequirementsTest {
 
         val board = testBoard(initialResource, 2)
         val neighbourBoard = testBoard(requiredResource, 0)
-        val table = Table(Arrays.asList(board, neighbourBoard))
+        val table = Table(listOf(board, neighbourBoard))
         val player = SimplePlayer(0, table)
 
         val transactions = createTransactions(Provider.RIGHT_PLAYER, requiredResource)
 
-        assertFalse(requirements.areMetWithoutNeighboursBy(board))
         assertTrue(requirements.areMetWithHelpBy(board, transactions))
-        assertTrue(requirements.areMetBy(player))
+        assertTrue(requirements.computeSatisfaction(player).satisfied)
 
         requirements.pay(player, transactions)