From 8d30eaabc7e25d7b1583eda58dee899b0a4691f4 Mon Sep 17 00:00:00 2001
From: Karl Ostmo <kostmo@gmail.com>
Date: Fri, 23 Feb 2024 17:40:20 -0800
Subject: [PATCH 1/9] Capability exercise cost

---
 app/doc/Swarm/Doc/Schema/Render.hs            |   3 +-
 app/doc/Swarm/Doc/Wiki/Cheatsheet.hs          |  25 ++--
 data/scenarios/Testing/00-ORDER.txt           |   1 +
 .../Testing/1777-capability-cost.yaml         |  86 ++++++++++++++
 ...-capability-cost-bad-entity-reference.yaml |  39 +++++++
 data/schema/entity.json                       |  20 +++-
 src/Swarm/Doc/Util.hs                         |   3 -
 src/Swarm/TUI/Controller.hs                   |   4 +-
 src/Swarm/TUI/Controller/Util.hs              |   9 ++
 src/Swarm/TUI/Model.hs                        |   1 +
 src/Swarm/TUI/Model/Menu.hs                   |   1 +
 src/Swarm/TUI/View.hs                         |  11 +-
 src/swarm-engine/Swarm/Game/CESK.hs           |   3 +-
 src/swarm-engine/Swarm/Game/Exception.hs      |  34 ++++--
 src/swarm-engine/Swarm/Game/State.hs          |   5 +-
 src/swarm-engine/Swarm/Game/Step.hs           |   2 +-
 .../Swarm/Game/Step/Combustion.hs             |  10 +-
 src/swarm-engine/Swarm/Game/Step/Const.hs     |  11 +-
 src/swarm-engine/Swarm/Game/Step/Util.hs      |   3 +-
 .../Swarm/Game/Step/Util/Command.hs           |  86 ++++++++++++--
 src/swarm-scenario/Swarm/Game/Device.hs       | 107 ++++++++++++++++++
 src/swarm-scenario/Swarm/Game/Entity.hs       |  97 +++++++++++-----
 src/swarm-scenario/Swarm/Game/Ingredients.hs  |  20 ++++
 src/swarm-scenario/Swarm/Game/Recipe.hs       |  24 ++--
 src/swarm-scenario/Swarm/Game/Robot.hs        |  10 +-
 swarm.cabal                                   |   4 +
 test/integration/Main.hs                      |   1 +
 test/unit/TestInventory.hs                    |   6 +-
 test/unit/TestRecipeCoverage.hs               |   4 +-
 29 files changed, 522 insertions(+), 108 deletions(-)
 create mode 100644 data/scenarios/Testing/1777-capability-cost.yaml
 create mode 100644 data/scenarios/Testing/_Validation/1777-capability-cost-bad-entity-reference.yaml
 create mode 100644 src/swarm-scenario/Swarm/Game/Device.hs
 create mode 100644 src/swarm-scenario/Swarm/Game/Ingredients.hs

diff --git a/app/doc/Swarm/Doc/Schema/Render.hs b/app/doc/Swarm/Doc/Schema/Render.hs
index be620e3ec..678ee59fb 100644
--- a/app/doc/Swarm/Doc/Schema/Render.hs
+++ b/app/doc/Swarm/Doc/Schema/Render.hs
@@ -25,7 +25,6 @@ import Swarm.Doc.Schema.Arrangement
 import Swarm.Doc.Schema.Parse
 import Swarm.Doc.Schema.Refined
 import Swarm.Doc.Schema.SchemaType
-import Swarm.Doc.Util
 import Swarm.Doc.Wiki.Util
 import Swarm.Util (applyWhen, brackets, quote, showT)
 import System.Directory (listDirectory)
