Introduction à SOAR : Présentation et tutoriel

Cyrille Baudouin
Cerv : Centre Européen de Réalité Virtuelle
ea3883 – lisyc
Laboratoire d’Informatique pour les SYstèmes Complexes
25 février 2005

1
 Introduction à SOAR : Présentation et tutoriel

Résumé
Ce document d’introduction à soar regroupe une description détaillée, quelques
éléments d’études et un tutoriel.
Mots-clés : soar, intelligence artificielle, tutoriel.

Table des matières

1 Introduction 3

2 Découvrir soar 4
2.1 Qu’est-ce que soar ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Comment soar fonctionne-t-il ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Le fonctionnement de soar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.4 Les possibilités de soar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.5 Quelques applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.6 Evolutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.7 Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

3 Utiliser soar 7
3.1 Ressources et installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2 Présentation de Eaters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3 Un première règle en soar : Hello-world . . . . . . . . . . . . . . . . . . . . . . . 8
3.4 Utiliser un opérateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.5 Première application : bouger vers le nord . . . . . . . . . . . . . . . . . . . . . . 9

4 Annexe I : Syntaxe de soar 10

4.1 grammaire BNF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

5 Annexes II : fichiers du tutoriel eater 12

5.1 hello-world.soar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5.2 hello-world-operator.soar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5.3 move-north.soar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5.4 move-north-2.soar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.5 move-to-food.soar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5.6 move.soar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.7 advanced-move.soar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Enib - Cerv 2 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

1 Introduction

Enib - Cerv 3 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

2 Découvrir soar
2.1 Qu’est-ce que soar ?
2.1.1 Une architecture pour simuler le raisonnement humaine
2.1.2 un langage d’intelligence artificielle
2.1.3 Une théorie unifié de la cognition
En .... Newell élargit encore la portée de soar puisqu’il propose d’en faire un candidat
à l’UCT (Unified Cognition Théorie).

2.2 Comment soar fonctionne-t-il ?

2.3 Le fonctionnement de soar
2.4 Les possibilités de soar
2.5 Quelques applications
2.5.1 Steve
Une des applications connues de soar est Steve [?],

2.5.2 Quake-soar
...

2.6 Evolutions
La première version de soar date de 1982 et la version courante est la 8.5.2. Le
graphique suivant1 montre l’évolution de soar accompagnée des résultats obtenus et des
idées qui ont inspirées les changements ou les ajouts de fonctionnalités.
1
Réalisé par John E. Laird dans une présentation du 23rd soar Workshop

Enib - Cerv 4 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

Les avancées prévues pour soar 9 sont :

1. l’activation de la mémoire de travail,
2. l’amélioration de l’apprentissage
– par renforcement,
– épisodique (peut-être)
3. le phénomène de destruction des règles dans le temps –rule-decay– (peut-être)

2.7 Extensions
soar est une architecture qui se veut générale et, pour cela, elle n’est pas forcément
simple ou optimale pour certains domaines ou certaines utilisations. Plusieurs équipes de
recherches ont donc créés leurs propres extensions de soar afin de résoudre des problèmes
spécifiques.

2.7.1 Langage naturel

NL-soar (Natural Language) [?] est une extension de soar pour la reconnaissance,
la génération de langage naturel et la gestion de conversation. L’approche de NL-soar
est incremental et permet le traitement du langage naturel en temps réel. NL-soar a été
implémenté pour l’anglais et partiellement pour le français et le polonais.
NL-soar a été utilise dans NTD-soar2 [?] ou il permet un langage entre 2 agents.
Cette extension est aussi présente dans TacAir-soar, ou les opérateurs associées au taches
2
NASA Test Director

Enib - Cerv 5 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

et au langage sont mélangés et sur un même plan décisionnel (communiquer est alors une
action comme les autres).
LG-soar3 , est une autre extension spécifique au langage et concerne l’extraction de
prédicat dans des textes en langage naturel par analyse syntaxique.

