Práctica 2. Sistemas basados en reglas en Robocode
Inteligencia Artificial 2009/10

FJRP, VMDB, SFL - CCIA-2009

Date: Noviembre-2009

Descripción de la práctica

Objetivos

Conocer y utilizar el motor de reglas JBoss Drools Expert
Experimentar con reglas de control para un robot ''de juguete''

Tareas a realizar

Se deberán implementar dos juegos de reglas DROOLS que definan dos robots con un comportamiento definido.

Se aconseja definir dos comportamientos opuestos, por ejemplo un robot con una estrategía atrevida y el otro con una estrategía más conservadaro.

Opcionalmente se puede plantear una pequeña comparativa informal del comportamiento de los robots implementados ante batallas y enemigos equivalentes.

Normas de entrega

La práctica se realizará de forma individual o en parejas.
La fecha límite de entrega para la convocatoria de febrero será el 11/2/2009 en el despacho 303.
Antes de esa fecha es posible entregar la práctica en horario de prácticas o de tutorias.
Se deberá entregar:
- Código fuente: reglas creadas + clases Java adicionales (preferiblemente en CD o en USB para copiarlo)
- Memoria en papel con la estructura que se indica
En el momento de la entrega se comprobará el funcionamiento de la práctica y el modo en que fue desarrollada, por lo que, salvo causas de fuerza mayor, será necesaria la presencia de todos los miembros del grupo.
Estructura de la memoria (aproximadamente 6-10 págs [o menos]):
1. Descripción breve del problema y de las herramientas utilizadas
2. Descripción de los dos robots implementados. Para cada uno:
  - Descripción breve de la estrategia que se pretende que guie al robot
  - Descripción textual de cada una de las reglas implementadas junto con su código.
  - Descripción de los elementos adicionales (definición de nuevos tipos de hechos, reglas de apoyo, etc)
3. Descripción del código adicional aportado (en caso de que exista)
  - Describir las clases Java y los métodos añadidos sobre el código de partida
4. Experimentos realizados (en caso de llevarlos a cabo) y resultados obtenidos
5. Conclusiones y problemas encontrados
6. Bibliografía consultada (libros, enlaces, código, ...)
Nota: Incluir Nombre, DNI y e-mail en la portada. No necesario es ningún tipo especial de encuadernación.

Descripción del problema

Se trata de construir un robot para el entorno de simulación de batallas Robocode cuyo control se realice mediante un conjunto de reglas de producción ejecutadas sobre el motor de reglas JBoss Drools Expert.

Se deberán implementar y documentar dos juegos de reglas para dos tipos de robots

uno con una estrategia ''cobarde'', orientado a evitar riesgos y a mantenerse con vida el mayor tiempo posible
otro con una estrategia ''agresiva'', orientado a acabar cuanto antes con sus enemigos

Herramientas a utilizar

Información sobre Robocode:

Página principal de Robocode (descargas, documentación y ejemplos)
- Javadoc
Robocode Argentina (tutoriales muy completos)
- Guia de programación: Tutorial de programación
  Incluye un resumen bastante completo sobre los eventos manejados por los robots de Robocode muy útil para la realización de la práctica.
- Manejo de ángulos y posiciones: Tutorial de programación

Información sobre JBoss Drools Expert

Página principal de JBoss Drools Expert
- Descarga (Drools 5.0 Binaries)
- Manual de usuario
  Prestad especial atención al capítulo 4 (en concreto a la sección 4.2), donde se explica el lenguaje de definición de reglas DRL

Código de partida

Se partirá de un esqueleto de Robot (fichero RobotDrools.java) que delega la gestión de sus eventos y la decisión de acciones al motor de reglas Drools.

El RobotDrools es de tipo AdvancedRobot, lo que permite ejecutar distintas acciones a la vez.
El método run() es llamado por el framework Robocode y, junto con los manejadores de eventos, contiene el código Java que controla el comportamiento del robot
En este caso en método run() delega las decisiones al motor de reglas, realizando el siguiente ciclo en cada turno
1. Todos los eventos recibidos desde el turno anterior ya habrán sido capturados por sus respectivos métodos gestores (onScannedRobot(), onHitByBullet(), ...) e incorporados a la Memoria Activa de DROOLS (objeto ksession de tipo StatefulKnowledgeSession) del motor de reglas
  - Los tipos de evento a disposición de DROOLS y susceptibles de ser utilizados en las reglas son:
  - Los eventos producidos en cada turno estarán disponibles en la memoria activa y podrán incluirse en el lado izquierdo de las reglas usando la sintaxis de DROOLS y accediendo a las propiedades disponibles (ver en los respectivos JavaDoc los métodos getPROPIEDAD() para ver con que propiedades cuenta cada evento).
