@jeremyckahn/farmhand 1.24.1 → 1.24.2

package/src/game-logic/reducers/purchaseItem.test.ts

@@ -1,4 +1,6 @@
 import { INFINITE_STORAGE_LIMIT } from '../../constants.js'
+import { huggingMachine } from '../../data/items.js'
+import { generateCow } from '../../utils/generateCow.js'
 import { testItem, testState } from '../../test-utils/index.js'
 
 import { purchaseItem } from './purchaseItem.js'
@@ -81,5 +83,132 @@ describe('purchaseItem', () => {
         })
       })
     })
+
+    test('respects an item maximum purchase quantity', () => {
+      const item = testItem({
+        id: 'sample-item-1',
+        getMaxPurchaseQuantity: () => 2,
+      })
+
+      expect(purchaseItem(state, item, 5)).toMatchObject({
+        inventory: [{ id: 'sample-item-1', quantity: 2 }],
+        todaysPurchases: { 'sample-item-1': 2 },
+        money: 8,
+      })
+    })
+
+    test('does not purchase when an item maximum is negative', () => {
+      const item = testItem({
+        id: 'sample-item-1',
+        getMaxPurchaseQuantity: () => -2,
+      })
+
+      expect(purchaseItem(state, item, 1)).toMatchObject({
+        inventory: [],
+        todaysPurchases: {},
+        money: 10,
+      })
+    })
+
+    describe('the item has a maximum purchase quantity', () => {
+      test.each([
+        [1, 10],
+        [2, 20],
+        [3, 30],
+      ])(
+        'limits Hugging Machines to the Cow Pen capacity of %i cows',
+        (purchasedCowPen, cowCapacity) => {
+          state = testState({
+            inventory: [],
+            money: 10_000,
+            purchasedCowPen,
+            valueAdjustments: { [huggingMachine.id]: 1 },
+          })
+
+          expect(huggingMachine.getMaxPurchaseQuantity?.(state)).toEqual(
+            cowCapacity
+          )
+        }
+      )
+
+      test('limits the purchase to the remaining Cow Pen capacity', () => {
+        state = testState({
+          inventory: [{ id: huggingMachine.id, quantity: 9 }],
+          money: 10_000,
+          purchasedCowPen: 1,
+          valueAdjustments: { [huggingMachine.id]: 1 },
+        })
+
+        expect(purchaseItem(state, huggingMachine, 2)).toMatchObject({
+          inventory: [{ id: huggingMachine.id, quantity: 10 }],
+          todaysPurchases: { [huggingMachine.id]: 1 },
+          money: 9_500,
+          pendingPeerMessages: [
+            { message: 'purchased 1 unit of Hugging Machine.' },
+          ],
+        })
+      })
+
+      test('does not purchase a Hugging Machine when capacity is full', () => {
+        state = testState({
+          inventory: [{ id: huggingMachine.id, quantity: 10 }],
+          money: 10_000,
+          purchasedCowPen: 1,
+          valueAdjustments: { [huggingMachine.id]: 1 },
+        })
+
+        expect(purchaseItem(state, huggingMachine, 1)).toMatchObject({
+          inventory: [{ id: huggingMachine.id, quantity: 10 }],
+          todaysPurchases: {},
+          money: 10_000,
+        })
+      })
+
+      test('does not purchase a Hugging Machine when already over capacity', () => {
+        state = testState({
+          inventory: [{ id: huggingMachine.id, quantity: 11 }],
+          money: 10_000,
+          purchasedCowPen: 1,
+          valueAdjustments: { [huggingMachine.id]: 1 },
+        })
+
+        expect(purchaseItem(state, huggingMachine, 1)).toMatchObject({
+          inventory: [{ id: huggingMachine.id, quantity: 11 }],
+          todaysPurchases: {},
+          money: 10_000,
+        })
+      })
+
+      test('does not purchase a Hugging Machine when all capacity is in use', () => {
+        state = testState({
+          cowInventory: Array.from({ length: 6 }, () =>
+            generateCow({ isUsingHuggingMachine: true })
+          ),
+          inventory: [{ id: huggingMachine.id, quantity: 4 }],
+          money: 10_000,
+          purchasedCowPen: 1,
+          valueAdjustments: { [huggingMachine.id]: 1 },
+        })
+
+        expect(purchaseItem(state, huggingMachine, 1)).toMatchObject({
+          inventory: [{ id: huggingMachine.id, quantity: 4 }],
+          todaysPurchases: {},
+          money: 10_000,
+        })
+      })
+
+      test('does not purchase a Hugging Machine without a Cow Pen', () => {
+        state = testState({
+          money: 10_000,
+          valueAdjustments: { [huggingMachine.id]: 1 },
+        })
+
+        expect(purchaseItem(state, huggingMachine, 1)).toMatchObject({
+          inventory: [],
+          todaysPurchases: {},
+          money: 10_000,
+        })
+      })
+    })
   })
 })

