swarm 0.2.0.0 → 0.3.0.0

raw patch · 183 files changed

+11542/−3008 lines, 183 filesdep +text-ropedep ~brickdep ~lineardep ~lspPVP ok

version bump matches the API change (PVP)

Dependencies added: text-rope

Dependency ranges changed: brick, linear, lsp, megaparsec

API changes (from Hackage documentation)

Files

• CHANGELOG.md +78/−0
• app/Main.hs +26/−3
• bench/Benchmark.hs +6/−7
• data/entities.yaml +139/−30
• data/recipes.yaml +38/−0
• data/scenarios/Challenges/00-ORDER.txt +6/−0
• data/scenarios/Challenges/Mazes/easy_cave_maze.yaml +0/−1
• data/scenarios/Challenges/Mazes/easy_spiral_maze.yaml +0/−1
• data/scenarios/Challenges/Mazes/invisible_maze.yaml +0/−3
• data/scenarios/Challenges/Mazes/loopy_maze_sol.sw +0/−4
• data/scenarios/Challenges/Ranching/00-ORDER.txt +1/−0
• data/scenarios/Challenges/Ranching/_gated-paddock/enclosure-checking.sw +255/−0
• data/scenarios/Challenges/Ranching/_gated-paddock/fence-construction.sw +217/−0
• data/scenarios/Challenges/Ranching/_gated-paddock/meandering-sheep.sw +144/−0
• data/scenarios/Challenges/Ranching/gated-paddock.yaml +543/−0
• data/scenarios/Challenges/_bucket-brigade/brigade.sw +94/−0
• data/scenarios/Challenges/_bucket-brigade/hauler.sw +44/−0
• data/scenarios/Challenges/_bucket-brigade/powerplant.sw +20/−0
• data/scenarios/Challenges/_friend/cat.sw +75/−0
• data/scenarios/Challenges/_friend/friend-solution.sw +18/−0
• data/scenarios/Challenges/_ice-cream/customer.sw +60/−0
• data/scenarios/Challenges/_ice-cream/solution.sw +68/−0
• data/scenarios/Challenges/_wolf-goat-cabbage/cross.sw +40/−0
• data/scenarios/Challenges/_wolf-goat-cabbage/multi-item-possession.sw +4/−0
• data/scenarios/Challenges/_wolf-goat-cabbage/together-on-east-bank.sw +28/−0
• data/scenarios/Challenges/_wolf-goat-cabbage/unattended-together.sw +35/−0
• data/scenarios/Challenges/_word-search/create-puzzle.sw +247/−0
• data/scenarios/Challenges/_word-search/solution.sw +127/−0
• data/scenarios/Challenges/_word-search/verify-solution.sw +183/−0
• data/scenarios/Challenges/bucket-brigade.yaml +216/−0
• data/scenarios/Challenges/friend.yaml +94/−0
• data/scenarios/Challenges/hanoi.yaml +4/−4
• data/scenarios/Challenges/ice-cream.yaml +241/−0
• data/scenarios/Challenges/teleport.yaml +4/−3
• data/scenarios/Challenges/wolf-goat-cabbage.yaml +125/−0
• data/scenarios/Challenges/word-search.yaml +387/−0
• data/scenarios/Fun/00-ORDER.txt +1/−0
• data/scenarios/Fun/_logo-burst/coordinator.sw +12/−0
• data/scenarios/Fun/_logo-burst/drone.sw +67/−0
• data/scenarios/Fun/logo-burst.yaml +84/−0
• data/scenarios/Speedruns/curry.yaml +4/−2
• data/scenarios/Speedruns/forester.yaml +3/−1
• data/scenarios/Speedruns/mithril.yaml +3/−1
• data/scenarios/Testing/00-ORDER.txt +9/−0
• data/scenarios/Testing/1034-custom-attributes.yaml +134/−0
• data/scenarios/Testing/201-require/201-require-device-creative.yaml +2/−2
• data/scenarios/Testing/201-require/201-require-device-creative1.yaml +2/−2
• data/scenarios/Testing/201-require/201-require-device.yaml +2/−2
• data/scenarios/Testing/201-require/533-reprogram-simple.yaml +7/−7
• data/scenarios/Testing/201-require/533-reprogram.yaml +5/−5
• data/scenarios/Testing/378-objectives.yaml +4/−1
• data/scenarios/Testing/394-build-drill.yaml +8/−2
• data/scenarios/Testing/397-wrong-missing.yaml +38/−0
• data/scenarios/Testing/562-lodestone.sw +0/−2
• data/scenarios/Testing/562-lodestone.yaml +1/−0
• data/scenarios/Testing/795-prerequisite/00-ORDER.txt +4/−0
• data/scenarios/Testing/795-prerequisite/795-prerequisite-and.yaml +50/−0
• data/scenarios/Testing/795-prerequisite/795-prerequisite-cycle-with-not.yaml +42/−0
• data/scenarios/Testing/795-prerequisite/795-prerequisite-mutually-exclusive.yaml +61/−0
• data/scenarios/Testing/795-prerequisite/795-prerequisite-or.yaml +49/−0
• data/scenarios/Testing/858-inventory/00-ORDER.txt +3/−0
• data/scenarios/Testing/858-inventory/858-counting-objective.yaml +36/−0
• data/scenarios/Testing/858-inventory/858-nonpossession-objective.yaml +35/−0
• data/scenarios/Testing/858-inventory/858-possession-objective.yaml +33/−0
• data/scenarios/Testing/920-meet.yaml +52/−0
• data/scenarios/Testing/955-heading.yaml +28/−0
• data/scenarios/Testing/956-GPS.yaml +66/−0
• data/scenarios/Testing/958-isempty.yaml +57/−0
• data/scenarios/Testing/961-custom-capabilities.yaml +42/−0
• data/scenarios/Testing/_Validation/795-prerequisite-cycle.yaml +38/−0
• data/scenarios/Testing/_Validation/795-prerequisite-nonexistent-reference.yaml +38/−0
• data/scenarios/Testing/_Validation/795-prerequisite-self-reference.yaml +31/−0
• data/scenarios/Tutorials/00-ORDER.txt +2/−2
• data/scenarios/Tutorials/bind.yaml +0/−81
• data/scenarios/Tutorials/bind2-solution.sw +11/−0
• data/scenarios/Tutorials/bind2.yaml +111/−0
• data/scenarios/Tutorials/build.yaml +7/−20
• data/scenarios/Tutorials/conditionals.yaml +0/−3
• data/scenarios/Tutorials/craft.yaml +5/−0
• data/scenarios/Tutorials/crash-secret.sw +26/−28
• data/scenarios/Tutorials/def.yaml +0/−1
• data/scenarios/Tutorials/equip.yaml +61/−0
• data/scenarios/Tutorials/farming.sw +1/−7
• data/scenarios/Tutorials/farming.yaml +5/−1
• data/scenarios/Tutorials/install.yaml +0/−60
• data/scenarios/Tutorials/lambda.yaml +0/−1
• data/scenarios/Tutorials/move.yaml +12/−3
• data/scenarios/Tutorials/require.yaml +6/−7
• data/scenarios/Tutorials/requireinv.yaml +2/−3
• data/scenarios/Tutorials/world101.yaml +10/−3
• data/scenarios/classic.yaml +1/−0
• data/test/language-snippets/warnings/unused-vars/multiple-lambda-first-unused.sw +3/−0
• data/test/language-snippets/warnings/unused-vars/multiple-lambda-second-unused.sw +3/−0
• data/test/language-snippets/warnings/unused-vars/multiple-let-all-unused.sw +3/−0
• data/test/language-snippets/warnings/unused-vars/multiple-let-first-unused.sw +3/−0
• data/test/language-snippets/warnings/unused-vars/multiple-let-second-unused.sw +3/−0
• data/test/language-snippets/warnings/unused-vars/recursive-let.sw +1/−0
• data/test/language-snippets/warnings/unused-vars/shadowed-variable-lambda-unused.sw +1/−0
• data/test/language-snippets/warnings/unused-vars/shadowed-variable-let-intermediate-use.sw +4/−0
• data/test/language-snippets/warnings/unused-vars/shadowed-variable-let-unused.sw +3/−0
• data/test/language-snippets/warnings/unused-vars/single-bind-unused.sw +2/−0
• data/test/language-snippets/warnings/unused-vars/single-bind-used.sw +2/−0
• editors/emacs/swarm-mode.el +14/−7
• editors/vscode/syntaxes/swarm.tmLanguage.json +3/−3
• example/BFS-clear.sw +1/−1
• example/list.sw +2/−2
• src/Data/BoolExpr.hs +337/−0
• src/Data/BoolExpr/Simplify.hs +57/−0
• src/Swarm/App.hs +21/−16
• src/Swarm/DocGen.hs +22/−24
• src/Swarm/Game/CESK.hs +105/−96
• src/Swarm/Game/Display.hs +8/−8
• src/Swarm/Game/Entity.hs +62/−42
• src/Swarm/Game/Exception.hs +31/−31
• src/Swarm/Game/Log.hs +74/−0
• src/Swarm/Game/Recipe.hs +4/−6
• src/Swarm/Game/Robot.hs +58/−79
• src/Swarm/Game/Scenario.hs +22/−173
• src/Swarm/Game/Scenario/Cell.hs +62/−0
• src/Swarm/Game/Scenario/Objective.hs +195/−0
• src/Swarm/Game/Scenario/Objective/Graph.hs +144/−0
• src/Swarm/Game/Scenario/Objective/Logic.hs +46/−0
• src/Swarm/Game/Scenario/Objective/Presentation/Model.hs +117/−0
• src/Swarm/Game/Scenario/Objective/Presentation/Render.hs +91/−0
• src/Swarm/Game/Scenario/Objective/Validation.hs +50/−0
• src/Swarm/Game/Scenario/Objective/WinCheck.hs +83/−0
• src/Swarm/Game/Scenario/RobotLookup.hs +51/−0
• src/Swarm/Game/Scenario/Style.hs +37/−0
• src/Swarm/Game/Scenario/WorldDescription.hs +64/−0
• src/Swarm/Game/ScenarioInfo.hs +39/−23
• src/Swarm/Game/State.hs +91/−42
• src/Swarm/Game/Step.hs +465/−229
• src/Swarm/Game/Value.hs +0/−117
• src/Swarm/Game/World.hs +36/−13
• src/Swarm/Game/WorldGen.hs +6/−6
• src/Swarm/Language/Capability.hs +23/−10
• src/Swarm/Language/Context.hs +0/−1
• src/Swarm/Language/Elaborate.hs +39/−26
• src/Swarm/Language/LSP.hs +74/−27
• src/Swarm/Language/LSP/Hover.hs +260/−0
• src/Swarm/Language/LSP/VarUsage.hs +108/−0
• src/Swarm/Language/Module.hs +51/−0
• src/Swarm/Language/Parse.hs +55/−38
• src/Swarm/Language/Pipeline.hs +14/−11
• src/Swarm/Language/Pipeline/QQ.hs +2/−1
• src/Swarm/Language/Pretty.hs +7/−4
• src/Swarm/Language/Requirement.hs +6/−5
• src/Swarm/Language/Syntax.hs +420/−215
• src/Swarm/Language/Typecheck.hs +169/−126
• src/Swarm/Language/Types.hs +11/−42
• src/Swarm/Language/Value.hs +122/−0
• src/Swarm/TUI/Attr.hs +8/−2
• src/Swarm/TUI/Controller.hs +341/−153
• src/Swarm/TUI/Controller/Util.hs +53/−0
• src/Swarm/TUI/Model.hs +50/−729
• src/Swarm/TUI/Model/Achievement/Attainment.hs +47/−0
• src/Swarm/TUI/Model/Achievement/Definitions.hs +89/−0
• src/Swarm/TUI/Model/Achievement/Description.hs +70/−0
• src/Swarm/TUI/Model/Achievement/Persistence.hs +58/−0
• src/Swarm/TUI/Model/Failure.hs +51/−0
• src/Swarm/TUI/Model/Menu.hs +129/−0
• src/Swarm/TUI/Model/Name.hs +57/−0
• src/Swarm/TUI/Model/Repl.hs +266/−0
• src/Swarm/TUI/Model/StateUpdate.hs +158/−0
• src/Swarm/TUI/Model/UI.hs +312/−0
• src/Swarm/TUI/View.hs +200/−258
• src/Swarm/TUI/View/Achievement.hs +103/−0
• src/Swarm/TUI/View/CellDisplay.hs +59/−0
• src/Swarm/TUI/View/CustomStyling.hs +37/−0
• src/Swarm/TUI/View/Util.hs +159/−0
• src/Swarm/Util.hs +71/−43
• src/Swarm/Util/Location.hs +59/−0
• src/Swarm/Web.hs +58/−12
• swarm.cabal +66/−30
• test/integration/Main.hs +106/−45
• test/unit/Main.hs +4/−0
• test/unit/TestBoolExpr.hs +103/−0
• test/unit/TestEval.hs +24/−2
• test/unit/TestLSP.hs +88/−0
• test/unit/TestLanguagePipeline.hs +41/−2
• test/unit/TestNotification.hs +1/−1
• test/unit/TestPretty.hs +8/−3
• test/unit/TestUtil.hs +1/−1

@@ -1,5 +1,83 @@ # Revision history for swarm +## **0.3.0.0** - 2023-01-30++This is the first release of 2023! It contains:+- various new features and bugfixes (see subsections below)+- UI tweaks+- fewer typos (thanks @bwignall and @kostmo)+- upgraded dependencies (`>=lsp-1.6` and `>=brick-1.5`) and raised Stack resolver to use GHC 9.4 [#1001](https://github.com/swarm-game/swarm/pull/1001)+- a ton of internal refactoring++### Fixed bugs+* copy parent robot context to child when executing `build` by @byorgey in [#817](https://github.com/swarm-game/swarm/pull/817)+* Merge new requirements context with existing when running from REPL by @byorgey in [#965](https://github.com/swarm-game/swarm/pull/965)+* Reset `lastFrameTime` when starting a new scenario by @byorgey in [#855](https://github.com/swarm-game/swarm/pull/855)+* Fix capability checking, and refactor/add lots of comments by @byorgey in [#959](https://github.com/swarm-game/swarm/pull/959)+* Fix `EntityMap` merging by @byorgey in [#962](https://github.com/swarm-game/swarm/pull/962)+* Fix: add first heard message to log by @xsebek in [#842](https://github.com/swarm-game/swarm/pull/842)+* Fix hypothetical result of condition by @xsebek in [#940](https://github.com/swarm-game/swarm/pull/940)+* One file per achievement record by @kostmo in [#954](https://github.com/swarm-game/swarm/pull/954)+* Show duplicate robot logs by @xsebek in [#1022](https://github.com/swarm-game/swarm/pull/1022)+* Copy requirements map to robot context when loading a new `ProcessedTerm` by @byorgey in [#827](https://github.com/swarm-game/swarm/pull/827)+* Set REPL to `Working` when base has `program` field specified by @byorgey in [#846](https://github.com/swarm-game/swarm/pull/846)+* Create swarm subdirectories as necessary by @xsebek in [#943](https://github.com/swarm-game/swarm/pull/943)++### New Features++#### Swarm language+* implement Equip/Unequip by @kostmo in [#887](https://github.com/swarm-game/swarm/pull/887)+  * The great `install`/`equip` switch by @byorgey in [#989](https://github.com/swarm-game/swarm/pull/989)+* Meeting other robots by @byorgey in [#920](https://github.com/swarm-game/swarm/pull/920)+* New `heading` command by @byorgey in [#955](https://github.com/swarm-game/swarm/pull/955)+* Add `isempty : cmd bool` to check whether current cell has an entity by @byorgey in [#968](https://github.com/swarm-game/swarm/pull/968)++#### Entities+* Add `GPS receiver` device to provide `senseloc` capability by @byorgey in [#956](https://github.com/swarm-game/swarm/pull/956)+* Device with recipe for 'appear' capability by @kostmo in [#1027](https://github.com/swarm-game/swarm/pull/1027)+* device for setname by @kostmo in [#1028](https://github.com/swarm-game/swarm/pull/1028)++#### LSP improvements+* swarm-lang IDE hover by @kostmo in [#972](https://github.com/swarm-game/swarm/pull/972)+* Include `SrcLoc` info with variable binding sites by @byorgey in [#993](https://github.com/swarm-game/swarm/pull/993)+* Annotate ASTs with types at every node by @byorgey in [#991](https://github.com/swarm-game/swarm/pull/991)+* Improve OnHover for Def/Let, App and Const by @xsebek in [#986](https://github.com/swarm-game/swarm/pull/986)+* warn of unused variables by @kostmo in [#983](https://github.com/swarm-game/swarm/pull/983)++#### Web API+* Expose REPL history via web interface by @kostmo in [#821](https://github.com/swarm-game/swarm/pull/821)++#### Command line options+* Add full color mode option by @xsebek in [#851](https://github.com/swarm-game/swarm/pull/851)++#### New scenarios+* New ranching scenario by @kostmo in [#835](https://github.com/swarm-game/swarm/pull/835)+* new bind tutorial by @kostmo in [#895](https://github.com/swarm-game/swarm/pull/895)+* A "bucket brigade" of robots by @kostmo in [#885](https://github.com/swarm-game/swarm/pull/885)+* Ice Cream Shop by @kostmo in [#1008](https://github.com/swarm-game/swarm/pull/1008)+* word search by @kostmo in [#999](https://github.com/swarm-game/swarm/pull/999)+* Wolf, Goat, Cabbage scenario by @kostmo in [#944](https://github.com/swarm-game/swarm/pull/944)+* swarm logo animation by @kostmo in [#1018](https://github.com/swarm-game/swarm/pull/1018)++#### Scenario development+* Boolean expressions of objective prerequisites by @kostmo in [#927](https://github.com/swarm-game/swarm/pull/927)+* support 'orientationMap' by @kostmo in [#1023](https://github.com/swarm-game/swarm/pull/1023)+* support custom attributes defined in scenarios by @kostmo in [#1058](https://github.com/swarm-game/swarm/pull/1058)++#### UI enhancements+* show devices that enable commands by @kostmo in [#899](https://github.com/swarm-game/swarm/pull/899)+* Add a "driving mode" to the REPL by @kostmo in [#819](https://github.com/swarm-game/swarm/pull/819)++#### Achievements+* achievements board by @kostmo in [#796](https://github.com/swarm-game/swarm/pull/796)+* first tutorial completion achievement by @kostmo in [#925](https://github.com/swarm-game/swarm/pull/925)+* Add achievement for losing by @kostmo in [#945](https://github.com/swarm-game/swarm/pull/945)++#### Debugging+* Better CESK machine pretty-printing by @byorgey in [#948](https://github.com/swarm-game/swarm/pull/948)+* Add the full expected location for the data directory by @TristanCacqueray in [#908](https://github.com/swarm-game/swarm/pull/908)+* Extend logs for warnings by @xsebek in [#982](https://github.com/swarm-game/swarm/pull/982)+ ## **0.2.0.0** - 2022-11-01  A bunch of small fixes and improvements; special thanks to new

