# Rules and operators to remember locations that have food in them
# and forget locations when the food has been eaten. The food locations
# are organized on a stack. The stack has two dummy nodes at the beginning
# and end of the linked list.

# firstfood points to the dummy node at the head of the linked list.

sp {elaborate*firstfood
   (state <s> ^superstate nil)
-->
   (<s> ^food <f2> ^firstfood <f2>)	#the dummy node at the head
   (<s> ^food <f3>)			#the dummy node at the tail
   (<f2> ^nextfood <f3>)
   (<f3> ^x 0 ^y 0)}

# Notice locations that have food.

sp {elaborate*noticed*food*north
   (state <s> ^io.input-link <il>)
   (<il> ^my-location.north.content << normalfood bonusfood >> )
   (<il> ^eater <e>)
   (<e> ^x <x> ^y <y>)
-->
   (<s> ^noticed-food <n>)
   (<n> ^x <x> ^y (- <y> 1))}

sp {elaborate*noticed*food*south
   (state <s> ^io.input-link <il>)
   (<il> ^my-location.south.content << normalfood bonusfood >> )
   (<il> ^eater <e>)
   (<e> ^x <x> ^y <y>)
-->
   (<s> ^noticed-food <n>)
   (<n> ^x <x> ^y (+ <y> 1))}

sp {elaborate*noticed*food*east
   (state <s> ^io.input-link <il>)
   (<il> ^my-location.east.content << normalfood bonusfood >> )
   (<il> ^eater <e>)
   (<e> ^x <x> ^y <y>)
-->
   (<s> ^noticed-food <n>)
   (<n> ^x (+ <x> 1 ) ^y <y>)}

sp {elaborate*noticed*food*west
   (state <s> ^io.input-link <il>)
   (<il> ^my-location.west.content << normalfood bonusfood >> )
   (<il> ^eater <e>)
   (<e> ^x <x> ^y <y>)
-->
   (<s> ^noticed-food <n>)
   (<n> ^x (- <x> 1 ) ^y <y>)}

# Operator to remember food

sp {propose*remember*food
   (state <s> ^noticed-food <n>)
   (<n> ^x <x> ^y <y>)
 - {(<s> ^food <f>)
    (<f> ^x <x> ^y <y>)}
-->
   (<s> ^operator <o> + =)
   (<o> ^name remember
        ^x <x> ^y <y>)}

sp {apply*remember*food
   (state <s> ^operator <o>)
   (<o> ^name remember
        ^x <x> ^y <y>)
   (<s> ^firstfood <ff>) #head of stack of food locations
   (<s> ^firstfood.nextfood <nf>) #first actual food location
-->
   (<s> ^food <f>)
   (<f> ^x <x> ^y <y> ^nextfood <nf>)
   (<ff> ^nextfood <nf> - )
   (<ff> ^nextfood <f>)}

# Operator to forget food

sp {propose*forget*food
   (state <s> ^io.input-link.eater <e>)
   (<e> ^x <x> ^y <y>)
   (<s> ^food <f>)
   (<f> ^x <x> ^y <y>)
-->
   (<s> ^operator <o> + =)
   (<o> ^name forget
        ^x <x> ^y <y>) }

sp {apply*forget*food
   (state <s> ^operator <o>)
   (<o> ^name forget
        ^x <x> ^y <y>)
   (<s> ^food <f> 
        ^food <prevf>)
   (<f> ^x <x> ^y <y> ^nextfood <nf>)
   (<prevf> ^nextfood <f>)
-->
   (<s> ^food <f> - )
   (<prevf> ^nextfood <f> - )
   (<prevf> ^nextfood <nf>)
}