2.7.2 Travail d’équipe, collaboration et Négociation

STEAM (Shell for TEAMwork ) [?] est un framework qui explicite la collaboration
entre des agents. STEAM est basé sur la théorie des ”intentions réunies” (joint intentions).
Il peut-être utilisé avec soar puisqu’il se base sur des concepts de but (but individuel
et but de l’équipe) et d’opérateurs. DYNAMITE est un autre projet qui concerne la
négociation entre agent.

2.7.3 Autre implémentations de soar

soar-Lite est une implémentation de soar plus légère et plus modulaire. soar-lite
peut être construite à partir des sources de soar (8.4) en modifiant les options de com-
pilation. Les performances de soar-Lite sont jusqu’à quatre fois supérieures à celle de
soar mais certaines fonctionnalités coûteuse sont absente (apprentissage).
Tinysoar est une autre implémentation partielle de soar conçue pour les systèmes
temps-réels embarqués.

2.7.4 Prise en compte des emotions

Le comportement est lié au raisonnement mais aussi au émotions, qui sont difficile-
ment representable et exploitable dans soar. soar-Emote est une extension qui propose
d’ajouter le statut émotionnel de l’agent dans le processus décisionnel.

3
LG pour Link Grammar

Enib - Cerv 6 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

3 Utiliser soar
Cette partie s’inspire de la première partie du tutoriel ”officiel” distribué avec soar.
Nous y présenterons les concepts de bases nécessaires pour la bonne utilisation de soar.

3.1 Ressources et installation

soar est disponible et téléchargeable sur le site officiel pour Linux, windows et Mac
OS.