2. Incorpora a la memoria activa un objeto EstadoRobot con el estado actual del robot (posición, energía, etc)
  El objeto EstadoRoobot ofrece exactamente las mismas propiedades que el objeto de Robocode RobotStatus
3. Incorpora a la memoria activa un objeto EstadoBatalla con el estado actual del entorno de Robocode (núm. de oponentes, tamaño del campo de batalla, etc)
4. Lanza el proceso de inferencia de DROOLS pidiendo la ejecución de todas las reglas activadas por los hechos actuales
5. Elimina de la memoria activa los hechos actuales (eventos, estado robot, etc)
6. Recupera los hechos de tipo Accion insertados por las reglas ejecutadas e inicia su ejecución
7. Pasa el control a Robocode con el método execute(), indicándole que el Robot ha terminado su turno
El comportamiento de este robot está determinado por las reglas presentes en el fichero de reglas ''reglas_robot.drl'' que se carga en el motor de inferencias nada más iniciar el robot.
- Dichas reglas serán activadas por los eventos introducidos en la memoria activa por los gestores de eventos y por los objetos EstadoRobot y EstadoBatalla introducidos por el método run()
- Las posibles acciones a realizar se encapsulan en hechos/objetos de tipo Accion, donde se indica el tipo de acción junto con un parámetro de tipo double para cada acción y su respectiva prioridad
  Tipos de acciones estándar considerados:
  - Accion.AVANZAR: avanza el núm. de pixels indicados por parámetro (invocará el método setAhead(parámetro))
  - Accion.RETROCEDER: retrocede el núm. de pixels indicados por parametro (invocará el método setAhead(parámetro))
  - Accion.STOP: detiene el moviento del robot, no tiene en cuenta el valor de parámetro (invocará el método setStop())
  - Accion.DISPARAR: dispara con la intensidad indicada por parametro (invocará el método setFire(parámetro))
  - Accion.GIRAR_TANQUE_DER: gira el tanque hacia la derecha el núm. de grados indicados por parametro (invocará el método setTurnRight(parámetro))
  - Accion.GIRAR_TANQUE_IZQ: gira el tanque hacia la izquierda el núm. de grados indicados por parametro (invocará el método setTurnLeft(parámetro))
  - Accion.GIRAR_RADAR_DER: gira el radar hacia la derecha el núm. de grados indicados por parametro (invocará el método setTurnRadarRight(parámetro))
  - Accion.GIRAR_RADAR_IZQ: gira el radar hacia la izquierda el núm. de grados indicados por parametro (invocará el método setTurnRadarLeft(parámetro))
  - Accion.GIRAR_CANON_DER: gira el cañón hacia la derecha el núm. de grados indicados por parametro (invocará el método setTurnGunRight(parámetro))
  - Accion.GIRAR_CANON_IZQ: gira el cañón hacia la izquierda el núm. de grados indicados por parametro (invocará el método setTurnGunLeft(parámetro))

Método run() de RobotDrools

package drools_robocode;
...
public class RobotDrools extends AdvancedRobot {
    ...
   public void run() {
    	DEBUG.habilitarModoDebug(System.getProperty("robot.debug", "true").equals("true"));    	

    	// Crear Base de Conocimiento y cargar reglas
    	crearBaseConocimiento();

        // Hacer que movimiento de tanque, radar y cañon sean independientes
        setAdjustGunForRobotTurn(true);
        setAdjustRadarForGunTurn(true);
        setAdjustRadarForRobotTurn(true);

        while (true) {
     	    DEBUG.mensaje("inicio turno");
            //cargarEventos();  // se hace en los métodos onXXXXXEvent()
            cargarEstadoRobot();
            cargarEstadoBatalla();

            // Lanzar reglas
            DEBUG.mensaje("hechos en memoria activa");
            DEBUG.volcarHechos(ksession);           
            ksession.fireAllRules();
            limpiarHechosIteracionAnterior();

            // Recuperar acciones
            Vector<Accion> acciones = recuperarAcciones();
            DEBUG.mensaje("acciones resultantes");
            DEBUG.volcarAcciones(acciones);

            // Ejecutar Acciones
            ejecutarAcciones(acciones);
       	    DEBUG.mensaje("fin turno\n");
            execute();  // Informa a robocode del fin del turno (llamada bloqueante)
        }

    }
    ...

}  // Fin RobotDrools

Uso del código aportado e integración en Robocode

Descarga: código de partida(drools_robocode.tar.gz) [30/11/2009]

Ficheros incluidos

