#character 'A'

paintWhite

forward(2)
right
forward(1)
right
forward(2)
backward(1)
right
forward(1)

stopPainting

# Writes the word 'robo' on the ground.
# The script was created using the remote control.
# map: default.map
# letter r 
paintBlack 
forward(1)
right
forward(1)
stopPainting

forward(1)

# letter o 
paintBlack
forward(1)
right
forward(1)
right
forward(1)
right
forward(1)
stopPainting

right
forward(1)
forward(1)
left
right
right
backward(1)

# letter b 
paintBlack
forward(1)
forward(1)
left
forward(1)
left
forward(1)
left
forward(1)
stopPainting

backward(1)
backward(1)
right
right

# letter o
paintBlack
forward(1)
right
forward(1)
right
forward(1)
right
forward(1)
stopPainting

right
forward(1)
forward(1)

repeat(n){...instructions...}

Example1:
# a square of 2x2

repeat(4)
{
	forward(2)
	right
}

repeat{...instructions...}

Example2:
# just goes forward
# (but eventually will stay hitting a wall)

repeat
{
	forward(1)
}

repeatWhile(condition){...instructions...}

Example3:
# keeps going forward, 
# but stops when it can't go any further

repeatWhile(frontIsClear)
{
	forward(1)
}

Break

Example4:
# keep going forward, until you can't go any further

repeat
{
	if(frontIsObstacle)
    {
		break
	}
	else
	{	
		forward(1)
	}
}

if(condition){...instructions...}

Example5: 
# if you see white paint on your left, make it black

if(leftIsWhite)
{
	left
	forward(1)
	paintBlack
	stopPainting
	backward(1)
	right
}

if(condition){...instructions...}else{...instructions...}

Example6:
# if you see white paint on your left, make it black
# else drive a few steps forward

if(leftIsWhite)
{
	left
	forward(1)
	paintBlack
	stopPainting
	backward(1)
	right
}
else
{
	forward(3)
}

Example7:
if(leftIsWhite)
{
    left
    forward(1)    
}

Example8:
				
repeatWhile(not frontIsClear and (leftIsWhite or rightIsWhite)){
    forward(1)
}

if(flipCoin and not rightIsWhite)
{
    right
    backward(1)
}

if(true and false){
    # this instruction is never executed
    forward(1)
}

Example9:
forward
maybeToRight(8)
forward

procedure maybeToRight(n){
    if(n < 5){
        right
    }
}

repeat{
    if(leftIsWhite){
        # There's a white spot on your left
        left
        forward(1)
        end
    }
    else{
        # There's no white spot yet
        forward(1)
    }
}

repeatWhile(leftIsObstacle){
    forward(1)
}


left
forward(1)

repeat{
    if(rightIsObstacle){
        if(frontIsClear){
            forward(1)
        }

        else{
            left
        }
    }

    else{
        right
        forward(1)
    }

    if(frontIsBeacon){
        pickUp
        end
    }
}

procedure name(par1, par2, ... , parN){...instructions...}

Example10:
# define how to draw a rectangle

procedure rectangle(width, height)
{
	paintWhite
	repeat(2)
	{
		forward(height)
		right
		forward(width)
		right
	}
	stopPainting
}

name(arg1, arg2, . . . , argN)

Example11:
# these instructions will be performed

forward(1)

rectangle(3,2) # a call to the 'rectangle' procedure

forward(3)

rectangle(1,4) # another call with other arguments


# this is the definition of 'rectangle' procedure

procedure rectangle(width, height)
{
	paintWhite
	repeat(2)
	{
		forward(height)
		right
		forward(width)
		right
	}
	stopPainting
}

Example12:
# these instructions will be performed

toWall()    # no arguments
right
forward

# go forward until you reach a wall

procedure toWall()     # no parameters
{
    repeat
    {
        if(frontIsObstacle)
        {
            # stop "toWall" procedure,
            # continue with right and forward

            return
        }
        else{
            forward
        }
    }
}

return(arg)

Example13:
# this instruction will be performed

forward(double(3))

# double the given amount

procedure double(n)
{
    return(2 * n)
}

Example14:
# these instructions will be performed

toWall()
right
forward

# go forward until you reach a wall

procedure toWall()
{
      # notice that no loops are used

      if(frontIsObstacle)
      {
          # stop "toWall" procedure
          return
      }
      else{
          # do one step
          forward
          # and do a recursive call!
          toWall()
      }
}