Watch for robots as well (#2538)

* fix `wakeWatchingRobots` to allow calling it more than once
* make Debug tutorial system robot more efficient using `watchRobots`
* change ranching scenario solution to work with watching for robots (do not step on the watched space too soon)
* move robot naming state to separate module
* move robots state and lenses to an internal module
* make gopher move silently
* allow empty appear parameter making robot invisible
* closes #2522 - **this PR is a rebased version with the new map and commands reverted**
* closes #2518
* closes #2395

Author: xsebek

data/scenarios/Challenges/Ranching/_capture/opponent.sw

@@ -22,6 +22,14 @@ def getDirection = \n.
     };
     end;
 
+def forDirs = \c.
+  forwardRes <- c forward;
+  rightRes <- c right;
+  backRes <- c back;
+  leftRes <- c left;
+  pure (forwardRes, rightRes, backRes, leftRes)
+  end;
+
 def watchDir = \n.
     watch $ getDirection n;
     if (n > 0) {
@@ -51,6 +59,18 @@ def reWatch =
     watchDir 4;
     end;
 
+def reWatchEntities = \instantCont.
+    s1 <- instant (
+        forDirs (\d. watch d; scan d)
+    );
+    wait 10000;
+    instant (
+        s2 <- forDirs scan;
+        if (s1 != s2) {instantCont} {}
+    );
+    reWatchEntities instantCont
+    end
+
 def locationIsOpen =
     emptyHere <- isempty;
     blockedCount <- countBlocked 4;
@@ -104,9 +124,7 @@ def handleBlockage =
     end;
 
 def go =
-    instant reWatch;
-    wait 1000;
-    instant handleBlockage;
+    reWatchEntities handleBlockage;
     go;
     end;
 

data/scenarios/Challenges/Ranching/_capture/solution.sw

@@ -106,14 +106,21 @@ def go =
     turn right;
     doN 2 move;
     turn back;
+    log "building bots 1!"; // 4,-6
     buildBot right;
-    turn back;
+    
+    // walk around the watched place
+    turn right;
     move;
-
-    turn left;
+    turn right;
     move;
+    turn left;
+
+    log "building bots 2!";
     buildBot left;
     turn back;
+    wait 20;
+    log "going back now!";
     move;
 
     place obj;

data/scenarios/Challenges/_gopher/gopher.sw

@@ -20,7 +20,7 @@ def goDir = \dist. \d1. \d2.
         turn d2;
     } {};
 
-    doN (abs dist) move;
+    doN (abs dist) (instant (appear "" (inl ()); move; appear "o" (inl ())));
     end;
 
 def randSwap = \f. \g.

data/scenarios/Tutorials/debug-hint.sw

@@ -13,96 +13,118 @@ def foreachF = \s.\e.\com.\state.
   }
 end;
 
+def foldM : (rec l. Unit + a * l) -> b -> (b -> a -> Cmd b) -> Cmd b =
+  \xs. \b. \f. case xs
+    (\_. pure b)
+    (λmatch \h. \t. b' <- f b h; foldM t b' f)
+end
+
 // An infinite while cycle that carries a state.
-def iterate = \state.\com.
-  n <- com state;
-  iterate n com;
-end;
+def iterate = \state. \com. n <- com state; iterate n com end
 
-tydef RobotState = [gave_win: Bool, said_log_missing: Bool, said_loc: (Int * Int)] end;
+// -------------------------------------------------------------------------
+// Robot State - this allows us to skip some commands, so that this hont robot
+// does not have to busy-wait to meet each robot
+tydef RobotState = [gave_win: Bool, said_loc: Int * Int, said_log_missing: Bool] end
 
 // setters
-def set_gave_win         : Bool -> RobotState -> RobotState = \v.\s. [gave_win=v,          said_log_missing=s.said_log_missing, said_loc=s.said_loc] end;
-def set_said_log_missing : Bool -> RobotState -> RobotState = \v.\s. [gave_win=s.gave_win, said_log_missing=v,                  said_loc=s.said_loc] end;
-def set_said_loc  : (Int * Int) -> RobotState -> RobotState = \v.\s. [gave_win=s.gave_win, said_log_missing=s.said_log_missing, said_loc=v         ]end;
+def set_gave_win: Bool -> RobotState -> RobotState 
+  = \v. \s.
+  [gave_win = v, said_loc = s.said_loc, said_log_missing = s.said_log_missing]
+end
 
-tydef RobotsStateList = rec l. Unit + (Actor * RobotState * l) end;
+def set_said_log_missing: Bool -> RobotState -> RobotState 
+  = \v. \s.
+  [gave_win = s.gave_win, said_loc = s.said_loc, said_log_missing = v]
+end
 
-def emptyList = inl () end;
+def set_said_loc: (Int * Int) -> RobotState -> RobotState 
+  = \v. \s.
+  [gave_win = s.gave_win, said_loc = v, said_log_missing = s.said_log_missing]
+end
 
-// At the beginning all robots can be given Win.
+// At the beginning each robot can be given Win.
 def defaultState: RobotState =
-  [gave_win=False, said_log_missing=False, said_loc=(-100,-100)]
-end;
+  [gave_win = false, said_loc = (-100, -100), said_log_missing = false]
+end
 
