Implement food cost

Author: prfarlow1

.idea/misc.xml

@@ -0,0 +1,14 @@
+package com.peterfarlow.core
+
+enum class Food(val symbol: String) {
+    INVERTEBRATE("I"),
+    SEED("S"),
+    RODENT("R"),
+    FISH("F"),
+    FRUIT("C"),
+    WILD("W");
+
+    companion object {
+        fun deserialize(symbol: Char): Food = values().first { it.symbol == symbol.toString() }
+    }
+}

core/src/main/java/com/peterfarlow/core/Food.kt

@@ -0,0 +1,108 @@
+package com.peterfarlow.core
+
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+import kotlinx.parcelize.RawValue
+
+sealed class FoodCost(open val items: Collection<Food>) : Parcelable {
+
+    abstract fun payFoodCost(availableFood: Collection<Food>): FoodCostOutcome
+
+    fun canAfford(availableFood: Collection<Food>) = payFoodCost(availableFood).isSuccess
+
+    @Parcelize
+    object JustWild : FoodCost(setOf(Food.WILD)) {
+        override fun payFoodCost(availableFood: Collection<Food>): FoodCostOutcome {
+            return if (availableFood.isEmpty()) {
+                FoodCostOutcome.Failure(this)
+            } else {
+                val usedFood = availableFood.toMutableList().apply {
+                    removeFirst()
+                }
+                FoodCostOutcome.Success(usedFood)
+            }
+        }
+
+        override fun toString() = "JustWild"
+    }
+
+    @Parcelize
+    object None : FoodCost(emptyList()) {
+        override fun payFoodCost(availableFood: Collection<Food>) =
+            FoodCostOutcome.Success(emptyList())
+
+        override fun toString() = "None"
+    }
+
+    @Parcelize
+    data class Any(override val items: @RawValue Collection<Food>) : FoodCost(items) {
+        override fun payFoodCost(availableFood: Collection<Food>): FoodCostOutcome {
+            if (availableFood.isEmpty()) return FoodCostOutcome.Failure(this)
+            val remainingFood = availableFood.toMutableList()
+            for (food in items) {
+                if (remainingFood.remove(food)) {
+                    return FoodCostOutcome.Success(listOf(food))
+                }
+            }
+            return FoodCostOutcome.Failure(this)
+        }
+    }
+
+    @Parcelize
+    data class All(override val items: @RawValue Collection<Food>) : FoodCost(items) {
+        override fun payFoodCost(availableFood: Collection<Food>): FoodCostOutcome {
+            if (availableFood.isEmpty()) return FoodCostOutcome.Failure(this)
+            val remainingFood = availableFood.toMutableList()
+            val missingFood = mutableListOf<Food>()
+            val usedFood = mutableListOf<Food>()
+            val sortedFoodCost = items.sorted() // put the wilds last
+            for (food in sortedFoodCost) {
+                if (remainingFood.remove(food)) {
+                    usedFood.add(food)
+                } else {
+                    if (food == Food.WILD) {
+                        if (remainingFood.isEmpty()) {
+                            missingFood.add(food)
+                        } else {
+                            val first = remainingFood.first()
+                            remainingFood.remove(first)
+                            usedFood.add(first)
+                        }
+                    } else {
+                        missingFood.add(food)
+                    }
+                }
+            }
+            return if (missingFood.isEmpty()) {
+                FoodCostOutcome.Success(usedFood)
+            } else {
+                FoodCostOutcome.Failure(All(missingFood))
+            }
+        }
+    }
+}
+
+sealed class FoodCostOutcome {
+    data class Success(val foodUsed: Collection<Food>) : FoodCostOutcome()
+    data class Failure(val missingFood: FoodCost) : FoodCostOutcome()
+
+    val isSuccess get() = this is Success
+}
+
+fun String.toFoodCost(): FoodCost {
+    val parts = split("-")
+    check(parts.size == 2)
+    return when {
+        parts[0] == "any" -> {
+            FoodCost.Any(parts[1].toFoodList())
+        }
+        parts[0] == "all" -> {
+            FoodCost.All(parts[1].toFoodList())
+        }
+        else -> {
+            throw IllegalArgumentException()
+        }
+    }
+}
+
+fun String.toFoodList(): List<Food> = toCharArray().map { Food.deserialize(it) }

core/src/main/java/com/peterfarlow/core/FoodCost.kt

@@ -18,7 +18,7 @@ data class Bird(
     val latinName: String = "",
     val points: Points = 0,
     val habitat: Set<Habitat>,
-    val foodCosts: Set<FoodCost>,
+    val foodCost: FoodCost,
     val nestType: NestType,
     val description: String = "",
     val wingspan: Int,
@@ -54,16 +54,6 @@ enum class NestType {
     NONE
 }
 
-
-enum class Food {
-    WORM,
-    WHEAT,
-    MOUSE,
-    FISH,
-    CHERRY,
-    WILD
-}
-
 enum class FoodDiceFace {
     WORM,
     WHEAT,
@@ -73,8 +63,6 @@ enum class FoodDiceFace {
     WORM_WHEAT
 }
 
-typealias FoodCost = Set<Food>
-
 @Parcelize
 data class PlayerFoodSupply(
     val worms: Int = 0,

core/src/main/java/com/peterfarlow/core/TurnAction.kt

@@ -0,0 +1,28 @@
+package com.peterfarlow.core
+
+import org.hamcrest.MatcherAssert.assertThat
+import org.hamcrest.core.IsEqual.equalTo
+import org.junit.Test
+
+class FoodCostTest {
+
+    private val testMap: List<Triple<FoodCost, List<Food>, FoodCostOutcome>> = listOf(
+        Triple("any-ISR".toFoodCost(), "I".toFoodList(), FoodCostOutcome.Success("I".toFoodList())),
+        Triple("all-RCF".toFoodCost(), "C".toFoodList(), FoodCostOutcome.Failure("all-RF".toFoodCost())),
+        Triple(FoodCost.None, emptyList(), FoodCostOutcome.Success(emptyList())),
+        Triple("all-SSS".toFoodCost(), "SS".toFoodList(), FoodCostOutcome.Failure("all-S".toFoodCost())),
+        Triple("all-RRSWW".toFoodCost(), "FFFFFFFFSRR".toFoodList(), FoodCostOutcome.Success("SRRFF".toFoodList())),
+        Triple("all-CCSRW".toFoodCost(), "CCCCCCCCCC".toFoodList(), FoodCostOutcome.Failure("all-SR".toFoodCost()))
+    )
+
+    @Test
+    fun testFood() {
+        testMap.forEach {
+            assertThat(
+                "input ${it.first} ${it.second}",
+                it.first.payFoodCost(it.second),
+                equalTo(it.third)
+            )
+        }
+    }
+}