@@ -1,3 +1,4 @@+{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} @@ -14,11 +15,12 @@ import Swarm.DocGen (EditorType (..), GenerateDocs (..), PageAddress (..), SheetType (..), generateDocs) import Swarm.Language.LSP (lspMain) import Swarm.Language.Pipeline (processTerm)-import Swarm.TUI.Model (AppOpts (..))+import Swarm.TUI.Model (AppOpts (..), ColorMode (..)) import Swarm.Version import Swarm.Web (defaultPort) import System.Exit (exitFailure, exitSuccess) import System.IO (hPrint, stderr)+import Text.Read (readMaybe)  gitInfo :: Maybe GitInfo gitInfo = either (const Nothing) Just ($$tGitInfoCwdTry)@@ -45,7 +47,17 @@         , command "version" (info (pure Version) (progDesc "Get current and upstream version."))         ]     )-    <|> Run <$> (AppOpts <$> seed <*> scenario <*> run <*> autoplay <*> cheat <*> webPort <*> pure gitInfo)+    <|> Run+      <$> ( AppOpts+              <$> seed+              <*> scenario+              <*> run+              <*> autoplay+              <*> cheat+              <*> color+              <*> webPort+              <*> pure gitInfo+          )  where   format :: Parser CLI   format =@@ -98,13 +110,24 @@             <> help ("Set the web service port (or disable it with 0). Default to " <> show defaultPort <> ".")         )   scenario :: Parser (Maybe String)-  scenario = optional $ strOption (long "scenario" <> short 'c' <> metavar "FILE" <> help "Name of a scenario to load")+  scenario = optional $ strOption (long "scenario" <> short 'i' <> metavar "FILE" <> help "Name of an input scenario to load")   run :: Parser (Maybe String)   run = optional $ strOption (long "run" <> short 'r' <> metavar "FILE" <> help "Run the commands in a file at startup")   autoplay :: Parser Bool   autoplay = switch (long "autoplay" <> short 'a' <> help "Automatically run the solution defined in the scenario, if there is one. Mutually exclusive with --run.")   cheat :: Parser Bool   cheat = switch (long "cheat" <> short 'x' <> help "Enable cheat mode. This allows toggling Creative Mode with Ctrl+v and unlocks \"Testing\" scenarios in the menu.")+  color :: Parser (Maybe ColorMode)+  color = optional $ option colorModeParser (long "color" <> short 'c' <> metavar "MODE" <> help "Use none/8/16/full color mode.")+  colorModeParser =+    Data.Foldable.asum+      [ ColorMode8 <$ text "8"+      , ColorMode16 <$ text "16"+      , ColorMode240 <$> maybeReader (\case ('2' : '4' : '0' : '_' : w) -> readMaybe w; _ -> Nothing)+      , FullColor <$ text "full"+      , NoColor <$ text "none"+      ]+  text t = maybeReader (\x -> if x == t then Just x else Nothing)  cliInfo :: ParserInfo CLI cliInfo =

@@ -9,8 +9,6 @@ import Control.Monad.State (evalStateT, execStateT) import Criterion.Main (Benchmark, bench, bgroup, defaultConfig, defaultMainWith, whnfAppIO) import Criterion.Types (Config (timeLimit))-import Data.Int (Int64)-import Linear.V2 (V2 (V2)) import Swarm.Game.CESK (emptyStore, initMachine) import Swarm.Game.Display (defaultRobotDisplay) import Swarm.Game.Robot (TRobot, mkRobot)@@ -22,13 +20,14 @@ import Swarm.Language.Pipeline (ProcessedTerm) import Swarm.Language.Pipeline.QQ (tmQ) import Swarm.Language.Syntax (north)+import Swarm.Util.Location  -- | The program of a robot that does nothing. idleProgram :: ProcessedTerm idleProgram = [tmQ| {} |]  -- | The program of a robot which waits a random number of ticks, changes its---   appearence, then waits another random number of ticks, places a tree, and+--   appearance, then waits another random number of ticks, places a tree, and --   then self-destructs. treeProgram :: ProcessedTerm treeProgram =@@ -70,14 +69,14 @@   |]  -- | Initializes a robot with program prog at location loc facing north.-initRobot :: ProcessedTerm -> V2 Int64 -> TRobot-initRobot prog loc = mkRobot () Nothing "" [] (Just north) loc defaultRobotDisplay (initMachine prog Context.empty emptyStore) [] [] False False 0+initRobot :: ProcessedTerm -> Location -> TRobot+initRobot prog loc = mkRobot () Nothing "" [] (Just loc) north defaultRobotDisplay (initMachine prog Context.empty emptyStore) [] [] False False 0  -- | Creates a GameState with numRobot copies of robot on a blank map, aligned --   in a row starting at (0,0) and spreading east.-mkGameState :: (V2 Int64 -> TRobot) -> Int -> IO GameState+mkGameState :: (Location -> TRobot) -> Int -> IO GameState mkGameState robotMaker numRobots = do-  let robots = [robotMaker (V2 (fromIntegral x) 0) | x <- [0 .. numRobots - 1]]+  let robots = [robotMaker (Location (fromIntegral x) 0) | x <- [0 .. numRobots - 1]]   Right initState <- runExceptT classicGame0   execStateT     (mapM addTRobot robots)

@@ -74,6 +74,16 @@     Can be used to build a simple furnace, among other things.   properties: [portable] +- name: handle+  display:+    attr: device+    char: 'h'+  description:+  - Ergonomic affordance for manipulating objects. Also grants the "setname" capability, allowing one+    to assign a "handle" to robots.+  properties: [portable]+  capabilities: [setname]+ - name: lodestone   display:     attr: iron@@ -84,6 +94,15 @@   properties: [portable]   capabilities: [negation] +- name: beaglepuss+  display:+    attr: rubber+    char: 'B'+  description:+  - Iconic novelty disguise. Renders one either completely inconspicuous, or the opposite.+  properties: [portable]+  capabilities: [appear]+ - name: boulder   display:     attr: rock@@ -106,7 +125,7 @@     char: 'Å'     priority: 11   description:-  - A tunnel in a mountain through which robots can freely move.+  - A tunnel in a mountain through which anything can freely move.   properties: []  - name: copper ore@@ -326,15 +345,43 @@     information, made of twisted cotton fibers.  Multiple strings can     also be woven into larger configurations such as cloth or nets.   - |-    A string device enables two commands: the first, `format : a ->-    text`, can turn any value into a suitable text representation.-    The second is the infix operator `++ : text -> text -> text`-    which can be used to concatenate two text values.  For example,+    An equipped `string` device enables several commands for working with+    `text` values:   - |+    `format : a -> text` can turn any value into a suitable text+    representation.+  - |+    The infix operator `++ : text -> text -> text`+    can be used to concatenate two text values.  For example,+  - |     "Number of widgets: " ++ format numWidgets+  - |+    `chars : text -> int` computes the number of characters in a+    `text` value.+  - |+    `split : int -> text -> text * text` splits a `text` value into+    two pieces, one before the given index and one after.   properties: [portable]   capabilities: [text] +- name: decoder ring+  display:+    attr: silver+    char: 'O'+  description:+  - |+    A handy lookup table for converting from characters to numeric codes and+    back, shaped for some reason into a ring.  When equipped, it+    enables two functions:+  - |+    `charAt : int -> text -> int` returns the numeric code of the+    character at a specific index in a (0-indexed) `text` value.+  - |+    `toChar : int -> text` creates a singleton (length-1) `text`+    value containing a character with the given numeric code.+  properties: [portable]+  capabilities: [code]+ - name: lambda   display:     attr: flower@@ -379,11 +426,11 @@     attr: wood     char: 'B'   description:-  - A robot with a boat installed can float on top of water without drowning.+  - A robot with a boat equipped can float on top of water without drowning.   - |-    Note: most devices are automatically installed on robots that+    Note: most devices are automatically equipped on robots that     will require them; but this doesn't work in the case of boats since floating is not-    associated with any particular command.  To manually ensure a boat is installed on+    associated with any particular command.  To manually ensure a boat is equipped on     a robot, just add the special command `require "boat"` to the robot's program.   properties: [portable]   capabilities: [float]@@ -645,7 +692,7 @@     attr: device     char: '%'   description:-  - Installing treads on a robot allows it to move and turn.+  - Equipping treads on a robot allows it to move and turn.   - The `move` command moves the robot forward one unit.   - 'Example:'   - '  move; move; // move two units'@@ -673,8 +720,8 @@     char: '<'   description:   - A grabber arm is an all-purpose, hydraulically controlled device that can-    manipulate other items and robots via the `grab`, `place`, `give`,-    and `install` commands.+    manipulate other items and robots via the `grab`, `place`, and `give`+    commands.   - The `grab` command takes no arguments; it simply grabs whatever is     available, and also returns the name of the grabbed thing as a string.     It raises an exception if run in a cell that does not contain an item.@@ -682,13 +729,10 @@     place.  The item is removed from the robot's inventory and placed     in the robot's current cell (which must be empty).  Raises an     exception if the operation fails.-  - "The `give` command takes two arguments: the robot to+  - "The `give` command takes two arguments: the actor to     give an item to (which can be at most 1 cell away), and the name     of the item to give. Raises an exception if the operation fails."-  - "The `install` command takes two arguments: the robot-    on which to install a device (which can be at most 1 cell away),-    and the name of the device to install."-  capabilities: [grab, give, place, install]+  capabilities: [grab, give, place]   properties: [portable]  - name: fast grabber@@ -697,7 +741,7 @@     char: '≪'   description:   - A fast grabber is an improved version of the basic grabber - not only-    can it 'grab', 'place', 'give', and 'install', it can also 'swap'.+    can it 'grab', 'place', and 'give', it can also 'swap'.   - The 'swap' command allows the robot to execute grab and place at the     same time so that the location where the robot is standing does not     become empty.@@ -706,9 +750,26 @@   - In addition you retain the capability to use the 'atomic' command,     with which you can implement other commands that are safe when     run in parallel.-  capabilities: [grab, swap, give, place, install, atomic]+  capabilities: [grab, swap, give, place, atomic]   properties: [portable] +- name: welder+  display:+    attr: device+    char: 'f'+  description:+  - |+    A welder can be used to affix other gadgets to one's robot, providing+    the `equip` and `unequip` commands.+  - |+    The `equip` command takes one argument: the name of the device to equip.+    Raises an exception if the device is not in your inventory.+  - |+    The `unequip` command takes one argument: the name of the device to unequip.+    Raises an exception if the device is not equipped.+  capabilities: [equip, unequip]+  properties: [portable]+ - name: harvester   display:     attr: device@@ -869,9 +930,13 @@     about their surroundings.  Simply give `scan` a direction in which to scan,     and information about the scanned item (if any) will be added to the robot's     inventory."-  - "A scanner also enables the `blocked` command, which returns a+  - "A scanner also enables `blocked : cmd bool`, which returns a      boolean value indicating whether the robot's path is blocked-     (i.e. whether executing a `move` command would fail)."+     (i.e. whether executing a `move` command would fail);+     `ishere : text -> cmd bool` for checking whether the current+     cell contains a particular entity; and `isempty : cmd bool` for+     checking whether the current cell is empty of entities. Note that+     `ishere` and `isempty` do not detect robots, only entities."   - "Finally, robots can use the `upload` command to copy their accumulated     knowledge to another nearby robot; for example, `upload base`."   properties: [portable]@@ -921,10 +986,10 @@     attr: device     char: '@'   description:-  - "Allows a robot to hear what nearby robots are saying."-  - "Simply having this device installed will automatically-     add messages said by nearby robots to this robot's log,-     assuming it has a logger installed."+  - "Allows a robot to hear anything being said nearby."+  - "Simply having this device equipped will automatically+     add messages said by nearby actors to this robot's log,+     assuming it has a logger equipped."   - "That way you can view any heard message later either in      the logger or the message window."   - "To wait for a message and get the string value, use:"@@ -996,9 +1061,16 @@     attr: device     char: 'N'   description:-  - "A compass gives a robot the ability to orient using cardinal directions: north, south, west, and east."-  - "Example:"-  - "turn west; move; turn north"+  - |+    A compass gives a robot the ability to orient using the cardinal+    directions north, south, west, and east; for example, `turn west;+    move; turn north`.+  - |+    It also enables the `heading : cmd dir` command, which returns the+    robot's current heading. For example, the following code moves+    east and then restores the same heading as before:+  - |+    d <- heading; turn east; move; turn d   properties: [portable]   capabilities: [orient] @@ -1031,7 +1103,7 @@     attr: device     char: 'Ю'   description:-  - An I/O cable can be used to communicate with an adjacent robot.+  - An I/O cable can be used to communicate with adjacent actors.   properties: [portable]  - name: rubber band@@ -1048,7 +1120,7 @@   - "This seems like a safe way to execute `grab` only when there is a     rock to grab.  However, it is actually possible for the `grab` to     fail, if some other robot B snatches the rock right after robot A sensed-    it and before robot A got around to grab it on the next game tick."+    it and before robot A got around to grabbing it on the next game tick."   - "This will make robot A very sad and it will crash."   - "To prevent this situation, robot A can wrap the commands in `atomic`, like so:"   - |@@ -1063,9 +1135,46 @@     char: '#'   description:   - A net is a device woven out of many strings.  With a net-    installed, you can use the `try` command to catch errors. For example,+    equipped, you can use the `try` command to catch errors. For example,   - |     `try {move} {turn left}`   - will attempt to move, but if that fails, turn left instead.   properties: [portable]   capabilities: [try]++- name: antenna+  display:+    attr: silver+    char: 'Y'+  description:+  - A device for transforming electric current into radio waves, and+    vice versa.+  - |+    It can be used to locate nearby actors, by bouncing radio+    waves off them and listening for the echo.  This capability can be+    accessed via two commands:+  - |+    `meet : cmd (() + actor)` tries to locate a+    nearby actor (a robot, or... something else?) up to one cell away.+    It returns a reference to the nearest actor, or a unit value if+    none are found.+  - |+    `meetAll : (b -> actor -> cmd b) -> b -> cmd b` runs a command on+    every nearby actor (other than oneself), folding over the results+    to compute a final result of type `b`.  For example, if `x`, `y`,+    and `z` are nearby actors, then `meetAll f b0` is equivalent to+    `b1 <- f b0 x; b2 <- f b1 y; f b2 z`.+  properties: [portable]+  capabilities: [meet]++- name: GPS receiver+  display:+    attr: device+    char: 'G'+  description:+  - |+    A GPS receiver triangulates your current (x,y) coordinates from+    some convenient satellite signals,+    enabling the command `whereami : cmd (int * int)`.+  properties: [portable]+  capabilities: [senseloc]

@@ -459,6 +459,8 @@   - [4, big motor]   - [64, iron plate]   - [16, rubber]+  required:+  - [1, welder]   out:   - [1, tank treads] @@ -478,6 +480,21 @@   - [1, fast grabber]  - in:+  - [2, copper wire]+  - [1, copper pipe]+  - [1, iron plate]+  - [1, I/O cable]+  out:+  - [1, welder]++- in:+  - [1, copper pipe]+  out:+  - [1, handle]+  required:+  - [1, welder]++- in:   - [4, circuit]   - [1, iron plate]   - [3, copper pipe]@@ -508,6 +525,20 @@   out:   - [1, bitcoin] +- in:+  - [2, silver]+  - [2, copper wire]+  out:+  - [1, antenna]++- in:+  - [1, antenna]+  - [1, clock]+  - [1, circuit]+  - [1, compass]+  out:+  - [1, GPS receiver]+ ## MAGIC  - in:@@ -703,6 +734,13 @@   - [1, strange loop]   out:   - [1, rubber band]++- in:+  - [1, rubber]+  - [1, glass]+  - [1, string]+  out:+  - [1, beaglepuss]  ######################################### ##                COTTON               ##

@@ -1,5 +1,11 @@ chess_horse.yaml teleport.yaml 2048.yaml+word-search.yaml+ice-cream.yaml hanoi.yaml+bucket-brigade.yaml+wolf-goat-cabbage.yaml+friend.yaml Mazes+Ranching