package/src/game-logic/reducers/purchaseItem.ts

@@ -13,7 +13,14 @@ export const purchaseItem = (
   howMany: number = 1
 ): farmhand.state => {
   const { money, todaysPurchases, valueAdjustments } = state
-  const numberOfItemsToAdd = Math.min(howMany, inventorySpaceRemaining(state))
+
+  const getMaxPurchaseQuantity =
+    item.getMaxPurchaseQuantity?.(state) ?? Infinity
+
+  const numberOfItemsToAdd = Math.max(
+    0,
+    Math.min(howMany, inventorySpaceRemaining(state), getMaxPurchaseQuantity)
+  )
 
   if (numberOfItemsToAdd === 0) {
     return state
@@ -28,7 +35,7 @@ export const purchaseItem = (
 
   state = prependPendingPeerMessage(
     state,
-    PURCHASED_ITEM_PEER_NOTIFICATION('', howMany, item)
+    PURCHASED_ITEM_PEER_NOTIFICATION('', numberOfItemsToAdd, item)
   )
 
   return addItemToInventory(

package/src/utils/getItemById.test.ts

@@ -0,0 +1,18 @@
+import { carrot } from '../data/items.js'
+
+import { getItemById } from './getItemById.js'
+
+vitest.mock('../data/maps.js')
+vitest.mock('../data/items.js')
+
+describe('getItemById', () => {
+  test('returns the item for a known id', () => {
+    expect(getItemById('carrot')).toEqual(carrot)
+  })
+
+  test('throws an informative error for an unknown id', () => {
+    expect(() => getItemById('not-a-real-item')).toThrow(
+      'Unknown item id: not-a-real-item'
+    )
+  })
+})

package/src/utils/getItemById.ts

@@ -0,0 +1,14 @@
+import { itemsMap } from '../data/maps.js'
+
+/**
+ * @throws If no item exists for the provided id.
+ */
+export const getItemById = (id: string): farmhand.item => {
+  const item = itemsMap[id as keyof typeof itemsMap]
+
+  if (!item) {
+    throw new Error(`Unknown item id: ${id}`)
+  }
+
+  return item
+}

package/src/utils/getPlotImage.ts

@@ -64,9 +64,7 @@ export const getPlotImage = (
 
     if (getPlotContentType(plotContents) === itemType.WEED) {
       const weedColors = ['yellow', 'orange', 'pink']
-      // TODO: Handle negative coordinates by using Math.abs(x * y) to avoid
-      // negative modulo index.
-      const color = weedColors[(x * y) % weedColors.length]
+      const color = weedColors[Math.abs(x * y) % weedColors.length]
 
       return (itemImages as Record<string, string>)[`weed-${color}`]
     }

package/src/utils/transformStateDataForImport.test.ts

@@ -27,6 +27,15 @@ describe('transformStateDataForImport', () => {
     expect(sanitizedState).toEqual(stateWithoutVersion)
   })
 
+  test('it does not throw if cowBreedingPen and cowInventory are missing', () => {
+    delete state.cowBreedingPen
+    delete state.cowInventory
+
+    const sanitizedState = transformStateDataForImport(state as any)
+
+    expect(sanitizedState.cowBreedingPen).toBeUndefined()
+  })
+
   test('it calculates experience from itemsSold if experience is 0', () => {
     state.experience = 0
     state.itemsSold = {

package/src/utils/transformStateDataForImport.ts

@@ -34,20 +34,17 @@ export const transformStateDataForImport = (
   // cowInventory, but at least one player's game somehow got into that state.
   // This block detects such an invalid state and corrects it.
   {
-    // TODO: Add defensive check safeguards for sanitizedState.cowBreedingPen
-    // and sanitizedState.cowInventory to prevent TypeError crashes during
-    // corrupt/legacy state imports.
-    const { cowId1, cowId2 } =
-      sanitizedState.cowBreedingPen as farmhand.state['cowBreedingPen']
+    const { cowId1, cowId2 } = (sanitizedState.cowBreedingPen ?? {}) as Partial<
+      farmhand.state['cowBreedingPen']
+    >
 
-    const cowPenIdMap = (sanitizedState.cowInventory as farmhand.cow[]).reduce(
-      (acc: Record<string, farmhand.cow>, cow: farmhand.cow) => {
-        acc[cow.id] = cow
+    const cowPenIdMap = (
+      (sanitizedState.cowInventory ?? []) as farmhand.cow[]
+    ).reduce((acc: Record<string, farmhand.cow>, cow: farmhand.cow) => {
+      acc[cow.id] = cow
 
-        return acc
-      },
-      {}
-    )
+      return acc
+    }, {})
 
     const isCowInBreedingPenMissingFromInventory = [cowId1, cowId2].some(
       cowId => {