bot garden

Author: stefanseifert

src/services/BotGarden.ts

@@ -4,12 +4,24 @@ import { ref } from 'vue'
 import Flower from './enum/Flower'
 import getAllEnumValues from '@brdgm/brdgm-commons/src/util/enum/getAllEnumValues'
 import Season from './enum/Season'
+import getNextSeason from '@/util/getNextSeason'
 
 /**
  * Manages Lady Pei's garden.
  */
 export default class BotGarden {
 
+  // Base garden holds 2 flowers per season
+  static readonly BASE_CAPACITY = 2
+  // Big extension adds 3 flower slots; max 1 per season, 3 total
+  static readonly BIG_EXTENSION_CAPACITY = 3
+  static readonly MAX_BIG_EXTENSIONS_PER_SEASON = 1
+  static readonly MAX_TOTAL_BIG_EXTENSIONS = 3
+  // Small extension adds 2 flower slots each; max 2 per season, 3 total; requires big extension
+  static readonly SMALL_EXTENSION_CAPACITY = 2
+  static readonly MAX_SMALL_EXTENSIONS_PER_SEASON = 2
+  static readonly MAX_TOTAL_SMALL_EXTENSIONS = 3
+
   private readonly _seasons
   private readonly _flowerOrder: Flower[]
 
@@ -23,11 +35,86 @@ export default class BotGarden {
   }
 
   /**
-   * Plants the given flower.
-   * @param flower Flower to plan
+   * Plants the given flower in Lady Pei's garden.
+   * Chooses the first empty space beginning with the next season and continuing clockwise.
+   * If every space is full, adds an extension (big first, then small) to the next eligible season.
+   * @param flower Flower to plant
+   * @param currentSeason The current season
+   * @returns true if the flower was planted, false if the garden is full
+   */
+  public plant(flower: Flower, currentSeason: Season) : boolean {
+    // Try to find an existing empty space, starting from next season clockwise
+    let season = getNextSeason(currentSeason)
+    for (let i = 0; i < 4; i++) {
+      const gs = this.getGardenSeason(season)
+      if (gs.flowers.length < BotGarden.getSeasonCapacity(gs)) {
+        gs.flowers.push(flower)
+        this.sortFlowers(gs)
+        return true
+      }
+      season = getNextSeason(season)
+    }
+
+    // No empty space — add an extension and place the flower
+    season = getNextSeason(currentSeason)
+    for (let i = 0; i < 4; i++) {
+      const gs = this.getGardenSeason(season)
+      if (this.canAddBigExtension(gs)) {
+        gs.bigExtension++
+        gs.flowers.push(flower)
+        this.sortFlowers(gs)
+        return true
+      }
+      if (this.canAddSmallExtension(gs)) {
+        gs.smallExtensions++
+        gs.flowers.push(flower)
+        this.sortFlowers(gs)
+        return true
+      }
+      season = getNextSeason(season)
+    }
+
+    return false
+  }
+
+  /**
+   * Gets the total flower capacity for a garden season (base + extensions).
    */
-  public plant(flower: Flower) : void {
+  static getSeasonCapacity(gardenSeason: GardenSeason) : number {
+    return BotGarden.BASE_CAPACITY
+      + gardenSeason.bigExtension * BotGarden.BIG_EXTENSION_CAPACITY
+      + gardenSeason.smallExtensions * BotGarden.SMALL_EXTENSION_CAPACITY
+  }
+
+  private getGardenSeason(season: Season) : GardenSeason {
+    const gs = this._seasons.value.find(s => s.season === season)
+    if (!gs) {
+      throw new Error(`Season ${season} not found in garden.`)
+    }
+    return gs
+  }
+
+  private get totalBigExtensions() : number {
+    return this._seasons.value.reduce((sum, s) => sum + s.bigExtension, 0)
+  }
+
+  private get totalSmallExtensions() : number {
+    return this._seasons.value.reduce((sum, s) => sum + s.smallExtensions, 0)
+  }
+
+  private canAddBigExtension(gardenSeason: GardenSeason) : boolean {
+    return gardenSeason.bigExtension < BotGarden.MAX_BIG_EXTENSIONS_PER_SEASON
+      && this.totalBigExtensions < BotGarden.MAX_TOTAL_BIG_EXTENSIONS
+  }
+
+  private canAddSmallExtension(gardenSeason: GardenSeason) : boolean {
+    return gardenSeason.bigExtension > 0
+      && gardenSeason.smallExtensions < BotGarden.MAX_SMALL_EXTENSIONS_PER_SEASON
+      && this.totalSmallExtensions < BotGarden.MAX_TOTAL_SMALL_EXTENSIONS
+  }
 
+  private sortFlowers(gardenSeason: GardenSeason) : void {
+    gardenSeason.flowers.sort((a, b) => this._flowerOrder.indexOf(a) - this._flowerOrder.indexOf(b))
   }
 
   /**

tests/unit/services/BotGarden.spec.ts

@@ -0,0 +1,234 @@
+import BotGarden from '@/services/BotGarden'
+import Flower from '@/services/enum/Flower'
+import Season from '@/services/enum/Season'
+import { GardenSeason } from '@/store/state'
+import { expect } from 'chai'
+
+const FLOWER_ORDER = [Flower.RED, Flower.PURPLE, Flower.YELLOW, Flower.BLUE, Flower.ORANGE]
+
+function makeGarden(overrides?: Partial<Record<Season, Partial<GardenSeason>>>) : GardenSeason[] {
+  const defaults: GardenSeason[] = [
+    { season: Season.SPRING, flowers: [], bigExtension: 0, smallExtensions: 0 },
+    { season: Season.SUMMER, flowers: [], bigExtension: 0, smallExtensions: 0 },
+    { season: Season.AUTUMN, flowers: [], bigExtension: 0, smallExtensions: 0 },
+    { season: Season.WINTER, flowers: [], bigExtension: 0, smallExtensions: 0 },
+  ]
+  if (overrides) {
+    for (const gs of defaults) {
+      const o = overrides[gs.season]
+      if (o) {
+        Object.assign(gs, o)
+      }
+    }
+  }
+  return defaults
+}
+
+function findSeason(garden: BotGarden, season: Season) : GardenSeason {
+  return garden.seasons.find(s => s.season === season)!
+}
+
+describe('services/BotGarden', () => {
+
+  describe('getSeasonCapacity', () => {
+    it('base only', () => {
+      expect(BotGarden.getSeasonCapacity({ season: Season.SPRING, flowers: [], bigExtension: 0, smallExtensions: 0 }))
+        .to.eq(2)
+    })
+
+    it('with big extension', () => {
+      expect(BotGarden.getSeasonCapacity({ season: Season.SPRING, flowers: [], bigExtension: 1, smallExtensions: 0 }))
+        .to.eq(5)
+    })
+
+    it('with big and one small extension', () => {
+      expect(BotGarden.getSeasonCapacity({ season: Season.SPRING, flowers: [], bigExtension: 1, smallExtensions: 1 }))
+        .to.eq(7)
+    })
+
+    it('with big and two small extensions', () => {
+      expect(BotGarden.getSeasonCapacity({ season: Season.SPRING, flowers: [], bigExtension: 1, smallExtensions: 2 }))
+        .to.eq(9)
+    })
+  })
+
+  describe('plant', () => {
+    it('plants in next season when empty', () => {
+      const garden = BotGarden.fromPersistence(makeGarden(), FLOWER_ORDER)
+
+      garden.plant(Flower.RED, Season.SPRING)
+
+      expect(findSeason(garden, Season.SUMMER).flowers).to.eql([Flower.RED])
+    })
+
+    it('skips full seasons and plants in next available', () => {
+      const garden = BotGarden.fromPersistence(makeGarden({
+        [Season.SUMMER]: { flowers: [Flower.RED, Flower.BLUE] },
+      }), FLOWER_ORDER)
+
+      garden.plant(Flower.YELLOW, Season.SPRING)
+
+      expect(findSeason(garden, Season.SUMMER).flowers).to.have.length(2)
+      expect(findSeason(garden, Season.AUTUMN).flowers).to.eql([Flower.YELLOW])
+    })
+
+    it('wraps around to earlier seasons', () => {
+      const garden = BotGarden.fromPersistence(makeGarden({
+        [Season.SUMMER]: { flowers: [Flower.RED, Flower.BLUE] },
+        [Season.AUTUMN]: { flowers: [Flower.RED, Flower.BLUE] },
+        [Season.WINTER]: { flowers: [Flower.RED, Flower.BLUE] },
+      }), FLOWER_ORDER)
+
+      garden.plant(Flower.YELLOW, Season.SPRING)
+
+      expect(findSeason(garden, Season.SPRING).flowers).to.eql([Flower.YELLOW])
+    })
+
+    it('plants multiple flowers sequentially', () => {
+      const garden = BotGarden.fromPersistence(makeGarden({
+        [Season.SPRING]: { flowers: [Flower.RED] },
+        [Season.SUMMER]: { flowers: [Flower.BLUE] },
+        [Season.AUTUMN]: { flowers: [Flower.PURPLE] },
+        [Season.WINTER]: { flowers: [Flower.ORANGE] },
+      }), FLOWER_ORDER)
+
+      garden.plant(Flower.YELLOW, Season.SPRING)
+      garden.plant(Flower.RED, Season.SPRING)
+
+      // First goes to SUMMER (next after SPRING, has 1 flower < 2 capacity)
+      expect(findSeason(garden, Season.SUMMER).flowers).to.eql([Flower.YELLOW, Flower.BLUE])
+      // Second goes to AUTUMN (SUMMER now full)
+      expect(findSeason(garden, Season.AUTUMN).flowers).to.eql([Flower.RED, Flower.PURPLE])
+    })
+
+    it('adds big extension when all base spaces full', () => {
+      const garden = BotGarden.fromPersistence(makeGarden({
+        [Season.SPRING]: { flowers: [Flower.RED, Flower.BLUE] },
+        [Season.SUMMER]: { flowers: [Flower.RED, Flower.BLUE] },
+        [Season.AUTUMN]: { flowers: [Flower.RED, Flower.BLUE] },
+        [Season.WINTER]: { flowers: [Flower.RED, Flower.BLUE] },
+      }), FLOWER_ORDER)
+
+      garden.plant(Flower.YELLOW, Season.SPRING)
+
+      const summer = findSeason(garden, Season.SUMMER)
+      expect(summer.bigExtension).to.eq(1)
+      expect(summer.flowers).to.eql([Flower.RED, Flower.YELLOW, Flower.BLUE])
+    })
+
+    it('adds big extension to next eligible season when first already has one', () => {
+      const garden = BotGarden.fromPersistence(makeGarden({
+        [Season.SPRING]: { flowers: [Flower.RED, Flower.BLUE] },
+        [Season.SUMMER]: { flowers: Array(9).fill(Flower.RED), bigExtension: 1, smallExtensions: 2 },
+        [Season.AUTUMN]: { flowers: [Flower.RED, Flower.BLUE] },
+        [Season.WINTER]: { flowers: [Flower.RED, Flower.BLUE] },
+      }), FLOWER_ORDER)
+
+      garden.plant(Flower.YELLOW, Season.SPRING)
+
+      // SUMMER is fully extended and full, so big extension goes to AUTUMN
+      const autumn = findSeason(garden, Season.AUTUMN)
+      expect(autumn.bigExtension).to.eq(1)
+      expect(autumn.flowers).to.eql([Flower.RED, Flower.YELLOW, Flower.BLUE])
+    })
+
+    it('respects max 3 total big extensions', () => {
+      const garden = BotGarden.fromPersistence(makeGarden({
+        [Season.SPRING]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1 },
+        [Season.SUMMER]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1 },
+        [Season.AUTUMN]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1 },
+        [Season.WINTER]: { flowers: [Flower.RED] },
+      }), FLOWER_ORDER)
+
+      // WINTER has base space available — no new big extension needed
+      garden.plant(Flower.YELLOW, Season.AUTUMN)
+
+      expect(findSeason(garden, Season.WINTER).flowers).to.eql([Flower.RED, Flower.YELLOW])
+      expect(findSeason(garden, Season.WINTER).bigExtension).to.eq(0)
+    })
+
+    it('uses existing big extension space before adding new extension', () => {
+      const garden = BotGarden.fromPersistence(makeGarden({
+        [Season.SPRING]: { flowers: [Flower.RED, Flower.BLUE] },
+        [Season.SUMMER]: { flowers: [Flower.RED, Flower.BLUE, Flower.PURPLE], bigExtension: 1 },
+        [Season.AUTUMN]: { flowers: [Flower.RED, Flower.BLUE] },
+        [Season.WINTER]: { flowers: [Flower.RED, Flower.BLUE] },
+      }), FLOWER_ORDER)
+
+      garden.plant(Flower.YELLOW, Season.SPRING)
+
+      // SUMMER has big extension with 3/5 flowers — still has room
+      const summer = findSeason(garden, Season.SUMMER)
+      expect(summer.flowers).to.eql([Flower.RED, Flower.PURPLE, Flower.YELLOW, Flower.BLUE])
+      expect(summer.bigExtension).to.eq(1)
+    })
+
+    it('adds small extension when big extensions exhausted', () => {
+      const garden = BotGarden.fromPersistence(makeGarden({
+        [Season.SPRING]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1 },
+        [Season.SUMMER]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1 },
+        [Season.AUTUMN]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1 },
+        [Season.WINTER]: { flowers: [Flower.RED] },
+      }), FLOWER_ORDER)
+
+      // Fill WINTER base
+      garden.plant(Flower.YELLOW, Season.AUTUMN)  // goes to WINTER (base space)
+      // Now all base + big extension spaces full, 3 big extensions used
+      // WINTER can't get big (3 total) or small (no big). Next is SPRING which has big → gets small.
+      garden.plant(Flower.PURPLE, Season.AUTUMN)
+
+      const spring = findSeason(garden, Season.SPRING)
+      expect(spring.smallExtensions).to.eq(1)
+      expect(spring.flowers).to.have.length(6)
+    })
+
+    it('small extension requires big extension on same season', () => {
+      const garden = BotGarden.fromPersistence(makeGarden({
+        [Season.SPRING]: { flowers: [Flower.RED, Flower.BLUE] },
+        [Season.SUMMER]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1 },
+        [Season.AUTUMN]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1 },
+        [Season.WINTER]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1 },
+      }), FLOWER_ORDER)
+
+      // All big ext slots full. SPRING (no big ext) can't get small ext.
+      // From WINTER: next is SPRING (full base, no big ext → skip big [max total], skip small [no big]),
+      // then SUMMER (full 5/5 → needs ext, can't add big [max total], can add small [has big])
+      garden.plant(Flower.ORANGE, Season.WINTER)
+
+      expect(findSeason(garden, Season.SPRING).smallExtensions).to.eq(0)
+      expect(findSeason(garden, Season.SUMMER).smallExtensions).to.eq(1)
+      expect(findSeason(garden, Season.SUMMER).flowers).to.have.length(6)
+    })
+
+    it('max 2 small extensions per season', () => {
+      const garden = BotGarden.fromPersistence(makeGarden({
+        [Season.SPRING]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1, smallExtensions: 2 },
+        [Season.SUMMER]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1 },
+        [Season.AUTUMN]: { flowers: [Flower.RED, Flower.BLUE, Flower.RED, Flower.BLUE, Flower.RED], bigExtension: 1 },
+        [Season.WINTER]: { flowers: [Flower.RED, Flower.BLUE] },
+      }), FLOWER_ORDER)
+
+      // SPRING is 9/9 (base 2 + big 3 + 2 small * 2 = 9), can't add more small
+      // From WINTER: next is SPRING (full, max small), SUMMER (full 5/5, add small)
+      garden.plant(Flower.ORANGE, Season.WINTER)
+
+      expect(findSeason(garden, Season.SPRING).smallExtensions).to.eq(2)
+      expect(findSeason(garden, Season.SUMMER).smallExtensions).to.eq(1)
+      expect(findSeason(garden, Season.SUMMER).flowers).to.have.length(6)
+    })
+
+    it('returns false when no space available at all', () => {
+      // Max capacity: 4 seasons * 9 = 36 flowers
+      // But only 3 big ext and 3 small ext available
+      // Max = 3 seasons * (2+3+4) + 1 season * 2 = 3*9 + 2 = 29
+      const garden = BotGarden.fromPersistence(makeGarden({
+        [Season.SPRING]: { flowers: Array(9).fill(Flower.RED), bigExtension: 1, smallExtensions: 2 },
+        [Season.SUMMER]: { flowers: Array(7).fill(Flower.RED), bigExtension: 1, smallExtensions: 1 },
+        [Season.AUTUMN]: { flowers: Array(5).fill(Flower.RED), bigExtension: 1 },
+        [Season.WINTER]: { flowers: [Flower.RED, Flower.RED] },
+      }), FLOWER_ORDER)
+
+      expect(garden.plant(Flower.YELLOW, Season.SPRING)).to.eq(false)
+    })
+  })
+})