(http://sitemaker.umich.edu/\acronyme{soar}/\acronyme{soar}_software_downloads)

Cette version 8.5.2 de soar suite contient (entre autres) :

– soar v8.5.2,
– Visual soar v4.5.3,
– SGIO v1.1.2,
– Le manuel officiel,
– Le tutoriel officiel en 6 parties,
– Eaters 3.0.8 et Tanksoar 3.0.8.
Pour ce tutoriel, nous utiliserons directement Eaters qui dispose de sa propre interface
graphique et qui se charge de lancer soar.

3.2 Présentation de Eaters

Ce tutoriel est centré sur l’utilisation de soar et non sur la façon de l’interfacer avec
l’extérieur. Dans le but de s’abstraire de ses problèmes nous utiliserons ici un programme
déjà fonctionnel : Eaters. Eaters est un petit jeu qui n’est pas sans rappeler le célèbre
”Pacman”.
Dans ce jeu, des agents eaters contrôlés par soar sont en compétition et parcourent
leur environnement à la recherche de nourriture. Le jeu se joue sur un plateau carré
quadrillé de quinze cases sur quinze cases bordée par un mur. Des murs (distant les uns
des autres) sont générés aléatoirement sur la grille. Toutes les cases non murée contiennent
une pastille de nourriture qui peut-être ”normale” (jaune) ou ”bonus” (rouge).
—¿ capture eaters commentée
Lors de leur création, les agents eaters sont placés aléatoirement sur la grille dans
une case non murée. Les agents n’ont pas accès a l’intégralité des informations sur le
monde : ils ne perçoivent qu’un carré de deux cases de coté comme le montre la fenêtre
de perception associée à chaque agent.
—¿ capture perception agent
A chaque tour (cycle de décision de soar), un eater peut se déplacer sur une case
adjacente (nord, sud, est, ouest) ou sauter par dessus une case occupé ou non. Lorsqu’un
eater arrive sur une nouvelle case ou se trouve de la nourriture, il la consomme ce qui
lui rapporte des points (1 point pour la nourriture normale et 5 point pour la nourriture
bonus). Un saut coûte 5 point et l’eater et si la case sauté contient de la nourriture, elle

Enib - Cerv 7 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

n’est pas consommée. Lorsque deux eater se rencontrent, leur score est équilibré et ils
sont tous les deux renvoyés sur une case non occupée choisi au hasard.
L’interface de Eaters permet de créer un nouvel agent, de le détruire, de sélectionner
le fichier de règles qui lui sera appliqué. Les trois boutons (step, run et stop) permettent
de contrôler la simulation.
—¿capture console comandes
Plusieurs fichiers de règles (*.soar) sont livrés avec la distribution de Eaters et sont
donnés en annexe II. Ces fichiers se trouvent dans le repertoire :
[repertoire d’’installation de \acronyme{soar}
suite]\eaters-3.0.8\agents\tutorial
Il n’est pas utile de consulter ces fichiers pour le moment puisque nous allons les réécrire
au fur et a mesure du tutoriel. Ils pourront servir de référence ou d’exemple.

3.3 Un première règle en soar : Hello-world

Pour ne pas couper à la tradition, nous allons afficher faire afficher la chaı̂ne ”hello-
world” par notre agent eater.
Cette règle est déjà écrite dans le fichier ”hello-world-rule”. Vous pouvez le charger
en sélectionnant le repertoire ”tutorial” puis en choisissant le bon fichier. Pour tester la
règle, il suffit ensuite de créer un nouveau eater (create eater ) puis de le lancer (bouton
”run”).
—¿ capture choix fichier
Une règle doit toujours être composé des même éléments : un nom, des conditions, des
actions. Nous pouvons donc écrire notre règle comme ci-dessous :

nom : "hello-world"
conditions : si j’existe,
actions alors j’affiche "hello-world" puis je m’arr^
ete.

Notre eater ne peut pas interpréter le langage naturel et cette règle doit donc être
traduite pour être compréhensible par notre eater.
— ¿ image règle ”hello-world” annotée
La condition ”j’existe” est assimilé a l’existence du premier état dans la mémoire de
travail (working memory ou WE) de soar.

3.4 Utiliser un opérateur

Dans soar, on utilise rarement des règles comme celle que l’on vient d’écrire, c’est
à dire des règles associant directement une perception (j’existe) à une action (j’affiche
”hello-world”). On utilise des opérateurs (operators) qui réalisent des actions soit dans
l’environnement soit dans ”l’esprit” des agents. On peut par exemple avoir un opérateur
qui déplace l’agent de case en case ou un opérateur pour se souvenir du chemin emprunté
(il n’agit alors que sur la représentation interne que l’agent à du monde). soar exécute
le cycle suivant.

Enib - Cerv 8 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

1. L’agent perçoit le monde et propose des opérateurs

2. L’agent sélectionne un opérateur
3. L’agent applique l’opérateur
L’étape 1 est réalisée grace à des règles qui vont créer des nouveaux opérateurs et/ou
associer des préférences aux opérateurs sélectionnables. l’étape 2 se résume à la sélection
du meilleur opérateur (comparaison des préférences). La troisième étape est réalisée grâce
aux règles d’application associées aux opérateurs.
Nous allons maintenant reprendre la règle ”hello-world” du point précèdent et la mo-
difier pour respecter ce cycle. Vous pouvez créer un nouveau fichier texte (on l’appellera
”opérateur-hello-world.soar” par exemple) avec votre éditeur de texte préféré dans le
repertoire tutoriel (ou un nouveau repertoire) et recopier la règle précédente.
Nous allons donc écrire deux règles au lieu d’une : la règle de proposition de l’opérateur
et la règle d’application de l’opérateur.

propose hello-world :
si j’existe,
alors, je propose l’opérateur "hello-world"

applique hello-world :
si l’opérateur "hello-world" est sélectionné
alors j’affiche "hello-world"
puis je m’arr^ete.

3.5 Première application : bouger vers le nord

Enib - Cerv 9 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

4 Annexe I : Syntaxe de soar

4.1 grammaire BNF
Cette annexe décrit la grammaire BNF (Backus-Naur form) de soar. Cette annexe
peut être utilisée pour vérifier la correction d’un fichier soar ou pour créer un parseur.

4.1.1 grammaire de production

<\acronyme{soar}-production> ::= sp "{" <production-name>
[<documentation>] [<flags>]
<condition-side> --> <action-side> "}"

<documentation> ::= """ [<string>] """

<flags> ::= ":" (o-support | i-support | chunk | default)

<condition-side> ::= <state-imp-cond> <cond>*

<state-imp-cond> ::= "(" (state | impasse) [<id_test>]
<attr_value_tests>+ ")"
<cond> ::= <positive_cond> | "-" <positive_cond>
<positive_cond> ::= <conds_for_one_id> | "{" <cond>+ "}"
<conds_for_one_id> ::= "(" [(state|impasse)] <id_test>
<attr_value_tests>+ ")"

<id_test> ::= <test>

<attr_value_tests> ::= ["-"] "^" <attr_test> ("." <attr_test>)*

<value_test>*
<attr_test> ::= <test>
<value_test> ::= <test>["+"]
| <conds_for_one_id> ["+"]
<test> ::= <conjunctive_test>
| <simple_test>
<conjunctive_test> ::= "{" <simple_test>+ "}"
<simple_test> ::= <disjunction_test>
| <relational_test>
<disjunction_test> ::= "<<" <constant>+ ">>"
<relational_test> ::= [<relation>] <single_test>
<relation> ::= "<>" | "<" | ">" | "<="
| ">=" | "=" | "<=>"
<single_test> ::= <variable>
| <constant>
<variable> ::= "<" <sym_constant>
">" <constant> ::= <sym_constant>
| <int_constant>

Enib - Cerv 10 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

| <float_constant>

Remarque sur la ”Condition Side” : Dans un ¡id test¿, seul une ¡variable¿ peut être
utilisée dans un ¡single test¿.

<rhs> ::= <rhs_action>*

<rhs_action> ::= "(" <variable> <attr_value_make>+ ")"
| <func_call>
<func_call> ::= "(" <func_name> <rhs_value>* ")"
<func_name> ::= <sym_constant> | "+" | "-" | "*" | "/"
<rhs_value> ::= <constant> | <func_call> | <variable>
<attr_value_make> ::= "^" <variable_or_sym_constant>
("." <variable_or_sym_constant>)* <value_make> +
<variable_or_sym_constant>
::= <variable> | <sym_constant>

<value_make> ::= <rhs_value> <preference_specifier>*

<preference-specifier>
::= <unary-preference> [","]
| <unary-or-binary-preference> [","]
| <unary-or-binary-preference> <rhs_value> [","]
<unary-pref> ::= "+" | "-" | "!" | "~" | "@"
<unary-or-binary-pref>
::= ">" | "=" | "<" | "&"

Enib - Cerv 11 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

5 Annexes II : fichiers du tutoriel eater

5.1 hello-world.soar
########################################################################
# From Chapter 2 of \acronyme{soar} 8 Tutorial #### This rule
writes "Hello World" and halts.

sp {hello-world
(state <s> ^type state)
-->
(write |Hello World|)
(halt)
}

5.2 hello-world-operator.soar
########################################################################
# From Chapter 3 of \acronyme{soar} 8 Tutorial #### This operator
writes "Hello World" and halts.

sp {propose*hello-world
(state <s> ^type state)
-->
(<s> ^operator <o> +)
(<o> ^name hello-world)
}

sp {apply*hello-world
(state <s> ^operator <o>)
(<o> ^name hello-world)
-->
(write |Hello World|)
(halt)
}

5.3 move-north.soar
########################################################################
# From Chapter 4 of \acronyme{soar} 8 Tutorial # #
Propose*move-north: # If I exist, then propose the move-north
operator.

sp {propose*move-north
(state <s> ^type state)
-->
(<s> ^operator <o> +)
(<o> ^name move-north)}

Enib - Cerv 12 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

# Apply*move-north:
# If the move-north operator is selected, then generate an output command to
# move north.

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

## short cut version

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

5.4 move-north-2.soar
########################################################################
# From Chapter 5 of \acronyme{soar} 8 Tutorial # Corrected from
move-north.\acronyme{soar} so that operator applies more than
once. # # Propose*move-north: # If I am at some location, then
propose the move-north operator.

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

# Apply*move-north:
# If the move-north operator is selected, then generate an output command to
# move north.

sp {apply*move-north
(state <s> ^operator.name move-north
^io.output-link <ol>)
-->

Enib - Cerv 13 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

(<ol> ^move.direction north)}

# Apply*move-north*remove-move
# If the move-north successfully performs a move command, then remove
# the command from the output-link

sp {apply*move-north*remove-move
(state <s> ^operator.name move-north
^io.output-link <ol>)
(<ol> ^move <move>)
(<move> ^status complete)
-->
(<ol> ^move <move> -)}

5.5 move-to-food.soar
########################################################################
# From Chapter 6 of \acronyme{soar} 8 Tutorial # # These are the
final versions of the rules. # # This program proposes the
move-to-food operator in any direction # that contains normal or
bonus food. If there is no food nearby, no # instances of the
operator will be proposed and the halt operator # will be
proposed.

# Propose*move-to-food*normalfood
# If there is normalfood in an adjacent cell,
# propose move-to-food in the direction of that cell
# and indicate that this operator can be selected randomly.

sp {propose*move-to-food
(state <s> ^io.input-link.my-location.<dir>.content
<< normalfood bonusfood >>)
-->
(<s> ^operator <o> + =)
(<o> ^name move-to-food
^direction <dir>)}

# Apply*move-to-food
# If the move-to-food operator for a direction is selected,
# generate an output command to move in that direction.

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

Enib - Cerv 14 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

-->
(<ol> ^move.direction <dir>)}

