####################################################################
#  Eater "wall-and-loc"
#  v. 6
#  Remembers wall and location of initial impact with an outer wall.
#
# Requirements:
#  1. Eater must change direction in a clockwise manner
#     on impact with an interior or outer wall.
#  2. Eater must remember location of initial "impact"
#     with an outer wall, and stop when eater reaches it.
#  3. Eater must remember which wall it is currently by.
#     If eater is in a corner, eater must remember two walls.
####################################################################


###
# Initialize some variables.
# Possible values for ^stop: 
#   - empty  (no location stored)
#   - stored (location stored)
#   - wait   (eater has moved away from location)
#   - halt   (eater has returned to locaiton)
###
sp {initialize*state*directions
   (state <ss> ^type state ^superstate nil)
   -->
   (<ss> ^rotated-clockwise <n> <e> <s> <w>)  
   (<n> ^name north ^rotated east)
   (<e> ^name east  ^rotated south)
   (<s> ^name south ^rotated west)
   (<w> ^name west  ^rotated north)
   (<ss> ^initial-location <il>)
   (<il> ^x 0 ^y 0 ^stop empty)
   (<ss> ^wall none) 
   (<ss> ^coord-to-wall <ctw1> <ctw2> <ctw3> <ctw4>)
   (<ctw1> ^x 1  ^wall west)
   (<ctw2> ^x 15 ^wall east)
   (<ctw3> ^y 1  ^wall north)
   (<ctw4> ^y 15 ^wall south)
   }


##################################################################################
########################### Remember initial location ############################
##################################################################################

###
# If eater reaches an outher wall for the first time, save eater's location.
###
sp {propose*save-location
   (state <s> ^initial-location <il>)
   (<s> ^io.input-link.eater <e>)
   (<e> ^x <eater-x> ^y <eater-y>)
   (<il> ^x 0 ^y 0)
   (<s> ^wall <> none)
-->
   (<s> ^operator <o> + >)
   (<o> ^name save-location ^x <eater-x> ^y <eater-y>)
   }

sp {apply*save-location
   (state <s> ^operator <o>)
   (<o> ^name save-location)
   (<o> ^x <x> ^y <y>)
   (<s> ^initial-location <il>)
-->
   (<il> ^x <x> ^y <y> ^stop stored)
   (<il> ^x 0 -)
   (<il> ^y 0 -)
   (<il> ^stop empty -)
   }

###
# Once eater moves one cell away from the stored location, 
# switch the stop variable. Next time eater reaches this location,
# eater will be forced to stop (i.e. a full circle).
###

# Check for horizontal movement
sp {propose*switch-stop*horizontally
   (state <s> ^initial-location <il>)
   (<s> ^io.input-link.eater <e>)
   (<e> ^x <eater-x> ^y <eater-y>)
   (<il> ^stop stored ^x <> <eater-x>)
-->
   (<s> ^operator <o> + >)
   (<o> ^name switch-stop ^switch wait)
   }

# Check for vertical movement
sp {propose*switch-stop*vertically
   (state <s> ^initial-location <il>)
   (<s> ^io.input-link.eater <e>)
   (<e> ^x <eater-x> ^y <eater-y>)
   (<il> ^stop stored ^y <> <eater-y>)
-->
   (<s> ^operator <o> + >)
   (<o> ^name switch-stop ^switch wait)
   }


###
# Once eater reaches its initial position (full circle), halt.
###
sp {propose*halt-eater
   (state <s> ^initial-location <il>)
   (<s> ^io.input-link.eater <e>)
   (<e> ^x <eater-x> ^y <eater-y>)
   (<il> ^x <eater-x> ^y <eater-y>)
   (<il> ^stop wait)
-->
   (<s> ^operator <o> + >)
   (<o> ^name switch-stop ^switch halt)
   }
  

# Change switch value
sp {apply*switch-stop
   (state <s> ^operator <o>)
   (<o> ^name switch-stop ^switch <switch>)
   (<s> ^initial-location <il>)
   (<il> ^stop <old-switch> { <old-switch> <> <switch> })
-->
   (<il> ^stop <switch>)
   (<il> ^stop <old-switch> -)
   }



#################################################################################
########################### Remember current wall(s) ############################
#################################################################################

###
# If eater is not by an outer wall, make sure that the only wall added is "none."
###
sp {propose*no-walls
   (state <s> ^io.input-link.eater <e>)
   (<e> ^x <x> { <x> > 1 < 15 })
   (<e> ^y <y> { <y> > 1 < 15 })
 - (<s> ^wall none)
-->
   (<s> ^operator <o> + >)
   (<o> ^name add-wall ^wall none)
   }


###
# Eater is by an outer wall ("this"), but not in the corner.
# Add this wall, make sure no other exists.
###

# Horizontally (north or south)
sp {propose*add-horizontal-wall
   (state <s> ^io.input-link.eater <e>)
   (<e> ^y <eater-y> ^x <eater-x> { <eater-x> > 1 < 15 } )
   (<s> ^coord-to-wall <ctw>)
   (<ctw> ^y <eater-y> ^wall <wall>)
 - (<s> ^wall <wall>)
-->
   (<s> ^operator <o> + >)
   (<o> ^name add-wall ^wall <wall>)
   }