-def query : Actor -> RobotsStateList -> RobotState = \rob.\l.
-  case l (\_. defaultState) (λmatch \r. λmatch \s.\tail.
-    if (r == rob) {s} {query rob tail}
-  )
-end;
+// The list of met robots
+tydef RobotsStateList = rec l. Unit + (Actor * RobotState * l) end
 
-def update : Actor -> RobotState -> RobotsStateList -> RobotsStateList = \rob.\s.\l.
-  case l (\_. inr (rob, s, emptyList)) (λmatch \nr. λmatch \ns. \tail.
-    if (nr == rob) {
-      inr (rob, s, tail)
-    } {
-      inr (nr, ns, update rob s tail)
-    }
-  )
-end;
+def emptyList = inl () end
 
-myLoc <- whereami;
+def query: Actor -> RobotsStateList -> RobotState 
+  = \rob. λcase
+    (\_. defaultState)
+    (λmatch \r. λmatch \s. \rest.
+      if (r == rob) {s} {query rob rest}
+    )
+end
 
-def foldM : (rec l. Unit + a * l) -> b -> (b -> a -> Cmd b) -> Cmd b =
-  \xs. \b. \f. case xs
-    (\_. pure b)
-    (λmatch \h.\t. b2 <- f b h; foldM t b2 f)
+def update: Actor -> RobotState -> RobotsStateList -> RobotsStateList 
+  = \rob. \s. λcase
+      (\_. inr (rob, s, emptyList))
+      (λmatch \r. λmatch \os. \rest.
+        if (r == rob) {inr (rob, s, rest)} {inr (r, os, update rob s rest)}
+      )
+end
+
+// -------------------------------------------------------------------------
+// Running state
+tydef State = [can_wait: Bool, list: RobotsStateList] end
+
+def updateList: Actor -> RobotState -> State -> State 
+  = \rob. \rs. \state.
+  [can_wait = true, list = update rob rs state.list]
 end
 
+// -------------------------------------------------------------------------
+// Running state
+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 -> RobotsStateList -> Cmd RobotsStateList = \msg. \ok.
+def tryGive: Text -> State -> Cmd State 
+  = \msg. \state.
+  if (state.can_wait) {watch down; wait 2048} {};
   instant (
-    rs <- meetAll;
-    foldM rs ok (\stateList.\rob.
-      let state = query rob stateList in
+    rs <- meetall;
+    foldM rs state (
+      \stateAcc. \rob. let state = query rob stateAcc.list in
       robLoc <- as rob {whereami};
       hasLog <- as rob {try {log "test"; pure true} {pure false}};
       if (state.gave_win) {
-        // log $ "skipping the robot " ++ format rob ++ "because it already has a Win";
-        pure stateList
+        pure stateAcc
       }
-      $elif (robLoc != myLoc && state.said_loc != robLoc) {
-        log $ "the robot " ++ format rob ++ " is not in my cell";
-        pure (update rob (set_said_loc robLoc state) stateList);
+      $ elif (robLoc != myLoc && state.said_loc != robLoc) {
+        log ("the robot" ++ format rob ++ "is not in my cell");
+        pure (updateList rob (set_said_loc robLoc state) stateAcc)
       }
-      $elif (not hasLog && state.said_log_missing)
-      {
-        say $ "the robot " ++ format rob ++ " is missing a logger!";
-        pure (update rob (set_said_log_missing true state) stateList)
-      }
-      { // else 
+      $ elif (not hasLog && state.said_log_missing) {
+        say ("the robot " ++ format rob ++ "is missing a logger!");
+        pure (updateList rob (set_said_log_missing true state) stateAcc)
+      } // else
+       {
         try {
-          reprogram rob { log msg; };
-          log $ "successfully reprogrammed robot " ++ format rob;
+          reprogram rob {log msg};
+          log ("successfully reprogrammed robot " ++ format rob);
           give rob "Win";
-          log $ "successfully gave Win to robot " ++ format rob;
-          pure (update rob (set_gave_win true state) stateList)
+          log ("successfully gave Win to robot " ++ format rob);
+          pure (updateList rob (set_gave_win true state) stateAcc)
         } {
-          log $ "the robot " ++ format rob ++ " is probably still active!";
-          pure stateList
-        };
+          log ("the robot " ++ format rob ++ "is probably still active!");
+          pure [can_wait = false, list = stateAcc.list]
+        }
       }
     )
   )
-end;
+end
 
 // -------------------------------------------------------------------------
 // RUN
 // -------------------------------------------------------------------------
-
 log "Hi, I am the system hint robot";
-iterate emptyList (tryGive
+iterate [can_wait=true, list=emptyList] (tryGive
   $ "Send a robot to `salvage` me and come back to"
   ++ " `give base \"Win\"`.  When the rescue robot stands"
   ++ " where I am and executes `salvage`, all my inventory"
@@ -111,4 +133,4 @@ iterate emptyList (tryGive
   ++ "NOTE: if you are still viewing me when I am salvaged,"
   ++ " you will be in for a surprise!  If this happens just"
   ++ " type `view base` to return to viewing your base."
-)
+)