@@ -15,7 +15,6 @@   def until = \p. \c. b <- p; if b {} {c; until p c} end;   def fwd = until blocked move end;   build {-    require "branch predictor"; // #540     turn east;     until (ishere "goal") (fwd; turn right; fwd; turn left);     grab

@@ -16,7 +16,6 @@   def until = \p. \c. b <- p; if b {} {c; until p c} end;   def fwd = until blocked move end;   build {-    require "branch predictor"; // #540     turn west;     until (ishere "goal") (fwd; turn right);     grab

@@ -25,9 +25,6 @@   def rightBlocked = tR; b <- blocked; tL; return b end;   def mazeStep = ifC rightBlocked {ifC blocked {tL} {move}} {tR; move} end;   build {-    require "treads"; require "branch predictor"; require "lambda";-    require "strange loop"; require "scanner"; require "grabber";   // #540-     forever (mazeStep; ifC (ishere "goal") {grab; return ()} {})   } robots:

@@ -14,9 +14,5 @@   tB; move; tB end; build {-  require "treads"; require "scanner"; require "lambda";-  require "strange loop"; require "branch predictor";-  require "grabber";  // #540-   require 500 "rock"; DFS }

@@ -0,0 +1,1 @@+gated-paddock.yaml

@@ -0,0 +1,255 @@+// Algorithm:+// ----------+// Maintain current direction until a wall is encountered.+// Then enter "wall-following mode".+// This mode presumes the wall is not a loop.+// Wall-following mode exploits recursion to keep track of how many left turns were made+// and then unwinds them again by ensuring each is paired with a right turn.+// Once the recursion is fully unwound, the robot proceeds along its original direction+// (though it may now be laterally displaced).+//+// (If it was a loop, then an "oriented breadcrumb" would need to be left.+// The breadcrumb is oriented in case a single-width passage is backtracked+// along the opposite wall.)++/** A "gate" is walkable, so we need to supplement the "blocked" check with this function.+Since fences are "unwalkable", they do not need to be mentioned in this function.+*/+def isFenced =+    s <- scan forward;+    return (+        case s+            (\_. false)+            (\x. x == "gate")+    );+    end;++def isBlockedOrFenced =+    b <- blocked;+    f <- isFenced;+    return (b || f);+    end;++// Returns true if we've already placed two+// breadcrumbs on a given tile, false otherwise.+def leaveBreadcrumbs =+    +    let bc1 = "fresh breadcrumb" in+    let bc2 = "treaded breadcrumb" in++    wasTraversedOnce <- ishere bc1;+    if wasTraversedOnce {+        _crumb <- grab;+        make bc2;+        place bc2;+        return false;+    } {+        wasTraversedTwice <- ishere bc2;+        if wasTraversedTwice {+            return true;+        } {+            // Make sure nothing's in the way before we place+            // our breadcrumb:+            x <- scan down;+            case x return (\y.+                // If we're on a water tile, get rid of+                // it with our special "drilling" recipe+                if (y == "water") {+                    drill down;+                    // Nothing will remain on the ground.+                    // after making the "steam" via+                    // the drilling recipe.+                } {+                    grab;+                    return ();+                };+            );++            make bc1;+            place bc1;+            return false;+        };+    };+    end;++def goForwardToPatrol = \wasBlocked.+    b <- isBlockedOrFenced;+    if b {+        turn left;+        goForwardToPatrol true;+        turn right;+        goForwardToPatrol false;+    } {+        if wasBlocked {+            isLoop <- leaveBreadcrumbs;+            if isLoop {+                fail "loop";+            } {};+        } {};+        move;+    };+    end;++/**+There should only be one place in the+code where an exception is thrown: that is,+if a treaded breadcrumb is encountered.+*/+def checkIsEnclosedInner =+    try {+        goForwardToPatrol false;+        // Water is the outer boundary+        hasWater <- ishere "water";+        if hasWater {+            return false;+        } {+            checkIsEnclosedInner;+        };+    } {+        return true;+    };+    end;++def checkIsEnclosed =++    // The "evaporator" drill is used+    // to clear water tiles.+    let specialDrill = "evaporator" in+    create specialDrill;+    equip specialDrill;++    // NOTE: System robots can walk on water+    // so we only need this if we want to+    // demo the algorithm with a player robot.+//    create "boat";+//    equip "boat";++    checkIsEnclosedInner;+    end;++def boolToInt = \b. if (b) {return 1} {return 0}; end;++def countAdjacentBlockages =++    turn left;+    b1 <- isBlockedOrFenced;+    c1 <- boolToInt b1;++    turn left;+    b2 <- isBlockedOrFenced;+    c2 <- boolToInt b2;++    turn left;+    b3 <- isBlockedOrFenced;+    c3 <- boolToInt b3;++    turn left;+    b4 <- isBlockedOrFenced;+    c4 <- boolToInt b4;++    return $ c1 + c2 + c3 + c4;+    end;++// Step forward, observing left and right.+def observeLeftAndRight =+    move;+    turn left;+    amBlockedLeft <- isBlockedOrFenced;+    val1 <- boolToInt amBlockedLeft;++    turn back;+    amBlockedRight <- isBlockedOrFenced;+    val2 <- boolToInt amBlockedRight;++    turn right;+    move;+    return $ val1 + val2;+    end;+++/** If the four cardinal directions have at most+one blockage, then there will exist an orientation+where both that direction and its opposite direction+are clear.+So we can step that direction, check to the left and+right of us, then step in the opposite direction+and do the same. This allows us to check the 4+blocks that touch the corners of the center block.+*/+def countDiagonalBlockages =+    // First, orient to the clear front-to-back path+    amBlocked <- isBlockedOrFenced;+    if amBlocked {turn left;} {};++    // Second, step to both sides+    fwdCount <- observeLeftAndRight;+    backCount <- observeLeftAndRight;+    return $ fwdCount + backCount;+    end;++def isStandingOnBridge =+    onFence <- ishere "fence";+    onGate <- ishere "gate";+    if (onFence || onGate) {+        adjCount <- countAdjacentBlockages;+        if (adjCount > 1) {+            return true;+        } {+            diagCount <- countDiagonalBlockages;+            return $ (adjCount + diagCount) > 1;+        };+    } {return false};+    end;++def getValForSheepIndex = \predicateCmd. \i.+    try {+        // This will throw an exception if+        // the sheep has already drowned.+        r <- robotnumbered i;+        didSucceed <- as r {predicateCmd};++        boolToInt didSucceed;+    } {+        return 0;+    }+    end;++/**+There are 3 sheep.+They have indices 1, 2, 3.+(The base has index 0).++THIS DOES NOT WORK!+*/+def countSheepWithRecursive = \predicateCmd. \i.++    if (i > 0) {+        val <- getValForSheepIndex predicateCmd i;+        recursiveCount <- countSheepWithRecursive predicateCmd $ i - 1;+        return $ val + recursiveCount;+    } {+        return 0;+    }+    end;+++def countSheepWith = \predicateCmd.++    val1 <- getValForSheepIndex predicateCmd 1;+    val2 <- getValForSheepIndex predicateCmd 2;+    val3 <- getValForSheepIndex predicateCmd 3;+    return $ val1 + val2 + val3;++    end;+++justFilledGap <- as base {+    isStandingOnBridge;+};++if (justFilledGap) {+    enclosedCount <- countSheepWith checkIsEnclosed;+    return $ enclosedCount >= 1;+} {+    return false;+}

@@ -0,0 +1,217 @@+def doN = \n. \f. if (n > 0) {f; doN (n - 1) f} {}; end;++def processTree =+    grab;+    fenceCount <- count "fence";+    if (fenceCount < 90) {+        make "log";+        make "board";+        doN 2 $ make "fence";+    } {};+    end;++def makeHarvester =+    doN 3 $ make "log";+    doN 3 $ make "board";+    make "box";+    doN 2 $ make "wooden gear";+    make "harvester";+    equip "harvester";+    end;++def grabTwoRows =+    doN 7 (processTree; move);+    processTree;+    turn right;+    move;+    turn right;++    doN 7 (processTree; move);+    processTree;+    end;+++def grabTrees =+    doN 7 move;+    turn right;++    grabTwoRows;++    turn left;+    move;+    turn left;++    grabTwoRows;++    turn left;+    move;+    turn left;++    grabTwoRows;++    end;+++def harvestIfClover =+    x <- scan down;+    case x return (\y.+        if (y == "clover") {+            harvest;+            return ();+        } {};+    );+    end;+++def buildFence =+    doN 6 move;+    turn right;+    doN 4 (place "fence"; move);+    turn left;+    doN 30 (place "fence"; move);+    turn left;+    doN 15 (place "fence"; move);+    turn left;+    doN 30 (place "fence"; move);+    turn left;+    doN 10 (place "fence"; move);+    make "gate";+    place "gate";+    turn right;+    end;++def gatherClover =+    doN 8 move;+    turn left;+    doN 8 move;+    turn left;++    doN 19 (harvestIfClover; move;);+    turn right;+    move;+    turn right;+    doN 19 (harvestIfClover; move;);+    turn right;+    end;++def plantCloverColumn = \direction. \extraStep.+    doN 6 (+        extraStep;+        harvest;+        move;+    );++    turn direction;+    move;+    turn direction;+    move;+    end;++def plantCloverField =+    doN 4 move;+    +    plantCloverColumn right $place "clover";+    plantCloverColumn left $ place "clover";+    plantCloverColumn right $ place "clover";+    plantCloverColumn left $ place "clover";+    plantCloverColumn right $ place "clover";+    end;+++def harvestCloverField =+    doN 5 move;+    turn right;+    doN 5 move;+    turn right;+    wait 200;+    +    plantCloverColumn right $ return ();+    plantCloverColumn left $ return ();+    plantCloverColumn right $ return ();+    plantCloverColumn left $ return ();+    plantCloverColumn right $ return ();+    end;+++def travelRow = \action.+    doN 28 (action; move);+    action;+    end;++def placeCloverRow =+    travelRow $ place "clover";+    end;+++def distributeCloverInPaddock =+    turn left;+    doN 4 move;+    placeCloverRow;+    turn left;+    doN 2 move;+    turn left;+    placeCloverRow;+    turn right;+    doN 2 move;+    turn right;+    placeCloverRow;+    turn left;+    doN 2 move;+    turn left;+    placeCloverRow;+    end;+++def pickupWool =+    x <- scan down;+    case x return (\y.+        if (y == "wool") {+            grab;+            return ();+        } {};+    );+    end;++def sweep2rows =+    travelRow pickupWool;+    turn right;+    move;+    turn right;+    travelRow pickupWool;+    turn left;+    move;+    turn left;+    end;+++def sweepAreaForWool =+    doN 5 sweep2rows;+    turn left;+    doN 10 move;+    turn right;++    woolCount <- count "wool";+    if (woolCount >= 3) {+        make "sweater";+    } {};++    end;++def collectWool =+    wait 500;++    turn back;++    let forever : cmd unit -> cmd unit = \c. c ; forever c in+    forever sweepAreaForWool;+    end;+++grabTrees;+makeHarvester;+buildFence;+gatherClover;+plantCloverField;+doN 3 harvestCloverField;+distributeCloverInPaddock;+collectWool;

@@ -0,0 +1,144 @@+// A "sheep" that wanders around randomly.++/** A "gate" is walkable, so we need to supplement the "blocked" check with this function.+Since fences are "unwalkable", they do not need to be mentioned in this function.+*/+def isFenced =+    s <- scan forward;+    return (+        case s+            (\_. false)+            (\x. x == "gate")+    );+    end;++def isBlockedOrFenced =+    b <- blocked;+    f <- isFenced;+    return (b || f);+    end;++def elif = \p.\t.\e. {if p t e} end;+++def turnToClover = \direction.++  x <- scan direction;+  case x (\_. return false;) (\y.+    if (y == "clover") {+      turn direction;+      return true;+    } {+      return false;+    };+  );+  end;+++/**+If there is adjacent clover,+turn that direction.+*/+def turnCloverDirection =++    foundN <- turnToClover north;+    if (foundN) {return true} {+      foundE <- turnToClover east;  +      if (foundE) {return true} {+        foundS <- turnToClover south;+        if (foundS) {return true} {+          turnToClover west;+        }+      }+    }+    end;++def decideDirection =++  let randdir : cmd dir =+    d <- random 4;+    return $ if (d == 0) {+        north+      } $ elif (d == 1) {+        east+      } $ elif (d == 2) {+        south+      } {+        west+      }+    in++  cloverCount <- count "clover";+  if (cloverCount > 4) {+    d <- randdir;+    turn d;+  } {+    nearClover <- turnCloverDirection;+    if (nearClover) {} {+      d <- randdir;+      turn d;+    }+  }+  end;++let forever : cmd unit -> cmd unit = \c. c ; forever c in+let repeat : int -> cmd unit -> cmd unit =+  \n. \c. if (n == 0) {} {c ; repeat (n-1) c} in+++forever (+  n <- random 30;+  wait (30 + n);++  decideDirection;++  dist <- random 3;+  repeat dist (++    b <- isBlockedOrFenced;+    if b {} {+      move;+    };++    // Sheep can drown.+    hasWater <- ishere "water";+    if hasWater {+      say "The jolly jumbuck sprang into the billabong. \"You'll never catch me alive!\", said he.";+      selfdestruct;+    } {};++    // Eat clover.+    x <- scan down;+    case x return (\y.+        if (y == "clover") {+            harvest;+            cloverCount <- count "clover";+            if (cloverCount < 2) {+              say "yum!"+            } {};+        } {};+    );+  );+  r <- random 30;+  if (r == 0) { say "baaa" } {};++  hasClover <- has "clover";+  if (hasClover) {+    r <- random 8;+    if (r == 0) { +      let item = "wool" in+      hasWool <- has item;+      if (hasWool) {+        // Make sure nothing's in the way before we place+        // our wool:+        x <- scan down;+        case x return (\_.+          grab;+          return ();+        );++        place item;+      } {};+    } {};+  } {};+)

@@ -0,0 +1,543 @@+version: 1+name: Pastoral Island+author: Karl Ostmo+description: |+  Start a wool industry from the local fauna.+creative: false+objectives:+  - id: enclose_sheep+    teaser: Paddock sheep+    goal:+      - |+        You've homesteaded on a small island in the ocean.+        It's time to gather resources to trade.+      - |+        You encounter some feral sheep (@). They slowly wander the island and eat grass.+        Your mind wanders to textiles...+      - |+        First, paddock at least one sheep so they don't drown.+        Make sure there are no gaps in the fence!+      - |+        Note that you can use the "drill" command (by way of the "post puller" tool)+        to demolish a fence that has been "placed".+    condition: |-+      // Algorithm:+      // ----------+      // Maintain current direction until a wall is encountered.+      // Then enter "wall-following mode".+      // This mode presumes the wall is not a loop.+      // Wall-following mode exploits recursion to keep track of how many left turns were made+      // and then unwinds them again by ensuring each is paired with a right turn.+      // Once the recursion is fully unwound, the robot proceeds along its original direction+      // (though it may now be laterally displaced).+      //+      // (If it was a loop, then an "oriented breadcrumb" would need to be left.+      // The breadcrumb is oriented in case a single-width passage is backtracked+      // along the opposite wall.)++      /** A "gate" is walkable, so we need to supplement the "blocked" check with this function.+      Since fences are "unwalkable", they do not need to be mentioned in this function.+      */+      def isFenced =+          s <- scan forward;+          return (+              case s+                  (\_. false)+                  (\x. x == "gate")+          );+          end;++      def isBlockedOrFenced =+          b <- blocked;+          f <- isFenced;+          return (b || f);+          end;++      // Returns true if we've already placed two+      // breadcrumbs on a given tile, false otherwise.+      def leaveBreadcrumbs =++          let bc1 = "fresh breadcrumb" in+          let bc2 = "treaded breadcrumb" in++          wasTraversedOnce <- ishere bc1;+          if wasTraversedOnce {+              _crumb <- grab;+              make bc2;+              place bc2;+              return false;+          } {+              wasTraversedTwice <- ishere bc2;+              if wasTraversedTwice {+                  return true;+              } {+                  // Make sure nothing's in the way before we place+                  // our breadcrumb:+                  x <- scan down;+                  case x return (\y.+                      // If we're on a water tile, get rid of+                      // it with our special "drilling" recipe+                      if (y == "water") {+                          drill down;+                          // Nothing will remain on the ground.+                          // after making the "steam" via+                          // the drilling recipe.+                      } {+                          grab;+                          return ();+                      };+                  );++                  make bc1;+                  place bc1;+                  return false;+              };+          };+          end;++      def goForwardToPatrol = \wasBlocked.+          b <- isBlockedOrFenced;+          if b {+              turn left;+              goForwardToPatrol true;+              turn right;+              goForwardToPatrol false;+          } {+              if wasBlocked {+                  isLoop <- leaveBreadcrumbs;+                  if isLoop {+                      fail "loop";+                  } {};+              } {};+              move;+          };+          end;++      /**+      There should only be one place in the+      code where an exception is thrown: that is,+      if a treaded breadcrumb is encountered.+      */+      def checkIsEnclosedInner =+          try {+              goForwardToPatrol false;+              // Water is the outer boundary+              hasWater <- ishere "water";+              if hasWater {+                  return false;+              } {+                  checkIsEnclosedInner;+              };+          } {+              return true;+          };+          end;++      def checkIsEnclosed =++          // The "evaporator" drill is used+          // to clear water tiles.+          let specialDrill = "evaporator" in+          create specialDrill;+          equip specialDrill;++          // NOTE: System robots can walk on water+          // so we only need this if we want to+          // demo the algorithm with a player robot.+      //    create "boat";+      //    equip "boat";++          checkIsEnclosedInner;+          end;++      def boolToInt = \b. if (b) {return 1} {return 0}; end;++      def countAdjacentBlockages =++          turn left;+          b1 <- isBlockedOrFenced;+          c1 <- boolToInt b1;++          turn left;+          b2 <- isBlockedOrFenced;+          c2 <- boolToInt b2;++          turn left;+          b3 <- isBlockedOrFenced;+          c3 <- boolToInt b3;++          turn left;+          b4 <- isBlockedOrFenced;+          c4 <- boolToInt b4;++          return $ c1 + c2 + c3 + c4;+          end;++      // Step forward, observing left and right.+      def observeLeftAndRight =+          move;+          turn left;+          amBlockedLeft <- isBlockedOrFenced;+          val1 <- boolToInt amBlockedLeft;++          turn back;+          amBlockedRight <- isBlockedOrFenced;+          val2 <- boolToInt amBlockedRight;++          turn right;+          move;+          return $ val1 + val2;+          end;+++      /** If the four cardinal directions have at most+      one blockage, then there will exist an orientation+      where both that direction and its opposite direction+      are clear.+      So we can step that direction, check to the left and+      right of us, then step in the opposite direction+      and do the same. This allows us to check the 4+      blocks that touch the corners of the center block.+      */+      def countDiagonalBlockages =+          // First, orient to the clear front-to-back path+          amBlocked <- isBlockedOrFenced;+          if amBlocked {turn left;} {};++          // Second, step to both sides+          fwdCount <- observeLeftAndRight;+          backCount <- observeLeftAndRight;+          return $ fwdCount + backCount;+          end;++      def isStandingOnBridge =+          onFence <- ishere "fence";+          onGate <- ishere "gate";+          if (onFence || onGate) {+              adjCount <- countAdjacentBlockages;+              if (adjCount > 1) {+                  return true;+              } {+                  diagCount <- countDiagonalBlockages;+                  return $ (adjCount + diagCount) > 1;+              };+          } {return false};+          end;++      def getValForSheepIndex = \predicateCmd. \i.+          try {+              // This will throw an exception if+              // the sheep has already drowned.+              r <- robotnumbered i;+              didSucceed <- as r {predicateCmd};++              boolToInt didSucceed;+          } {+              return 0;+          }+          end;++      /**+      There are 3 sheep.+      They have indices 1, 2, 3.+      (The base has index 0).++      THIS DOES NOT WORK!+      */+      def countSheepWithRecursive = \predicateCmd. \i.++          if (i > 0) {+              val <- getValForSheepIndex predicateCmd i;+              recursiveCount <- countSheepWithRecursive predicateCmd $ i - 1;+              return $ val + recursiveCount;+          } {+              return 0;+          }+          end;+++      def countSheepWith = \predicateCmd.++          val1 <- getValForSheepIndex predicateCmd 1;+          val2 <- getValForSheepIndex predicateCmd 2;+          val3 <- getValForSheepIndex predicateCmd 3;+          return $ val1 + val2 + val3;++          end;+++      justFilledGap <- as base {+          isStandingOnBridge;+      };++      if (justFilledGap) {+          enclosedCount <- countSheepWith checkIsEnclosed;+          return $ enclosedCount >= 1;+      } {+          return false;+      }+  - id: feed_sheep+    teaser: Feed sheep+    goal:+      - |+        Safe! Your sheep are now hungry.+        Offer them something tasty and you may be rewarded.+      - |+        The sheep will move toward something edible on+        an adjacent tile and will eat it if they walk over it.+      - |+        You may want to add a gate to the fence+        to give yourself easier access.+    condition: |-+      def getTruthForSheepIndex = \predicateCmd. \i.+          try {+              // This will throw an exception if+              // the sheep has already drowned.+              r <- robotnumbered i;+              as r {predicateCmd};+          } {+              return false;+          };+          end;++      def anySheep = \predicateCmd. \i.++          if (i > 0) {+              didSucceed <- getTruthForSheepIndex predicateCmd i;+              if didSucceed {+                  return true;+              } {+                  anySheep predicateCmd $ i - 1;+              };+          } {+              return false;+          };+          end;++      anySheep (has "clover") 3;+    prerequisite: enclose_sheep+  - goal:+      - |+        Yum! Contented, well-fed sheep may drop wool.+      - |+        Winter is coming! Collect three wool bundles to make a sweater.+      - |+        Each sheep drops a finite amount over+        their lifetime.+    condition: |-+      as base {+        has "sweater";+      };+    prerequisite: feed_sheep+robots:+  - name: base+    dir: [0, 1]+    devices:+      - treads+      - scanner+      - dictionary+      - branch predictor+      - strange loop+      - clock+      - ADT calculator+      - comparator+      - workbench+      - grabber+      - welder+      - lambda+      - logger+      - hearing aid+      - counter+      - mirror+      - post puller+    inventory:+      - [0, fence]+      - [0, gate]+      - [10, hinge]+  - name: sheep+    description:+      - meandering livestock+    display:+      invisible: false+      char: '@'+    system: true+    dir: [0, 1]+    inventory:+      - [4, wool]+    program: |+      run "scenarios/Challenges/Ranching/_gated-paddock/meandering-sheep.sw";+entities:+  - name: fence+    display:+      char: '#'+    description:+      - Keeps sheep in. And some other things out.+    properties: [known, portable, unwalkable]+  - name: post puller+    display:+      char: 'P'+      attr: rock+    capabilities: [drill]+    description:+      - Good for dismantling fences.+    properties: [known, portable]+  - name: scrap wood+    display:+      char: '\'+    description:+      - Scrap wood. Can be reconditioned into boards.+    properties: [known, portable]+  - name: sweater+    display:+      attr: gold+      char: 'S'+    description:+      - A warm wool sweater. Just in time for winter!+    properties: [known, portable]+  - name: clover+    display:+      attr: flower+      char: '%'+    description:+      - A tasty stack for fluffy ruminants.+    properties: [portable, growable]+    growth: [80, 100]+  - name: gate+    display:+      char: '/'+      attr: rock+    description:+      - A gate permits the player to pass through, but sheep cannot.+    properties: [known]+  - name: hinge+    display:+      char: 'U'+      attr: rock+    description:+      - Facilitates swinging action.+    properties: [known, portable]+  - name: cabin+    display:+      char: Π+      attr: rock+    description:+      - Home sweet home.+    properties: [known, unwalkable]+  - name: pier+    display:+      char: 且+      attr: rock+    description:+      - Docking area for ships+    properties: [known]+  - name: fresh breadcrumb+    display:+      char: '.'+    description:+      - A marker that can be put down and found again. Used only by judge robot.+    properties: [portable]+  - name: treaded breadcrumb+    display:+      char: 'x'+    description:+      - A marker that can be put down and found again (for a second time). Used only by judge robot.+    properties: [portable]+  - name: evaporator+    display:+      char: 'E'+    description:+      - A tool that allows clearing a water tile. Used only by judge robot.+    properties: [portable]+    capabilities: [drill]+  - name: wool+    display:+      char: 'ω'+      attr: gold+    description:+      - A bundle of raw animal fiber.+    properties: [portable]+  - name: steam+    display:+      char: 'Z'+    description:+      - What's left after evaporating water. Used only by judge robot.+    properties: [portable]+recipes:+  - in:+      - [2, board]+    out:+      - [1, fence]+  - in:+      - [3, wool]+    out:+      - [1, sweater]+  - in:+      - [1, scrap wood]+    out:+      - [1, board]+  - in:+      - [0, fresh breadcrumb]+    out:+      - [1, fresh breadcrumb]+  - in:+      - [1, fresh breadcrumb]+    out:+      - [1, treaded breadcrumb]+  - in:+      - [1, fence]+    out:+      - [1, scrap wood]+    required:+      - [1, post puller]+  - in:+      - [1, water]+    out:+      - [1, steam]+    required:+      - [1, evaporator]+  - in:+      - [1, hinge]+      - [1, fence]+    out:+      - [1, gate]+known: [mountain, tree, water]+seed: 0+solution: |+  run "scenarios/Challenges/Ranching/_gated-paddock/fence-construction.sw"+world:+  default: [dirt, water]+  palette:+    'B': [grass, null, base]+    '.': [grass]+    't': [dirt, tree]+    'x': [stone, mountain]+    'c': [stone, cabin]+    's': [grass, null, sheep]+    '%': [grass, clover, null]+    'H': [stone, pier, null]+    '~': [dirt, water]+  upperleft: [-34, 11]+  map: |-+    ~~~~.......~~~~~~~~~~~~~.......................~~~~~~+    ~~.............~~~~.......%.%%%%%%..%%%%%.%.......~~~+    ~........................%%%%%%%%%%%%%..%%%%.......~~+    ~...................................................~+    .............................x.xx........tttttttt...~+    .........................................tttttttt...~+    ..........................xxxxx..........tttttttt...~+    .........................................tttttttt...~+    ...........s.............................tttttttt....+    ....x....................................tttttttt....+    ...xx................................................+    ..xx.....................................B......c....+    ...x.................................................+    ..............................s......................+    .....................................................+    ....................................................~+    ~..............s...................................~~+    ~~.......xxx...........x.........................~~~~+    ~~~............xx............x............~~~~H~~~~~~+    ~~~.....................................~~~~~~H~~~~~~+    ~~.....................................~~~~~~~H~~~~~~+    ~~..............................~~~~~~~~~~~~~~H~~~~~~+    ~~~~...................~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -0,0 +1,94 @@+def doN = \n. \f. if (n > 0) {f; doN (n - 1) f} {}; end;++def forever = \c. c; forever c; end;++def pollUntilHas = \item.+    itemInInventory <- has item;+    if itemInInventory {} {+        pollUntilHas item;+    };+    end;++def pollUntilCount = \targetCount. \item.+    itemCount <- count item;+    if (itemCount < targetCount) {+        pollUntilCount targetCount item;+    } {};+    end;++def waitToGiveUntilHas = \item. \recipient.+    pollUntilHas item;+    give recipient item;+    end;++/** The "depth" is the number of spaces between+the root robot and the target item.+It is one minus the distance to the target item.+*/+def recurseUntilDepth = \depth.+    let item = "coal lump" in+    child <- build {++        // NOTE: Treads are auto-equipped via the implicit "require"+        move;+        unequip "treads";++        pollUntilCount depth "repro kit";++        // Use the recipe from "repro kit"+        make "3D printer";++        equip "solar panel";+        equip "grabber";+        equip "3D printer";+        equip "dictionary";+        equip "branch predictor";+        equip "comparator";+        equip "calculator";+        equip "lambda";+        equip "strange loop";+        equip "string";+        equip "clock";+        equip "counter";+        equip "mirror";+        equip "scanner";+        equip "logger";+        equip "net";++        if (depth > 1) {+            recurseUntilDepth $ depth - 1;+            forever $ waitToGiveUntilHas item parent;+        } {+            make "bucketwheel excavator";+            forever (+                drill forward;+                give parent item;+            );+        };+    };++    let kitGiftCount = depth in+    // say $ "Going to give child " ++ (format kitGiftCount) ++ " repro kits.";+    doN kitGiftCount $ give child "repro kit";++    end;++def makeBriquette =+    let briquette = "coal briquette" in+    pollUntilCount 100 "coal lump";+    make briquette;+    briquetteAlreadyPlaced <- ishere briquette;+    if briquetteAlreadyPlaced {} {+        place briquette;+    };+    end;++def go =+    // Use the recipe from "repro kit" to unpack the right+    // set of items to be taken from the inventory with the implicit "require":+    make "3D printer";+    recurseUntilDepth 8;+    forever makeBriquette;+    end;++go;

@@ -0,0 +1,44 @@+def doN = \n. \f. if (n > 0) {f; doN (n - 1) f} {}; end;++/** The function argument returns a boolean.+Keep running the function until either the+loop counter runs out or the function returns true.+*/+def doNTimesOr = \n. \f.+    if (n > 0) {+        shouldQuit <- f;+        if shouldQuit {} {+            doN (n - 1) f;+        }+    } {};+    end;++def forever = \c. c; forever c; end;++def traverseRoad =+    doN 11 (+        move;+        wait 7;+    );+    end;++def patrol =+    let briquette = "coal briquette" in+    traverseRoad;+    doNTimesOr 40 (+        briquetteIsHere <- ishere briquette;+        if briquetteIsHere {grab; return ()} {};+        return briquetteIsHere;+    );+    turn back;+    traverseRoad;++    hasBriquette <- has briquette;+    if hasBriquette {+        say "Delivered!";+        make "energy";+    } {};+    turn back;+    end;++forever patrol;

@@ -0,0 +1,20 @@+def doN = \n. \f. if (n > 0) {f; doN (n - 1) f} {}; end;++def flashLights =+    doN 8 (+        move;+        wait 8;+        turn back;+    );+    end;++def checkForEnergy = \lastCount.+    hauler <- robotnamed "hauler";+    energyCount <- as hauler {+        count "energy";+    };+    if (energyCount > lastCount) {flashLights} {};+    checkForEnergy energyCount;+    end;++checkForEnergy 0;

@@ -0,0 +1,75 @@+def forever : cmd unit -> cmd unit = \c. c ; forever c end++def repeat : int -> cmd unit -> cmd unit =+  \n. \c. if (n == 0) {} {c ; repeat (n-1) c}+end++def elif = \t. \then. \else. {if t then else} end+def else = \t. t end++def abs = \n. if (n < 0) {-n} {n} end++def randdir : cmd dir =+  d <- random 4;+  return (+    if (d == 0) {north}+    $ elif (d == 1) {east}+    $ elif (d == 2) {south}+    $ else {west}+  )+end++def chooseWait : cmd int =+  t <- random (16*2);+  return (16 + t)+end++def wander =+  d <- randdir;+  turn d;+  dist <- random 2;+  try {repeat dist move} {};+  r <- random 5;+  if (r == 0) { say "meow" } {}+end++def disappointed = \cat. say "meow??"; cat end++def follow : cmd unit -> actor -> cmd unit = \cat. \r.+  rLoc <- as r {whereami};+  myLoc <- whereami;+  let dx = fst rLoc - fst myLoc in+  let dy = snd rLoc - snd myLoc in+  if (abs dx > abs dy)+  { if (dx < 0) {turn west} {turn east} }+  { if (dy < 0) {turn south} {turn north} };+  if (abs dx != 0 || abs dy != 0) {try { move } { disappointed cat }} {};+  wait 4;+  follow cat r+end++def love = \cat.+  say "purr";+  fishGiver <- meet;+  case fishGiver+    (\_. disappointed cat)+    (\r. follow cat r)+end++def cat = \start. \fishCount. \waitTime.+  if (waitTime == 0) { wander; start } { wait 1 };+  n <- count "fish";+  if (n > fishCount)+  { say "yum!";+    if (n >= 3) { love start } { cat start n (waitTime - 1) }+  }+  { cat start fishCount (waitTime - 1) }+end++def startCat =+  n <- count "fish";+  w <- chooseWait;+  cat startCat n w+end;++startCat

@@ -0,0 +1,18 @@+def m2 = move; move end+def m5 = m2; m2; move end+def m10 = m5; m5 end+def m20 = m10; m10 end++def give_fish = \n.+  if (n == 0) {}+  { mcat <- meet;+    case mcat (\_. give_fish n) (\cat. give cat "fish"; give_fish (n-1))+  }+end;++build {+  require 3 "fish";+  m2; turn left; m20;+  give_fish 3;+  turn back; m20; turn right; m2+}

@@ -0,0 +1,60 @@+def doN = \n. \f. if (n > 0) {f; doN (n - 1) f} {}; end;++def approachShop =+    doN 5 (+        move;+        wait 8;+    );+    end;++def placeOrder =+    scoopCountExtra <- random 4000;+    let scoopCount = 1000 + scoopCountExtra in+    say $ format scoopCount ++ " scoops of vanilla ice cream, no more, no less! And top it with a cherry, please.";+    return scoopCount;+    end;++def waitForItem = \item.+    hasItem <- has item;+    if hasItem {+        return ();+    } {+        wait 1;+        waitForItem item;+    }+    end;++/**+If we receive the cherry+when we also have the correct number of+scoops, then we produce this item+as a sempahore for the goal evaluation.++Otherwise, we express our disappointment.+*/+def createCompletedSemaphore = \targetCount.+    scoopcount <- count "scoop";+    if (scoopcount < targetCount) {+        say "That's not enough ice cream! Terrible service.";+    } {+        if (scoopcount > targetCount) {+            say "That's too much ice cream!";+        } {+            say "Just right! Here's your money.";+            give base "bitcoin";+        };+    };+    turn back;+    approachShop;+    selfdestruct;+    end;++def runScript =+    approachShop;+    waitForItem "cone";+    targetScoopCount <- placeOrder;+    waitForItem "cherry";+    createCompletedSemaphore targetScoopCount;+    end;++runScript;

@@ -0,0 +1,68 @@+def serveCustomer = \cone. \customer.+    give customer cone;+    end;++def getCounter =+    move;+    c <- grab;+    equip c;+    end;++def getBriefcase =+    turn left;+    move;+    move;+    b <- grab;+    equip b;+    turn back;+    move;+    move;+    end;++def getIngredients =+    move;+    move;+    cone <- grab;+    move;+    cherry <- grab;+    turn back;+    move;+    move;+    move;+    turn right;+    return (cone, cherry);+    end;++def meetCustomer =+    maybeCustomer <- meet;+    case maybeCustomer (\_. meetCustomer) return;+    end;++def serveScoop = \customer.+    let s = "scoop" in+    make s;+    give customer s;+    end;++def scoopUntil = \customer. \targetRemainingIngredientCount.+    currentCount <- count "milk";+    if (currentCount > targetRemainingIngredientCount) {+        serveScoop customer;+        scoopUntil customer targetRemainingIngredientCount;+    } {};+    end;++def runSolution = \targetRemainingIngredientCount.+    getBriefcase;+    coneAndCherry <- getIngredients;+    getCounter;+    customer <- meetCustomer;++    let cone = fst coneAndCherry in+    let cherry = snd coneAndCherry in+    serveCustomer cone customer;+    scoopUntil customer targetRemainingIngredientCount;+    give customer cherry;+    end;++runSolution 2712;

@@ -0,0 +1,40 @@+def doN = \n. \f. if (n > 0) {f; doN (n - 1) f} {}; end;++def crossRiver =+    doN 18 move;+    end;++move;+move;+goat <- grab;+turn east;+crossRiver;+place goat;+turn back;+crossRiver;+turn right;+move;+wolf <- grab;+turn right;+crossRiver;+place wolf;+turn right;+move;+goat2 <- grab;+turn right;+crossRiver;+place goat2;+turn left;+move;+cabbage <- grab;+turn left;+crossRiver;+place cabbage;+turn back;+crossRiver;+turn right;+move;+goat3 <- grab;+turn right;+crossRiver;+place goat3;

@@ -0,0 +1,4 @@+has_wolf <- has "wolf";+has_goat <- has "goat";+has_cabbage <- has "cabbage";+return $ (has_wolf && has_goat) || (has_goat && has_cabbage) || (has_wolf && has_cabbage);

@@ -0,0 +1,28 @@+def get_x_coord = \r.+    as r {+        pos <- whereami;+        return $ fst pos;+    };+    end;++def all_on_bank = \baseX. \robotName.+    r <- robotnamed robotName;+    thisX <- get_x_coord r;++    as r {+        try {grab; return ()} {};+        move;+        try {grab; return ()} {};+        move;+        try {grab; return ()} {};++        has_wolf <- has "wolf";+        has_goat <- has "goat";+        has_cabbage <- has "cabbage";+        return $ baseX == thisX && has_wolf && has_goat && has_cabbage;+    };+    end;++baseX <- get_x_coord base;++all_on_bank baseX "east_detector";

@@ -0,0 +1,35 @@+def get_x_coord = \r.+    as r {+        pos <- whereami;+        return $ fst pos;+    };+    end;++def is_unattended_together = \baseX. \robotName.+    r <- robotnamed robotName;+    thisX <- get_x_coord r;++    if (baseX == thisX) {+        return false;+    } {+        as r {+            try {grab; return ()} {};+            move;+            try {grab; return ()} {};+            move;+            try {grab; return ()} {};++            has_wolf <- has "wolf";+            has_goat <- has "goat";+            has_cabbage <- has "cabbage";+            return $ (has_wolf && has_goat) || (has_goat && has_cabbage);+        };        +    }+    end;++baseX <- get_x_coord base;++west_bad <- is_unattended_together baseX "west_detector";+east_bad <- is_unattended_together baseX "east_detector";++return $ west_bad || east_bad;

@@ -0,0 +1,247 @@+def doN = \n. \f. if (n > 0) {f; doN (n - 1) f} {}; end;++def intersperse = \n. \f2. \f1. if (n > 0) {+        f1;+        if (n > 1) {+            f2;+        } {};+        intersperse (n - 1) f2 f1;+    } {};+    end;++def whichOrdinal = \str.+    if (str == "capital C") {+        return 0;+    } {+        if (str == "capital O") {+            return 1;+        } {+            if (str == "capital W") {+                return 2;+            } {+                return (-1);+            }+        }+    }+    end;++/**+Returns -1 if not a recognized letter.+*/+def getAdjacentOrdinal = \d.+    maybeEntity <- scan d;+    str <- case maybeEntity (\_. return "") (\s. return s);+    whichOrdinal str;+    end;++/**+Call a function repeatedly with the numeric argument,+in descending order.+*/+def iterN = \n. \f.+    if (n > 0) {+        let newNum = n - 1 in+        f newNum;+        iterN newNum f;+    } {};+    end;++def chooseLetter = \i.+    if (i == 0) {+        return "capital C";+    } {+        if (i == 1) {+            return "capital O";+        } {+            return "capital W";+        }+    };+    end;++/**+We only need to probe further if+the letter above us is an O.+Then we need to check whether the letter+above that is a C or a W.+*/+def getExcludedVerticalLetter =+    northOrdinal <- getAdjacentOrdinal north;+    if (northOrdinal == 1) {+        currentLoc <- whereami;+        teleport self (fst currentLoc, snd currentLoc + 1);+        doubleNorthOrdinal <- getAdjacentOrdinal north;+        teleport self currentLoc;++        if (doubleNorthOrdinal == 2) {+            return 0;+        } {+            if (doubleNorthOrdinal == 0) {+                return 2;+            } {+                return (-1);+            }+        }+    } {+        return (-1);+    }+    end;++/**+To ensure there are limited numbers of solutions+(preferably exactly one),+make sure we're not completing a word+horizontally (foward or backward)+or vertically (upward or downward), except if we+are in the designated location.+*/+def reRoll = \excludedVertical. \expectedFwdOrdinal. \expectedBkwdOrdinal.++    // NOTE: excludeTwo and excludeZero+    // are mutually exclusive!+    let excludeTwo = expectedFwdOrdinal == 2 in+    let excludeZero = expectedBkwdOrdinal == 0 in++    // NOTE: Excluded letters can only be 0 or 2.+    // 1 is always a valid option.++    if excludeZero {+        if (excludedVertical == 2) {+            return 1;+        } {+            // Zero is the only excluded value,+            // so just offset a choice between 0 and 1 upward by 1, +            // to make it a choice between 1 and 2.+            val <- random 2;+            return $ val + 1;+        };+    } {+        if excludeTwo {+            if (excludedVertical == 0) {+                return 1;+            } {+                // Two is the only excluded value,+                // so make it a choice between 0 and 1.+                random 2;+            };+        } {+            if (excludedVertical == 0) {+                // Zero is the only excluded value,+                // so just offset a choice between 0 and 1 upward by 1, +                // to make it a choice between 1 and 2.+                val <- random 2;+                return $ val + 1;+            } {+                if (excludedVertical == 2) {+                    // Two is the only excluded value,+                    // so make it a choice between 0 and 1.+                    random 2;+                } {+                    // No values are excluded, so select random from+                    // the full range.+                    random 3;+                }+            };+        };+    };+    end;++def singleTile = \expectedFwdOrdinal. \expectedBkwdOrdinal.+    excludedVertical <- getExcludedVerticalLetter;+    letterIndex <- reRoll excludedVertical expectedFwdOrdinal expectedBkwdOrdinal;+    chosenLetter <- chooseLetter letterIndex;+    place chosenLetter;+    return letterIndex;+    end;++def crossBack = \n.+    currentLoc <- whereami;+    teleport self (0, snd currentLoc - 1);+    end;++/**+Recursive. Tracks the completion of the word in both the forward+and backward directions.+*/+def layTilesRow = \expectedFwdOrdinal. \expectedBkwdOrdinal. \n.+    placedIndex <- singleTile expectedFwdOrdinal expectedBkwdOrdinal;++    if (n > 1) {+        move;++        newFwdOrdinal <- if (placedIndex == expectedFwdOrdinal || placedIndex == 0) {+            return $ placedIndex + 1;+        } {+            return 0;+        };++        newBkwdOrdinal <- if (placedIndex == expectedBkwdOrdinal || placedIndex == 2) {+            return $ placedIndex - 1;+        } {+            return 2;+        };++        layTilesRow newFwdOrdinal newBkwdOrdinal $ n - 1;+    } {};+    end;++def giveLetterNumbered = \n.+    letter <- chooseLetter n;+    give base letter;+    end;++def removeBoulder =+    baseLoc <- as base {whereami};+    teleport self (fst baseLoc - 1, snd baseLoc);++    // Remove the boulder blocking the player's path+    grab;++    // Make sure the base "knows" about the letters+    // to get rid of the question marks ("?").+    iterN 3 giveLetterNumbered;++    selfdestruct;+    end;++def createImpossiblePuzzle = \width. \height.+    intersperse height (crossBack width) (layTilesRow 0 2 width);+    end;++/**+This word center is padded by+one cell from the vertical and horizontal+edges of the playfield.+This means that the word will not exist+horizontally at either the top or bottom edge,+nor will it exist vertically at the left or+right edge of the playfield.+*/+def overwriteWithWord = \width. \height.++    randX <- random $ width - 2;+    randY <- random $ height - 2;+    let insertionX = 1 + randX in+    let insertionY = 1 + randY in+    teleport self (insertionX, -insertionY);++    // Rotate to random orientation+    turnCount <- random 3;+    doN turnCount $ turn left;++    move;+    turn back;++    // Place all three letters of the word+    iterN 3 $ \x.+        chosenLetter <- chooseLetter x;+        swap chosenLetter;+        move;+    end;++def createPuzzle = \width. \height.+    createImpossiblePuzzle width height;+    overwriteWithWord width height;+    removeBoulder;+    end;++createPuzzle 25 15;

@@ -0,0 +1,127 @@+def doN = \n. \f. if (n > 0) {f; doN (n - 1) f} {}; end;++def intersperse = \n. \f2. \f1. if (n > 0) {+        f1;+        if (n > 1) {+            f2;+        } {};+        intersperse (n - 1) f2 f1;+    } {};+    end;++def waitUntilUnblocked =+    x <- blocked;+    if x {+        wait 1;+        waitUntilUnblocked;+    } {};+    end;++def whichOrdinal =+    isC <- ishere "capital C";+    if (isC) {+        return 0;+    } {+        isO <- ishere "capital O";+        if (isO) {+            return 1;+        } {+            isW <- ishere "capital W";+            if (isW) {+                return 2;+            } {+                return (-1);+            }+        }+    }+    end;++// Go to upper-left corner+def goToCorner =+    myLoc <- whereami;+    doN (fst myLoc) move;+    turn right;+    doN (-(snd myLoc)) move;+    turn right;+    end;++def highlightLetter =+    drill down;+    end;++def traverseRow = \expectedOrdinal. \colCount.++    theFoundOrdinal <- whichOrdinal;++    // Logic: the first letter of the target word is *always*+    // considered a "match".+    let shouldAdvance = theFoundOrdinal == expectedOrdinal || theFoundOrdinal == 0 in+    newExpectedOrdinal <- if shouldAdvance {+        return $ theFoundOrdinal + 1;+    } {+        // Reset the progress+        return 0;+    };++    if (newExpectedOrdinal == 3) {+        turn back;++        intersperse 3 move highlightLetter;+        return true;+    } {+        if (colCount > 1) {+            move;+            traverseRow newExpectedOrdinal (colCount - 1);+        } {+          return false;+        };+    };+    end;++def advanceRow =+    turn left;+    move;+    turn left;+    end;++/**+Travels forward and then backward+across a row, to check for solutions+in either direction.+*/+def traverseCols = \width. \height. +    didWin <- traverseRow 0 width;+    if didWin {+        return true;+    } {+        turn back;+        didWinBackward <- traverseRow 0 width;+        if didWinBackward {+            return true;+        } {+            if (height > 1) {+                advanceRow;+                traverseCols width $ height - 1;+            } {+                return false;+            };+        }+    } +    end;++def solve = \boardWidth. \boardHeight.+    waitUntilUnblocked;+    goToCorner;++    wonHorizontally <- traverseCols boardWidth boardHeight;+    if wonHorizontally {+        return true;+    } {+        // If we did not find a horizontal solution,+        // look for vertical solutions.+        turn right;+        traverseCols boardHeight boardWidth;+    }+    end;++solve 25 15;

@@ -0,0 +1,183 @@+/**+Algorithm:+We only need to check the base's+current position: if we find three contiguous highlights,+then we know that the player has just completed their+third highlight.+*/++def whichOrdinal =+    isC <- ishere "lowercase c";+    if (isC) {+        return 0;+    } {+        isO <- ishere "lowercase o";+        if (isO) {+            return 1;+        } {+            isW <- ishere "lowercase w";+            if (isW) {+                return 2;+            } {+                return (-1);+            }+        }+    }+    end;+++def whichHighlightedOrdinal = \str.+    if (str == "lowercase c") {+        return 0;+    } {+        if (str == "lowercase o") {+            return 1;+        } {+            if (str == "lowercase w") {+                return 2;+            } {+                return (-1);+            }+        }+    }+    end;++def countConsecutive = \expectedOrdinal. \n.++    thisOrdinal <- whichOrdinal;+    nextOrdinal <- if (thisOrdinal == expectedOrdinal) {+        return $ expectedOrdinal + 1;+    } {+        return 0;+    };++    if (nextOrdinal == 3) {+        return true;+    } {+        if (n > 1) {+            move;+            countConsecutive nextOrdinal $ n - 1;+        } {+            return false;+        };+    };+    end;++def checkBackAndForth =++    foundBackward <- countConsecutive 0 3;+    if (foundBackward) {+        return true;+    } {+        turn back;+        countConsecutive 0 3;+    }+    end;++def checkDirections = \n.+    if (n > 0) {+        wasFound <- checkBackAndForth;+        if wasFound {+            return true;+        } {+            turn left;+            checkDirections $ n - 1;+        }+    } {+        return false;+    }+    end;++def isMarkedInDirection = \d.+    scanResult <- scan d;+    ordinalNum <- case scanResult+        (\_. return (-1))+        whichHighlightedOrdinal;+    return $ ordinalNum >= 0;+    end;++/**+It's possible we could be one cell away from+a marked cell after finishing, either due+to using a directional `drill` command instead of+`drill down`, or due to an apparent bug which+does not evaluate the goal condition between the+`drill` and a `move` command.+*/+def moveToMarkedCell = \n.+    if (n > 0) {+        isMarkedAhead <- isMarkedInDirection forward;+        if isMarkedAhead {+            move;+            return true;+        } {+            turn left;+            moveToMarkedCell $ n - 1;+        };+    } {+        return false;+    };+    end;++/**+Orient ourselves such that+a marked cell is behind us.+*/+def findMarkBehind = \n.+    if (n > 0) {+        isMarkedBehind <- isMarkedInDirection back;+        if isMarkedBehind {+            return true;+        } {+            turn left;+            findMarkBehind $ n - 1;+        };+    } {+        return false;+    };+    end;++/**+The cell we're on might be in the middle of a word,+rather than the end. Determine the orientation of+the line, then move along it until reaching the end.++Algorithm:+0. Assumption: we are currently on a marked cell.+1. Turn in all all four directions to `scan back`+   for a second marked cell. Stop turning if+   we encounter one.+   If none found after 4 turns, abort.+2. `scan forward` to see if there is a marked cell in+   the opposite direction.+   `move` (foward) once if there is. Since the word+   is only three cells long, this will be the other+   end of it.+*/+def moveToWordExtrema =+    foundCellBehind <- findMarkBehind 4;+    if foundCellBehind {+        isMarkedAhead <- isMarkedInDirection forward;+        if isMarkedAhead {+            move;+        } {};+    } {};+    end;++def checkSoln =+    isMarkedHere <- isMarkedInDirection down;+    atMarkedCell <- if isMarkedHere {+        return true;+    } {+        moveToMarkedCell 4;+    };++    if atMarkedCell {+        moveToWordExtrema;+        checkDirections 4;+    } {+        return false;+    }+    end;++as base {checkSoln};

@@ -0,0 +1,216 @@+version: 1+name: Bucket Brigade+author: Karl Ostmo+description: |+  Convey resources with limited mobility+creative: false+robots:+  - name: base+    display:+      char: 'Ω'+      attr: robot+    heavy: true+    dir: [0, 1]+    devices:+      - 3D printer+      - ADT calculator+      - branch predictor+      - clock+      - comparator+      - counter+      - dictionary+      - grabber+      - hearing aid+      - lambda+      - logger+      - mirror+      - net+      - scanner+      - strange loop+      - string+      - workbench+      - briquette press+    inventory:+      - [10, repro kit]+      - [1, treads]+  - name: hauler+    system: true+    dir: [-1, 0]+    devices:+      - furnace+    display:+      invisible: false+      char: '='+      attr: robot+    program: |+      run "scenarios/Challenges/_bucket-brigade/hauler.sw"+  - name: powerplant+    system: true+    dir: [1, 0]+    display:+      invisible: false+      char: '▒'+      attr: gold+    program: |+      run "scenarios/Challenges/_bucket-brigade/powerplant.sw"+objectives:+  - id: deliver_coal_lump+    teaser: Get coal to base+    goal:+      - Deliver a "coal lump" to the base.+      - |+        To excavate coal from the "lignite mine" (M), a robot needs to+        `drill` while in posession of a "bucketwheel excavator".+      - |+        To assemble the excavator, you'll need to repurpose+        some "treads".+        Unfortunately, you have only one set of "treads".+        You'll have to make do...+    condition: |+      as base {has "coal lump"}+  - goal:+      - Your base got some coal!+      - Now fashion more of it into a "coal briquette", and place it+        so that the hauler (=) can pick it up.+      - The hauler will periodically stop at the base+        to check if a load is available.+    condition: |+      hauler <- robotnamed "hauler";+      as hauler {has "coal briquette"}+    prerequisite: deliver_coal_lump+solution: |+  run "scenarios/Challenges/_bucket-brigade/brigade.sw"+entities:+  - name: bucketwheel excavator+    display:+      char: 'x'+    description:+      - A powerful machine designed to remove overburden in mining operations.+    properties: [known, portable]+    capabilities: [drill]+  - name: lignite mine+    display:+      attr: copper+      char: 'M'+    description:+      - Requires heavy equipment to remove the overburden.+    properties: [known]+  - name: coal lump+    display:+      char: 'c'+    description:+      - Primitive, sooty fuel.+    properties: [known, portable]+  - name: coal briquette+    display:+      char: 'q'+    description:+      - A compressed, convenient form of coal for consumption and transport.+    properties: [known, portable]+  - name: briquette press+    display:+      char: 'P'+    description:+      - A device to compress coal lumps into briquettes.+    properties: [known, portable]+  - name: energy+    display:+      char: 'E'+    description:+      - The result of burning a coal briquettte.+    properties: [portable]+  - name: repro kit+    display:+      char: 'k'+    description:+      - Kit that can be unpacked into everything a robot needs to reproduce.+    properties: [known, portable]+recipes:+  - in:+      - [1, repro kit]+    out:+      - [1, 3D printer]+      - [1, ADT calculator]+      - [1, branch predictor]+      - [1, calculator]+      - [1, clock]+      - [1, comparator]+      - [1, counter]+      - [1, dictionary]+      - [1, grabber]+      - [1, lambda]+      - [1, lodestone]+      - [1, logger]+      - [1, metal drill]+      - [1, mirror]+      - [1, net]+      - [1, scanner]+      - [1, solar panel]+      - [1, string]+      - [1, strange loop]+      - [1, welder]+      - [1, workbench]+  - in:+      - [1, treads]+    out:+      - [1, bucketwheel excavator]+  - in:+      - [1, lignite mine]+    out:+      - [1, lignite mine]+      - [1, coal lump]+    required:+      - [1, bucketwheel excavator]+      - [1, metal drill]+  - in:+      - [100, coal lump]+    out:+      - [1, coal briquette]+    required:+      - [1, briquette press]+  - in:+      - [1, coal briquette]+    out:+      - [1, energy]+    required:+      - [1, furnace]+++known: [boulder, lignite mine]+seed: 0+world:+  default: [grass]+  palette:+    'B': [dirt, null, base]+    '.': [dirt]+    '=': [stone]+    'M': [stone, lignite mine]+    'H': [stone, null, hauler]+    'Z': [stone, null, powerplant]+    'w': [grass]+    's': [stone]+    'A': [stone, boulder]+    '┌': [stone, upper left corner]+    '┐': [stone, upper right corner]+    '└': [stone, lower left corner]+    '┘': [stone, lower right corner]+    '─': [stone, horizontal wall]+    '│': [stone, vertical wall]+  upperleft: [0, 0]+  map: |-+    ww...A.AA.A..A.AA....A..ww+    w..A..A.AA........A......w+    .AA..A......M....A....A...+    ....A..A..................+    .A...A.A..................+    ..AA......................+    ...A..A...............┌┐..+    ..A.................┌┐││..+    .....A.............┌────┐.+    ...................│sZss│.+    .A.................└────┘.+    .....A......B==========H=.+    ..........................+    .............┌┐.┌──────┐..+    w......A.....└┘.└──────┘..+    ww........................

@@ -0,0 +1,94 @@+version: 1+name: Make a Friend+author: Brent Yorgey+description: |+  Win the trust of a furry companion.+creative: false+robots:+  - name: base+    display:+      char: 'Ω'+      attr: robot+    heavy: true+    dir: [0, 1]+    devices:+      - 3D printer+      - ADT calculator+      - antenna+      - branch predictor+      - clock+      - comparator+      - counter+      - dictionary+      - grabber+      - hearing aid+      - lambda+      - logger+      - mirror+      - net+      - scanner+      - strange loop+      - string+      - toolkit+      - workbench+    inventory:+      - [10, ADT calculator]+      - [10, antenna]+      - [10, treads]+      - [10, branch predictor]+      - [10, fish]+      - [10, solar panel]+      - [10, grabber]+      - [10, lambda]+      - [10, strange loop]+      - [10, logger]+      - [10, clock]+      - [10, comparator]+      - [10, calculator]+  - name: cat+    system: true+    dir: [-1, 0]+    display:+      invisible: false+      char: 'c'+      attr: sand+    devices:+      - logger+    program: |+      run "scenarios/Challenges/_friend/cat.sw"+objectives:+  - goal:+      - There's a cat wandering around in the field.  Bring it back to+        your base.  If you give it something it likes, perhaps you can+        get it to follow you.+    condition: |+      c <- robotNamed "cat";+      catLoc <- as c {whereami};+      baseLoc <- as base {whereami};+      return (catLoc == baseLoc)+solution: |+  run "scenarios/Challenges/_friend/friend-solution.sw"+entities:+  - name: fish+    display:+      char: 'f'+    description:+      - A smelly fish. Rather unappetizing to a robot.+    properties: [known, portable]++known: [fish]+seed: 0+world:+  offset: true+  palette:+    'Ω': [grass, null, base]+    '.': [stone]+    ',': [grass]+    'c': [grass, null, cat]+    '*': [grass, flower]+    '@': [stone, boulder]+  upperleft: [-20, 2]+  map: |-+    c,..,,,,,,..,,,,...,.+    ,..,,,,,,,...........+    *,.,@,,,,,,,.....,..Ω

@@ -57,7 +57,7 @@       // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~       // if       //  0. I stand on unlocked X-      //  1. place noth of me is NOT empty+      //  1. place north of me is NOT empty       // then       //  - lock X       run "scenarios/Challenges/hanoi-invariant.sw"@@ -157,7 +157,7 @@ world:   default: [grass, null]   palette:-    ' ': [grass]+    ',': [grass]     '_': [stone]     'v': [stone, null, base]     '┌': [stone, upper left corner]@@ -182,5 +182,5 @@     │2│.│.│     │3│.│.│     └─┴─┴─┘-     ^ ^ ^ -       X   +    ,^,^,^,+    ,,,X,,,

@@ -0,0 +1,241 @@+version: 1+name: Ice Cream Shop+author: Karl Ostmo+description: |+  Serve a demanding customer+creative: false+seed: 0+objectives:+  - goal:+      - |+        Congratulations on the grand opening of your new ice cream shop.+        You have advertised: "All you can eat, for 1 bitcoin!"+      - |+        A customer is approaching the "Counter". They look hungry!+      - "..."+      - |+        Customer: "`give` me a cone, and then I'll tell you how many scoops I want."+      - "..."+      - |+        Oh dear, you've forgotten to stock your shop with a "calculator".+        Let's hope this order is simple.+    condition: |+      customer <- robotnamed "customer";+      as customer {has "cone"};+  - goal:+      - |+        `give` the customer exactly what they request.+      - |+        Perhaps there is something else around the shop that can assist with+        preparing the order...+    condition: |+      as base {+        has "bitcoin";+      };+robots:+  - name: base+    dir: [0, 1]+    devices:+      - branch predictor+      - treads+      - antenna+      - comparator+      - workbench+      - grabber+      - dictionary+      - lambda+      - logger+      - welder+      - hearing aid+      - scanner+      - strange loop+    inventory:+      - [5000, egg]+      - [5000, milk]+      - [5000, sugar]+      - [5000, ice]+      - [5000, vanilla]+  - name: customer+    system: true+    dir: [0, -1]+    display:+      invisible: false+      attr: 'iron'+    inventory:+      - [1, bitcoin]+    program: |+      run "scenarios/Challenges/_ice-cream/customer.sw"+solution: |+   run "scenarios/Challenges/_ice-cream/solution.sw"+entities:+  - name: scoop+    display:+      char: '@'+    description:+      - A single scoop of vanilla ice cream+    properties: [portable]+  - name: cherry+    display:+      char: '6'+      attr: 'red'+    properties: [portable]+    description:+      - A traditional ice cream garnish+  - name: Counter+    display:+      char: '▒'+      attr: 'sand'+    properties: [portable, known]+    capabilities: [count]+    description:+      - Where customers are served.+      - Also... it can count things.+  - name: cone+    display:+      char: 'V'+      attr: 'sand'+    properties: [portable]+    description:+      - A conical, edible container for ice cream+  - name: egg+    display:+      char: 'e'+      attr: 'gold'+    properties: [portable]+    description:+      - Organic from local, free-range, meticulously pampered chickens.+  - name: milk+    display:+      char: 'm'+      attr: 'silver'+    properties: [portable]+    description:+      - Pasteurized, homogenized, commoditized, metabolized.+  - name: ice+    display:+      char: 'i'+      attr: 'snow'+    properties: [portable]+    description:+      - Ice cream is better cold, don't you think?+  - name: sugar+    display:+      char: 's'+      attr: 'snow'+    properties: [portable]+    description:+      - Basis of most desserts+  - name: vanilla+    display:+      char: 'v'+      attr: 'wood'+    properties: [portable]+    description:+      - Traditional ice cream flavoring+  - name: briefcase+    display:+      char: 'B'+      attr: rubber+    capabilities: [sum, prod]+    properties: [portable]+    description:+      - Standard business accoutrement.+      - Particularly useful for `meet`-ings.+      - Enables the `case` expression.+  - name: awning1+    display:+      char: '▒'+      attr: flower+    description:+      - Decoration+    properties: [known]+  - name: awning2+    display:+      char: '▒'+      attr: snow+    description:+      - Decoration+    properties: [known]+  - name: cone left+    display:+      char: '\'+      attr: wood+    description:+      - Decoration+    properties: [known]+  - name: cone right+    display:+      char: '/'+      attr: wood+    description:+      - Decoration+    properties: [known]+  - name: cone top+    display:+      char: 'M'+      attr: wood+    description:+      - Decoration+    properties: [known]+  - name: cone inside+    display:+      char: 'Z'+      attr: wood+    description:+      - Decoration+    properties: [known]+  - name: decorative scoop+    display:+      char: 'O'+      attr: snow+    description:+      - Decoration+    properties: [known]+recipes:+  - in:+      - [1, egg]+      - [1, milk]+      - [1, sugar]+      - [1, ice]+      - [1, vanilla]+    out:+      - [1, scoop]+known: []+world:+  default: [grass]+  upperleft: [0, 0]+  offset: false+  palette:+    '@': [stone, boulder]+    '.': [grass]+    ':': [stone]+    'B': [stone, briefcase]+    '6': [stone, cherry]+    'V': [stone, cone]+    Ω: [stone, null, base]+    X: [stone, null, customer]+    'y': [stone, awning1]+    'z': [stone, awning2]+    '┌': [stone, upper left corner]+    '┐': [stone, upper right corner]+    '└': [stone, lower left corner]+    '┘': [stone, lower right corner]+    '─': [stone, horizontal wall]+    '│': [stone, vertical wall]+    '\': [stone, cone left]+    '/': [stone, cone right]+    'Z': [stone, cone inside]+    '^': [stone, cone top]+    'O': [stone, decorative scoop]+    'x': [stone, Counter]+  map: |+    ...X..........+    ...:..........+    ...:..........+    ...:..........+    ...:.......OO.+    yzy:yzyz..OOOO+    ┌─┐x┌──┐..^^^^+    │B:Ω:V6│..\ZZ/+    └──────┘...\/.+    

@@ -58,6 +58,7 @@ world:   default: [ice, water]   palette:+    ',': [ice, water]     ' ': [ice, water]     '~': [ice, wavy water]     '*': [grass, flower]@@ -74,9 +75,9 @@   upperleft: [-1, 3]   map: |     ~~   ~         ~    ~-    ~┌─────┐~  ┌─────┐~  +    ~┌─────┐~  ┌─────┐~ ,     ┌┘.....└───┘T...*└┐ ~-    │_....._   _..λ.._│  +    │_....._   _..λ.._│ ,     └┐.....┌───┐*...T┌┘ ~-    ~└─────┘ ~~└─────┘~  +    ~└─────┘ ~~└─────┘~ ,     ~~~   ~        ~    ~

@@ -0,0 +1,125 @@+version: 1+name: Lake crossing+author: Karl Ostmo+description: |+  Deposit all three items on the eastern shore of the lake.+creative: false+robots:+  - name: base+    display:+      char: 'U'+      attr: wood+    dir: [0, 1]+    devices:+      - ADT calculator+      - branch predictor+      - treads+      - lodestone+      - compass+      - comparator+      - counter+      - dictionary+      - grabber+      - lambda+      - logger+      - mirror+      - net+      - scanner+      - strange loop+      - boat+  - name: east_detector+    system: true+    dir: [0, 1]+    display:+      invisible: true+  - name: west_detector+    system: true+    dir: [0, 1]+    display:+      invisible: true+objectives:+  - goal:+      - |+        Ferry all three of the wolf, goat, and cabbage across the lake.+        However, only one of these can be carried at a time.+      - |+        Furthermore, if left unattended together, the wolf will eat the goat,+        or the goat will eat the cabbage.+    condition: |+      run "data/scenarios/Challenges/_wolf-goat-cabbage/together-on-east-bank.sw";+    prerequisite:+      previewable: true+      logic:+        not:+          or: +            - id: unattended_disaster+            - id: carrying_two_items+  - goal:+      - Carrying two items at once is not allowed!+    condition: |+      as base {+        run "data/scenarios/Challenges/_wolf-goat-cabbage/multi-item-possession.sw";+      };+    id: carrying_two_items+    optional: true+    hidden: true+  - id: unattended_disaster+    teaser: Something was eaten+    goal:+      - Leaving an animal alone with its food is not allowed!+    condition: |+      run "data/scenarios/Challenges/_wolf-goat-cabbage/unattended-together.sw";+    optional: true+    hidden: true    +solution: |+  run "scenarios/Challenges/_wolf-goat-cabbage/cross.sw"+entities:+  - name: wolf+    display:+      char: 'w'+      attr: silver+    description:+      - A wolf. Likes to eat goats.+    properties: [known, portable]+  - name: goat+    display:+      char: 'g'+      attr: sand+    description:+      - A goat. Likes to eat cabbage.+    properties: [known, portable]+  - name: cabbage+    display:+      char: 'c'+      attr: green+    description:+      - A cabbage.+    properties: [known, portable]+known: [water, boulder]+seed: 0+world:+  default: [blank]+  palette:+    'A': [stone, boulder]+    'B': [stone, boulder, base]+    '.': [grass]+    'e': [grass, null, east_detector]+    '~': [dirt, water]+    'w': [grass, wolf]+    'g': [grass, goat]+    'c': [grass, cabbage, west_detector]+  upperleft: [0, 0]+  map: |-+    AAAAAAAAAAAAAAAAAAAAA+    AAAAAAAA~~~~~AAAAAAAA+    AAAAA~~~~~~~~~~~AAAAA+    AAA~~~~~~~~~~~~~~~AAA+    AA~~~~~~~~~~~~~~~~~AA+    Aw~~~~~~~~~~~~~~~~~.A+    Ag~~~~~~~~~~~~~~~~~.A+    Ac~~~~~~~~~~~~~~~~~eA+    AB~~~~~~~~~~~~~~~~~AA+    AAA~~~~~~~~~~~~~~~AAA+    AAAAA~~~~~~~~~~~AAAAA+    AAAAAAAA~~~~~AAAAAAAA+    AAAAAAAAAAAAAAAAAAAAA

@@ -0,0 +1,387 @@+version: 1+name: Word search+author: Karl Ostmo+description: |+  Find the word+seed: 2+creative: false+objectives:+  - id: prepare_playfield+    teaser: Wait patiently+    goal:+      - |+        First, wait for the playfield to be set up,+        and then your path forward will be cleared.+      - |+        You can speed this process up with CTRL+x.+    condition: |+      as base {knows "capital C"};+  - goal:+      - Use the `drill` command (e.g. "drill down" when on top of the+        intended letter) to mark the sequence of letters that+        spells COW within the designated playfield.+      - |+        The sequence may appear horizontally in either the+        leftward or rightward direction,+        or vertically in either the upward or downward direction.+        Diagonal appearances are not valid.+    prerequisite: prepare_playfield+    condition: |+      /**+      Algorithm:+      We only need to check the base's+      current position: if we find three contiguous highlights,+      then we know that the player has just completed their+      third highlight.+      */++      def whichOrdinal =+          isC <- ishere "lowercase c";+          if (isC) {+              return 0;+          } {+              isO <- ishere "lowercase o";+              if (isO) {+                  return 1;+              } {+                  isW <- ishere "lowercase w";+                  if (isW) {+                      return 2;+                  } {+                      return (-1);+                  }+              }+          }+          end;+++      def whichHighlightedOrdinal = \str.+          if (str == "lowercase c") {+              return 0;+          } {+              if (str == "lowercase o") {+                  return 1;+              } {+                  if (str == "lowercase w") {+                      return 2;+                  } {+                      return (-1);+                  }+              }+          }+          end;++      def countConsecutive = \expectedOrdinal. \n.++          thisOrdinal <- whichOrdinal;+          nextOrdinal <- if (thisOrdinal == expectedOrdinal) {+              return $ expectedOrdinal + 1;+          } {+              return 0;+          };++          if (nextOrdinal == 3) {+              return true;+          } {+              if (n > 1) {+                  move;+                  countConsecutive nextOrdinal $ n - 1;+              } {+                  return false;+              };+          };+          end;++      def checkBackAndForth =++          foundBackward <- countConsecutive 0 3;+          if (foundBackward) {+              return true;+          } {+              turn back;+              countConsecutive 0 3;+          }+          end;++      def checkDirections = \n.+          if (n > 0) {+              wasFound <- checkBackAndForth;+              if wasFound {+                  return true;+              } {+                  turn left;+                  checkDirections $ n - 1;+              }+          } {+              return false;+          }+          end;++      def isMarkedInDirection = \d.+          scanResult <- scan d;+          ordinalNum <- case scanResult+              (\_. return (-1))+              whichHighlightedOrdinal;+          return $ ordinalNum >= 0;+          end;++      /**+      It's possible we could be one cell away from+      a marked cell after finishing, either due+      to using a directional `drill` command instead of+      `drill down`, or due to an apparent bug which+      does not evaluate the goal condition between the+      `drill` and a `move` command.+      */+      def moveToMarkedCell = \n.+          if (n > 0) {+              isMarkedAhead <- isMarkedInDirection forward;+              if isMarkedAhead {+                  move;+                  return true;+              } {+                  turn left;+                  moveToMarkedCell $ n - 1;+              };+          } {+              return false;+          };+          end;++      /**+      Orient ourselves such that+      a marked cell is behind us.+      */+      def findMarkBehind = \n.+          if (n > 0) {+              isMarkedBehind <- isMarkedInDirection back;+              if isMarkedBehind {+                  return true;+              } {+                  turn left;+                  findMarkBehind $ n - 1;+              };+          } {+              return false;+          };+          end;++      /**+      The cell we're on might be in the middle of a word,+      rather than the end. Determine the orientation of+      the line, then move along it until reaching the end.++      Algorithm:+      0. Assumption: we are currently on a marked cell.+      1. Turn in all all four directions to `scan back`+        for a second marked cell. Stop turning if+        we encounter one.+        If none found after 4 turns, abort.+      2. `scan forward` to see if there is a marked cell in+        the opposite direction.+        `move` (foward) once if there is. Since the word+        is only three cells long, this will be the other+        end of it.+      */+      def moveToWordExtrema =+          foundCellBehind <- findMarkBehind 4;+          if foundCellBehind {+              isMarkedAhead <- isMarkedInDirection forward;+              if isMarkedAhead {+                  move;+              } {};+          } {};+          end;++      def checkSoln =+          isMarkedHere <- isMarkedInDirection down;+          atMarkedCell <- if isMarkedHere {+              return true;+          } {+              moveToMarkedCell 4;+          };++          if atMarkedCell {+              moveToWordExtrema;+              checkDirections 4;+          } {+              return false;+          }+          end;++      as base {checkSoln};++robots:+  - name: base+    display:+      attr: flower+    dir: [-1, 0]+    devices:+      - treads+      - ADT calculator+      - branch predictor+      - GPS receiver+      - clock+      - comparator+      - counter+      - dictionary+      - lambda+      - logger+      - mirror+      - net+      - scanner+      - strange loop+      - string+      - highlighter+    inventory:+      - [3, ink]+  - name: lettersetter+    system: true+    dir: [1, 0]+    display:+      invisible: true+    inventory:+      - [376, capital C]+      - [376, capital O]+      - [376, capital W]+    program: |+      run "scenarios/Challenges/_word-search/create-puzzle.sw"+solution: |+  // Hard-coded for seed=2:+  def doN = \n. \f. if (n > 0) {f; doN (n - 1) f} {}; end;+  def waitUntilUnblocked =+    x <- blocked;+    if x {+        wait 1;+        waitUntilUnblocked;+    } {};+    end;+  waitUntilUnblocked;+  doN 11 move;+  turn right;+  doN 2 move;+  drill down;+  move;+  drill down;+  move;+  drill down;+  // run "scenarios/Challenges/_word-search/solution.sw"+entities:+  - name: capital C+    display:+      char: 'C'+    description:+      - C is for California+  - name: capital O+    display:+      char: 'O'+    description:+      - O is for Oklahoma+  - name: capital W+    display:+      char: 'W'+    description:+      - W is for Washington+  - name: lowercase c+    display:+      char: 'c'+      attr: gold+    description:+      - c is for cantaloupe+  - name: lowercase o+    display:+      char: 'o'+      attr: gold+    description:+      - o is for orange+  - name: lowercase w+    display:+      char: 'w'+      attr: gold+    description:+      - w is for watermelon+  - name: highlighter+    display:+      char: 'P'+      attr: gold+    capabilities: [drill]+    description:+      - Instrument for marking found words+    properties: [known, portable]+  - name: ink+    display:+      char: 'K'+      attr: gold+    description:+      - Ink for marking found words+    properties: [known, portable]+recipes:+  - in:+      - [1, capital C]+      - [1, ink]+    out:+      - [1, lowercase c]+    required:+      - [1, highlighter]+  - in:+      - [1, capital O]+      - [1, ink]+    out:+      - [1, lowercase o]+    required:+      - [1, highlighter]+  - in:+      - [1, capital W]+      - [1, ink]+    out:+      - [1, lowercase w]+    required:+      - [1, highlighter]+  - in:+      - [1, lowercase c]+    out:+      - [1, capital C]+      - [1, ink]+    required:+      - [1, highlighter]+  - in:+      - [1, lowercase o]+    out:+      - [1, capital O]+      - [1, ink]+    required:+      - [1, highlighter]+  - in:+      - [1, lowercase w]+    out:+      - [1, capital W]+      - [1, ink]+    required:+      - [1, highlighter]+known: [boulder]+world:+  default: [dirt]+  upperleft: [0, 0]+  offset: false+  palette:+    '@': [stone, boulder]+    '.': [grass]+    'a': [grass, null, lettersetter]+    '#': [dirt]+    Ω: [stone, null, base]+  map: |+    a........................###+    .........................###+    .........................###+    .........................###+    .........................###+    .........................###+    .........................###+    .........................###+    .........................###+    .........................@@@+    .........................@Ω@+    .........................@@@+    .........................###+    .........................###+    .........................###

@@ -1,1 +1,2 @@ GoL.yaml+logo-burst.yaml

@@ -0,0 +1,12 @@+def forever : cmd unit -> cmd unit = \c. c ; forever c end++def alternate =+  wait 50;+  say "Green light";+  make "bit (1)";+  wait 100;+  say "Red light";+  make "bit (0)";+  end;++forever alternate;

@@ -0,0 +1,67 @@++def repeat : int -> cmd unit -> cmd unit =+  \n. \c. if (n == 0) {} {c ; repeat (n-1) c}+end+def abs = \n. if (n < 0) {-n} {n} end+def elif = \t. \then. \else. {if t then else} end+def else = \t. t end++def randdir : cmd dir =+  d <- random 4;+  return (+    if (d == 0) {north}+    $ elif (d == 1) {east}+    $ elif (d == 2) {south}+    $ else {west}+  )+end;++def wander =+  d <- randdir;+  turn d;+  dist <- random 4;+  try {repeat dist move} {};+end;++def disperse =+  r <- robotnamed "stoplight";+  greenLight <- as r {has "bit (1)"};+  if greenLight {+    wander;+    disperse;+  } {};+  end;++def converge = \loc. \currentLoc.++  let xDist = fst currentLoc - fst loc in+  let yDist = snd currentLoc - snd loc in++  if (xDist < 0) {+    turn east;+  } {+    if (xDist > 0) {+      turn west;+    } {};+  };+  repeat (abs xDist) move;++  if (yDist < 0) {+    turn north;+  } {+    if (yDist > 0) {+      turn south;+    } {};+  };+  repeat (abs yDist) move;+  end;++def go = \loc.+  disperse;+  currentLoc <- whereami;+  converge loc currentLoc;+  go loc;+  end;++loc <- whereami;+go loc;

@@ -0,0 +1,84 @@+version: 1+name: Logo burst+author: Karl Ostmo+description: |+  Animate the Swarm logo+creative: false+seed: 0+robots:+  # We include a base robot to stabilize the screen at a fixed position.+  - name: base+    display:+      invisible: true+    dir: [1, 0]+    devices:+      - logger+      - hearing aid+  - name: botRight+    system: true+    display:+      invisible: false+    dir: [1, 0]+    program: |+      run "scenarios/Fun/_logo-burst/drone.sw"+  - name: botUp+    system: true+    display:+      invisible: false+    dir: [0, 1]+    program: |+      run "scenarios/Fun/_logo-burst/drone.sw"+  - name: botLeft+    system: true+    display:+      invisible: false+    dir: [-1, 0]+    program: |+      run "scenarios/Fun/_logo-burst/drone.sw"+  - name: botDown+    system: true+    display:+      invisible: false+    dir: [0, -1]+    program: |+      run "scenarios/Fun/_logo-burst/drone.sw"+  - name: stoplight+    system: true+    display:+      invisible: false+    dir: [0, 1]+    devices:+      - lodestone+    inventory:+      - [1, bit (0)]+    program: |+      run "scenarios/Fun/_logo-burst/coordinator.sw"+  +known: [boulder, tree, water, wavy water]+world:+  default: [blank]+  upperleft: [0, 0]+  offset: false+  palette:+    'Ω': [blank, null, base]+    's': [blank, null, stoplight]+    '.': [blank]+    ' ': [blank]+    '@': [blank, boulder]+    'T': [blank, tree]+    '▒': [blank, water]+    '~': [blank, wavy water]+    '>': [blank, null, botRight]+    '^': [blank, null, botUp]+    '<': [blank, null, botLeft]+    'v': [blank, null, botDown]+  map: |+    s                   v                                     .+    .                                                         . +    . v<^vv<<@   ^^     vv    >^v^T    ^^^v<     <><      v   >+    T  ^<        >^  <  >>   v>   v<   >T   <v>  <<▒^  @><>   .+    .   <@v^^>>   @v  >  <T  <v<T<Ω^>   v><v<     << <<T^ v<  . +    . >     >>   v@ @@> <<   ~v   <    >~  ^~    >>  @^  >v   .+    .   >>^v^^^    < ~ T~v    v<   <~   >>T  <v   vv      ▒>  . +    .                             ▒                           . +    .                   ^      ^     v       >      >         .

@@ -1,10 +1,12 @@ version: 1 name: Curry author: Brent Yorgey-description: Race to make a bowl of curry as fast as possible.+description: Race to make a bowl of curry as quickly as possible.   See the Swarm wiki for more information on Swarm speedrunning. objectives:-  - condition: as base {has "curry"}+  - goal:+      - Make a bowl of curry as quickly as possible!+    condition: as base {has "curry"} robots:   - name: base     loc: [0,0]

@@ -4,7 +4,9 @@ description: Race to harvest 1024 trees as quickly as possible.   See the Swarm wiki for more information on Swarm speedrunning. objectives:-  - condition: as base {n <- count "tree"; return (n >= 1024)}+  - goal:+      - Harvest 1024 trees as quickly as possible!+    condition: as base {n <- count "tree"; return (n >= 1024)} robots:   - name: base     loc: [0,0]

@@ -4,7 +4,9 @@ description: Race to mine some mithril.   See the Swarm wiki for more information on Swarm speedrunning. objectives:-  - condition: as base {has "mithril"}+  - goal:+      - Mine some mithril as quickly as possible!+    condition: as base {has "mithril"} robots:   - name: base     loc: [0,0]

@@ -13,4 +13,13 @@ 378-objectives.yaml 684-swap.yaml 699-movement-fail+858-inventory+795-prerequisite 710-multi-robot.yaml+920-meet.yaml+955-heading.yaml+397-wrong-missing.yaml+961-custom-capabilities.yaml+956-GPS.yaml+958-isempty.yaml+1034-custom-attributes.yaml

@@ -0,0 +1,134 @@+version: 1+name: Rainbow color custom attributes+description: |+  Custom attributes with rainbow colors+creative: false+attrs:+  - name: rainbow1+    fg: "#ffadad"+  - name: rainbow2+    fg: "#ffd6a5"+  - name: rainbow3+    fg: "#ffff96"+  - name: rainbow4+    fg: "#caffbf"+  - name: rainbow5+    fg: "#9bf6ff"+  - name: rainbow6+    fg: "#a0c4ff"+  - name: rainbow7+    fg: "#bdb2ff"+  - name: redOnYellow+    fg: "#ff0000"+    bg: ffff00+  - name: cyanOnMagenta+    fg: 00ffff+    bg: "#ff00ff"+  - name: italicAndUnderline+    style:+      - Italic+      - Underline+  - name: boldAndStrikethrough+    style:+      - Bold+      - Strikethrough+entities:+  - name: color1+    display:+      char: '▒'+      attr: rainbow1+    description:+      - c1+    properties: [known]+  - name: color2+    display:+      char: '▒'+      attr: rainbow2+    description:+      - c2+    properties: [known]+  - name: color3+    display:+      char: '▒'+      attr: rainbow3+    description:+      - c3+    properties: [known]+  - name: color4+    display:+      char: '▒'+      attr: rainbow4+    description:+      - c4+    properties: [known]+  - name: color5+    display:+      char: '▒'+      attr: rainbow5+    description:+      - c5+    properties: [known]+  - name: color6+    display:+      char: '▒'+      attr: rainbow6+    description:+      - c6+    properties: [known]+  - name: color7+    display:+      char: '▒'+      attr: rainbow7+    description:+      - c7+    properties: [known]+  - name: redYellow+    display:+      char: 'R'+      attr: redOnYellow+    description:+      - Red on Yellow+    properties: [known]+  - name: cyanMagenta+    display:+      char: 'C'+      attr: cyanOnMagenta+    description:+      - Cyan on Magenta+    properties: [known]+  - name: italicUnderline+    display:+      char: 'X'+      attr: italicAndUnderline+    description:+      - Italic and Underline+    properties: [known]+  - name: boldStrikethrough+    display:+      char: 'X'+      attr: boldAndStrikethrough+    description:+      - Bold and Strikethrough+    properties: [known]+robots: []+world:+  default: [blank]+  palette:+    '.': [blank]+    '1': [blank, color1]+    '2': [blank, color2]+    '3': [blank, color3]+    '4': [blank, color4]+    '5': [blank, color5]+    '6': [blank, color6]+    '7': [blank, color7]+    'R': [blank, redYellow]+    'C': [blank, cyanMagenta]+    'I': [blank, italicUnderline]+    'B': [blank, boldStrikethrough]+  upperleft: [0, 0]+  map: |-+    .1234567..R.....II.+    .1234567..R........+    .1234567.....C..BB.+    .1234567.....C.....

@@ -8,10 +8,10 @@       try {         r <- robotNumbered 1;         p <- as r {whereami};-        boatInstalled <- as r {installed "boat"};+        boatEquipped <- as r {equipped "boat"};         b1 <- as r {count "boat"};         b0 <- as base {count "boat"};-        return (p == (2,0) && b0 == 0 && boatInstalled && b1 == 0);+        return (p == (2,0) && b0 == 0 && boatEquipped && b1 == 0);       } { return false } creative: true solution: |

@@ -8,10 +8,10 @@       try {         r <- robotNumbered 1;         p <- as r {whereami};-        boatInstalled <- as r {installed "boat"};+        boatEquipped <- as r {equipped "boat"};         b1 <- as r {count "boat"};         b0 <- as base {count "boat"};-        return (p == (2,0) && b0 == 1 && boatInstalled && b1 == 0);+        return (p == (2,0) && b0 == 1 && boatEquipped && b1 == 0);       } { return false } creative: true solution: |

@@ -8,10 +8,10 @@       try {         r <- robotNumbered 1;         p <- as r {whereami};-        boatInstalled <- as r {installed "boat"};+        boatEquipped <- as r {equipped "boat"};         b1 <- as r {count "boat"};         b0 <- as base {count "boat"};-        return (p == (2,0) && b0 == 0 && boatInstalled && b1 == 0);+        return (p == (2,0) && b0 == 0 && boatEquipped && b1 == 0);       } { return false } solution: |   build {require "boat"; move; require "boat"; move}

@@ -1,7 +1,7 @@ version: 1-name: Install devices while reprogramming+name: Equip devices while reprogramming description: |-  While executing 'reprogram', we should install any required devices which+  While executing 'reprogram', we should equip any required devices which   the target robot doesn't have.   https://github.com/swarm-game/swarm/pulls/533 objectives:@@ -14,13 +14,13 @@          fred <- robotNamed "fred";         p <- as fred {whereami};-        boatInstalled <- as fred {installed "boat"};-        drillInstalled <- as fred {installed "metal drill"};-        solarInstalled <- as fred {installed "solar panel"};-        treadsInstalled <- as fred {installed "treads"};+        boatEquipped <- as fred {equipped "boat"};+        drillEquipped <- as fred {equipped "metal drill"};+        solarEquipped <- as fred {equipped "solar panel"};+        treadsEquipped <- as fred {equipped "treads"};          return (p == (2,0)-                && boatInstalled && drillInstalled && solarInstalled && treadsInstalled+                && boatEquipped && drillEquipped && solarEquipped && treadsEquipped                 && base_boats == 1 && base_solar == 1                 && base_treads == 1 && base_drills == 1                );

@@ -1,7 +1,7 @@ version: 1-name: Install devices + entities while reprogramming+name: Equip devices + entities while reprogramming description: |-  While executing 'reprogram', we should install any required devices and+  While executing 'reprogram', we should equip any required devices and   give required entities which the target robot doesn't have.   https://github.com/swarm-game/swarm/pulls/533 objectives:@@ -15,11 +15,11 @@          fred <- robotNamed "fred";         p <- as fred {whereami};-        boatInstalled <- as fred {installed "boat"};-        drillInstalled <- as fred {installed "metal drill"};+        boatEquipped <- as fred {equipped "boat"};+        drillEquipped <- as fred {equipped "metal drill"};         fred_rocks <- as fred {count "rock"}; -        return (p == (2,0) && boatInstalled && drillInstalled+        return (p == (2,0) && boatEquipped && drillEquipped                 && base_boats == 1 && base_solar == 1                 && base_treads == 1 && base_drills == 1                 && base_rocks == 42 && fred_rocks == 8

@@ -3,7 +3,9 @@ description: |   First, get some trees; then, use them to build a harvester. objectives:-  - goal:+  - id: get_trees+    teaser: Get trees+    goal:       - Your first goal is to get three trees.     condition: |       try {@@ -14,6 +16,7 @@       - Nice job.  Now, build a harvester.     condition: |       try { as base {has "harvester"} } {return false}+    prerequisite: get_trees solution: |   build {turn right; move; move; grab; move; grab; move; grab; turn back; move; move; move; move};   wait 16;

@@ -9,7 +9,7 @@       try {         as base {l <- has "detonator"; return (not l)}       } { return false }-# When testing, add `s <- build {...}; n <- as s {whoami}; log n` +# When testing, add `s <- build {...}; n <- as s {whoami}; log n` solution: |   def forever = \c. c ; forever c end;   def unblock = try {drill forward} {} end;@@ -18,7 +18,13 @@   r <- build {     wait 2;     log "Hi, I am builder";-    forever (build {log "Hi, I am pusher"; turn forward; forever push}; log "- robot built")+    forever (+      build {+        log "Hi, I am pusher";+        forever push+      };+      log "- robot built"+    )   };   wait 10;   place "detonator";

@@ -0,0 +1,38 @@+version: 1+name: Test issue 397 (wrong device reported missing)+description: |+  A scenario designed to trigger issue 397, where in certain+  situations involving a capability with no candidate devices,+  an incorrect error message was generated reporting some other+  device to be missing.+  https://github.com/swarm-game/swarm/issues/397+objectives:+  - condition: |+      t <- time; return (t == 2)+    goal:+    - |+      This is a dummy condition that just ensures the base has had+      time to run the problematic `build` command.  The scenario+      *should* generate an error message; what we really care about is+      whether the generated error message is correct, which is checked+      in test/integration/Main.hs .+solution: |+  build {move; turn right; loc <- whereami}+robots:+  - name: base+    dir: [0,1]+    devices:+      - 3D printer+      - logger+    inventory:+      - [1, treads]+      - [1, solar panel]+world:+  default: [blank]+  palette:+    'Ω': [grass, null, base]+    '.': [grass]+  upperleft: [0,1]+  map: |+    .+    Ω

@@ -32,10 +32,8 @@ until (ishere "lodestone") {grab};  // get two bit (0)-// TODO: require should not be necessary build {   log "Hi!";-  require "branch predictor";   repeat (     log "I am going for a bit";     turn east; m2; x <- until (ishere "bit (0)") {harvest}; turn back; m2; place x;

@@ -27,6 +27,7 @@       - branch predictor     inventory:       - [10, drill]+      - [10, lambda]       - [10, logger]       - [10, compass]       - [10, treads]

@@ -0,0 +1,4 @@+795-prerequisite-or.yaml+795-prerequisite-and.yaml+795-prerequisite-mutually-exclusive.yaml+795-prerequisite-cycle-with-not.yaml

@@ -0,0 +1,50 @@+version: 1+name: |+  Prerequisite objectives: AND+description: |+  Complete an objective with a prerequisite entailing both of two other objectives.+objectives:+  - goal:+      - Achieve both of two other objectives+    condition: |+      return true;+    prerequisite:+      previewable: true+      logic:+        and:+          - have_furnace+          - have_gear+  - id: have_furnace+    goal:+      - Make a "furnace".+    condition: |+      as base {has "furnace"};+    optional: true+  - id: have_gear+    goal:+      - Make a "wooden gear".+    condition: |+      as base {has "wooden gear"};+    optional: true+solution: |+  make "furnace";+  make "wooden gear";+robots:+  - name: base+    display:+      char: 'Ω'+      attr: robot+    dir: [0, 1]+    devices:+      - workbench+      - grabber+    inventory:+      - [2, board]+      - [5, rock]+world:+  default: [blank]+  palette:+    'x': [grass, null, base]+  upperleft: [0, 0]+  map: |+    x

@@ -0,0 +1,42 @@+version: 1+name: |+  Prerequisite objectives: non-dependency cycle due to the NOT+description: |+  This should NOT be rejected by the parser.+  The two objectives do reference each other,+  but the NOT is a distinct reference from the non-negated goal.+objectives:+  - id: have_furnace+    goal:+      - Make a "furnace".+    condition: |+      as base {has "furnace"};+    prerequisite:+      not: have_gear+  - id: have_gear+    goal:+      - Make a "wooden gear".+    condition: |+      as base {has "wooden gear"};+    prerequisite: have_furnace+solution: |+  make "wooden gear";+  make "furnace";+robots:+  - name: base+    display:+      char: 'Ω'+      attr: robot+    dir: [0, 1]+    devices:+      - workbench+    inventory:+      - [2, board]+      - [5, rock]+world:+  default: [blank]+  palette:+    'x': [grass, null, base]+  upperleft: [0, 0]+  map: |+    x

@@ -0,0 +1,61 @@+version: 1+name: |+  Mutually exclusive prerequisites+description: |+  Complete an objective with a prerequisite of either of two other objectives.+objectives:+  - goal:+      - Either obtain a "furnace" WITHOUT a "flower", or obtain both a "wooden gear" and "flower".+    condition: |+      return true;+    prerequisite:+      previewable: true+      logic:+        or:+          - and:+            - id: have_furnace+            - not:+                id: have_flower+          - and:+            - id: have_gear+            - id: have_flower+  - id: have_furnace+    goal:+      - Make a "furnace".+    condition: |+      as base {has "furnace"};+    +    optional: true+  - id: have_gear+    goal:+      - Make a "wooden gear".+    condition: |+      as base {has "wooden gear"};+    optional: true+  - id: have_flower+    goal:+      - Possess a "flower".+    condition: |+      as base {has "flower"};+    optional: true+solution: |+  make "furnace"+robots:+  - name: base+    display:+      char: 'Ω'+      attr: robot+    dir: [0, 1]+    devices:+      - workbench+      - grabber+    inventory:+      - [2, board]+      - [5, rock]+world:+  default: [blank]+  palette:+    'x': [grass, flower, base]+  upperleft: [0, 0]+  map: |+    x

@@ -0,0 +1,49 @@+version: 1+name: |+  Prerequisite objectives: OR+description: |+  Complete an objective with a prerequisite of either of two other objectives.+objectives:+  - goal:+      - Achieve one of two other objectives+    condition: |+      return true;+    prerequisite:+      previewable: true+      logic:+        or:+          - id: have_furnace+          - id: have_gear+  - id: have_furnace+    goal:+      - Make a "furnace".+    condition: |+      as base {has "furnace"};+    optional: true+  - id: have_gear+    goal:+      - Make a "wooden gear".+    condition: |+      as base {has "wooden gear"};+    optional: true+solution: |+  make "wooden gear"+robots:+  - name: base+    display:+      char: 'Ω'+      attr: robot+    dir: [0, 1]+    devices:+      - workbench+      - grabber+    inventory:+      - [2, board]+      - [5, rock]+world:+  default: [blank]+  palette:+    'x': [grass, flower, base]+  upperleft: [0, 0]+  map: |+    x

@@ -0,0 +1,3 @@+858-possession-objective.yaml+858-nonpossession-objective.yaml+858-counting-objective.yaml

@@ -0,0 +1,36 @@+version: 1+name: Evaluate count of an item+description: |+  The goal criteria is exactly the same as+  858-possession-objective but evaluated+  with the "count" function instead.+creative: false+objectives:+  - goal:+      - |+        Get 1 tree.+    condition: |-+      as base {+        itemCount <- count "tree";+        return $ itemCount > 0;+      };+robots:+  - name: base+    dir: [0, 1]+    devices:+      - treads+      - scanner+      - grabber+solution: |+  move;+  grab;+known: [tree]+world:+  default: [blank]+  palette:+    'B': [grass, null, base]+    'w': [grass, tree]+  upperleft: [0, 0]+  map: |-+    w+    B

@@ -0,0 +1,35 @@+version: 1+name: Evaluate nonpossession of an item+description: |+  Opposite test case of 858-possession-objective+creative: false+objectives:+  - goal:+      - |+        Get rid of 1 tree.+    condition: |-+      as base {+        x <- has "tree";+        return $ not x;+      };+robots:+  - name: base+    dir: [0, 1]+    devices:+      - treads+      - scanner+      - grabber+    inventory:+      - [1, tree]+solution: |+  place "tree";+known: [tree]+world:+  default: [blank]+  palette:+    'B': [grass, null, base]+    'w': [grass]+  upperleft: [0, 0]+  map: |-+    w+    B

@@ -0,0 +1,33 @@+version: 1+name: Evaluate possession of an item+description: |+  test case+creative: false+objectives:+  - goal:+      - |+        Get 1 tree.+    condition: |-+      as base {+        has "tree";+      };+robots:+  - name: base+    dir: [0, 1]+    devices:+      - treads+      - scanner+      - grabber+solution: |+  move;+  grab;+known: [tree]+world:+  default: [blank]+  palette:+    'B': [grass, null, base]+    'w': [grass, tree]+  upperleft: [0, 0]+  map: |-+    w+    B

@@ -0,0 +1,52 @@+version: 1+name: Test meet and meetAll commands+description: |+  Make sure meet prefers a robot on the same cell, and test meetAll+  by giving everyone a boat.+objectives:+  - condition: |+      r0 <- robotNamed "other0";+      b0 <- as r0 { has "boat" };+      teleport self (0,0);+      b1 <- meetAll (\b. \r. b0 <- as r {has "boat"}; return (b && b0)) true;+      n2 <- as r0 { count "boat" };+      return (b0 && b1 && (n2 == 2))+solution: |+  mr0 <- meet;+  case mr0 (\_. return ()) (\r0. give r0 "boat");+  meetAll (\_. \r. give r "boat") ()+robots:+  - name: base+    loc: [0,0]+    dir: [1,0]+    devices:+      - logger+      - antenna+      - ADT calculator+      - grabber+    inventory:+      - [7, boat]+  - name: other0+    loc: [0,0]+    dir: [1,0]+  - name: other+    dir: [1,0]+world:+  default: [blank]+  palette:+    '.': [grass]+    'Ω': [grass, null]+    'o': [grass, null, other]+    '┌': [stone, upper left corner]+    '┐': [stone, upper right corner]+    '└': [stone, lower left corner]+    '┘': [stone, lower right corner]+    '─': [stone, horizontal wall]+    '│': [stone, vertical wall]+  upperleft: [-2, 2]+  map: |+    ┌───┐+    │.o.│+    │oΩo│+    │.o.│+    └───┘

@@ -0,0 +1,28 @@+version: 1+name: Test heading command+description: |+  Test the `heading` command.+  https://github.com/swarm-game/swarm/issues/955+objectives:+  - condition: |+      loc <- as base {whereami};+      h <- as base {heading};+      return $ loc == (1,-1) && h == north+solution: |+  h <- heading; turn east; move; move; turn right; move; move; turn h+robots:+  - name: base+    dir: [0,1]+    devices:+      - treads+      - compass+world:+  default: [blank]+  palette:+    '^': [grass, null, base]+    '.': [grass]+  upperleft: [-1, 1]+  map: |+    ^..+    ...+    ...

@@ -0,0 +1,66 @@+version: 1+name: Test GPS receiver device+description: |+  Test the `whereami` command and GPS receiver device.+  https://github.com/swarm-game/swarm/issues/956+objectives:+  - condition: |+      loc <- as base {whereami};+      return $ loc == (0,0)+    goal:+      - |+        The goal is to move back to the origin after being+        unceremoniously teleported to a random location.  The only way+        to do this is to use a GPS receiver device to learn the+        current location and use the result to decide how to move.+solution: |+  def x = \n. \c. if (n == 0) {} {c ; x (n-1) c} end;+  def abs = \n. if (n<0) {-n} {n} end;+  wait 2;+  loc <- whereami;+  turn (if (fst loc < 0) {east} {west}); x (abs (fst loc)) move;+  turn (if (snd loc < 0) {north} {south}); x (abs (snd loc)) move;+robots:+  - name: base+    dir: [0,1]+    loc: [-5,5]+    devices:+      - clock+      - dictionary+      - GPS receiver+      - treads+      - compass+      - ADT calculator+      - strange loop+      - comparator+      - calculator+      - branch predictor+      - logger+  - name: teleporter+    dir: [0,1]+    loc: [0,0]+    system: true+    display:+      invisible: true+    program: |+      x <- random 11;+      y <- random 11;+      teleport base (x-5, y-5)+world:+  default: [blank]+  palette:+    '.': [grass]+  upperleft: [-5, 5]+  map: |+    ...........+    ...........+    ...........+    ...........+    ...........+    ...........+    ...........+    ...........+    ...........+    ...........+    ...........+

@@ -0,0 +1,57 @@+version: 1+name: Test isempty+description: |+  Test the `isempty` command.+objectives:+  - condition: |+      as base {has "thneed"}+    goal:+      - |+        The goal is to pick up the thing right after the empty+        spot in the row.+solution: |+  def find_thing =+    e <- isempty;+    move;+    if e {} {find_thing}+  end;+  find_thing;+  grab+robots:+  - name: base+    dir: [1,0]+    devices:+      - scanner+      - branch predictor+      - grabber+      - strange loop+      - lambda+      - dictionary+      - logger+      - treads+      - solar panel+entities:+  - name: thneed+    display:+      attr: gold+      char: 'Y'+    description:+    - A thing that everyone needs!+    properties: [portable]+world:+  default: [blank]+  palette:+    '.': [grass]+    '>': [grass, tree, base]+    'o': [grass, rock]+    '$': [grass, LaTeX]+    'i': [grass, cotton]+    '0': [grass, bit (0)]+    '1': [grass, bit (1)]+    'R': [grass, pixel (R)]+    'G': [grass, pixel (G)]+    'B': [grass, pixel (B)]+    'Y': [grass, thneed]+  upperleft: [-5, 5]+  map: |+    >o$i01R.YGB

@@ -0,0 +1,42 @@+version: 1+name: Test issue 961 (custom entities providing capabilities)+description: |+  Test that custom entities providing a capability are considered+  when equipping a new robot.+  https://github.com/swarm-game/swarm/issues/961+objectives:+  - condition: |+      mover <- robotNumbered 1;+      as mover { loc <- whereami; return $ loc == (0,1) }+    goal:+    - |+      Get a robot to (0,1)!+solution: |+  build {move}+entities:+  - name: wheels+    display:+      attr: device+      char: 'o'+    description:+    - A non-traditional means of locomotion.+    properties: [known, portable]+    capabilities: [move]+robots:+  - name: base+    dir: [0,1]+    devices:+      - 3D printer+      - logger+    inventory:+      - [1, wheels]+      - [1, solar panel]+world:+  default: [blank]+  palette:+    'Ω': [grass, null, base]+    '.': [grass]+  upperleft: [0,1]+  map: |+    .+    Ω

@@ -0,0 +1,38 @@+version: 1+name: |+  Prerequisite objectives: dependency cycle+description: |+  This should be rejected by the parser.+objectives:+  - id: have_furnace+    goal:+      - Make a "furnace".+    condition: |+      as base {has "furnace"};+    prerequisite: have_gear+  - id: have_gear+    goal:+      - Make a "wooden gear".+    condition: |+      as base {has "wooden gear"};+    prerequisite: have_furnace+solution: |+  make "wooden gear"+robots:+  - name: base+    display:+      char: 'Ω'+      attr: robot+    dir: [0, 1]+    devices:+      - workbench+    inventory:+      - [2, board]+      - [5, rock]+world:+  default: [blank]+  palette:+    'x': [grass, null, base]+  upperleft: [0, 0]+  map: |+    x

@@ -0,0 +1,38 @@+version: 1+name: |+  Prerequisite objectives: Nonexistent reference+description: |+  This scenario should be unparseable due to typo "shave_furnace" vs "have_furnace"+objectives:+  - goal:+      - Achieve one of two other objectives+    condition: |+      return true;+    prerequisite: shave_furnace+  - id: have_furnace+    goal:+      - Make a "furnace".+    condition: |+      as base {has "furnace"};+    optional: true+solution: |+  make "furnace"+robots:+  - name: base+    display:+      char: 'Ω'+      attr: robot+    dir: [0, 1]+    devices:+      - workbench+      - grabber+    inventory:+      - [2, board]+      - [5, rock]+world:+  default: [blank]+  palette:+    'x': [grass, flower, base]+  upperleft: [0, 0]+  map: |+    x

@@ -0,0 +1,31 @@+version: 1+name: |+  Prerequisite objectives: dependency cycle (self-reference)+description: |+  This should be rejected by the parser.+objectives:+  - id: have_furnace+    goal:+      - Make a "furnace".+    condition: |+      as base {has "furnace"};+    prerequisite: have_furnace+solution: |+  make "furnace"+robots:+  - name: base+    display:+      char: 'Ω'+      attr: robot+    dir: [0, 1]+    devices:+      - workbench+    inventory:+      - [5, rock]+world:+  default: [blank]+  palette:+    'x': [grass, null, base]+  upperleft: [0, 0]+  map: |+    x

@@ -5,9 +5,9 @@ place.yaml types.yaml type-errors.yaml-bind.yaml-install.yaml+equip.yaml build.yaml+bind2.yaml crash.yaml scan.yaml def.yaml

@@ -1,81 +0,0 @@-version: 1-name: Bind notation-description: |-  Learn about command return types and how to bind the results.-objectives:-  - goal:-      - |-        Every command returns a value.  However, some simple commands, like-        `move`, do not have any meaningful-        value to return.  Swarm has a special type, `unit`, with only one value,-        called `()`. Since there is only one possible value of type-        `unit`, returning it does not convey any information.-        Thus, the type of `move` is `cmd unit`.-      - |-        Other commands do return a nontrivial value after executing.-        For example, `grab` has type-        `cmd text`, and returns the name of the-        grabbed entity as a text value. Try it:-      - |-        move; grab-      - |-        To use the result of a command later, you need bind notation, which-        consists of a variable name and a leftwards-pointing arrow-        before the command.  For example:-      - |-        move; t <- grab; place t-      - |-        In the above example, the result returned by `grab` is assigned-        to the variable name `t`, which can then be used later.-        This could be useful, for example, if you do not care what you-        grabbed and just want to move it to another cell, or if you-        are not sure of the name of the thing being grabbed.-      - Once you are done experimenting, do `place "Win"` to finish this challenge.-        (Note, you might need to `grab` the entity you are standing on-        or move to an empty cell first, since each cell can only-        contain at most one entity.)-    condition: |-      try {-        w <- as base {has "Win"};-        return (not w);-      } { return false }-solution: |-  place "Win"-entities:-  - name: Win-    display:-      attr: device-      char: 'W'-    description:-      - Do `place "Win"` once you are done with this challenge.-      - You might need to `grab` the entity you are standing on-        or move to an empty cell first.-    properties: [known, portable]-robots:-  - name: base-    dir: [1,0]-    devices:-      - treads-      - grabber-      - logger-      - compass-      - dictionary-    inventory:-      - [1, Win]-      - [0, tree]-world:-  default: [blank]-  palette:-    '>': [grass, null, base]-    'T': [grass, tree]-    '┌': [stone, upper left corner]-    '┐': [stone, upper right corner]-    '└': [stone, lower left corner]-    '┘': [stone, lower right corner]-    '─': [stone, horizontal wall]-    '│': [stone, vertical wall]-  upperleft: [-1, 1]-  map: |-    ┌───┐-    │>TT│-    └───┘

@@ -0,0 +1,11 @@+build {+    move; move;+    turn right;+    move; move; move; move; move; move;+    x <- grab;+    turn left;+    move;+    turn left;+    move; move;+    place x;+}

@@ -0,0 +1,111 @@+version: 1+name: Bind notation+creative: false+description: |+  Learn about command return types and how to bind the results.+objectives:+  - id: grab_artifact+    teaser: Retrieve artifact+    goal:+      - |+        A pedestal stands conspicuously empty in the center of the room.+        Perhaps its intended contents lie nearby?+      - |+        Build a robot to retrieve and restore the mystery artifact to its proper place!+      - |+        Note: If you find yourself stuck, you can select "Start over" from+        the "Quit" (CTRL+q) dialog.+    condition: |+      try {+        p <- robotnamed "floorspot";+        w <- as p {ishere "Hastur"};+        return (not w);+      } { return false }+  - goal:+      - |+        Your robot obtained the misplaced artifact! Next you need to put it back+        on the pedestal.  But neither you nor your robot knows the+        artifact's name.  How can it be placed?+      - |+        Every command returns a value.  However, some simple commands, like+        `move`, do not have any meaningful+        value to return.  Swarm has a special type, `unit`, with only one value,+        called `()`. Since there is only one possible value of type+        `unit`, returning it does not convey any information.+        Thus, the type of `move` is `cmd unit`.+      - |+        Other commands do return a nontrivial value after executing.+        For example, `grab` has type `cmd text`, and returns the name of the+        grabbed entity as a text value.+      - |+        To use the result of a command later, you need "bind notation", which+        consists of a variable name and a leftwards-pointing arrow+        before the command.  For example:+      - |+        move; t <- grab; place t+      - |+        In the above example, the result returned by `grab` is assigned+        to the variable name `t`, which can then be used later.+        This is useful, for example, if you do not care what you+        grabbed and just want to move it to another cell, or if you+        are not sure of the name of the thing being grabbed.+      - |+        Reminder: if you need to start over, your previous commands are+        accessible in the REPL history (up-arrow).+    condition: |+      try {+        p <- robotnamed "pedestal";+        w <- as p {ishere "Hastur"};+        return w;+      } { return false }+    prerequisite: grab_artifact+solution: |+  run "data/scenarios/Tutorials/bind2-solution.sw"+entities:+  - name: Hastur+    display:+      attr: gold+      char: 'H'+    description:+      - The Unspeakable One+    properties: [portable]+robots:+  - name: base+    dir: [0,1]+    display:+      char: Ω+      attr: robot+    devices:+      - 3D printer+    inventory:+      - [1, solar panel]+      - [1, treads]+      - [1, grabber]+  - name: floorspot+    system: true+  - name: pedestal+    system: true+world:+  default: [blank]+  palette:+    '.': [blank, null]+    'Ω': [blank, null, base]+    'x': [dirt, null]+    'H': [blank, Hastur, floorspot]+    's': [stone, null, pedestal]+    '┌': [stone, upper left corner]+    '┐': [stone, upper right corner]+    '└': [stone, lower left corner]+    '┘': [stone, lower right corner]+    '─': [stone, horizontal wall]+    '│': [stone, vertical wall]+  upperleft: [-1, -3]+  map: |+    ┌─────────┐+    │.........│+    │...xxx...│+    │...xsx...│+    │...xxxH..│+    │.........│+    │Ω┌───────┘+    └─┘........

@@ -14,11 +14,9 @@       - You can build a robot with `build {COMMANDS}`,         where in place of `COMMANDS` you write the sequence         of commands for the robot to execute (separated by semicolons).-      - Build a robot to harvest the flower and place it next-        to the water.       - |-        TIP: You can use the name of the flower directly ("pickerelweed"),-        or you can use bind notation: `f <- harvest; ... ; place f;`.+        Build a robot to harvest the "flower" and place it next+        to the water.       - |         TIP: Newly built robots start out facing the same         direction as their parent, which in the tutorials will always be north.@@ -26,26 +24,15 @@       try {         teleport self (0,-1);         turn east;-        a <- ishere "pickerelweed";+        a <- ishere "flower";         move;-        b <- ishere "pickerelweed";+        b <- ishere "flower";         move;-        c <- ishere "pickerelweed";+        c <- ishere "flower";         return (a || b || c);       } { return false }-entities:-  - name: pickerelweed-    display:-      attr: flower-      char: '*'-    description:-      - A small plant that grows near the water.-    properties: [known, portable, growable]-    # It would make sense for the plant to NOT grow away from water.-    # But if the player sent a robot that grabbed it and then did not-    # place it, another robot would need to salvage that robot. solution: |-  build {turn right; move; move; t <- harvest; turn right; move; place t}+  build {turn right; move; move; harvest; turn right; move; place "flower"} robots:   - name: base     dir: [0,1]@@ -69,7 +56,7 @@     'Ω': [grass, null, base]     '.': [grass]     '~': [ice, water]-    '*': [grass, pickerelweed]+    '*': [grass, flower]     '┌': [stone, upper left corner]     '┐': [stone, upper right corner]     '└': [stone, lower left corner]

@@ -62,9 +62,6 @@   def pick = move; ifC (ishere VSR) {grab; return ()} {} end;   def pickrow = x4 pick; turn back; x4 move end;   build {-    require "treads"; require "branch predictor"; require "grabber";-    require "lambda"; require "scanner";  // #540-     turn south; x4 (move; tL; pickrow; tL); tB; x4 move; x4 (give base VSR)   } robots:

@@ -15,6 +15,11 @@         available recipes.       - Your goal is to make a "branch predictor", so you will have to make         some "branch"es first.+      - |+        Note: when used after opening quotes in the REPL, the Tab key can cycle through+        possible completions of a name. E.g., type:+      - |+        > make "br[Tab][Tab]     condition: |       try {         as base {has "branch predictor"}

@@ -15,41 +15,39 @@ end;  // At the beginning all robots can be given Win.-def allOK: robot -> bool = \rob.+def allOK: actor -> bool = \rob.   true end; +myLoc <- whereami;+ // Try to give a robot a Win, filtering out those that were already given a Win. // The robot will also receive instructions, so it **must have a logger!**-def tryGive: text -> (robot -> bool) -> int -> cmd (robot -> bool) = \msg.\f.\i.-  r <- try {-    robotNumbered i;-  } {-    log $ "could not find robot " ++ format i;-    return self-  };-  if (r != self && f r) {-    log $ "found the robot " ++ format i;-    l <- whereami;-    rl <- as r {whereami}; wait 1;  // WHY is this 'wait 1' required???-    if (l != rl) {-      log $ "the robot" ++ format i ++ "is not in my cell";-      return f;+def tryGive: text -> (actor -> bool) -> cmd (actor -> bool) = \msg.+  // (b -> actor -> cmd b) -> b -> cmd b+  meetAll $ \f.\rob.+    if (not $ f rob) {+      log $ "skipping the robot " ++ format rob ++ "because it already has a Win";+      return f     } {-      try {-        reprogram r { log msg; };-        log $ "successfully reprogrammed robot " ++ format i;-        give r "Win";-        log $ "successfully gave Win to robot " ++ format i;+      robLoc <- as rob {whereami};+      if (robLoc != myLoc) {+        log $ "the robot" ++ format rob ++ "is not in my cell";+        return f;       } {-        log $ "the robot " ++ format i ++ "is missing a logger!"-      };-      return (\rob. (rob != r && f rob));+        try {+          reprogram rob { log msg; };+          log $ "successfully reprogrammed robot " ++ format rob;+          give rob "Win";+          log $ "successfully gave Win to robot " ++ format rob;+          return (\r. (rob != r && f rob));+        } {+          log $ "the robot " ++ format rob ++ "is missing a logger!";+          return f;+        };+        +      }     }-  } {-    log $ "skipping the robot " ++ format i;-    return f-  } end;  // -------------------------------------------------------------------------@@ -57,7 +55,7 @@ // -------------------------------------------------------------------------  log "Hi, I am secret";-iterate allOK (foreachF 1 16 $ tryGive+iterate allOK (tryGive   $ "Send a robot to `salvage` me and come back to `give base \"Win\"`.\n"   ++ "When the rescue robot stands where I am and executes `salvage`,\n"   ++ "all my inventory and logs will go to it, including the \"Win\".\n"