##################################################################

# Elaboration productions

sp { elaborate*init
   (state <s> ^superstate nil)
   -->
   (<s> ^close-distance 800)
}

sp { elaborate*robot*stopped
   (state <s> ^io.input-link.currentcycle.robot.Vel 0.0)
   -->
   (<s> ^condition robot-stopped)
}

sp { elaborate*robot*moving
   (state <s> ^io.input-link.currentcycle.robot.Vel { <v> <> 0.0 } )
   -->
   (<s> ^condition robot-moving)
}

sp { elaborate*object-nearby-in-front
   (state <s> ^io.input-link.currentcycle <c>)
   (<c> ^sonar.sonar <son>)
   (<s> ^close-distance <cl>)
   (<son> ^number << 2 3 4 5 >> )
   (<son> ^reading { <v> < <cl> } )
   -->
   (<s> ^condition object-nearby-in-front)
}

sp { elaborate*object-nearby-to-right
   (state <s> ^io.input-link.currentcycle <c>)
   (<c> ^sonar.sonar <son>)
   (<s> ^close-distance <cl>)
   (<son> ^number << 6 7 >> )
   (<son> ^reading { <v> < <cl> } )
   -->
   (<s> ^condition object-nearby-to-right)
}

sp { elaborate*object-nearby-to-left
   (state <s> ^io.input-link.currentcycle <c>)
   (<c> ^sonar.sonar <son>)
   (<s> ^close-distance <cl>)
   (<son> ^number << 0 1 >> )
   (<son> ^reading { <v> < <cl> } )
   -->
   (<s> ^condition object-nearby-to-left)
}

##################################################################

# Operators

sp { propose*move*forward
   (state <s>)
   (<s> ^condition robot-stopped)
 - (<s> ^condition object-nearby-in-front)
 - (<s> ^action moving-forward)
   -->
   (<s> ^operator <o> + = )
   (<o> ^name move-forward)
   (<o> ^target-velocity 200)
}

sp { apply*move*forward
   (state <s> ^io.output-link <ol> ^operator <o>)
   (<o> ^name move-forward)
   (<o> ^target-velocity <vel>)
   -->
   (<s> ^action moving-forward)
   (<ol> ^command <com>)
   (<com> ^name setVel ^param1 <vel>)
}

# turn right
sp { propose*start*turn*right
   (state <s>)
   (<s> ^condition object-nearby-in-front)
 - (<s> ^condition object-nearby-to-right)
 - (<s> ^action turning-right)
   -->
   (<s> ^operator <o> + =)
   (<o> ^name start-turn-right)
}

sp { apply*start*turn*right
   (state <s> ^io.output-link <ol> ^operator <o>)
   (<o> ^name start-turn-right)
   -->
   (<s> ^action turning-right)
   (<ol> ^command <com>)
   (<com> ^name setVel2 ^param1 150 ^param2 0)
}

sp { propose*stop*turn*right
   (state <s>)
 - (<s> ^condition object-nearby-in-front)
   (<s> ^action turning-right)
   -->
   (<s> ^operator <o> + =)
   (<o> ^name stop-turn-right)
}

sp { apply*stop*turn*right
   (state <s> ^io.output-link <ol> ^operator <o>)
   (<o> ^name stop-turn-right)
   -->
   (<s> ^action turning-right -)
   (<ol> ^command <com>)
   (<com> ^name setVel ^param1 200)
}

# turn left
sp { propose*start*turn*left
   (state <s>)
   (<s> ^condition object-nearby-in-front)
 - (<s> ^condition object-nearby-to-left)
 - (<s> ^action turning-left)
   -->
   (<s> ^operator <o> + =)
   (<o> ^name start-turn-left)
}

sp { apply*start*turn*left
   (state <s> ^io.output-link <ol> ^operator <o>)
   (<o> ^name start-turn-left)
   -->
   (<s> ^action turning-left)
   (<ol> ^command <com>)
   (<com> ^name setVel2 ^param1 0 ^param2 150)
}

sp { propose*stop*turn*left
   (state <s>)
 - (<s> ^condition object-nearby-in-front)
   (<s> ^action turning-left)
   -->
   (<s> ^operator <o> + =)
   (<o> ^name stop-turn-left)
}

sp { apply*stop*turn*left
   (state <s> ^io.output-link <ol> ^operator <o>)
   (<o> ^name stop-turn-left)
   -->
   (<s> ^action turning-left -)
   (<ol> ^command <com>)
   (<com> ^name setVel ^param1 200)
}

# rotate
sp { propose*start*rotate
   (state <s>)
   (<s> ^condition object-nearby-in-front)
   (<s> ^condition object-nearby-to-right)
   (<s> ^condition object-nearby-to-left)
 - (<s> ^action rotating)
   -->
   (<s> ^operator <o> + =)
   (<o> ^name start-rotating)
}

sp { apply*start*rotate
   (state <s> ^io.output-link <ol> ^operator <o>)
   (<o> ^name start-rotating)
   -->
   (<s> ^action rotating)
   (<ol> ^command <com>)
   (<com> ^name setVel2 ^param1 -100 ^param2 100)
}

sp { propose*stop*rotate
   (state <s>)
 - (<s> ^condition object-nearby-in-front)
   (<s> ^action rotating)
   -->
   (<s> ^operator <o> + =)
   (<o> ^name stop-rotating)
}

sp { apply*stop*rotate
   (state <s> ^io.output-link <ol> ^operator <o>)
   (<o> ^name stop-rotating)
   -->
   (<s> ^action rotating -)
   (<ol> ^command <com>)
   (<com> ^name setVel ^param1 200)
}

# Wait operator

sp { propose*wait*operator
   (state <s> ^attribute state
              ^choices none
             -^operator.name wait)
   -->
   (<s> ^operator <o> +)
   (<o> ^name wait)
}

sp { apply*wait*operator
   (state <s> ^operator <o>)
   (<o> ^name wait)
   -->
   (<o> ^random elaboration)
}

##################################################################

# Action removal production

# The test of the output-link guarantees that
# there has been an output phase between the application/elaboration
# that placed the output command on the link and the firing of this one.  
sp { apply*remove-command
        (state <s> ^io.output-link <ol>)
        (<ol> ^command <com>)
	(<com> ^status complete)
	(<s> ^operator.name <any>)
        -->
	(<ol> ^command <com> -) }