Make all transactions available

Sometimes the strategic move can be to spend more money on a different player, rather than less money on the wrong player.
We need to make these strategic moves available through the UI.

To make up for the explosion in combinations, we just have to get rid of the options that result in the same money for each neighbour.
As long as we give the same amounts, we don't care whether it's for wood or clay.

Related:
https://github.com/joffrey-bion/seven-wonders/issues/50

5 files changed, 62 insertions, 56 deletions

diff --git a/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/Cards.kt b/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/Cards.kt
index d5468283..b097734a 100644
--- a/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/Cards.kt
+++ b/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/Cards.kt
@@ -8,7 +8,7 @@ import org.luxons.sevenwonders.model.cards.CardPlayability
 import org.luxons.sevenwonders.model.cards.Color
 import org.luxons.sevenwonders.model.cards.PlayabilityLevel
 import org.luxons.sevenwonders.model.resources.ResourceTransactions
-import org.luxons.sevenwonders.model.resources.noTransactions
+import org.luxons.sevenwonders.model.resources.singleOptionNoTransactionNeeded
 
 internal data class Card(
     val name: String,
@@ -55,7 +55,7 @@ private object Playability {
         isPlayable = true,
         isChainable = true,
         minPrice = 0,
-        cheapestTransactions = setOf(noTransactions()),
+        transactionOptions = singleOptionNoTransactionNeeded(),
         playabilityLevel = PlayabilityLevel.CHAINABLE,
     )
 
@@ -63,7 +63,7 @@ private object Playability {
         isPlayable = satisfaction.satisfied,
         isChainable = false,
         minPrice = satisfaction.minPrice,
-        cheapestTransactions = satisfaction.cheapestTransactions,
+        transactionOptions = satisfaction.transactionOptions,
         playabilityLevel = satisfaction.level,
     )
 
@@ -71,7 +71,7 @@ private object Playability {
         isPlayable = true,
         isChainable = false,
         minPrice = 0,
-        cheapestTransactions = setOf(noTransactions()),
+        transactionOptions = singleOptionNoTransactionNeeded(),
         playabilityLevel = PlayabilityLevel.SPECIAL_FREE,
     )
 }
diff --git a/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/Requirements.kt b/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/Requirements.kt
index 945f4463..b78a5057 100644
--- a/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/Requirements.kt
+++ b/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/Requirements.kt
@@ -2,12 +2,9 @@ package org.luxons.sevenwonders.engine.cards
 
 import org.luxons.sevenwonders.engine.Player
 import org.luxons.sevenwonders.engine.boards.Board
-import org.luxons.sevenwonders.engine.resources.Resources
-import org.luxons.sevenwonders.engine.resources.asResources
-import org.luxons.sevenwonders.engine.resources.bestSolution
-import org.luxons.sevenwonders.engine.resources.emptyResources
-import org.luxons.sevenwonders.engine.resources.execute
+import org.luxons.sevenwonders.engine.resources.*
 import org.luxons.sevenwonders.model.resources.ResourceTransactions