@@ -77,7 +76,7 @@ makePandocTable titleMap (SchemaData _ (ToplevelSchema theTitle theDescription _
     ItemList xs ->
       makePropsTable False listColumnHeadings titleMap
         . M.fromList
-        $ zip (map tshow [0 :: Int ..]) xs
+        $ zip (map showT [0 :: Int ..]) xs
 
   mkTable x = doc $ case x of
     ObjectProperties props -> makePropsTable True propertyColumnHeadings titleMap props
diff --git a/app/doc/Swarm/Doc/Wiki/Cheatsheet.hs b/app/doc/Swarm/Doc/Wiki/Cheatsheet.hs
index 363a8c054..4033fd7a5 100644
--- a/app/doc/Swarm/Doc/Wiki/Cheatsheet.hs
+++ b/app/doc/Swarm/Doc/Wiki/Cheatsheet.hs
@@ -18,8 +18,8 @@ import Control.Lens.Combinators (to)
 import Data.Foldable (find, toList)
 import Data.List (transpose)
 import Data.Map.Lazy qualified as Map
-import Data.Maybe (fromMaybe, isJust)
-import Data.Set qualified as Set
+import Data.Maybe (isJust)
+import Data.Set qualified as S
 import Data.Text (Text)
 import Data.Text qualified as T
 import Data.Text.IO qualified as T
@@ -27,6 +27,7 @@ import Swarm.Doc.Schema.Render
 import Swarm.Doc.Util
 import Swarm.Doc.Wiki.Matrix
 import Swarm.Doc.Wiki.Util
+import Swarm.Game.Device qualified as D
 import Swarm.Game.Display (displayChar)
 import Swarm.Game.Entity (Entity, EntityMap (entitiesByName), entityDisplay, entityName, loadEntities)
 import Swarm.Game.Entity qualified as E
@@ -110,7 +111,7 @@ commandToList :: Const -> [Text]
 commandToList c =
   map
     escapeTable
-    [ addLink ("#" <> tshow c) . codeQuote $ constSyntax c
+    [ addLink ("#" <> showT c) . codeQuote $ constSyntax c
     , codeQuote . prettyTextLine $ inferConst c
     , maybe "" Capability.capabilityName $ Capability.constCaps c
     , Syntax.briefDoc . Syntax.constDoc $ Syntax.constInfo c
@@ -172,13 +173,13 @@ capabilityRow PageAddress {..} em cap =
   linkCommand c =
     ( if T.null commandsAddress
         then id
-        else addLink (commandsAddress <> "#" <> tshow c)
+        else addLink (commandsAddress <> "#" <> showT c)
     )
       . codeQuote
       $ constSyntax c
 
   cs = [c | c <- Syntax.allConst, let mcap = Capability.constCaps c, isJust $ find (== cap) mcap]
-  es = fromMaybe [] $ E.entitiesByCap em Map.!? cap
+  es = E.devicesForCap cap em
 
 capabilityTable :: PageAddress -> EntityMap -> [Capability] -> Text
 capabilityTable a em cs = T.unlines $ header <> map (listToRow mw) capabilityRows
@@ -201,8 +202,8 @@ entityToList e =
     escapeTable
     [ codeQuote . T.singleton $ e ^. entityDisplay . to displayChar
     , addLink ("#" <> linkID) $ view entityName e
-    , T.intercalate ", " $ Capability.capabilityName <$> Set.toList (view E.entityCapabilities e)
-    , T.intercalate ", " . map tshow . filter (/= E.Pickable) $ toList props
+    , T.intercalate ", " $ Capability.capabilityName <$> Map.keys (D.getMap $ view E.entityCapabilities e)
+    , T.intercalate ", " . map showT . filter (/= E.Pickable) $ toList props
     , if E.Pickable `elem` props
         then ":heavy_check_mark:"
         else ":negative_squared_cross_mark:"
@@ -225,13 +226,13 @@ entityToSection e =
     , ""
     , " - Char: " <> (codeQuote . T.singleton $ e ^. entityDisplay . to displayChar)
     ]
-      <> [" - Properties: " <> T.intercalate ", " (map tshow $ toList props) | not $ null props]
+      <> [" - Properties: " <> T.intercalate ", " (map showT $ toList props) | not $ null props]
       <> [" - Capabilities: " <> T.intercalate ", " (Capability.capabilityName <$> caps) | not $ null caps]
       <> ["\n"]
       <> [Markdown.docToMark $ view E.entityDescription e]
  where
   props = view E.entityProperties e
-  caps = Set.toList $ view E.entityCapabilities e
+  caps = S.toList $ D.getCapabilitySet $ view E.entityCapabilities e
 
 entitiesPage :: PageAddress -> [Entity] -> Text
 entitiesPage _a es =
@@ -255,11 +256,11 @@ recipeRow PageAddress {..} r =
     [ T.intercalate ", " (map formatCE $ view recipeInputs r)
     , T.intercalate ", " (map formatCE $ view recipeOutputs r)
     , T.intercalate ", " (map formatCE $ view recipeCatalysts r)
-    , tshow $ view recipeTime r
-    , tshow $ view recipeWeight r
+    , showT $ view recipeTime r
+    , showT $ view recipeWeight r
     ]
  where
-  formatCE (c, e) = T.unwords [tshow c, linkEntity $ view entityName e]
+  formatCE (c, e) = T.unwords [showT c, linkEntity $ view entityName e]
   linkEntity t =
     if T.null entityAddress
       then t
diff --git a/data/scenarios/Testing/00-ORDER.txt b/data/scenarios/Testing/00-ORDER.txt
index 31aa77126..790917913 100644
--- a/data/scenarios/Testing/00-ORDER.txt
+++ b/data/scenarios/Testing/00-ORDER.txt
@@ -59,4 +59,5 @@ Achievements
 1634-message-colors.yaml
 1681-pushable-entity.yaml
 1747-volume-command.yaml
+1777-capability-cost.yaml
 1775-custom-terrain.yaml
diff --git a/data/scenarios/Testing/1777-capability-cost.yaml b/data/scenarios/Testing/1777-capability-cost.yaml
new file mode 100644
index 000000000..2280fa3ff
--- /dev/null
+++ b/data/scenarios/Testing/1777-capability-cost.yaml
@@ -0,0 +1,86 @@
+version: 1
+name: Capability cost
+description: |
+  Consume inventory by exercising device capabilities
+creative: false
+seed: 0
+objectives:
+  - goal:
+      - |
+        Eliminate the `packing peanut`{=entity}s
+    condition: |
+      judge <- robotnamed "judge";
+      as judge {
+        dist <- sniff "packing peanut";
+        return $ dist < 0;
+      }
+solution: |
+  move;
+  turn right;
+  move;
+  place "packing peanut";
+  ignite down;
+  move;
+  move;
+  ignite forward;
+robots:
+  - name: base
+    dir: east
+    devices:
+      - treads
+      - logger
+      - Zippo
+      - grabber
+    inventory:
+      - [2, lighter fluid]
+      - [1, packing peanut]
+  - name: judge
+    dir: east
+    system: true
+entities:
+  - name: lighter fluid
+    display:
+      char: 'f'
+    description:
+      - Fuel for a Zippo
+    properties: [known, pickable]
+  - name: Zippo
+    display:
+      char: 'z'
+    description:
+      - Ignites things
+    properties: [known, pickable]
+    capabilities:
+      - capability: ignite
+        cost:
+          - [1, "lighter fluid"]
+  - name: packing peanut
+    display:
+      attr: snow
+      char: 's'
+    description:
+      - Easy to drop, but impossible to pick up.
+      - Highly combustible.
+    properties: [known, combustible]
+    combustion:
+      ignition: 0.5
+      duration: [10, 20]
+      product: ash
+known: [water, ash]
+world:
+  dsl: |
+    {water}
+  palette:
+    'B': [grass, erase, base]
+    'j': [grass, erase, judge]
+    '.': [grass, erase]
+    'c': [grass, packing peanut]
+  upperleft: [-1, 1]
+  map: |
+    ......
+    Bcccc.
+    .j....
+    .cccc.
+    ......
+    .cccc.
+    ......
diff --git a/data/scenarios/Testing/_Validation/1777-capability-cost-bad-entity-reference.yaml b/data/scenarios/Testing/_Validation/1777-capability-cost-bad-entity-reference.yaml
new file mode 100644
index 000000000..8e90fbeaa
--- /dev/null
+++ b/data/scenarios/Testing/_Validation/1777-capability-cost-bad-entity-reference.yaml
@@ -0,0 +1,39 @@
+version: 1
+name: Capability cost - bad entity reference
+description: |
+  Capability cost recipe for 'ignite' in `Zippo`{=entity}
+  references a non-existent entity
+creative: false
+robots:
+  - name: base
+    dir: east
+    devices:
+      - Zippo
+entities:
+  - name: heavier fluid
+    display:
+      char: 'f'
+    description:
+      - Fuel for a Zippo
+    properties: [known, pickable]
+  - name: Zippo
+    display:
+      char: 'z'
+    description:
+      - Ignites things
+    properties: [known, pickable]
+    capabilities:
+      - capability: ignite
+        cost:
+          - [1, "lighter fluid"]
+known: []
+world:
+  dsl: |
+    {grass}
+  palette:
+    'B': [grass, null, base]
+    '.': [grass]
+  upperleft: [-1, 1]
+  map: |
+    ..
+    B.
diff --git a/data/schema/entity.json b/data/schema/entity.json
index 9c8ced9a4..c709de4a7 100644
--- a/data/schema/entity.json
+++ b/data/schema/entity.json
@@ -97,7 +97,25 @@
             "default": [],
             "type": "array",
             "items": {
-                "type": "string"
+                "oneOf": [
+                    {
+                        "type": "string"
+                    },
+                    {
+                        "type": "object",
+                        "additionalProperties": false,
+                        "properties": {
+                            "capability": {
+                                "description": "Capability name",
+                                "type": "string"
+                            },
+                            "cost": {
+                                "$ref": "inventory.json",
+                                "description": "A list of ingredients consumed by the command."
+                            }
+                        }
+                    }
+                ]
             },
             "description": "A list of capabilities provided by entity, when it is equipped as a device. See [Capabilities](https://github.com/swarm-game/swarm/wiki/Capabilities-cheat-sheet)."
         }
diff --git a/src/Swarm/Doc/Util.hs b/src/Swarm/Doc/Util.hs
index f4714df05..95a9885ea 100644
--- a/src/Swarm/Doc/Util.hs
+++ b/src/Swarm/Doc/Util.hs
@@ -30,9 +30,6 @@ codeQuote = wrap '`'
 addLink :: Text -> Text -> Text
 addLink l t = T.concat ["[", t, "](", l, ")"]
 
-tshow :: (Show a) => a -> Text
-tshow = T.pack . show
-
 -- * Common symbols
 
 operators :: [Const]
diff --git a/src/Swarm/TUI/Controller.hs b/src/Swarm/TUI/Controller.hs
index d8db13871..d9ea85c4a 100644
--- a/src/Swarm/TUI/Controller.hs
+++ b/src/Swarm/TUI/Controller.hs
@@ -91,7 +91,7 @@ import Swarm.Game.State.Robot
 import Swarm.Game.State.Runtime
 import Swarm.Game.State.Substate
 import Swarm.Game.Step (finishGameTick, gameTick)
-import Swarm.Language.Capability (Capability (CDebug, CGod, CMake), constCaps)
+import Swarm.Language.Capability (Capability (CGod, CMake), constCaps)
 import Swarm.Language.Context
 import Swarm.Language.Key (KeyCombo, mkKeyCombo)
 import Swarm.Language.Module
@@ -309,7 +309,7 @@ handleMainEvent ev = do
   let isRunning = maybe True isRunningModal mt
   let isPaused = s ^. gameState . temporal . paused
   let isCreative = s ^. gameState . creativeMode
-  let hasDebug = fromMaybe isCreative $ s ^? gameState . to focusedRobot . _Just . robotCapabilities . Lens.contains CDebug
+  let hasDebug = hasDebugCapability isCreative s
   case ev of
     AppEvent ae -> case ae of
       Frame
diff --git a/src/Swarm/TUI/Controller/Util.hs b/src/Swarm/TUI/Controller/Util.hs
index 88950aac0..5683f4d9a 100644
--- a/src/Swarm/TUI/Controller/Util.hs
+++ b/src/Swarm/TUI/Controller/Util.hs
@@ -10,13 +10,17 @@ import Control.Lens
 import Control.Monad (forM_, unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Map qualified as M
+import Data.Set qualified as S
 import Graphics.Vty qualified as V
+import Swarm.Game.Device
+import Swarm.Game.Robot (robotCapabilities)
 import Swarm.Game.State
 import Swarm.Game.State.Landscape
 import Swarm.Game.State.Robot
 import Swarm.Game.State.Substate
 import Swarm.Game.Universe
 import Swarm.Game.World qualified as W
+import Swarm.Language.Capability (Capability (CDebug))
 import Swarm.TUI.Model
 import Swarm.TUI.Model.UI
 import Swarm.TUI.View.Util (generateModal)
@@ -97,3 +101,8 @@ mouseLocToWorldCoords (Brick.Location mouseLoc) = do
           mx = snd mouseLoc' + fst regionStart
           my = fst mouseLoc' + snd regionStart
        in pure . Just $ Cosmic (region ^. subworld) $ W.Coords (mx, my)
+
+hasDebugCapability :: Bool -> AppState -> Bool
+hasDebugCapability isCreative s =
+  maybe isCreative (S.member CDebug . getCapabilitySet) $
+    s ^? gameState . to focusedRobot . _Just . robotCapabilities
diff --git a/src/Swarm/TUI/Model.hs b/src/Swarm/TUI/Model.hs
index 16e24a79c..ddb4039e6 100644
--- a/src/Swarm/TUI/Model.hs
+++ b/src/Swarm/TUI/Model.hs
@@ -117,6 +117,7 @@ import GitHash (GitInfo)
 import Graphics.Vty (ColorMode (..))
 import Network.Wai.Handler.Warp (Port)
 import Swarm.Game.Entity as E
+import Swarm.Game.Ingredients
 import Swarm.Game.Robot
 import Swarm.Game.Robot.Concrete
 import Swarm.Game.Robot.Context
diff --git a/src/Swarm/TUI/Model/Menu.hs b/src/Swarm/TUI/Model/Menu.hs
index 93e1d9e1a..8c7e40ec3 100644
--- a/src/Swarm/TUI/Model/Menu.hs
+++ b/src/Swarm/TUI/Model/Menu.hs
@@ -21,6 +21,7 @@ import Data.Text (Text)
 import Data.Vector qualified as V
 import Swarm.Game.Achievement.Definitions
 import Swarm.Game.Entity as E
+import Swarm.Game.Ingredients
 import Swarm.Game.ScenarioInfo (
   ScenarioCollection,
   ScenarioInfo (..),
diff --git a/src/Swarm/TUI/View.hs b/src/Swarm/TUI/View.hs
index b7271c69e..927025534 100644
--- a/src/Swarm/TUI/View.hs
+++ b/src/Swarm/TUI/View.hs
@@ -73,8 +73,10 @@ import Network.Wai.Handler.Warp (Port)
 import Numeric (showFFloat)
 import Swarm.Constant
 import Swarm.Game.CESK (CESK (..))
+import Swarm.Game.Device (getMap)
 import Swarm.Game.Display
 import Swarm.Game.Entity as E
+import Swarm.Game.Ingredients
 import Swarm.Game.Land
 import Swarm.Game.Location
 import Swarm.Game.Recipe
@@ -122,6 +124,7 @@ import Swarm.Language.Typecheck (inferConst)
 import Swarm.Log
 import Swarm.TUI.Border
 import Swarm.TUI.Controller (ticksPerFrameCap)
+import Swarm.TUI.Controller.Util (hasDebugCapability)
 import Swarm.TUI.Editor.Model
 import Swarm.TUI.Editor.View qualified as EV
 import Swarm.TUI.Inventory.Sorting (renderSortMethod)
@@ -1003,7 +1006,7 @@ drawKeyMenu s =
 
   isReplWorking = s ^. gameState . gameControls . replWorking
   isPaused = s ^. gameState . temporal . paused
-  hasDebug = fromMaybe creative $ s ^? gameState . to focusedRobot . _Just . robotCapabilities . Lens.contains CDebug
+  hasDebug = hasDebugCapability creative s
   viewingBase = (s ^. gameState . robotInfo . viewCenterRule) == VCRobot 0
   creative = s ^. gameState . creativeMode
   cheat = s ^. uiState . uiCheatMode
@@ -1209,8 +1212,8 @@ explainEntry s e =
     , drawMarkdown (e ^. entityDescription)
     , explainRecipes s e
     ]
-      <> [drawRobotMachine s False | e ^. entityCapabilities . Lens.contains CDebug]
-      <> [drawRobotLog s | e ^. entityCapabilities . Lens.contains CLog]
+      <> [drawRobotMachine s False | CDebug `M.member` getMap (e ^. entityCapabilities)]
+      <> [drawRobotLog s | CLog `M.member` getMap (e ^. entityCapabilities)]
 
 displayProperties :: [EntityProperty] -> Widget Name
 displayProperties = displayList . mapMaybe showProperty
@@ -1359,7 +1362,7 @@ drawRecipe me inv (Recipe ins outs reqs time _weight) =
 
 -- | Ad-hoc entity to represent time - only used in recipe drawing
 timeE :: Entity
-timeE = mkEntity (defaultEntityDisplay '.') "ticks" mempty [] []
+timeE = mkEntity (defaultEntityDisplay '.') "ticks" mempty [] mempty
 
 drawReqs :: IngredientList Entity -> Widget Name
 drawReqs = vBox . map (hCenter . drawReq)
diff --git a/src/swarm-engine/Swarm/Game/CESK.hs b/src/swarm-engine/Swarm/Game/CESK.hs
index 3ee7d3401..8dedcffb6 100644
--- a/src/swarm-engine/Swarm/Game/CESK.hs
+++ b/src/swarm-engine/Swarm/Game/CESK.hs
@@ -86,8 +86,9 @@ import Data.IntMap.Strict (IntMap)
 import Data.IntMap.Strict qualified as IM
 import GHC.Generics (Generic)
 import Prettyprinter (Doc, Pretty (..), encloseSep, hsep, (<+>))
-import Swarm.Game.Entity (Count, Entity)
+import Swarm.Game.Entity (Entity)
 import Swarm.Game.Exception
+import Swarm.Game.Ingredients (Count)
 import Swarm.Game.Tick
 import Swarm.Game.World (WorldUpdate (..))
 import Swarm.Language.Context
diff --git a/src/swarm-engine/Swarm/Game/Exception.hs b/src/swarm-engine/Swarm/Game/Exception.hs
index f1b957117..7910f91a5 100644
--- a/src/swarm-engine/Swarm/Game/Exception.hs
+++ b/src/swarm-engine/Swarm/Game/Exception.hs
@@ -9,6 +9,7 @@ module Swarm.Game.Exception (
   Exn (..),
   IncapableFix (..),
   formatExn,
+  IncapableFixWords (..),
 
   -- * Helper functions
   formatIncapable,
@@ -25,7 +26,7 @@ import Data.Text qualified as T
 import GHC.Generics (Generic)
 import Swarm.Constant
 import Swarm.Game.Achievement.Definitions
-import Swarm.Game.Entity (EntityMap, deviceForCap, entityName)
+import Swarm.Game.Entity (EntityMap, devicesForCap, entityName)
 import Swarm.Language.Capability (Capability (CGod), capabilityName)
 import Swarm.Language.Pretty (prettyText)
 import Swarm.Language.Requirement (Requirements (..))
@@ -54,7 +55,9 @@ data IncapableFix
   = -- | 'Swarm.Language.Syntax.Equip' the missing device on yourself/target
     FixByEquip
   | -- | Add the missing device to your inventory
-    FixByObtain
+    FixByObtainDevice
+  | -- | Add the missing consumables to your inventory
+    FixByObtainConsumables
   deriving (Eq, Show, Generic, FromJSON, ToJSON)
 
 -- | The type of exceptions that can be thrown by robot programs.
@@ -99,11 +102,17 @@ formatExn em = \case
 -- INCAPABLE HELPERS
 -- ------------------------------------------------------------------
 
+data IncapableFixWords = IncapableFixWords
+  { fixVerb :: Text
+  , fixNoun :: Text
+  }
+
 -- | Pretty-print an 'IncapableFix': either "equip" or "obtain".
-formatIncapableFix :: IncapableFix -> Text
+formatIncapableFix :: IncapableFix -> IncapableFixWords
 formatIncapableFix = \case
-  FixByEquip -> "equip"
-  FixByObtain -> "obtain"
+  FixByEquip -> IncapableFixWords "equip" "device"
+  FixByObtainDevice -> IncapableFixWords "obtain" "device"
+  FixByObtainConsumables -> IncapableFixWords "obtain" "consumables"
 
 -- | Pretty print the incapable exception with an actionable suggestion
 --   on how to fix it.
@@ -156,12 +165,13 @@ formatIncapable em f (Requirements caps _ inv) tm
              , swarmRepoUrl <> "issues/26"
              ]
   | not (S.null caps) =
-      unlinesExText
-        ( "You do not have the devices required for:"
-            :| squote (prettyText tm)
-            : "Please " <> formatIncapableFix f <> ":"
-            : (("- " <>) . formatDevices <$> filter (not . null) deviceSets)
-        )
+      let IncapableFixWords fVerb fNoun = formatIncapableFix f
+       in unlinesExText
+            ( T.unwords ["You do not have the", fNoun, "required for:"]
+                :| squote (prettyText tm)
+                : "Please " <> fVerb <> ":"
+                : (("- " <>) . formatDevices <$> filter (not . null) deviceSets)
+            )
   | otherwise =
       unlinesExText
         ( "You are missing required inventory for:"
@@ -171,7 +181,7 @@ formatIncapable em f (Requirements caps _ inv) tm
         )
  where
   capList = S.toList caps
-  deviceSets = map (`deviceForCap` em) capList
+  deviceSets = map (`devicesForCap` em) capList
   devicePerCap = zip capList deviceSets
   -- capabilities not provided by any device
   capsNone = map (capabilityName . fst) $ filter (null . snd) devicePerCap
diff --git a/src/swarm-engine/Swarm/Game/State.hs b/src/swarm-engine/Swarm/Game/State.hs
index 15927070a..0867682f0 100644
--- a/src/swarm-engine/Swarm/Game/State.hs
+++ b/src/swarm-engine/Swarm/Game/State.hs
@@ -101,6 +101,7 @@ import Data.Text.Lazy.Encoding qualified as TL
 import GHC.Generics (Generic)
 import Linear (V2 (..))
 import Swarm.Game.CESK (emptyStore, finalValue, initMachine)
+import Swarm.Game.Device (getCapabilitySet, getMap)
 import Swarm.Game.Entity
 import Swarm.Game.Failure (SystemFailure (..))
 import Swarm.Game.Land
@@ -599,7 +600,7 @@ pureScenarioToGameState scenario theSeed now toRun gsc =
 
   TerrainEntityMaps _ em = sLandscape ^. scenarioTerrainAndEntities
   baseID = 0
-  (things, devices) = partition (null . view entityCapabilities) (M.elems (entitiesByName em))
+  (things, devices) = partition (M.null . getMap . view entityCapabilities) (M.elems (entitiesByName em))
 
   getCodeToRun (CodeToRun _ s) = s
 
@@ -644,7 +645,7 @@ pureScenarioToGameState scenario theSeed now toRun gsc =
   allCapabilities r =
     inventoryCapabilities (r ^. equippedDevices)
       <> inventoryCapabilities (r ^. robotInventory)
-  initialCaps = mconcat $ map allCapabilities robotList
+  initialCaps = getCapabilitySet $ mconcat $ map allCapabilities robotList
   initialCommands =
     filter
       (maybe True (`S.member` initialCaps) . constCaps)
diff --git a/src/swarm-engine/Swarm/Game/Step.hs b/src/swarm-engine/Swarm/Game/Step.hs
index a59dee95c..e04b2133b 100644
--- a/src/swarm-engine/Swarm/Game/Step.hs
+++ b/src/swarm-engine/Swarm/Game/Step.hs
@@ -684,7 +684,7 @@ stepCESK cesk = case cesk of
 
         devicesForCaps, requiredDevices :: Set (Set Text)
         -- possible devices to provide each required capability
-        devicesForCaps = S.map (S.fromList . map (^. entityName) . (`deviceForCap` em)) caps
+        devicesForCaps = S.map (S.fromList . map (^. entityName) . (`devicesForCap` em)) caps
         -- outright required devices
         requiredDevices = S.map S.singleton devs
 
diff --git a/src/swarm-engine/Swarm/Game/Step/Combustion.hs b/src/swarm-engine/Swarm/Game/Step/Combustion.hs
index d71a16511..106ffce46 100644
--- a/src/swarm-engine/Swarm/Game/Step/Combustion.hs
+++ b/src/swarm-engine/Swarm/Game/Step/Combustion.hs
@@ -21,6 +21,7 @@ import Control.Carrier.State.Lazy
 import Control.Effect.Lens
 import Control.Lens as Lens hiding (Const, distrib, from, parts, use, uses, view, (%=), (+=), (.=), (<+=), (<>=))
 import Control.Monad (forM_, when)
+import Data.Maybe (fromMaybe)
 import Data.Text qualified as T
 import Linear (zero)
 import Swarm.Effect as Effect (Time, getNow)
@@ -90,11 +91,10 @@ addCombustionBot ::
   Cosmic Location ->
   m Integer
 addCombustionBot inputEntity combustibility ts loc = do
-  botInventory <- case maybeCombustionProduct of
-    Nothing -> return []
-    Just n -> do
-      maybeE <- uses (landscape . terrainAndEntities . entityMap) (lookupEntityName n)
-      return $ maybe [] (pure . (1,)) maybeE
+  em <- use $ landscape . terrainAndEntities . entityMap
+  let botInventory = fromMaybe [] $ do
+        e <- (`lookupEntityName` em) =<< maybeCombustionProduct
+        return $ pure (1, e)
   combustionDurationRand <- uniform durationRange
   let combustionProg = combustionProgram combustionDurationRand combustibility
   zoomRobots
diff --git a/src/swarm-engine/Swarm/Game/Step/Const.hs b/src/swarm-engine/Swarm/Game/Step/Const.hs
index 3bb88deba..d0049dc2d 100644
--- a/src/swarm-engine/Swarm/Game/Step/Const.hs
+++ b/src/swarm-engine/Swarm/Game/Step/Const.hs
@@ -1032,7 +1032,7 @@ execConst runChildProg c vs s k = do
             (childRobot ^. equippedDevices)
             cmd
             "The target robot"
-            FixByObtain
+            FixByObtainDevice
 
         -- update other robot's CESK machine, environment and context
         -- the childRobot inherits the parent robot's environment
@@ -1079,7 +1079,7 @@ execConst runChildProg c vs s k = do
         pid <- use robotID
 
         (toEquip, toGive) <-
-          checkRequirements (r ^. robotInventory) E.empty E.empty cmd "You" FixByObtain
+          checkRequirements (r ^. robotInventory) E.empty E.empty cmd "You" FixByObtainDevice
 
         -- Pick a random display name.
         displayName <- randomName
@@ -1499,7 +1499,7 @@ execConst runChildProg c vs s k = do
         -- help with later error message generation.
         possibleDevices :: [(Maybe Capability, [Entity])]
         possibleDevices =
-          map (Just &&& (`deviceForCap` em)) caps -- Possible devices for capabilities
+          map (Just &&& (`devicesForCap` em)) caps -- Possible devices for capabilities
             ++ map ((Nothing,) . (: [])) devs -- Outright required devices
 
         -- A device is OK if it is available in the inventory of the
@@ -1550,10 +1550,11 @@ execConst runChildProg c vs s k = do
         -- Now, ensure there is at least one device available to be
         -- equipped for each requirement.
         let missingDevices = map snd . filter (null . fst) $ partitionedDevices
+        let IncapableFixWords fVerb fNoun = formatIncapableFix fixI
         null missingDevices
           `holdsOrFail` ( singularSubjectVerb subject "do"
-                            : "not have required devices, please"
-                            : formatIncapableFix fixI <> ":"
+                            : "not have required " <> fNoun <> ", please"
+                            : fVerb <> ":"
                             : (("\n  - " <>) . formatDevices <$> missingDevices)
                         )
 
diff --git a/src/swarm-engine/Swarm/Game/Step/Util.hs b/src/swarm-engine/Swarm/Game/Step/Util.hs
index aba1d0f33..fb9bb039e 100644
--- a/src/swarm-engine/Swarm/Game/Step/Util.hs
+++ b/src/swarm-engine/Swarm/Game/Step/Util.hs
@@ -22,6 +22,7 @@ import Data.Set qualified as S
 import Data.Text (Text)
 import Data.Text qualified as T
 import Linear (zero)
+import Swarm.Game.Device
 import Swarm.Game.Entity hiding (empty, lookup, singleton, union)
 import Swarm.Game.Exception
 import Swarm.Game.Location
@@ -92,7 +93,7 @@ hasCapability :: (Has (State Robot) sig m, Has (State GameState) sig m) => Capab
 hasCapability cap = do
   isPrivileged <- isPrivilegedBot
   caps <- use robotCapabilities
-  return (isPrivileged || cap `S.member` caps)
+  return (isPrivileged || cap `S.member` getCapabilitySet caps)
 
 -- | Ensure that either a robot has a given capability, OR we are in creative
 --   mode.
diff --git a/src/swarm-engine/Swarm/Game/Step/Util/Command.hs b/src/swarm-engine/Swarm/Game/Step/Util/Command.hs
index 8c9bbae9f..c6a2bfb90 100644
--- a/src/swarm-engine/Swarm/Game/Step/Util/Command.hs
+++ b/src/swarm-engine/Swarm/Game/Step/Util/Command.hs
@@ -20,6 +20,8 @@ import Control.Effect.Lens
 import Control.Effect.Lift
 import Control.Lens as Lens hiding (Const, distrib, from, parts, use, uses, view, (%=), (+=), (.=), (<+=), (<>=))
 import Control.Monad (forM_, unless, when)
+import Data.List (find)
+import Data.List.NonEmpty qualified as NE
 import Data.IntSet qualified as IS
 import Data.Map qualified as M
 import Data.Sequence qualified as Seq
@@ -28,15 +30,18 @@ import Data.Set qualified as S
 import Data.Text (Text)
 import Data.Text qualified as T
 import Data.Time (getZonedTime)
+import Data.Tuple (swap)
 import Linear (zero)
 import Swarm.Game.Achievement.Attainment
 import Swarm.Game.Achievement.Definitions
 import Swarm.Game.Achievement.Description (getValidityRequirements)
 import Swarm.Game.CESK
+import Swarm.Game.Device
 import Swarm.Game.Display
 import Swarm.Game.Entity hiding (empty, lookup, singleton, union)
 import Swarm.Game.Entity qualified as E
 import Swarm.Game.Exception
+import Swarm.Game.Land
 import Swarm.Game.Location
 import Swarm.Game.Recipe
 import Swarm.Game.Robot
@@ -59,25 +64,88 @@ import Swarm.Language.Requirement qualified as R
 import Swarm.Language.Syntax
 import Swarm.Language.Text.Markdown qualified as Markdown
 import Swarm.Log
-import Swarm.Util hiding (both)
 import System.Clock (TimeSpec)
 import Prelude hiding (Applicative (..), lookup)
 
-data GrabbingCmd = Grab' | Harvest' | Swap' | Push' deriving (Eq, Show)
+data GrabbingCmd
+  = Grab'
+  | Harvest'
+  | Swap'
+  | Push'
+  deriving (Eq, Show)
 
 -- | Ensure that a robot is capable of executing a certain constant
 --   (either because it has a device which gives it that capability,
 --   or it is a system robot, or we are in creative mode).
-ensureCanExecute :: (Has (State Robot) sig m, Has (State GameState) sig m, Has (Throw Exn) sig m) => Const -> m ()
+--
+-- For certain capabilities that require payment of inventory
+-- items in order to be exercised, we pay the toll up front, regardless of
+-- other conditions that may preclude the capability from eventually
+-- being exercised (e.g. an obstacle that ultimately prevents a "move").
+--
+-- Note that there exist some code paths where the "toll"
+-- is bypassed, e.g. see 'hasCapabilityFor'.
+-- We should just try to avoid authoring scenarios that
+-- include toll-gated devices for those particular capabilities.
+--
+-- Since this function has the side-effect of removing items from the
+-- robot's inventory, we must be careful that it is executed exactly
+-- once per command.
+ensureCanExecute ::
+  ( Has (State Robot) sig m
+  , Has (State GameState) sig m
+  , Has (Throw Exn) sig m
+  ) =>
+  Const ->
+  m ()
 ensureCanExecute c =
   gets @Robot (constCapsFor c) >>= \case
     Nothing -> pure ()
     Just cap -> do
       isPrivileged <- isPrivilegedBot
-      robotCaps <- use robotCapabilities
-      let hasCaps = cap `S.member` robotCaps
-      (isPrivileged || hasCaps)
-        `holdsOr` Incapable FixByEquip (R.singletonCap cap) (TConst c)
+      -- Privileged robots can execute commands regardless
+      -- of equipped devices, and without expending
+      -- a capability's exercise cost.
+      unless isPrivileged $ do
+        robotCaps <- use robotCapabilities
+        let capProviders = M.lookup cap $ getMap robotCaps
+        case capProviders of
+          Nothing -> throwError $ Incapable FixByEquip (R.singletonCap cap) (TConst c)
+          Just rawCosts -> payExerciseCost c rawCosts
+
+payExerciseCost ::
+  ( Has (State Robot) sig m
+  , Has (State GameState) sig m
+  , Has (Throw Exn) sig m
+  ) =>
+  Const ->
+  NE.NonEmpty (DeviceUseCost Entity EntityName) ->
+  m ()
+payExerciseCost c rawCosts = do
+  em <- use $ landscape . terrainAndEntities . entityMap
+  let eitherCosts = mapM (promoteDeviceUseCost $ lookupEntityE $ entitiesByName em) rawCosts
+  costs <- case eitherCosts of
+    -- NOTE: Entity references have been validated already at scenario load time,
+    -- so we should never encounter this error.
+    Left e -> throwError $ Fatal e
+    Right cs -> return cs
+  inv <- use robotInventory
+  let getMissingIngredients = findLacking inv . ingredients . useCost
+      maybeFeasibleRecipe = find (null . getMissingIngredients) $ NE.sort costs
+  case maybeFeasibleRecipe of
+    Nothing ->
+      throwError $
+        Incapable FixByObtainConsumables (expenseToRequirement $ NE.head costs) (TConst c)
+    -- Consume the inventory
+    Just feasibleRecipe ->
+      forM_ (ingredients . useCost $ feasibleRecipe) $ \(cnt, e) ->
+        robotInventory %= deleteCount cnt e
+ where
+  expenseToRequirement :: DeviceUseCost Entity Entity -> R.Requirements
+  expenseToRequirement (DeviceUseCost d (ExerciseCost ingdts)) =
+    R.Requirements S.empty (S.singleton $ d ^. entityName) ingdtsMap
+   where
+    ingdtsMap = M.fromListWith (+) $ map (swap . fmap (view entityName)) ingdts
 
 -- | Clear watches that are out of range
 purgeFarAwayWatches ::
@@ -253,9 +321,9 @@ updateAvailableRecipes invs e = do
 
 updateAvailableCommands :: Has (State GameState) sig m => Entity -> m ()
 updateAvailableCommands e = do
-  let newCaps = e ^. entityCapabilities
+  let newCaps = getMap $ e ^. entityCapabilities
       keepConsts = \case
-        Just cap -> cap `S.member` newCaps
+        Just cap -> cap `M.member` newCaps
         Nothing -> False
       entityConsts = filter (keepConsts . constCaps) allConst
   knownCommands <- use $ discovery . availableCommands . notificationsContent
diff --git a/src/swarm-scenario/Swarm/Game/Device.hs b/src/swarm-scenario/Swarm/Game/Device.hs
new file mode 100644
index 000000000..a3770ba8f
--- /dev/null
+++ b/src/swarm-scenario/Swarm/Game/Device.hs
@@ -0,0 +1,107 @@
+-- |
+-- SPDX-License-Identifier: BSD-3-Clause
+--
+-- A device is an entity that provides capabilities.
+--
+-- Some capabilities have a cost to exercise.
+-- Items will be consumed from the inventory for
+-- invoking a command that utilizes a given capability.
+module Swarm.Game.Device (
+  SingleEntityCapabilities,
+  MultiEntityCapabilities,
+  Capabilities (..),
+  DeviceUseCost (..),
+  ExerciseCost (..),
+  getCapabilitySet,
+  zeroCostCapabilities,
+  transformIngredients,
+  promoteDeviceUseCost,
+)
+where
+
+import Control.Applicative ((<|>))
+import Data.Function (on)
+import Data.Hashable
+import Data.List.NonEmpty (NonEmpty (..))
+import Data.Map (Map)
+import Data.Map qualified as M
+import Data.Set (Set)
+import Data.Vector qualified as V
+import Data.Yaml
+import GHC.Generics (Generic)
+import Swarm.Game.Ingredients
+import Swarm.Language.Capability (Capability)
+
+-- This wrapper exists so that YAML can be parsed
+-- either as a list of 'Capability' or as a Map.
+newtype Capabilities e = Capabilities
+  { getMap :: Map Capability e
+  }
+  deriving (Show, Eq, Generic, ToJSON, Hashable, Functor)
+
+getCapabilitySet :: Capabilities e -> Set Capability
+getCapabilitySet (Capabilities m) = M.keysSet m
+
+zeroCostCapabilities :: Set Capability -> Capabilities (ExerciseCost e)
+zeroCostCapabilities = Capabilities . M.fromSet (const $ ExerciseCost [])
+
+type SingleEntityCapabilities e = Capabilities (ExerciseCost e)
+
+type MultiEntityCapabilities e en = Capabilities (NonEmpty (DeviceUseCost e en))
+
+-- | For JSON parsing only
+data CapabilityCost e = CapabilityCost
+  { capability :: Capability
+  , cost :: IngredientList e
+  }
+  deriving (Generic, FromJSON)
+
+-- | First, attempt to parse capabilities as a list.
+-- Otherwise, parse as a Map from capabilities to ingredients.
+instance (FromJSON e) => FromJSON (SingleEntityCapabilities e) where
+  parseJSON x =
+    Capabilities <$> (simpleList <|> costMap)
+   where
+    simpleList = M.fromSet (const $ ExerciseCost []) <$> parseJSON x
+    costMap = withArray "Capabilities" (fmap (M.fromList . map toMapEntry) . mapM parseJSON . V.toList) x
+    toMapEntry (CapabilityCost a b) = (a, ExerciseCost b)
+
+instance (Ord e, Semigroup e) => Semigroup (Capabilities e) where
+  Capabilities c1 <> Capabilities c2 =
+    Capabilities $ M.unionWith (<>) c1 c2
+
+instance (Ord e, Semigroup e) => Monoid (Capabilities e) where
+  mempty = Capabilities mempty
+
+-- | Exercising a capability may have a cost.
+newtype ExerciseCost e = ExerciseCost
+  { ingredients :: IngredientList e
+  }
+  deriving (Eq, Show, Generic, FromJSON, ToJSON, Hashable, Functor)
+
+instance (Eq e) => Ord (ExerciseCost e) where
+  compare = compare `on` (getCost . ingredients)
+
+data DeviceUseCost e en = DeviceUseCost
+  { device :: e
+  , useCost :: ExerciseCost en
+  }
+  deriving (Eq, Ord, Show, Generic, FromJSON, ToJSON, Functor)
+
+-- TODO Should this derive from an Applicative instance?
+promoteDeviceUseCost ::
+  Monad m =>
+  (e -> m e') ->
+  DeviceUseCost x e ->
+  m (DeviceUseCost x e')
+promoteDeviceUseCost f (DeviceUseCost d ex) =
+  DeviceUseCost d <$> transformIngredients f ex
+
+-- TODO Should this derive from an Applicative instance?
+transformIngredients ::
+  Monad m =>
+  (e -> m e') ->
+  ExerciseCost e ->
+  m (ExerciseCost e')
+transformIngredients f (ExerciseCost ings) =
+  ExerciseCost <$> mapM (traverse f) ings
diff --git a/src/swarm-scenario/Swarm/Game/Entity.hs b/src/swarm-scenario/Swarm/Game/Entity.hs
index 6513891d2..34205980d 100644
--- a/src/swarm-scenario/Swarm/Game/Entity.hs
+++ b/src/swarm-scenario/Swarm/Game/Entity.hs
@@ -47,15 +47,15 @@ module Swarm.Game.Entity (
   -- ** Entity map
   EntityMap (..),
   buildEntityMap,
+  lookupEntityE,
   validateEntityAttrRefs,
   loadEntities,
   allEntities,
   lookupEntityName,
-  deviceForCap,
+  devicesForCap,
 
   -- * Inventories
   Inventory,
-  Count,
 
   -- ** Construction
   empty,
@@ -95,6 +95,7 @@ import Control.Lens (Getter, Lens', lens, to, view, (^.))
 import Control.Monad (forM_, unless, (<=<))
 import Data.Bifunctor (first)
 import Data.Char (toLower)
+import Data.Either.Extra (maybeToEither)
 import Data.Function (on)
 import Data.Hashable
 import Data.IntMap (IntMap)
@@ -105,17 +106,19 @@ import Data.List (foldl')
 import Data.List.NonEmpty qualified as NE
 import Data.Map (Map)
 import Data.Map qualified as M
-import Data.Maybe (fromMaybe, isJust, listToMaybe)
+import Data.Maybe (isJust, listToMaybe)
 import Data.Set (Set)
-import Data.Set qualified as Set (fromList, member, toList, unions)
+import Data.Set qualified as Set (fromList, member)
 import Data.Text (Text)
 import Data.Text qualified as T
 import Data.Yaml
 import GHC.Generics (Generic)
+import Swarm.Game.Device
 import Swarm.Game.Display
 import Swarm.Game.Entity.Cosmetic (WorldAttr (..))
 import Swarm.Game.Entity.Cosmetic.Assignment (worldAttributes)
 import Swarm.Game.Failure
+import Swarm.Game.Ingredients
 import Swarm.Game.Location
 import Swarm.Game.ResourceLoading (getDataFileNameSafe)
 import Swarm.Language.Capability
@@ -277,7 +280,7 @@ data Entity = Entity
   -- grabbed.
   , _entityProperties :: Set EntityProperty
   -- ^ Properties of the entity.
-  , _entityCapabilities :: Set Capability
+  , _entityCapabilities :: SingleEntityCapabilities EntityName
   -- ^ Capabilities provided by this entity.
   , _entityInventory :: Inventory
   -- ^ Inventory of other entities held by this entity.
@@ -331,7 +334,7 @@ mkEntity ::
   -- | Properties
   [EntityProperty] ->
   -- | Capabilities
-  [Capability] ->
+  Set Capability ->
   Entity
 mkEntity disp nm descr props caps =
   rehashEntity $
@@ -347,7 +350,7 @@ mkEntity disp nm descr props caps =
       Nothing
       Nothing
       (Set.fromList props)
-      (Set.fromList caps)
+      (zeroCostCapabilities caps)
       empty
 
 ------------------------------------------------------------
@@ -363,11 +366,11 @@ mkEntity disp nm descr props caps =
 --   This enables scenario authors to specify iteration order of
 --   the 'Swarm.Language.Syntax.TagMembers' command.
 data EntityMap = EntityMap
-  { entitiesByName :: Map Text Entity
-  , entitiesByCap :: Map Capability [Entity]
+  { entitiesByName :: Map EntityName Entity
+  , entitiesByCap :: MultiEntityCapabilities Entity Entity
   , entityDefinitionOrder :: [Entity]
   }
-  deriving (Eq, Show, Generic, FromJSON, ToJSON)
+  deriving (Eq, Show, Generic, ToJSON)
 
 -- |
 -- Note that duplicates in a single 'EntityMap' are precluded by the
@@ -382,11 +385,11 @@ instance Semigroup EntityMap where
   EntityMap n1 c1 d1 <> EntityMap n2 c2 d2 =
     EntityMap
       (n1 <> n2)
-      (M.unionWith (<>) c1 c2)
+      (c1 <> c2)
       (filter ((`M.notMember` n2) . view entityName) d1 <> d2)
 
 instance Monoid EntityMap where
-  mempty = EntityMap M.empty M.empty []
+  mempty = EntityMap M.empty mempty []
   mappend = (<>)
 
 -- | Get a list of all the entities in the entity map.
@@ -399,8 +402,8 @@ lookupEntityName nm = M.lookup nm . entitiesByName
 
 -- | Find all entities which are devices that provide the given
 --   capability.
-deviceForCap :: Capability -> EntityMap -> [Entity]
-deviceForCap cap = fromMaybe [] . M.lookup cap . entitiesByCap
+devicesForCap :: Capability -> EntityMap -> [Entity]
+devicesForCap cap = maybe [] (NE.toList . NE.map device) . M.lookup cap . getMap . entitiesByCap
 
 -- | Validates references to 'Display' attributes
 validateEntityAttrRefs :: Has (Throw LoadingFailure) sig m => Set WorldAttr -> [Entity] -> m ()
@@ -429,14 +432,50 @@ buildEntityMap es = do
   case findDup (map fst namedEntities) of
     Nothing -> return ()
     Just duped -> throwError $ Duplicate Entities duped
-  return $
-    EntityMap
-      { entitiesByName = M.fromList namedEntities
-      , entitiesByCap = M.fromListWith (<>) . concatMap (\e -> map (,[e]) (Set.toList $ e ^. entityCapabilities)) $ es
-      , entityDefinitionOrder = es
-      }
+  case combineEntityCapsM entsByName es of
+    Left x -> throwError $ CustomMessage x
+    Right ebc ->
+      return $
+        EntityMap
+          { entitiesByName = entsByName
+          , entitiesByCap = ebc
+          , entityDefinitionOrder = es
+          }
  where
   namedEntities = map (view entityName &&& id) es
+  entsByName = M.fromList namedEntities
+
+-- Compare to 'combineEntityCapsM'
+combineEntityCaps ::
+  [Entity] ->
+  MultiEntityCapabilities Entity EntityName
+combineEntityCaps = mconcat . map mkForEntity
+ where
+  mkForEntity e = f <$> e ^. entityCapabilities
+   where
+    f = pure . DeviceUseCost e
+
+lookupEntityE :: Map Text b -> Text -> Either Text b
+lookupEntityE em en =
+  maybeToEither err $ M.lookup en em
+ where
+  err = T.unwords [quote en, "is not a valid entity name"]
+
+combineEntityCapsM ::
+  Map EntityName Entity ->
+  [Entity] ->
+  Either Text (MultiEntityCapabilities Entity Entity)
+combineEntityCapsM em =
+  fmap mconcat . mapM mkForEntity
+ where
+  transformCaps (Capabilities m) = do
+    Capabilities <$> mapM (transformIngredients $ lookupEntityE em) m
+
+  mkForEntity e = do
+    betterCaps <- transformCaps $ e ^. entityCapabilities
+    return $ f <$> betterCaps
+   where
+    f = pure . DeviceUseCost e
 
 ------------------------------------------------------------
 -- Serialization
@@ -456,7 +495,7 @@ instance FromJSON Entity where
               <*> v .:? "combustion"
               <*> v .:? "yields"
               <*> v .:? "properties" .!= mempty
-              <*> v .:? "capabilities" .!= mempty
+              <*> v .:? "capabilities" .!= Capabilities mempty
               <*> pure empty
           )
 
@@ -481,7 +520,7 @@ instance ToJSON Entity where
         ++ ["growth" .= (e ^. entityGrowth) | isJust (e ^. entityGrowth)]
         ++ ["yields" .= (e ^. entityYields) | isJust (e ^. entityYields)]
         ++ ["properties" .= (e ^. entityProperties) | not . null $ e ^. entityProperties]
-        ++ ["capabilities" .= (e ^. entityCapabilities) | not . null $ e ^. entityCapabilities]
+        ++ ["capabilities" .= (e ^. entityCapabilities) | not . M.null . getMap $ e ^. entityCapabilities]
 
 -- | Load entities from a data file called @entities.yaml@, producing
 --   either an 'EntityMap' or a parse error.
@@ -579,7 +618,7 @@ hasProperty :: Entity -> EntityProperty -> Bool
 hasProperty e p = p `elem` (e ^. entityProperties)
 
 -- | The capabilities this entity provides when equipped.
-entityCapabilities :: Lens' Entity (Set Capability)
+entityCapabilities :: Lens' Entity (SingleEntityCapabilities EntityName)
 entityCapabilities = hashedLens _entityCapabilities (\e x -> e {_entityCapabilities = x})
 
 -- | The inventory of other entities carried by this entity.
@@ -590,10 +629,6 @@ entityInventory = hashedLens _entityInventory (\e x -> e {_entityInventory = x})
 -- Inventory
 ------------------------------------------------------------
 
--- | A convenient synonym to remind us when an 'Int' is supposed to
---   represent /how many/ of something we have.
-type Count = Int
-
 -- | An inventory is really just a bag/multiset of entities.  That is,
 --   it contains some entities, along with the number of times each
 --   occurs.  Entities can be looked up directly, or by name.
@@ -707,8 +742,8 @@ isEmpty :: Inventory -> Bool
 isEmpty = all ((== 0) . fst) . elems
 
 -- | Compute the set of capabilities provided by the devices in an inventory.
-inventoryCapabilities :: Inventory -> Set Capability
-inventoryCapabilities = Set.unions . map (^. entityCapabilities) . nonzeroEntities
+inventoryCapabilities :: Inventory -> MultiEntityCapabilities Entity EntityName
+inventoryCapabilities = combineEntityCaps . nonzeroEntities
 
 -- | List elements that have at least one copy in the inventory.
 nonzeroEntities :: Inventory -> [Entity]
@@ -718,14 +753,14 @@ nonzeroEntities = map snd . filter ((> 0) . fst) . elems
 -- exist with nonzero count in the inventory.
 extantElemsWithCapability :: Capability -> Inventory -> [Entity]
 extantElemsWithCapability cap =
-  filter (Set.member cap . (^. entityCapabilities)) . nonzeroEntities
+  filter (M.member cap . getMap . (^. entityCapabilities)) . nonzeroEntities
 
 -- | Groups entities by the capabilities they offer.
 entitiesByCapability :: Inventory -> Map Capability (NE.NonEmpty Entity)
 entitiesByCapability inv =
   binTuples entityCapabilityPairs
  where
-  getCaps = Set.toList . (^. entityCapabilities)
+  getCaps = M.keys . getMap . (^. entityCapabilities)
   entityCapabilityPairs = concatMap ((\e -> map (,e) $ getCaps e) . snd) $ elems inv
 
 -- | Delete a single copy of a certain entity from an inventory.
diff --git a/src/swarm-scenario/Swarm/Game/Ingredients.hs b/src/swarm-scenario/Swarm/Game/Ingredients.hs
new file mode 100644
index 000000000..8998ac644
--- /dev/null
+++ b/src/swarm-scenario/Swarm/Game/Ingredients.hs
@@ -0,0 +1,20 @@
+-- |
+-- SPDX-License-Identifier: BSD-3-Clause
+module Swarm.Game.Ingredients (
+  IngredientList,
+  Count,
+  getCost,
+) where
+
+-- | A convenient synonym to remind us when an 'Int' is supposed to
+--   represent /how many/ of something we have.
+type Count = Int
+
+-- | An ingredient list is a list of entities with multiplicity.  It
+--   is polymorphic in the entity type so that we can use either
+--   entity names when serializing, or actual entity objects while the
+--   game is running.
+type IngredientList e = [(Count, e)]
+
+getCost :: IngredientList e -> Int
+getCost = sum . map fst
diff --git a/src/swarm-scenario/Swarm/Game/Recipe.hs b/src/swarm-scenario/Swarm/Game/Recipe.hs
index 1b123b04a..e55b85868 100644
--- a/src/swarm-scenario/Swarm/Game/Recipe.hs
+++ b/src/swarm-scenario/Swarm/Game/Recipe.hs
@@ -47,6 +47,7 @@ module Swarm.Game.Recipe (
   recipesFor,
   make,
   make',
+  findLacking,
 ) where
 
 import Control.Algebra (Has)
@@ -67,18 +68,13 @@ import Data.Yaml
 import GHC.Generics (Generic)
 import Swarm.Game.Entity as E
 import Swarm.Game.Failure
+import Swarm.Game.Ingredients
 import Swarm.Game.ResourceLoading (getDataFileNameSafe)
 import Swarm.Util.Effect (withThrow)
 import Swarm.Util.Lens (makeLensesNoSigs)
 import Swarm.Util.Yaml
 import Witch
 
--- | An ingredient list is a list of entities with multiplicity.  It
---   is polymorphic in the entity type so that we can use either
---   entity names when serializing, or actual entity objects while the
---   game is running.
-type IngredientList e = [(Count, e)]
-
 -- | A recipe represents some kind of process where inputs are
 --   transformed into outputs.
 data Recipe e = Recipe
@@ -220,6 +216,13 @@ data MissingIngredient = MissingIngredient MissingType Count Entity
 data MissingType = MissingInput | MissingCatalyst
   deriving (Show, Eq)
 
+-- | Determines whether recipe inputs are satisfied by a
+-- robot's inventory.
+findLacking :: Inventory -> [(Count, Entity)] -> [(Count, Entity)]
+findLacking robotInventory = filter ((> 0) . fst) . map countNeeded
+ where
+  countNeeded (need, entity) = (need - E.lookup entity robotInventory, entity)
+
 -- | Figure out which ingredients (if any) are lacking from an
 --   inventory to be able to carry out the recipe.  Catalysts are not
 --   consumed and so can be used even when equipped.
@@ -229,8 +232,6 @@ missingIngredientsFor (inv, ins) (Recipe inps _ cats _ _) =
     <> mkMissing MissingCatalyst (findLacking ins (findLacking inv cats))
  where
   mkMissing k = map (uncurry (MissingIngredient k))
-  findLacking inven = filter ((> 0) . fst) . map (countNeeded inven)
-  countNeeded inven (need, entity) = (need - E.lookup entity inven, entity)
 
 -- | Figure out if a recipe is available, /i.e./ if we at least know
 --   about all the ingredients.  Note it does not matter whether we have
@@ -259,7 +260,12 @@ make invs r = finish <$> make' invs r
   finish (invTaken, out) = (invTaken, out, r)
 
 -- | Try to make a recipe, but do not insert it yet.
-make' :: (Inventory, Inventory) -> Recipe Entity -> Either [MissingIngredient] (Inventory, IngredientList Entity)
+make' ::
+  (Inventory, Inventory) ->
+  Recipe Entity ->
+  Either
+    [MissingIngredient]
+    (Inventory, IngredientList Entity)
 make' invs@(inv, _) r =
   case missingIngredientsFor invs r of
     [] ->
diff --git a/src/swarm-scenario/Swarm/Game/Robot.hs b/src/swarm-scenario/Swarm/Game/Robot.hs
index 6d39bf774..a67671b52 100644
--- a/src/swarm-scenario/Swarm/Game/Robot.hs
+++ b/src/swarm-scenario/Swarm/Game/Robot.hs
@@ -76,8 +76,10 @@ import Data.Text (Text)
 import Data.Yaml (FromJSON (parseJSON), (.!=), (.:), (.:?))
 import GHC.Generics (Generic)
 import Linear
+import Swarm.Game.Device
 import Swarm.Game.Display (Display, curOrientation, defaultRobotDisplay, invisible)
 import Swarm.Game.Entity hiding (empty)
+import Swarm.Game.Ingredients
 import Swarm.Game.Land
 import Swarm.Game.Location (Heading, Location, toDirection, toHeading)
 import Swarm.Game.Robot.Walk
@@ -134,7 +136,7 @@ type instance RobotLogUpdatedMember 'TemplateRobot = ()
 data RobotR (phase :: RobotPhase) = RobotR
   { _robotEntity :: Entity
   , _equippedDevices :: Inventory
-  , _robotCapabilities :: Set Capability
+  , _robotCapabilities :: MultiEntityCapabilities Entity EntityName
   -- ^ A cached view of the capabilities this robot has.
   --   Automatically generated from '_equippedDevices'.
   , _robotLog :: RobotLogMember phase
@@ -288,7 +290,7 @@ robotKnows r e = contains0plus e (r ^. robotInventory) || contains0plus e (r ^.
 --   getter, not a lens, because it is automatically generated from
 --   the 'equippedDevices'.  The only way to change a robot's
 --   capabilities is to modify its 'equippedDevices'.
-robotCapabilities :: Getter Robot (Set Capability)
+robotCapabilities :: Getter Robot (MultiEntityCapabilities Entity EntityName)
 robotCapabilities = to _robotCapabilities
 
 -- | Is this robot a "system robot"?  System robots are generated by
@@ -303,7 +305,7 @@ selfDestruct :: Lens' Robot Bool
 runningAtomic :: Lens' Robot Bool
 walkabilityContext :: Getter Robot WalkabilityContext
 walkabilityContext = to $
-  \x -> WalkabilityContext (_robotCapabilities x) (_unwalkableEntities x)
+  \x -> WalkabilityContext (getCapabilitySet $ _robotCapabilities x) (_unwalkableEntities x)
 
 -- | A general function for creating robots.
 mkRobot ::
@@ -336,7 +338,7 @@ mkRobot ::
 mkRobot pid name descr loc dir disp m devs inv sys heavy unwalkables ts =
   RobotR
     { _robotEntity =
-        mkEntity disp name descr [] []
+        mkEntity disp name descr [] mempty
           & entityOrientation ?~ dir
           & entityInventory .~ fromElems inv
     , _equippedDevices = inst
diff --git a/swarm.cabal b/swarm.cabal
index e7480fe53..7f69597bc 100644
--- a/swarm.cabal
+++ b/swarm.cabal
@@ -183,11 +183,13 @@ library swarm-scenario
   exposed-modules:
     Swarm.Constant
     Swarm.Game.Achievement.Definitions
+    Swarm.Game.Device
     Swarm.Game.Display
     Swarm.Game.Entity
     Swarm.Game.Entity.Cosmetic
     Swarm.Game.Entity.Cosmetic.Assignment
     Swarm.Game.Failure
+    Swarm.Game.Ingredients
     Swarm.Game.Land
     Swarm.Game.Location
     Swarm.Game.Recipe
@@ -532,12 +534,14 @@ library
     Swarm.Game.Achievement.Description,
     Swarm.Game.Achievement.Persistence,
     Swarm.Game.CESK,
+    Swarm.Game.Device,
     Swarm.Game.Display,
     Swarm.Game.Entity,
     Swarm.Game.Entity.Cosmetic,
     Swarm.Game.Entity.Cosmetic.Assignment,
     Swarm.Game.Exception,
     Swarm.Game.Failure,
+    Swarm.Game.Ingredients,
     Swarm.Game.Land,
     Swarm.Game.Location,
     Swarm.Game.Recipe,
diff --git a/test/integration/Main.hs b/test/integration/Main.hs
index 413187cdb..3c95bf64f 100644
--- a/test/integration/Main.hs
+++ b/test/integration/Main.hs
@@ -370,6 +370,7 @@ testScenarioSolutions rs ui =
         , testSolution Default "Testing/1631-tags"
         , testSolution Default "Testing/1747-volume-command"
         , testSolution Default "Testing/1775-custom-terrain"
+        , testSolution (Sec 3) "Testing/1777-capability-cost"
         , testGroup
             -- Note that the description of the classic world in
             -- data/worlds/classic.yaml (automatically tested to some
diff --git a/test/unit/TestInventory.hs b/test/unit/TestInventory.hs
index e35ea1257..de8dc1cab 100644
--- a/test/unit/TestInventory.hs
+++ b/test/unit/TestInventory.hs
@@ -109,6 +109,6 @@ testInventory =
         )
     ]
  where
-  x = E.mkEntity (defaultEntityDisplay 'X') "fooX" mempty [] []
-  y = E.mkEntity (defaultEntityDisplay 'Y') "fooY" mempty [] []
-  z = E.mkEntity (defaultEntityDisplay 'Z') "fooZ" mempty [] []
+  x = E.mkEntity (defaultEntityDisplay 'X') "fooX" mempty [] mempty
+  y = E.mkEntity (defaultEntityDisplay 'Y') "fooY" mempty [] mempty
+  z = E.mkEntity (defaultEntityDisplay 'Z') "fooZ" mempty [] mempty
diff --git a/test/unit/TestRecipeCoverage.hs b/test/unit/TestRecipeCoverage.hs
index 65391b5db..c668a352f 100644
--- a/test/unit/TestRecipeCoverage.hs
+++ b/test/unit/TestRecipeCoverage.hs
@@ -8,9 +8,11 @@
 module TestRecipeCoverage where
 
 import Control.Lens ((^.))
+import Data.List.NonEmpty qualified as NE
 import Data.Map qualified as M
 import Data.Set qualified as Set
 import Data.Text qualified as T
+import Swarm.Game.Device
 import Swarm.Game.Entity (EntityMap (entitiesByCap), entityName)
 import Swarm.Game.Land
 import Swarm.Game.Recipe (recipeOutputs)
@@ -43,7 +45,7 @@ testDeviceRecipeCoverage gsi =
 
     -- Only include entities that grant a capability:
     entityNames =
-      Set.fromList . map (^. entityName) . concat . M.elems . entitiesByCap $
+      Set.fromList . map ((^. entityName) . device) . concatMap NE.toList . M.elems . getMap . entitiesByCap $
         initEntityTerrain (gsiScenarioInputs gsi) ^. entityMap
 
     getOutputsForRecipe r = map ((^. entityName) . snd) $ r ^. recipeOutputs

From da3fb0e361774d0b699f145c9f50b3d0ab1c0c19 Mon Sep 17 00:00:00 2001
From: Karl Ostmo <kostmo@gmail.com>
Date: Thu, 29 Feb 2024 12:26:12 -0800
Subject: [PATCH 2/9] derive traversable instances

---
 .../Testing/1777-capability-cost.yaml         | 18 +++++++++----
 .../Swarm/Game/Step/Util/Command.hs           |  2 +-
 src/swarm-scenario/Swarm/Game/Device.hs       | 26 +++----------------
 src/swarm-scenario/Swarm/Game/Entity.hs       |  8 +++---
 test/integration/Main.hs                      |  2 +-
 5 files changed, 21 insertions(+), 35 deletions(-)

diff --git a/data/scenarios/Testing/1777-capability-cost.yaml b/data/scenarios/Testing/1777-capability-cost.yaml
index 2280fa3ff..aa79d3367 100644
--- a/data/scenarios/Testing/1777-capability-cost.yaml
+++ b/data/scenarios/Testing/1777-capability-cost.yaml
@@ -9,11 +9,19 @@ objectives:
       - |
         Eliminate the `packing peanut`{=entity}s
     condition: |
-      judge <- robotnamed "judge";
-      as judge {
-        dist <- sniff "packing peanut";
-        return $ dist < 0;
-      }
+      hasLighterFluid <- as base {
+        has "lighter fluid";
+      };
+
+      if (not hasLighterFluid) {
+        judge <- robotnamed "judge";
+        as judge {
+          maybePath <- path (inL ()) (inR "packing peanut");
+          return $ case maybePath (\_. true) (\d. false);
+        }
+      } {
+        return false;
+      };
 solution: |
   move;
   turn right;
diff --git a/src/swarm-engine/Swarm/Game/Step/Util/Command.hs b/src/swarm-engine/Swarm/Game/Step/Util/Command.hs
index c6a2bfb90..a754b8c8c 100644
--- a/src/swarm-engine/Swarm/Game/Step/Util/Command.hs
+++ b/src/swarm-engine/Swarm/Game/Step/Util/Command.hs
@@ -123,7 +123,7 @@ payExerciseCost ::
   m ()
 payExerciseCost c rawCosts = do
   em <- use $ landscape . terrainAndEntities . entityMap
-  let eitherCosts = mapM (promoteDeviceUseCost $ lookupEntityE $ entitiesByName em) rawCosts
+  let eitherCosts = (traverse . traverse) (lookupEntityE $ entitiesByName em) rawCosts
   costs <- case eitherCosts of
     -- NOTE: Entity references have been validated already at scenario load time,
     -- so we should never encounter this error.
diff --git a/src/swarm-scenario/Swarm/Game/Device.hs b/src/swarm-scenario/Swarm/Game/Device.hs
index a3770ba8f..65688a3ea 100644
--- a/src/swarm-scenario/Swarm/Game/Device.hs
+++ b/src/swarm-scenario/Swarm/Game/Device.hs
@@ -14,8 +14,6 @@ module Swarm.Game.Device (
   ExerciseCost (..),
   getCapabilitySet,
   zeroCostCapabilities,
-  transformIngredients,
-  promoteDeviceUseCost,
 )
 where
 
@@ -37,7 +35,7 @@ import Swarm.Language.Capability (Capability)
 newtype Capabilities e = Capabilities
   { getMap :: Map Capability e
   }
-  deriving (Show, Eq, Generic, ToJSON, Hashable, Functor)
+  deriving (Show, Eq, Generic, ToJSON, Hashable, Functor, Foldable, Traversable)
 
 getCapabilitySet :: Capabilities e -> Set Capability
 getCapabilitySet (Capabilities m) = M.keysSet m
@@ -77,7 +75,7 @@ instance (Ord e, Semigroup e) => Monoid (Capabilities e) where
 newtype ExerciseCost e = ExerciseCost
   { ingredients :: IngredientList e
   }
-  deriving (Eq, Show, Generic, FromJSON, ToJSON, Hashable, Functor)
+  deriving (Eq, Show, Generic, FromJSON, ToJSON, Hashable, Functor, Foldable, Traversable)
 
 instance (Eq e) => Ord (ExerciseCost e) where
   compare = compare `on` (getCost . ingredients)
@@ -86,22 +84,4 @@ data DeviceUseCost e en = DeviceUseCost
   { device :: e
   , useCost :: ExerciseCost en
   }
-  deriving (Eq, Ord, Show, Generic, FromJSON, ToJSON, Functor)
-
--- TODO Should this derive from an Applicative instance?
-promoteDeviceUseCost ::
-  Monad m =>
-  (e -> m e') ->
-  DeviceUseCost x e ->
-  m (DeviceUseCost x e')
-promoteDeviceUseCost f (DeviceUseCost d ex) =
-  DeviceUseCost d <$> transformIngredients f ex
-
--- TODO Should this derive from an Applicative instance?
-transformIngredients ::
-  Monad m =>
-  (e -> m e') ->
-  ExerciseCost e ->
-  m (ExerciseCost e')
-transformIngredients f (ExerciseCost ings) =
-  ExerciseCost <$> mapM (traverse f) ings
+  deriving (Eq, Ord, Show, Generic, FromJSON, ToJSON, Functor, Foldable, Traversable)
diff --git a/src/swarm-scenario/Swarm/Game/Entity.hs b/src/swarm-scenario/Swarm/Game/Entity.hs
index 34205980d..c848d514a 100644
--- a/src/swarm-scenario/Swarm/Game/Entity.hs
+++ b/src/swarm-scenario/Swarm/Game/Entity.hs
@@ -468,12 +468,10 @@ combineEntityCapsM ::
 combineEntityCapsM em =
   fmap mconcat . mapM mkForEntity
  where
-  transformCaps (Capabilities m) = do
-    Capabilities <$> mapM (transformIngredients $ lookupEntityE em) m
+  transformCaps = (traverse . traverse) (lookupEntityE em)
 
-  mkForEntity e = do
-    betterCaps <- transformCaps $ e ^. entityCapabilities
-    return $ f <$> betterCaps
+  mkForEntity e =
+    fmap f <$> transformCaps (e ^. entityCapabilities)
    where
     f = pure . DeviceUseCost e
 
diff --git a/test/integration/Main.hs b/test/integration/Main.hs
index 3c95bf64f..e9acaecf4 100644
--- a/test/integration/Main.hs
+++ b/test/integration/Main.hs
@@ -370,7 +370,7 @@ testScenarioSolutions rs ui =
         , testSolution Default "Testing/1631-tags"
         , testSolution Default "Testing/1747-volume-command"
         , testSolution Default "Testing/1775-custom-terrain"
-        , testSolution (Sec 3) "Testing/1777-capability-cost"
+        , testSolution Default "Testing/1777-capability-cost"
         , testGroup
             -- Note that the description of the classic world in
             -- data/worlds/classic.yaml (automatically tested to some

From 7e2652151bf85f44ff41e67868b0b091ecd79d5d Mon Sep 17 00:00:00 2001
From: Karl Ostmo <kostmo@gmail.com>
Date: Thu, 29 Feb 2024 23:10:36 -0800
Subject: [PATCH 3/9] Show exercise cost in UI

---
 data/scenarios/Testing/00-ORDER.txt           |  1 +
 .../Testing/1262-display-device-commands.yaml | 54 +++++++++++++
 .../Testing/1777-capability-cost.yaml         |  2 +-
 src/Swarm/TUI/View.hs                         | 78 +++++++++++++++++--
 .../Swarm/Game/Step/Util/Command.hs           |  2 +-
 src/swarm-lang/Swarm/Language/Capability.hs   | 15 +++-
 src/swarm-scenario/Swarm/Game/Device.hs       | 29 ++++++-
 src/swarm-scenario/Swarm/Game/Robot.hs        |  2 -
 8 files changed, 168 insertions(+), 15 deletions(-)
 create mode 100644 data/scenarios/Testing/1262-display-device-commands.yaml

diff --git a/data/scenarios/Testing/00-ORDER.txt b/data/scenarios/Testing/00-ORDER.txt
index 790917913..9e1970a4f 100644
--- a/data/scenarios/Testing/00-ORDER.txt
+++ b/data/scenarios/Testing/00-ORDER.txt
@@ -36,6 +36,7 @@ Achievements
 1218-stride-command.yaml
 1234-push-command.yaml
 1256-halt-command.yaml
+1262-display-device-commands.yaml
 1295-density-command.yaml
 1138-structures
 1320-world-DSL
diff --git a/data/scenarios/Testing/1262-display-device-commands.yaml b/data/scenarios/Testing/1262-display-device-commands.yaml
new file mode 100644
index 000000000..884d8758e
--- /dev/null
+++ b/data/scenarios/Testing/1262-display-device-commands.yaml
@@ -0,0 +1,54 @@
+version: 1
+name: Device commands
+description: |
+  Demo display of commands offered by each device, along with their cost.
+creative: false
+robots:
+  - name: base
+    dir: east
+    devices:
+      - treads
+      - logger
+      - Fresnel lens
+      - string
+    inventory:
+      - [1, flash bulb]
+      - [1, photographic plate]
+entities:
+  - name: flash bulb
+    display:
+      char: 'f'
+    description:
+      - Consumables for a `Fresnel lens`{=entity} that enable `ignite`ing
+    properties: [known, pickable]
+  - name: photographic plate
+    display:
+      char: 'p'
+    description:
+      - Consumables for a `Fresnel lens`{=entity} that enable `scan`ning
+    properties: [known, pickable]
+  - name: Fresnel lens
+    display:
+      char: 'z'
+    description:
+      - Ignites things with sufficiently powerful light source
+    properties: [known, pickable]
+    capabilities:
+      - capability: ignite
+        cost:
+          - [1, "flash bulb"]
+      - capability: scan
+        cost:
+          - [2, "photographic plate"]
+known: [water]
+world:
+  dsl: |
+    {water}
+  palette:
+    'B': [grass, erase, base]
+    '.': [grass, erase]
+  upperleft: [-1, 1]
+  map: |
+    ...
+    .B.
+    ...
diff --git a/data/scenarios/Testing/1777-capability-cost.yaml b/data/scenarios/Testing/1777-capability-cost.yaml
index aa79d3367..04006210d 100644
--- a/data/scenarios/Testing/1777-capability-cost.yaml
+++ b/data/scenarios/Testing/1777-capability-cost.yaml
@@ -50,7 +50,7 @@ entities:
     display:
       char: 'f'
     description:
-      - Fuel for a Zippo
+      - Fuel for a `Zippo`{=entity}
     properties: [known, pickable]
   - name: Zippo
     display:
diff --git a/src/Swarm/TUI/View.hs b/src/Swarm/TUI/View.hs
index 927025534..00964a6dc 100644
--- a/src/Swarm/TUI/View.hs
+++ b/src/Swarm/TUI/View.hs
@@ -73,7 +73,7 @@ import Network.Wai.Handler.Warp (Port)
 import Numeric (showFFloat)
 import Swarm.Constant
 import Swarm.Game.CESK (CESK (..))
-import Swarm.Game.Device (getMap)
+import Swarm.Game.Device (commandCost, commandsForDeviceCaps, enabledCommands, getMap, ingredients)
 import Swarm.Game.Display
 import Swarm.Game.Entity as E
 import Swarm.Game.Ingredients
@@ -1210,6 +1210,7 @@ explainEntry s e =
   vBox $
     [ displayProperties $ Set.toList (e ^. entityProperties)
     , drawMarkdown (e ^. entityDescription)
+    , explainCapabilities (s ^. gameState) e
     , explainRecipes s e
     ]
       <> [drawRobotMachine s False | CDebug `M.member` getMap (e ^. entityCapabilities)]
@@ -1239,6 +1240,66 @@ displayProperties = displayList . mapMaybe showProperty
       , txt " "
       ]
 
+-- | This widget can have potentially multiple "headings"
+-- (one per capability), each with multiple commands underneath.
+-- Directly below each heading there will be a "exercise cost"
+-- description, unless the capability is free-to-exercise.
+explainCapabilities :: GameState -> Entity -> Widget Name
+explainCapabilities gs e
+  | null capabilitiesAndCommands = emptyWidget
+  | otherwise =
+      padBottom (Pad 1) $
+        vBox
+          [ hBorderWithLabel (txt "Enabled commands")
+          , hCenter
+              . vBox
+              . L.intersperse (padTop (Pad 1) . hCenter . txt $ T.replicate 10 "*")
+              $ map drawSingleCapabilityWidget capabilitiesAndCommands
+          ]
+ where
+  eLookup = lookupEntityE $ entitiesByName $ gs ^. landscape . terrainAndEntities . entityMap
+  eitherCosts = (traverse . traverse) eLookup $ e ^. entityCapabilities
+  capabilitiesAndCommands = case eitherCosts of
+    Right eCaps -> M.elems . getMap . commandsForDeviceCaps $ eCaps
+    Left x ->
+      error $
+        unwords
+          [ "Error: somehow an invalid entity reference escaped the parse-time check"
+          , T.unpack x
+          ]
+
+  drawSingleCapabilityWidget cmdsAndCost =
+    vBox
+      [ costWidget cmdsAndCost
+      , padLeft (Pad 1) . vBox . map renderCmdInfo . NE.toList $ enabledCommands cmdsAndCost
+      ]
+
+  renderCmdInfo c =
+    padTop (Pad 1) $
+      vBox
+        [ hBox
+            [ padRight (Pad 1) (txt . syntax $ constInfo c)
+            , padRight (Pad 1) (txt ":")
+            , withAttr magentaAttr . txt . prettyText $ inferConst c
+            ]
+        , padTop (Pad 1) . padLeft (Pad 1) . txtWrap . briefDoc . constDoc $ constInfo c
+        ]
+
+  costWidget cmdsAndCost =
+    if null ings
+      then emptyWidget
+      else padTop (Pad 1) $ vBox $ withAttr boldAttr (txt "Cost:") : map drawCost ings
+   where
+    ings = ingredients $ commandCost cmdsAndCost
+
+  drawCost (n, ingr) =
+    padRight (Pad 1) (str (show n)) <+> eName
+   where
+    eName = applyEntityNameAttr Nothing missing ingr $ txt $ ingr ^. entityName
+    missing = E.lookup ingr robotInv < n
+
+  robotInv = fromMaybe E.empty $ gs ^? to focusedRobot . _Just . robotInventory
+
 explainRecipes :: AppState -> Entity -> Widget Name
 explainRecipes s e
   | null recipes = emptyWidget
@@ -1350,16 +1411,21 @@ drawRecipe me inv (Recipe ins outs reqs time _weight) =
 
   -- If it's the focused entity, draw it highlighted.
   -- If the robot doesn't have any, draw it in red.
-  fmtEntityName missing ingr
-    | Just ingr == me = withAttr highlightAttr $ txtLines nm
-    | ingr == timeE = withAttr yellowAttr $ txtLines nm
-    | missing = withAttr invalidFormInputAttr $ txtLines nm
-    | otherwise = txtLines nm
+  fmtEntityName :: Bool -> Entity -> Widget n
+  fmtEntityName missing ingr =
+    applyEntityNameAttr me missing ingr $ txtLines nm
    where
     -- Split up multi-word names, one line per word
     nm = ingr ^. entityName
     txtLines = vBox . map txt . T.words
 
+applyEntityNameAttr :: Maybe Entity -> Bool -> Entity -> (Widget n -> Widget n)
+applyEntityNameAttr me missing ingr
+  | Just ingr == me = withAttr highlightAttr
+  | ingr == timeE = withAttr yellowAttr
+  | missing = withAttr invalidFormInputAttr
+  | otherwise = id
+
 -- | Ad-hoc entity to represent time - only used in recipe drawing
 timeE :: Entity
 timeE = mkEntity (defaultEntityDisplay '.') "ticks" mempty [] mempty
diff --git a/src/swarm-engine/Swarm/Game/Step/Util/Command.hs b/src/swarm-engine/Swarm/Game/Step/Util/Command.hs
index a754b8c8c..cf716bb06 100644
--- a/src/swarm-engine/Swarm/Game/Step/Util/Command.hs
+++ b/src/swarm-engine/Swarm/Game/Step/Util/Command.hs
@@ -20,9 +20,9 @@ import Control.Effect.Lens
 import Control.Effect.Lift
 import Control.Lens as Lens hiding (Const, distrib, from, parts, use, uses, view, (%=), (+=), (.=), (<+=), (<>=))
 import Control.Monad (forM_, unless, when)
+import Data.IntSet qualified as IS
 import Data.List (find)
 import Data.List.NonEmpty qualified as NE
-import Data.IntSet qualified as IS
 import Data.Map qualified as M
 import Data.Sequence qualified as Seq
 import Data.Set (Set)
diff --git a/src/swarm-lang/Swarm/Language/Capability.hs b/src/swarm-lang/Swarm/Language/Capability.hs
index 68a9e520c..3fb4e3abe 100644
--- a/src/swarm-lang/Swarm/Language/Capability.hs
+++ b/src/swarm-lang/Swarm/Language/Capability.hs
@@ -12,18 +12,24 @@ module Swarm.Language.Capability (
   Capability (..),
   capabilityName,
   constCaps,
+  constByCaps,
 ) where
 
+import Control.Arrow ((&&&))
 import Data.Aeson (FromJSONKey, ToJSONKey)
 import Data.Char (toLower)
 import Data.Data (Data)
 import Data.Hashable (Hashable)
+import Data.List.NonEmpty qualified as NE
+import Data.Map (Map)
+import Data.Maybe (mapMaybe)
 import Data.Text (Text)
 import Data.Text qualified as T
+import Data.Tuple (swap)
 import Data.Yaml
 import GHC.Generics (Generic)
 import Swarm.Language.Syntax
-import Swarm.Util (failT)
+import Swarm.Util (binTuples, failT)
 import Text.Read (readMaybe)
 import Witch (from)
 import Prelude hiding (lookup)
@@ -336,3 +342,10 @@ constCaps = \case
   -- currently don't.
   View -> Nothing -- TODO: #17 should require equipping an antenna
   Knows -> Nothing
+
+-- | Inverts the 'constCaps' mapping.
+constByCaps :: Map Capability (NE.NonEmpty Const)
+constByCaps =
+  binTuples $
+    map swap $
+      mapMaybe (sequenceA . (id &&& constCaps)) allConst
diff --git a/src/swarm-scenario/Swarm/Game/Device.hs b/src/swarm-scenario/Swarm/Game/Device.hs
index 65688a3ea..e913a1127 100644
--- a/src/swarm-scenario/Swarm/Game/Device.hs
+++ b/src/swarm-scenario/Swarm/Game/Device.hs
@@ -12,8 +12,10 @@ module Swarm.Game.Device (
   Capabilities (..),
   DeviceUseCost (..),
   ExerciseCost (..),
+  CommandsAndCost (..),
   getCapabilitySet,
   zeroCostCapabilities,
+  commandsForDeviceCaps,
 )
 where
 
@@ -28,7 +30,8 @@ import Data.Vector qualified as V
 import Data.Yaml
 import GHC.Generics (Generic)
 import Swarm.Game.Ingredients
-import Swarm.Language.Capability (Capability)
+import Swarm.Language.Capability (Capability, constByCaps)
+import Swarm.Language.Syntax (Const)
 
 -- This wrapper exists so that YAML can be parsed
 -- either as a list of 'Capability' or as a Map.
@@ -40,13 +43,13 @@ newtype Capabilities e = Capabilities
 getCapabilitySet :: Capabilities e -> Set Capability
 getCapabilitySet (Capabilities m) = M.keysSet m
 
-zeroCostCapabilities :: Set Capability -> Capabilities (ExerciseCost e)
-zeroCostCapabilities = Capabilities . M.fromSet (const $ ExerciseCost [])
-
 type SingleEntityCapabilities e = Capabilities (ExerciseCost e)
 
 type MultiEntityCapabilities e en = Capabilities (NonEmpty (DeviceUseCost e en))
 
+zeroCostCapabilities :: Set Capability -> SingleEntityCapabilities e
+zeroCostCapabilities = Capabilities . M.fromSet (const $ ExerciseCost [])
+
 -- | For JSON parsing only
 data CapabilityCost e = CapabilityCost
   { capability :: Capability
@@ -85,3 +88,21 @@ data DeviceUseCost e en = DeviceUseCost
   , useCost :: ExerciseCost en
   }
   deriving (Eq, Ord, Show, Generic, FromJSON, ToJSON, Functor, Foldable, Traversable)
+
+-- * Utils
+
+data CommandsAndCost e = CommandsAndCost
+  { commandCost :: ExerciseCost e
+  , enabledCommands :: NonEmpty Const
+  }
+
+-- | NOTE: Because each 'Const' is mapped to at most one
+-- 'Capability' by the 'constCaps' function, we know that
+-- a given 'Const' will not appear more than once as a value in the 'Map' produced by
+-- this function, i.e. for the  capabilities provided by a single 'Entity`
+-- ('SingleEntityCapabilities').
+commandsForDeviceCaps :: SingleEntityCapabilities e -> Capabilities (CommandsAndCost e)
+commandsForDeviceCaps = Capabilities . M.mapMaybeWithKey f . getMap
+ where
+  f cap xc =
+    CommandsAndCost xc <$> M.lookup cap constByCaps
diff --git a/src/swarm-scenario/Swarm/Game/Robot.hs b/src/swarm-scenario/Swarm/Game/Robot.hs
index a67671b52..50b0c25aa 100644
--- a/src/swarm-scenario/Swarm/Game/Robot.hs
+++ b/src/swarm-scenario/Swarm/Game/Robot.hs
@@ -71,7 +71,6 @@ import Control.Applicative ((<|>))
 import Control.Lens hiding (Const, contains)
 import Data.Hashable (hashWithSalt)
 import Data.Kind qualified
-import Data.Set (Set)
 import Data.Text (Text)
 import Data.Yaml (FromJSON (parseJSON), (.!=), (.:), (.:?))
 import GHC.Generics (Generic)
@@ -84,7 +83,6 @@ import Swarm.Game.Land
 import Swarm.Game.Location (Heading, Location, toDirection, toHeading)
 import Swarm.Game.Robot.Walk
 import Swarm.Game.Universe
-import Swarm.Language.Capability (Capability)
 import Swarm.Language.Pipeline (ProcessedTerm)
 import Swarm.Language.Syntax (Syntax)
 import Swarm.Language.Text.Markdown (Document)

From 83f26eb9032621a66f7395359a8c23030379116e Mon Sep 17 00:00:00 2001
From: Karl Ostmo <kostmo@gmail.com>
Date: Fri, 15 Mar 2024 20:13:43 -0700
Subject: [PATCH 4/9] Update src/swarm-scenario/Swarm/Game/Device.hs

Co-authored-by: Brent Yorgey <byorgey@gmail.com>
---
 src/swarm-scenario/Swarm/Game/Device.hs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/swarm-scenario/Swarm/Game/Device.hs b/src/swarm-scenario/Swarm/Game/Device.hs
index e913a1127..2645211bd 100644
--- a/src/swarm-scenario/Swarm/Game/Device.hs
+++ b/src/swarm-scenario/Swarm/Game/Device.hs
@@ -33,8 +33,8 @@ import Swarm.Game.Ingredients
 import Swarm.Language.Capability (Capability, constByCaps)
 import Swarm.Language.Syntax (Const)
 
--- This wrapper exists so that YAML can be parsed
--- either as a list of 'Capability' or as a Map.
+-- | The 'Capabilities e' wrapper type stores information of type @e@ for each of some set of capabilities.
+-- For example, @e@ could be a list of ingredients needed to exercise a capability, or a set of devices capable of providing a capability.
 newtype Capabilities e = Capabilities
   { getMap :: Map Capability e
   }

From 8cf1dd2e30f4e3455bd8db9e26711d491093851f Mon Sep 17 00:00:00 2001
From: Karl Ostmo <kostmo@gmail.com>
Date: Tue, 23 Apr 2024 19:18:36 -0700
Subject: [PATCH 5/9] Apply suggestions from code review

Co-authored-by: Brent Yorgey <byorgey@gmail.com>
---
 src/swarm-scenario/Swarm/Game/Device.hs | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/src/swarm-scenario/Swarm/Game/Device.hs b/src/swarm-scenario/Swarm/Game/Device.hs
index 2645211bd..e1032ff58 100644
--- a/src/swarm-scenario/Swarm/Game/Device.hs
+++ b/src/swarm-scenario/Swarm/Game/Device.hs
@@ -40,24 +40,28 @@ newtype Capabilities e = Capabilities
   }
   deriving (Show, Eq, Generic, ToJSON, Hashable, Functor, Foldable, Traversable)
 
+-- | Get the set of capabilities about which we are storing information.
 getCapabilitySet :: Capabilities e -> Set Capability
 getCapabilitySet (Capabilities m) = M.keysSet m
 
+-- | Records an 'ExerciseCost', i.e. list of consumed ingredients, per capability that can be exercised.  This represents information about a single entity/device, which can provide multiple capabilities (with a different exercise cost for each).
 type SingleEntityCapabilities e = Capabilities (ExerciseCost e)
 
+-- | Records a list of devices capable of providing each capability; along with each device is recorded the 'ExerciseCost' needed to use that device to achieve the given capability.
 type MultiEntityCapabilities e en = Capabilities (NonEmpty (DeviceUseCost e en))
 
+-- | Create a default 'SingleEntityCapabilities' map for a device which provides capabilities with no associated costs.
 zeroCostCapabilities :: Set Capability -> SingleEntityCapabilities e
 zeroCostCapabilities = Capabilities . M.fromSet (const $ ExerciseCost [])
 
--- | For JSON parsing only
+-- | Package together a capability and exercise cost; only used temporarily for parsing this information from JSON format.
 data CapabilityCost e = CapabilityCost
   { capability :: Capability
   , cost :: IngredientList e
   }
   deriving (Generic, FromJSON)
 
--- | First, attempt to parse capabilities as a list.
+-- | First, attempt to parse capabilities as a list, interpreted as a set of capabilities with no exercise cost.
 -- Otherwise, parse as a Map from capabilities to ingredients.
 instance (FromJSON e) => FromJSON (SingleEntityCapabilities e) where
   parseJSON x =
@@ -74,15 +78,17 @@ instance (Ord e, Semigroup e) => Semigroup (Capabilities e) where
 instance (Ord e, Semigroup e) => Monoid (Capabilities e) where
   mempty = Capabilities mempty
 
--- | Exercising a capability may have a cost.
+-- | Exercising a capability may have a cost, in the form of entities that must be consumed each time it is used.
 newtype ExerciseCost e = ExerciseCost
   { ingredients :: IngredientList e
   }
   deriving (Eq, Show, Generic, FromJSON, ToJSON, Hashable, Functor, Foldable, Traversable)
 
+-- | Sort 'ExerciseCost's by the total count of ingredients consumed.
 instance (Eq e) => Ord (ExerciseCost e) where
   compare = compare `on` (getCost . ingredients)
 
+-- | A device paired with a cost to use it.
 data DeviceUseCost e en = DeviceUseCost
   { device :: e
   , useCost :: ExerciseCost en
@@ -91,12 +97,15 @@ data DeviceUseCost e en = DeviceUseCost
 
 -- * Utils
 
+-- | A nonempty list of commands together with an exercise cost for using any of them (typically these will be a list of commands all requiring the same capability).
 data CommandsAndCost e = CommandsAndCost
   { commandCost :: ExerciseCost e
   , enabledCommands :: NonEmpty Const
   }
 
--- | NOTE: Because each 'Const' is mapped to at most one
+-- | Given mapping from capabilities to their exercise costs provided by a single device, turn it into an mapping from capabilities to their exercise cost and enabled commands.
+--
+-- NOTE: Because each 'Const' is mapped to at most one
 -- 'Capability' by the 'constCaps' function, we know that
 -- a given 'Const' will not appear more than once as a value in the 'Map' produced by
 -- this function, i.e. for the  capabilities provided by a single 'Entity`

From c7f1418171908252854354acf8f95eda4321cf5b Mon Sep 17 00:00:00 2001
From: Karl Ostmo <kostmo@gmail.com>
Date: Tue, 23 Apr 2024 22:16:51 -0700
Subject: [PATCH 6/9] Elaborate docstring (regarding type parameters)

---
 src/swarm-scenario/Swarm/Game/Device.hs | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/swarm-scenario/Swarm/Game/Device.hs b/src/swarm-scenario/Swarm/Game/Device.hs
index e1032ff58..f5155b5fd 100644
--- a/src/swarm-scenario/Swarm/Game/Device.hs
+++ b/src/swarm-scenario/Swarm/Game/Device.hs
@@ -33,8 +33,10 @@ import Swarm.Game.Ingredients
 import Swarm.Language.Capability (Capability, constByCaps)
 import Swarm.Language.Syntax (Const)
 
--- | The 'Capabilities e' wrapper type stores information of type @e@ for each of some set of capabilities.
--- For example, @e@ could be a list of ingredients needed to exercise a capability, or a set of devices capable of providing a capability.
+-- | The 'Capabilities e' wrapper type stores information of type @e@ for each
+-- of some set of capabilities.
+-- For example, @e@ could be a list of ingredients needed to exercise a
+-- capability, or a set of devices capable of providing a capability.
 newtype Capabilities e = Capabilities
   { getMap :: Map Capability e
   }
@@ -47,7 +49,11 @@ getCapabilitySet (Capabilities m) = M.keysSet m
 -- | Records an 'ExerciseCost', i.e. list of consumed ingredients, per capability that can be exercised.  This represents information about a single entity/device, which can provide multiple capabilities (with a different exercise cost for each).
 type SingleEntityCapabilities e = Capabilities (ExerciseCost e)
 
--- | Records a list of devices capable of providing each capability; along with each device is recorded the 'ExerciseCost' needed to use that device to achieve the given capability.
+-- | Records a list of devices capable of providing each capability;
+-- along with each device is recorded the 'ExerciseCost' needed to use
+-- that device to achieve the given capability.
+--
+-- See 'DeviceUseCost' for explanation of type parameters.
 type MultiEntityCapabilities e en = Capabilities (NonEmpty (DeviceUseCost e en))
 
 -- | Create a default 'SingleEntityCapabilities' map for a device which provides capabilities with no associated costs.
@@ -89,6 +95,17 @@ instance (Eq e) => Ord (ExerciseCost e) where
   compare = compare `on` (getCost . ingredients)
 
 -- | A device paired with a cost to use it.
+--
+-- At scenario parse time, the type parameters @e@ and @en@ will stand for
+-- 'Entity' and 'EntityName'.
+-- This is because `ExerciseCost` is a member of the 'Entity' datatype, and
+-- therefore can only refer to another 'Entity' by name before all 'Entity's
+-- are parsed.
+--
+-- However, after parse time, we are able to look up actual 'Entity' objects
+-- by name, and therefore can instantiate 'ExerciseCost' with 'Entity' as
+-- the type parameter.
+-- Then the two type parameters of 'DeviceUseCost' are both of 'Entity' type.
 data DeviceUseCost e en = DeviceUseCost
   { device :: e
   , useCost :: ExerciseCost en

From ac3a4b48de66f5cd18515a3df4b2b40e1bc05d24 Mon Sep 17 00:00:00 2001
From: Karl Ostmo <kostmo@gmail.com>
Date: Wed, 24 Apr 2024 21:54:39 -0700
Subject: [PATCH 7/9] update haddock

---
 src/swarm-engine/Swarm/Game/Exception.hs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/swarm-engine/Swarm/Game/Exception.hs b/src/swarm-engine/Swarm/Game/Exception.hs
index 7910f91a5..72a32a278 100644
--- a/src/swarm-engine/Swarm/Game/Exception.hs
+++ b/src/swarm-engine/Swarm/Game/Exception.hs
@@ -107,7 +107,8 @@ data IncapableFixWords = IncapableFixWords
   , fixNoun :: Text
   }
 
--- | Pretty-print an 'IncapableFix': either "equip" or "obtain".
+-- | Pretty-print an 'IncapableFix': either "equip device",
+-- "obtain device", or "obtain consumables".
 formatIncapableFix :: IncapableFix -> IncapableFixWords
 formatIncapableFix = \case
   FixByEquip -> IncapableFixWords "equip" "device"

From 608786c12658ac69e71a925a67adc0fe083aef72 Mon Sep 17 00:00:00 2001
From: Karl Ostmo <kostmo@gmail.com>
Date: Wed, 24 Apr 2024 22:54:36 -0700
Subject: [PATCH 8/9] remove asterisk dividers

---
 src/Swarm/TUI/View.hs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Swarm/TUI/View.hs b/src/Swarm/TUI/View.hs
index 00964a6dc..f32f999e6 100644
--- a/src/Swarm/TUI/View.hs
+++ b/src/Swarm/TUI/View.hs
@@ -1253,7 +1253,7 @@ explainCapabilities gs e
           [ hBorderWithLabel (txt "Enabled commands")
           , hCenter
               . vBox
-              . L.intersperse (padTop (Pad 1) . hCenter . txt $ T.replicate 10 "*")
+              . L.intersperse (txt " ") -- Inserts an extra blank line between major "Cost" sections
               $ map drawSingleCapabilityWidget capabilitiesAndCommands
           ]
  where

From 832b5bccca5a9ff640d78f425045b2477a522805 Mon Sep 17 00:00:00 2001
From: Karl Ostmo <kostmo@gmail.com>
Date: Wed, 24 Apr 2024 23:06:43 -0700
Subject: [PATCH 9/9] Deduplicate code with 'zeroCostCapabilities'

---
 src/swarm-scenario/Swarm/Game/Device.hs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/swarm-scenario/Swarm/Game/Device.hs b/src/swarm-scenario/Swarm/Game/Device.hs
index f5155b5fd..8999dc2c5 100644
--- a/src/swarm-scenario/Swarm/Game/Device.hs
+++ b/src/swarm-scenario/Swarm/Game/Device.hs
@@ -71,9 +71,9 @@ data CapabilityCost e = CapabilityCost
 -- Otherwise, parse as a Map from capabilities to ingredients.
 instance (FromJSON e) => FromJSON (SingleEntityCapabilities e) where
   parseJSON x =
-    Capabilities <$> (simpleList <|> costMap)
+    simpleList <|> (Capabilities <$> costMap)
    where
-    simpleList = M.fromSet (const $ ExerciseCost []) <$> parseJSON x
+    simpleList = zeroCostCapabilities <$> parseJSON x
     costMap = withArray "Capabilities" (fmap (M.fromList . map toMapEntry) . mapM parseJSON . V.toList) x
     toMapEntry (CapabilityCost a b) = (a, ExerciseCost b)