# Apply*move-to-food*remove-move:
# If the move-to-food operator is selected,
# and there is a completed move command on the output link,
# then remove that command.

sp {apply*move-to-food*remove-move
(state <s> ^io.output-link <ol>
^operator.name move-to-food)
(<ol> ^move <move>)
(<move> ^status complete)
-->
(<ol> ^move <move> -)}

5.6 move.soar
########################################################################
# From Chapter 8 of \acronyme{soar} 8 Tutorial # # These are the
final versions of the rules for the generalized move operator # #
Propose*move: # If there is normalfood, bonusfood, eater, or empty
in an adjacent cell, # propose move in the direction of that
cell # and indicate that this operator can be selected
randomly.

sp {propose*move
(state <s> ^io.input-link.my-location.<dir>.content
{ <content> <> wall })
-->
(<s> ^operator <o> + =)
(<o> ^name move
^direction <dir>
^content <content>)}

# Apply*move
# If the move operator for a direction is selected,
# generate an output command to move in that direction.

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

Enib - Cerv 15 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

# Apply*move*remove-move:
# If the move operator is selected,
# and there is a completed move command on the output link,
# then remove that command.

sp {apply*move*remove-move
(state <s> ^io.output-link <ol>
^operator.name move)
(<ol> ^move <direction>)
(<direction> ^status complete)
-->
(<ol> ^move <direction> -)}

