Computer Science E50a Wednesday Section . 7:30 . Emerson 106

TF: Alix Marchandise-Franquet September 30th, 1998

A new built-in class of robot: Robot

What more can robots of that class do?
They can sense more things than the basic ur_Robot:

the direction they are facing (East, West, North, South)
the presence/absence of wall segments
the presence/absence of beepers on their corner
the presence/absence of robots (of any class) on their corner
the presence/absence of beepers in their bag

Our old friend the ur_Robot could already sense number 2, 3 and 5. However, it only used this information to shut itslef off in case it attempted to pick an unexistent beeper for example.
Now, with the more sophisticated Robot, you have access to these informations through new built-in functions. Each of these can have one of two values: true or false.

facingNorth() // true if the Robot is facing North, false otherwise
facingEast()
facingWest()
facingSouth()
frontIsClear() // true if there is no wall section between the Robot's corner and the next corner in the direction it is facing
nextToABeeper() // true if there is a beeper on the Robot's corner
nextToARobot() // true if there is a robot (of any type) on the Robot's corner
anyBeepersInBeeperBag()

Negation !

You have a new tool for your programs: the possibility of negating a value, ie changing a true into a false and a false into a true. This means that you can get even more information regarding your Robot. By adding an exclamation mark ! in front of a condition, you can test for its negation.
For example, !frontIsClear() means that the front is blocked.

If ...

Now that you have these new conditions that you can test (whether the Robot is facing East or not etc...), you need a way to do so. This is where if is useful. This lets you have the robot execute some instructions only in certain situations (for example, you only want your robot to try picking up a beeper if there is one on his corner, otherwise you will get an error shutoff).

if ( condition )
{
instructions to be executed if the condition is true
}

Three important things:

enclose the condition that you want to test in parentheses ()
put curly braces {} around the set of instructions to be executed if true condition
indent!! remember the rule: indent every time you open a curly brace

If ... else ...

You can think of the else as "otherwise": if A do B, otherwise (ie if not A) then do C, where A is a condition that is tested, and B and C are sets of instructions.
if ( condition )
{
instructions to be executed if the condition is true
}
else
{
instructions to be executed if the condition is false
}

You can have nested if ... else statements. Example:
if (Karel.anyBeepersInBeeperBag())
{
// Karel only looks in here if there are Beepers in the bag
//otherwise it skips to the final else
if (Karel.nextToABeeper())
{
// at this point, Karel must have beepers in its bag
// and there must be a beeper on the corner
   Karel.pickBeeper();
   Karel.turnLeft();
}
else
{
// at this point, Karel has beepers in its bag,
// but there are no beepers on the corner
   Karel.putBeeper();
   Karel.turnRight();
}
}
else
{
// Karel will only turnLeft() and turnOff() if
// it had no beepers in its beeper bag
Karel.turnOff();
}

Note:
You don't necessarily need an else clause. Maybe you want Karel to turnLeft if it is facing East, but stay in the same position otherwise. Also, if in the if clause, you turnOff Karel, then you don't need an else either because you know that it will not execute any other instruction anyway. We will see another case later today.

Making your own conditions

Remember that last week, you were able to define new instructions for the robots.
This week, you learned how to define new conditions. These will also have one of two values: true or false (in lower case). These values are returned by the function you define. Since we are now returning values, we use a new word: Boolean where we used to write void in our new definitions. Boolean means that the function will return true or false. To build new conditions, we start from the basic ones (and their negations) that are built in the Robot class (see above).

Example with appropriate comments and indentation:

// A robot of class myRobot can turn around,
// figure out if it is on a busy corner and if its back is blocked
class myRobot : Robot
{
Boolean busyCorner();
Boolean backIsBlocked();
void turnAround();
};

// Makes the robot face the opposite direction
void myRobot :: turnAround()
{
turnLeft();
turnLeft();
}

// Returns true if there is at least one beeper and at least one other robot
// on the robot's corner, returns false otherwise
Boolean myRobot :: busyCorner()
{
if (nextToABeeper())
{
if (nextToARobot())
   {
      return true;
   }
}
return false;
}