# Horizontally (north or south): Remove other walls
sp {propose*remove-but-horizontal-wall
   (state <s> ^io.input-link.eater <e>)
   (<e> ^y <eater-y> ^x <eater-x> { <eater-x> > 1 < 15 } )
   (<s> ^coord-to-wall <ctw>)
   (<ctw> ^y <eater-y> ^wall <keep-wall>)
   (<s> ^wall <w> { <w> <> <keep-wall> })
-->
   (<s> ^operator <o> + =)
   (<o> ^name remove-wall ^wall <w>)
   }

# Vertically (east or west)
sp {propose*add-vertical-wall
   (state <s> ^io.input-link.eater <e>)
   (<e> ^x <eater-x> ^y <eater-y> { <eater-y> > 1 < 15 } )
   (<s> ^coord-to-wall <ctw>)
   (<ctw> ^x <eater-x> ^wall <wall>)
 - (<s> ^wall <wall>)
-->
   (<s> ^operator <o> + >)
   (<o> ^name add-wall ^wall <wall>)
   }

# Vertically (east or west): Remove other walls.
sp {propose*remove-but-vertical-wall
   (state <s> ^io.input-link.eater <e>)
   (<e> ^x <eater-x> ^y <eater-y> { <eater-y> > 1 < 15 } )
   (<s> ^coord-to-wall <ctw>)
   (<ctw> ^x <eater-x> ^wall <keep-wall>)
   (<s> ^wall <w> { <w> <> <keep-wall> })
-->
   (<s> ^operator <o> + =)
   (<o> ^name remove-wall ^wall <w>)
   }


###
# Eater is in the corner. Make sure both walls are added.
###

# Add vertical wall 
sp {propose*add-corner-vertical-wall
   (state <s> ^io.input-link.eater <e>)
   (<e> ^x <eater-x> ^y <eater-y>)
   (<s> ^coord-to-wall <ctw1> ^coord-to-wall <ctw2>)
   (<ctw1> ^x <eater-x> ^wall <wall-ver>)    # Match vertical wall
   (<ctw2> ^y <eater-y> ^wall <wall-hor>)    # Match horizontal wall
 - (<s> ^wall <wall-ver>)
-->
   (<s> ^operator <o> + >)
   (<o> ^name add-wall-no-remove ^wall <wall-ver>)
   }

# Add horizontal wall
sp {propose*add-corner-horizontal-wall
   (state <s> ^io.input-link.eater <e>)
   (<e> ^x <eater-x> ^y <eater-y>)
   (<s> ^coord-to-wall <ctw1> ^coord-to-wall <ctw2>)
   (<ctw1> ^x <eater-x> ^wall <wall-ver>)    # Match vertical wall
   (<ctw2> ^y <eater-y> ^wall <wall-hor>)    # Match horizontal wall
 - (<s> ^wall <wall-hor>)
-->
   (<s> ^operator <o> + >)
   (<o> ^name add-wall-no-remove ^wall <wall-hor>)
   }


###
# Application.
###

# Add one wall, removing any wall that is not "this"
sp {apply*add-wall
  (state <s> ^operator <o>)
  (<o> ^name add-wall ^wall <wall>)
  (<s> ^wall <w> { <w> <> <wall> })
-->
  (<s> ^wall <wall>)
  (<s> ^wall <w> -)
  }

# Add one wall, do not remove any walls
sp {apply*add-wall-no-remove
  (state <s> ^operator <o>)
  (<o> ^name add-wall-no-remove ^wall <wall> )
-->
  (<s> ^wall <wall>)
  }

# Remove any walls other than "this" (need after exiting a corner)
sp {apply*remove-wall
  (state <s> ^operator <o>)
  (<o> ^name remove-wall ^wall <wall>)
-->
  (<s> ^wall <wall> -)
  }

#################################################################################
################################### Movement ####################################
#################################################################################

###
# If eater is facing a wall, rotate eater clockwise
###
sp {propose*change-direction
   (state <s> ^io.input-link <il>)
   (<il> ^eater.direction <cur-dir>)
   (<s> ^rotated-clockwise <rd>)
   (<rd> ^name <cur-dir> ^rotated <new-dir>)
   (<s> ^io.input-link.my-location.<cur-dir>.content wall)
-->
   (<il> ^eater.direction <new-dir>)
   }


###
# Keep moving forward, if there is no "halt" signal.
###
sp {propose*move  
   (state <s> ^io.input-link <il>)
   (<il> ^eater.direction <cur-dir>)
   (<il> ^my-location.<cur-dir>.content { <content> <> wall }) 
   (<s> ^initial-location.stop <> halt)
-->
   (<s> ^operator <o> + <)
   (<o> ^name move ^direction <cur-dir>)}


###
# Apply move
###
sp {apply*move
   (state <s> ^io.output-link <ol>)
   (state <s> ^operator <o>)
   (<o> ^name move ^direction <dir>)
-->
   (<ol> ^move.direction <dir>)}


###
# Clean-up to allow next move to be applied
###
sp {apply*move*remove-move
   (state <s> ^io.output-link <ol>)
   (state <s> ^operator.name move)
   (<ol> ^move <direction>)
   (<direction> ^status complete)
-->
   (<ol> ^move <direction> -)}