+import org.luxons.sevenwonders.model.resources.bestPrice
 
 data class Requirements internal constructor(
     val gold: Int = 0,
@@ -37,15 +34,15 @@ data class Requirements internal constructor(
     }
 
     private fun satisfactionWithPotentialHelp(player: Player): RequirementsSatisfaction {
-        val (minPriceForResources, possibleTransactions) = bestSolution(resources, player)
-        val minPrice = minPriceForResources + gold
-        if (possibleTransactions.isEmpty()) {
+        val options = transactionOptions(resources, player)
+        val minPrice = options.bestPrice + gold
+        if (options.isEmpty()) {
             return RequirementsSatisfaction.unavailableResources()
         }
         if (player.board.gold < minPrice) {
-            return RequirementsSatisfaction.missingGoldForResources(minPrice, possibleTransactions)
+            return RequirementsSatisfaction.missingGoldForResources(minPrice, options)
         }
-        return RequirementsSatisfaction.metWithHelp(minPrice, possibleTransactions)
+        return RequirementsSatisfaction.metWithHelp(minPrice, options)
     }
 
     /**
diff --git a/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/RequirementsSatisfaction.kt b/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/RequirementsSatisfaction.kt
index f9566981..55ec1edb 100644
--- a/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/RequirementsSatisfaction.kt
+++ b/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/cards/RequirementsSatisfaction.kt
@@ -1,39 +1,40 @@
 package org.luxons.sevenwonders.engine.cards
 
 import org.luxons.sevenwonders.model.cards.PlayabilityLevel
-import org.luxons.sevenwonders.model.resources.PricedResourceTransactions
-import org.luxons.sevenwonders.model.resources.noTransactions
+import org.luxons.sevenwonders.model.resources.ResourceTransactionOptions
+import org.luxons.sevenwonders.model.resources.noTransactionOptions
+import org.luxons.sevenwonders.model.resources.singleOptionNoTransactionNeeded
 
 internal data class RequirementsSatisfaction(
     val satisfied: Boolean,
     val level: PlayabilityLevel,
     val minPrice: Int,
-    val cheapestTransactions: Set<PricedResourceTransactions>,
+    val transactionOptions: ResourceTransactionOptions,
 ) {
     companion object {
 
         internal fun noRequirements() =
-            RequirementsSatisfaction(true, PlayabilityLevel.NO_REQUIREMENTS, 0, setOf(noTransactions()))
+            RequirementsSatisfaction(true, PlayabilityLevel.NO_REQUIREMENTS, 0, singleOptionNoTransactionNeeded())
 
         internal fun enoughResources() =
-            RequirementsSatisfaction(true, PlayabilityLevel.ENOUGH_RESOURCES, 0, setOf(noTransactions()))
+            RequirementsSatisfaction(true, PlayabilityLevel.ENOUGH_RESOURCES, 0, singleOptionNoTransactionNeeded())
 
         internal fun enoughGold(minPrice: Int) =
-            RequirementsSatisfaction(true, PlayabilityLevel.ENOUGH_GOLD, minPrice, setOf(noTransactions()))
+            RequirementsSatisfaction(true, PlayabilityLevel.ENOUGH_GOLD, minPrice, singleOptionNoTransactionNeeded())
 
         internal fun enoughResourcesAndGold(minPrice: Int) =
-            RequirementsSatisfaction(true, PlayabilityLevel.ENOUGH_GOLD_AND_RES, minPrice, setOf(noTransactions()))
+            RequirementsSatisfaction(true, PlayabilityLevel.ENOUGH_GOLD_AND_RES, minPrice, singleOptionNoTransactionNeeded())
 
-        internal fun metWithHelp(minPrice: Int, cheapestTransactions: Set<PricedResourceTransactions>) =
-            RequirementsSatisfaction(true, PlayabilityLevel.REQUIRES_HELP, minPrice, cheapestTransactions)
+        internal fun metWithHelp(minPrice: Int, transactionOptions: ResourceTransactionOptions) =
+            RequirementsSatisfaction(true, PlayabilityLevel.REQUIRES_HELP, minPrice, transactionOptions)
 
         internal fun missingRequiredGold(minPrice: Int) =
-            RequirementsSatisfaction(false, PlayabilityLevel.MISSING_REQUIRED_GOLD, minPrice, emptySet())
+            RequirementsSatisfaction(false, PlayabilityLevel.MISSING_REQUIRED_GOLD, minPrice, noTransactionOptions())
 
-        internal fun missingGoldForResources(minPrice: Int, cheapestTransactions: Set<PricedResourceTransactions>) =
-            RequirementsSatisfaction(false, PlayabilityLevel.MISSING_GOLD_FOR_RES, minPrice, cheapestTransactions)
+        internal fun missingGoldForResources(minPrice: Int, transactionOptions: ResourceTransactionOptions) =
+            RequirementsSatisfaction(false, PlayabilityLevel.MISSING_GOLD_FOR_RES, minPrice, transactionOptions)
 
         internal fun unavailableResources() =
-            RequirementsSatisfaction(false, PlayabilityLevel.UNAVAILABLE_RESOURCES, Int.MAX_VALUE, emptySet())
+            RequirementsSatisfaction(false, PlayabilityLevel.UNAVAILABLE_RESOURCES, Int.MAX_VALUE, noTransactionOptions())
     }
 }
diff --git a/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/resources/BestPriceCalculator.kt b/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/resources/TransactionOptionsCalculator.kt
index 967bee2c..fbbcaa6e 100644
--- a/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/resources/BestPriceCalculator.kt
+++ b/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/resources/TransactionOptionsCalculator.kt
@@ -1,15 +1,11 @@
 package org.luxons.sevenwonders.engine.resources
 
 import org.luxons.sevenwonders.engine.Player
-import org.luxons.sevenwonders.model.resources.PricedResourceTransactions
-import org.luxons.sevenwonders.model.resources.Provider
-import org.luxons.sevenwonders.model.resources.ResourceType
+import org.luxons.sevenwonders.model.resources.*
 import java.util.*
 
-internal fun bestSolution(resources: Resources, player: Player): TransactionPlan =
-    BestPriceCalculator(resources, player).computeBestSolution()
-
-data class TransactionPlan(val price: Int, val possibleTransactions: Set<PricedResourceTransactions>)
+internal fun transactionOptions(resources: Resources, player: Player): ResourceTransactionOptions =
+    TransactionOptionsCalculator(resources, player).computeOptions()
 
 private class ResourcePool(
     val provider: Provider?,
@@ -21,16 +17,14 @@ private class ResourcePool(
     fun getCost(type: ResourceType): Int = if (provider == null) 0 else rules.getCost(type, provider)
 }
 
-private class BestPriceCalculator(resourcesToPay: Resources, player: Player) {
+private class TransactionOptionsCalculator(resourcesToPay: Resources, player: Player) {
 
     private val pools: List<ResourcePool>
     private val resourcesLeftToPay: MutableResources
     private val boughtResources: MutableMap<Provider, MutableResources> = EnumMap(Provider::class.java)
-    private val pricePaid: MutableMap<Provider, Int> = EnumMap(Provider::class.java)
-    private var totalPricePaid: Int = 0
+    private val pricePaidPerProvider: MutableMap<Provider, Int> = EnumMap(Provider::class.java)
 
-    private var bestSolutions: MutableSet<PricedResourceTransactions> = mutableSetOf()
-    private var bestPrice: Int = Integer.MAX_VALUE
+    private var optionsSoFar: MutableSet<PricedResourceTransactions> = mutableSetOf()
 
     init {
         val board = player.board
@@ -53,14 +47,17 @@ private class BestPriceCalculator(resourcesToPay: Resources, player: Player) {
         return ResourcePool(this, player.board.tradingRules, choices)
     }
 
-    fun computeBestSolution(): TransactionPlan {
+    fun computeOptions(): ResourceTransactionOptions {
         computePossibilities()
-        return TransactionPlan(bestPrice, bestSolutions)
+        return optionsSoFar.distinctBy { it.costByProvider }.sortedBy { it.totalPrice }
     }
 
+    private val PricedResourceTransactions.costByProvider: Map<Provider, Int>
+        get() = associate { it.provider to it.totalPrice }
+
     private fun computePossibilities() {
         if (resourcesLeftToPay.isEmpty()) {
-            updateBestSolutionIfNeeded()
+            addCurrentOption()
             return
         }
         for (type in ResourceType.values()) {
@@ -93,13 +90,11 @@ private class BestPriceCalculator(resourcesToPay: Resources, player: Player) {
 
     fun buyOne(provider: Provider, type: ResourceType, cost: Int) {
         boughtResources.getOrPut(provider) { MutableResources() }.add(type, 1)
-        pricePaid.merge(provider, cost) { old, new -> old + new }
-        totalPricePaid += cost
+        pricePaidPerProvider.merge(provider, cost) { old, new -> old + new }
     }
 
     fun unbuyOne(provider: Provider, type: ResourceType, cost: Int) {
-        totalPricePaid -= cost
-        pricePaid.merge(provider, -cost) { old, new -> old + new }
+        pricePaidPerProvider.merge(provider, -cost) { old, new -> old + new }
         boughtResources[provider]!!.remove(type, 1)
     }
 
@@ -114,15 +109,27 @@ private class BestPriceCalculator(resourcesToPay: Resources, player: Player) {
         }
     }
 
-    private fun updateBestSolutionIfNeeded() {
-        if (totalPricePaid > bestPrice) return
-
-        if (totalPricePaid < bestPrice) {
-            bestPrice = totalPricePaid
-            bestSolutions.clear()
+    private fun addCurrentOption() {
+        if (optionsSoFar.any { it < pricePaidPerProvider }) {
+            return
         }
         // avoid mutating the resources from the transactions
-        val transactionSet = boughtResources.mapValues { (_, res) -> res.copy() }.toTransactions(pricePaid)
-        bestSolutions.add(transactionSet)
+        val transactionsOption = boughtResources.mapValues { (_, res) -> res.copy() }.toTransactions(pricePaidPerProvider)
+        optionsSoFar.add(transactionsOption)
+        optionsSoFar.removeIf { it > pricePaidPerProvider }
     }
+
+    private operator fun PricedResourceTransactions.compareTo(prices: Map<Provider, Int>): Int = when {
+        left == prices.left -> right.compareTo(prices.right)
+        right == prices.right -> left.compareTo(prices.left)
+        else -> 0
+    }
+
+    private val Map<Provider, Int>.left: Int get() = this[Provider.LEFT_PLAYER] ?: 0
+    private val Map<Provider, Int>.right: Int get() = this[Provider.RIGHT_PLAYER] ?: 0
+
+    private val PricedResourceTransactions.left: Int
+        get() = firstOrNull { it.provider == Provider.LEFT_PLAYER }?.totalPrice ?: 0
+    private val PricedResourceTransactions.right: Int
+        get() = firstOrNull { it.provider == Provider.RIGHT_PLAYER }?.totalPrice ?: 0
 }
diff --git a/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/wonders/Wonder.kt b/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/wonders/Wonder.kt
index 4a99b9e9..03ed2f8f 100644
--- a/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/wonders/Wonder.kt
+++ b/sw-engine/src/main/kotlin/org/luxons/sevenwonders/engine/wonders/Wonder.kt
@@ -7,6 +7,7 @@ import org.luxons.sevenwonders.model.cards.CardBack
 import org.luxons.sevenwonders.model.cards.PlayabilityLevel
 import org.luxons.sevenwonders.model.resources.ResourceTransactions
 import org.luxons.sevenwonders.model.resources.ResourceType
+import org.luxons.sevenwonders.model.resources.noTransactionOptions
 import org.luxons.sevenwonders.model.wonders.WonderBuildability
 
 internal class Wonder(
@@ -53,14 +54,14 @@ private object Buildability {
     fun wonderFullyBuilt() = WonderBuildability(
         isBuildable = false,
         minPrice = Int.MAX_VALUE,
-        cheapestTransactions = emptySet(),
+        transactionsOptions = noTransactionOptions(),
         playabilityLevel = PlayabilityLevel.WONDER_FULLY_BUILT,
     )
 
     fun requirementDependent(satisfaction: RequirementsSatisfaction) = WonderBuildability(
         isBuildable = satisfaction.satisfied,
         minPrice = satisfaction.minPrice,
-        cheapestTransactions = satisfaction.cheapestTransactions,
+        transactionsOptions = satisfaction.transactionOptions,
         playabilityLevel = satisfaction.level,
     )
 }