# Select*move*bonusfood-better-than-normalfood
# If there is a proposed operator to move to a cell with bonusfood and
# there is a second proposed operator to move to a cell that is empty or
# has normalfood
# prefer the first operator.

sp {select*move*bonusfood-better-than-normalfood-empty
(state <s> ^operator <o1> +
^operator <o2> +)
(<o1> ^name move
^content bonusfood)
(<o2> ^name move
^content << normalfood empty >>)
-->
(<s> ^operator <o1> > <o2>)}

# Select*move*avoid-empty-eater
# If there is a proposed operator to move to an empty cell or a cell with
# another eater,
# then avoid that operator.

sp {select*move*avoid-empty-eater
(state <s> ^operator <o1> +)
(<o1> ^name move
^content << empty eater >>)
-->
(<s> ^operator <o1> <)}

5.7 advanced-move.soar
########################################################################
# From Chapter 9 of \acronyme{soar} 8 Tutorial # # These are the

Enib - Cerv 16 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

final versions of the rules for the generalized advanced move #

operator.

sp {initialize*state*directions
(state <ss> ^type state)
-->
(<ss> ^directions <n> <e> <s> <w>)
(<n> ^value north ^opposite south)
(<e> ^value east ^opposite west)
(<s> ^value south ^opposite north)
(<w> ^value west ^opposite east)}

