deliver, window box actions

Author: stefanseifert

src/services/BotActions.ts

@@ -10,6 +10,7 @@ import WindowStates from './WindowStates'
 import WindowSelection from './enum/WindowSelection'
 import PriceSelection from './enum/PriceSelection'
 import { cloneDeep } from 'lodash'
+import Player from './enum/Player'
 
 /**
  * Collects the bot's actions and manages the automatic actions.
@@ -78,6 +79,20 @@ export default class BotActions {
       case Action.PRICE:
         this.processPrice(botAction)
         break
+      case Action.DELIVERY:
+        if (!this.processDelivery(botAction)) {
+          // switch to window box if delivery is not possible
+          botAction.action = Action.WINDOW_BOX
+          this.processWindowBox(botAction)
+        }
+        break
+      case Action.WINDOW_BOX:
+        if (!this.processWindowBox(botAction)) {
+          // switch to delivery if defining window box is not possible
+          botAction.action = Action.DELIVERY
+          this.processDelivery(botAction)
+        }
+        break
     }
     return botAction
   }
@@ -131,6 +146,38 @@ export default class BotActions {
     }
   }
 
+  /**
+   * Executes bot delivery.
+   * @return true If the delivery was successful
+   */
+  private processDelivery(botAction: BotAction): boolean {
+    const currentSeasonFlowers = this.getFlowersOfCurrentSeason()
+    const window = this._windowStates.getBestMatchingDeliveryWindow(currentSeasonFlowers)
+    if (window) {
+      botAction.floor = window.floor
+      botAction.windowSelection = window.windowSelection
+      this._windowStates.addDelivery(window.floor, window.windowSelection, Player.BOT)
+      return true
+    }
+    return false
+  }
+
+  /**
+   * Executes bot defining a new window box.
+   * @return true If defining the window box was successful
+   */
+  private processWindowBox(botAction: BotAction): boolean {
+    const currentSeasonFlowers = this.getFlowersOfCurrentSeason()
+    const window = this._windowStates.getBestMatchingUndefinedWindow(currentSeasonFlowers, this._marketPrices)
+    if (window) {
+      botAction.floor = window.floor
+      botAction.windowSelection = window.windowSelection
+      this._windowStates.setWindowState(window.floor, window.windowSelection, window.flowers, [Player.BOT])
+      return true
+    }
+    return false
+  }
+
   private getFlowersOfCurrentSeason(): Flower[] {
     return this._botGarden.seasons.find(s => s.season === this._season)?.flowers || []
   }

src/services/WindowStates.ts

@@ -5,6 +5,7 @@ import WindowSelection from './enum/WindowSelection'
 import Flower from './enum/Flower'
 import Player from './enum/Player'
 import getAllEnumValues from '@brdgm/brdgm-commons/src/util/enum/getAllEnumValues'
+import MarketPrices from './MarketPrices'
 
 /**
  * Stores flowers of already defined windows.
@@ -49,6 +50,51 @@ export default class WindowStates {
     this._windowStates.value = this._windowStates.value.filter(dw => dw.floor !== floor || dw.windowSelection !== windowSelection)
   }
 
+  /**
+   * Get the best matching delivery window for the given flowers, based on the bot's defined windows and their priority.
+   */
+  public getBestMatchingDeliveryWindow(flowers: Flower[]) : WindowState|undefined {
+    // get all defined windows that are not fully delivered yet, already ordered in bot's priority
+    const windows = this._windowStates.value.filter(w => w.deliveries.length < 4)
+      .toSorted((a, b) => {
+        const matchA = getMatchCount(a.flowers, flowers)
+        const matchB = getMatchCount(b.flowers, flowers)
+        // sort windows by number of matching flowers, higher match has higher priority
+        if (matchB !== matchA) return matchB - matchA
+        // Sort windows by fewest missing flowers, as tie breaker. This ensures that if there are multiple windows with the same match count, the one with fewer missing flowers is prioritized.
+        return (a.flowers.length - matchA) - (b.flowers.length - matchB)
+      })
+    return windows[0]
+  }
+
+  /**
+   * Gets the best-matching undefined window for the given flowers.
+   * The flowers are also selected for the window, prioritizing more expensive flowers (based on the given market prices) in case there are more flowers than the window can hold.
+   */
+  public getBestMatchingUndefinedWindow(flowers: Flower[], marketPrices: MarketPrices) : WindowState|undefined {
+    // list all undefined windows, ordered top-to-bottom, left-to-right
+    const windows : WindowState[] = []
+    for (let floor = 4; floor >= 1; floor--) {
+      for (const windowSelection of [WindowSelection.LEFT, WindowSelection.RIGHT]) {
+        const existing = this._windowStates.value.find(dw => dw.floor === floor && dw.windowSelection === windowSelection)
+        if (!existing) {
+          windows.push({ floor, windowSelection, flowers: [], deliveries: [] })
+        }
+      }
+    }
+    // get the best-matching undefined window, skipping all windows larger then the given flowers
+    const bestMatch = windows.filter(w => w.floor <= flowers.length)[0]
+    if (bestMatch) {
+      // sort the given flowers by price, higher price first, to prioritize matching more expensive flowers (otherwise keeping the order by bot flower priority)
+      const flowersSorted = [...flowers].sort((a, b) => marketPrices.getPrice(b) - marketPrices.getPrice(a))
+      bestMatch.flowers = flowersSorted.slice(0, bestMatch.floor)
+    }
+    return bestMatch
+  }
+
+  /**
+   * Sorts the windows by floor (descending) and window position (left, right).
+   */
   private sortFloorsWindows() : void {
     const selectionOrder = [WindowSelection.LEFT, WindowSelection.RIGHT]
     this._windowStates.value.sort((a, b) =>
@@ -81,3 +127,22 @@ export default class WindowStates {
   }
 
 }
+
+/**
+ * Counts the number of matching flowers, taking duplicates in the flowers to match into account as well.
+ * @param flowers Given flowers
+ * @param flowersToMatch Flowers to match against
+ * @returns number of matching flowers
+ */
+function getMatchCount(flowers: Flower[], flowersToMatch: Flower[]) : number {
+  const flowersToMatchCopy = cloneDeep(flowersToMatch)
+  let matchCount = 0
+  for (const flower of flowers) {
+    const index = flowersToMatchCopy.indexOf(flower)
+    if (index >= 0) {
+      matchCount++
+      flowersToMatchCopy.splice(index, 1)
+    }
+  }
+  return matchCount
+}