drools_robocode
    RobotDrools.java:     implementación del robot guiado por DROOLS
    EstadoBatalla.java:   encapsula la información sobre el estado actual 
                            del campo de batalla  
    EstadoRobot.java:     encapsula la información sobre el estado actual 
                            del robot
    Accion.java:          encapsula las posibles acciones a realizar por el robot  
    Auxiliar.java:        funciones auxiliares para calulo de ángulos, posiciones, distancias
                            basadas en http://www.robocode-argentina.com.ar/descargas/trig.doc
                            (en caso de necesitar implementar funciones adicionales este es 
                            el lugar más cómodo para hacerlo)   
    ComprobarReglas.java: clase cargadora de ficheros de reglas, permite comprobar que 
                            los ficheros de reglas se compilan sin errores sin tener que 
                            lanzar el robot y realizar pequeñas pruebas insertando hechos
                            ''a mano''
    DEBUG.java:           clase con métodos para mostrar mensajes de depuración  

drools_robocode/reglas   (directorio de reglas)
    reglas_robot.drl: fichero de reglas de ejemplo, implementa un robot trazador simple

Compilación y uso

Pasos previos
- Descargar e instalar Robocode (.jar autoinstalable)
- Descargar y descomprimir DROOLS

Establecer los directorio de instalación en un par de variables de entorno

export ROBOCODE_PATH=/home/[....]/robocode/
export DROOLS_PATH=/home/[....]/drools/

Copiar el directorio del robot (drools_robocode) en directorio robots de la instalación de Robocode
```
tar xzvf drools_robocode.tar.gz 
cp -r drools_robocode $ROBOCODE_PATH/robots/
```

Establecer los ficheros .jar necesarios en una variable de entorno

export JARS=$ROBOCODE_PATH/libs/robocode.jar
export JARS=$JARS:$DROOLS_PATH/drools-core-5.0.1.jar:$DROOLS_PATH/drools-api-5.0.1.jar
export JARS=$JARS:$DROOLS_PATH/drools-compiler-5.0.1.jar
export JARS=$JARS:$DROOLS_PATH/lib/janino-2.5.15.jar:$DROOLS_PATH/lib/antlr-runtime-3.1.1.jar
export JARS=$JARS:$DROOLS_PATH/lib/mvel2-2.0.10.jar:$DROOLS_PATH/lib/joda-time-1.6.jar

Nota: indicad las versiones concretas de vuestra instalación

Compilar el robot (necesario la primera vez y siempre que se cambie o añada código java al paquete drools_robocode)
```
javac -cp $JARS:. $ROBOCODE_PATH/robots/drools_robocode/*java
```
Arrancar Robocode con las opciones necesarias para integrar el robot DROOLS
```
java -Xmx512M -Dsun.io.useCanonCaches=false -DNOSECURITY=true -DWORKINGDIRECTORY=$ROBOCODE_PATH \
     -Ddrools.dialect.java.compiler=JANINO \
     -Drobot.reglas=drools_robocode/reglas/reglas_robot.drl -Drobot.debug=false \
     -cp $JARS:. robocode.Robocode
```
Mediante la propiedad robot.reglas se indica el path del fichero de reglas (.drl) a utilizar
- el fichero de reglas debe estar en un subdirectorio que cuelgue de $ROBOCODE_PATH/robots]
- si no se indica esta propiedad se cargarán las reglas del fichero indicado en la constante FICHERO_REGLAS de la clase RobotDrools.java
- por defecto se usa $ROBOCODE_PATH/robots/drools_robocode/reglas_robot.drl
  - Importante:
    - En el caso de enfrentar a dos o más robots basados en DROOLS se deberá omitir esta propiedad (de lo contrario ambos robots usarían en mismo fichero de reglas)
    - Se deberán crear dos paquetes distintos y establecer el fichero de reglas de cada robot en la constante FICHERO_REGLAS de las clases RobotDrools.java respectivas
Mediante la propiedad robot.debug se indica si se mostrarán o no los mensaje de DEBUG en la consola del robot
El robot RobotDrools deberá aparecer en el grupo drools_robocode
(nuevo) Compilación y uso en MS Windows XP: windows.txt

Verificación del fichero de reglas

Se incluye una clase ComprobarReglas.java que permite ejecutar el compilador de reglas de DROOLS sin tener que cargar el robot en el entorno Robocode. También permite insertar hechos en la memoria activa ''a mano'' desde el código de ComprobarReglas.java (requiere recompilar, ver paso 5)

Desde el directorio $ROBOCODE_PATH/robots/

cd $ROBOCODE_PATH/robots/

java -Ddrools.dialect.java.compiler=JANINO \
     -Drobot.reglas=drools_robocode/reglas/[FICHERO_REGLAS.drl] -Drobot.debug=true \
     -cp $JARS:. drools_robocode.ComprobarReglas

ribadas 2009-12-09

Práctica 2. Sistemas basados en reglas en Robocode Inteligencia Artificial 2009/10

Práctica 2. Sistemas basados en reglas en Robocode
Inteligencia Artificial 2009/10