# Propose*move*no-backward:
# If there is normalfood, bonusfood, eater, or empty in an adjacent cell,
# and there is no last direction equal to the opposite direction for that # cell,
# propose move in the direction of that cell, with the cell’s content,
# and indicate that this operator can be selected randomly.

sp {propose*move*no-backward
(state <s> ^io.input-link.my-location.<dir>.content { <co> <> wall }
^directions <d>
-^last-direction <o-dir>)
(<d> ^value <dir>
^opposite <o-dir>)
-->
(<s> ^operator <o> +, =)
(<o> ^name move
^direction <dir>
^content <co>)}

# Apply*move
# If the move operator for a direction is selected,
# generate an output command to move in that direction.

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

# Apply*move*remove-move:
# If the move operator is selected,
# and there is a completed move command on the output link,
# then remove that command.

Enib - Cerv 17 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

sp {apply*move*remove-move
(state <s> ^io.output-link <ol>
^operator.name move)
(<ol> ^move <direction>)
(<direction> ^status complete)
-->
(<ol> ^move <direction> -)}

# Apply*move*create*last-direction
# If the move operator for a direction is selected,
# create an augmentation called last-direction with that direction.

sp {apply*move*create*last-direction
(state <s> ^operator <o>)
(<o> ^name move
^direction <direction>)
-->
(<s> ^last-direction <direction>)}

# Apply*move*remove*last-direction
# If the move operator for a direction is selected,
# and the last-direction is not equal to that direction,
# then remove the last-direction.

sp {apply*move*remove*last-direction
(state <s> ^operator <o>
^last-direction <direction>)
(<o> ^direction <> <direction>
^name move)
-->
(<s> ^last-direction <direction> -)}

# Select*move*bonusfood-better-than-normalfood
# If there is a proposed operator to move to a cell with bonusfood and
# there is a second proposed operator to move to a cell that is empty or
# has normalfood
# prefer the first operator.

sp {select*move*bonusfood-better-than-normalfood-empty
(state <s> ^operator <o1> +
^operator <o2> +)
(<o1> ^name move
^content bonusfood)
(<o2> ^name move
^content << normalfood empty >>)
-->

Enib - Cerv 18 Cyrille Baudouin

 Introduction à SOAR : Présentation et tutoriel

(<s> ^operator <o1> > <o2>)}

# Select*move*avoid-empty-eater
# If there is a proposed operator to move to an empty cell or a cell with
# another eater,
# then avoid that operator.

sp {select*move*avoid-empty-eater
(state <s> ^operator <o1> +)
(<o1> ^name move
^content << empty eater >>)
-->
(<s> ^operator <o1> <)}

# Select*move*reject*backward
# If there is a proposed operator to move in the direction
# opposite the last move,
# reject that operator.

sp {select*move*reject*backward
(state <s> ^operator <o> +
^directions <d>
^last-direction <dir>)
(<d> ^value <dir>
^opposite <o-dir>)
(<o> ^name move
^direction <o-dir>)
-->
(write | Reject | <o-dir>)
(<s> ^operator <o> -)}

Enib - Cerv 19 Cyrille Baudouin