flower order, next season

Author: stefanseifert

src/services/BotGarden.ts

@@ -0,0 +1,78 @@
+import { cloneDeep, shuffle } from 'lodash'
+import { GardenSeason } from '@/store/state'
+import { ref } from 'vue'
+import Flower from './enum/Flower'
+import getAllEnumValues from '@brdgm/brdgm-commons/src/util/enum/getAllEnumValues'
+import Season from './enum/Season'
+
+/**
+ * Manages Lady Pei's garden.
+ */
+export default class BotGarden {
+
+  private readonly _seasons
+  private readonly _flowerOrder: Flower[]
+
+  private constructor(seasons : GardenSeason[], flowerOrder: Flower[]) {
+    this._seasons = ref(seasons)
+    this._flowerOrder = flowerOrder
+  }
+
+  public get seasons() : readonly GardenSeason[] {
+    return this._seasons.value
+  }
+
+  /**
+   * Plants the given flower.
+   * @param flower Flower to plan
+   */
+  public plant(flower: Flower) : void {
+
+  }
+
+  /**
+   * Gets persistence view of garden seasons.
+   */
+  public toPersistence() : GardenSeason[] {
+    return cloneDeep(this._seasons.value)
+  }
+
+  /**
+   * Initialize Lady Pei's garden based on the player's selected flowers.
+   * Take two flowers from each family not in the player's garden, one from each family that is.
+   * Randomly assign one flower per season.
+   * @param playerFlowers Flowers the player has in their garden
+   * @param flowerOrder The order of flowers in the market (for Lady Pei's color priority)
+   * @returns BotGarden
+   */
+  public static new(playerFlowers : Flower[], flowerOrder: Flower[]) : BotGarden {
+    const allFlowers = getAllEnumValues(Flower)
+    const pool : Flower[] = []
+    for (const flower of allFlowers) {
+      if (playerFlowers.includes(flower)) {
+        pool.push(flower)
+      }
+      else {
+        pool.push(flower, flower)
+      }
+    }
+    const shuffled = shuffle(pool)
+    const allSeasons = getAllEnumValues(Season)
+    const seasons : GardenSeason[] = allSeasons.map((season, index) => ({
+      season,
+      flowers: [shuffled[index]],
+      bigExtension: 0,
+      smallExtensions: 0
+    }))
+    return new BotGarden(seasons, flowerOrder)
+  }
+
+  /**
+   * Re-creates garden seasons from persistence.
+   * Note that flower order must also be passed in, as it is not stored in the garden persistence (but rather market prices persistence).
+   */
+  public static fromPersistence(persistence : GardenSeason[], flowerOrder: Flower[]) : BotGarden {
+    return new BotGarden(cloneDeep(persistence), flowerOrder)
+  }
+
+}

src/services/MarketPrices.ts

@@ -22,6 +22,10 @@ export default class MarketPrices {
     return this._prices.value
   }
 
+  public get flowerOrder() : Flower[] {
+    return this._prices.value.map(item => item.flower)
+  }
+
   public getPrice(flower : Flower) : number {
     const price = this._prices.value.find(item => item.flower === flower)
     if (!price) {

src/util/getNextSeason.ts

@@ -0,0 +1,11 @@
+import Season from '@/services/enum/Season'
+
+const SEASON_ORDER = [Season.SPRING, Season.SUMMER, Season.AUTUMN, Season.WINTER]
+
+/**
+ * Gets the next season in season order.
+ */
+export default function getNextSeason(season: Season) : Season {
+  const index = SEASON_ORDER.indexOf(season)
+  return SEASON_ORDER[(index + 1) % SEASON_ORDER.length]
+}

src/views/SetupBot.vue

@@ -54,7 +54,7 @@ export default defineComponent({
     },
     flowerOrder() : Flower[] {
       const marketPrices = this.state.setup.initialMarketPrices ? MarketPrices.fromPersistence(this.state.setup.initialMarketPrices) : MarketPrices.new()
-      return marketPrices.prices.map(item => item.flower)
+      return marketPrices.flowerOrder
     }
   },
   methods: {

tests/unit/services/MarketPrices.spec.ts

@@ -15,10 +15,24 @@ describe('services/MarketPrices', () => {
   it('new - contains all flowers', () => {
     const marketPrices = MarketPrices.new()
 
-    const flowers = marketPrices.prices.map(item => item.flower)
+    const flowers = marketPrices.flowerOrder
     expect(flowers).to.include.members([Flower.RED, Flower.PURPLE, Flower.YELLOW, Flower.BLUE, Flower.ORANGE])
   })
 
+  it('flowerOrder', () => {
+    const marketPrices = MarketPrices.fromPersistence([
+      { flower: Flower.ORANGE, price: 4 },
+      { flower: Flower.BLUE, price: 4 },
+      { flower: Flower.RED, price: 4 },
+      { flower: Flower.YELLOW, price: 4 },
+      { flower: Flower.PURPLE, price: 4 },
+    ])
+
+    expect(marketPrices.flowerOrder).to.eql([
+      Flower.ORANGE, Flower.BLUE, Flower.RED, Flower.YELLOW, Flower.PURPLE
+    ])
+  })
+
   it('getPrice', () => {
     const marketPrices = MarketPrices.fromPersistence([
       { flower: Flower.RED, price: 5 },
@@ -93,6 +107,6 @@ describe('services/MarketPrices', () => {
     const restored = MarketPrices.fromPersistence(marketPrices.toPersistence())
     expect(restored.getPrice(Flower.RED)).to.eq(marketPrices.getPrice(Flower.RED))
     expect(restored.getPrice(Flower.BLUE)).to.eq(marketPrices.getPrice(Flower.BLUE))
-    expect(restored.prices.map(p => p.flower)).to.eql(marketPrices.prices.map(p => p.flower))
+    expect(restored.flowerOrder).to.eql(marketPrices.flowerOrder)
   })
 })

tests/unit/util/getNextSeason.spec.ts

@@ -0,0 +1,21 @@
+import Season from '@/services/enum/Season'
+import getNextSeason from '@/util/getNextSeason'
+import { expect } from 'chai'
+
+describe('util/getNextSeason', () => {
+  it('SPRING -> SUMMER', () => {
+    expect(getNextSeason(Season.SPRING)).to.eq(Season.SUMMER)
+  })
+
+  it('SUMMER -> AUTUMN', () => {
+    expect(getNextSeason(Season.SUMMER)).to.eq(Season.AUTUMN)
+  })
+
+  it('AUTUMN -> WINTER', () => {
+    expect(getNextSeason(Season.AUTUMN)).to.eq(Season.WINTER)
+  })
+
+  it('WINTER -> SPRING', () => {
+    expect(getNextSeason(Season.WINTER)).to.eq(Season.SPRING)
+  })
+})