Agrega un modo de salida intentando que sea más fácil generar tablas con la evolución...

[z.facultad/75.68/celdas.git] / trunk / src / main.cpp

diff --git a/trunk/src/main.cpp b/trunk/src/main.cpp
index 648505ac83c9789efe44714f78862d6ed80cb656..f059384ed2eb06780bba51de401418d6fb64fcd5 100644 (file)
--- a/trunk/src/main.cpp
+++ b/trunk/src/main.cpp
@@ -1,125 +1,172 @@
+

 #include "main.h"
 #include "main.h"

+#include <iostream>

 
 //
 
 //

-double CMiEntorno::AvanzarX()
-{
-       avanzo_en_x = true ;
-       return 0 ;
-}
-
-
-double CMiEntorno::AvanzarY()
-{
-       avanzo_en_y = true ;
-       return 0 ;
-}
-
-
-double CMiEntorno::AvanzarZ()
-{
-       avanzo_en_z = true ;
-       return 0 ;
-}
-
-
-CMiEntorno::CMiEntorno():
-       avanzo_en_x(true), avanzo_en_y(true), avanzo_en_z(true)
+void CMiEntorno::inicializar()

 {
        // Inicializo el Entorno
 {
        // Inicializo el Entorno

-       datos.add("robot.avanzo_en_x", 1) ;
-       datos.add("robot.avanzo_en_y", 1) ;
-       datos.add("robot.avanzo_en_z", 1) ;
-
-       datos.add("robot.sensor_1", 0) ;
-       datos.add("robot.sensor_2", 0) ;
-       datos.add("robot.sensor_3", 0) ;
+       datos.add("robot.sensor_adelante",      1) ;
+       datos.add("robot.sensor_atras",         0) ;
+       datos.add("robot.sensor_derecha",       0) ;
+       datos.add("robot.sensor_izquierda",     0) ;
+       datos.add("robot.avanzo_adelante",      0) ;
+       datos.add("robot.avanzo_atras",         0) ;
+       datos.add("robot.avanzo_derecha",       0) ;
+       datos.add("robot.avanzo_izquierda",     0) ;

 }
 
 
 void CMiEntorno::actualizar()
 {
 }
 
 
 void CMiEntorno::actualizar()
 {

-       datos.find("robot.sensor_1") = sensor_1 ;
-       datos.find("robot.sensor_2") = sensor_2 ;
-       datos.find("robot.sensor_3") = sensor_3 ;
-
-       datos.find("robot.avanzo_en_x") = avanzo_en_x?1:0 ;
-       datos.find("robot.avanzo_en_y") = avanzo_en_y?1:0 ;
-       datos.find("robot.avanzo_en_z") = avanzo_en_z?1:0 ;
-
-       
+       datos.set_val("robot.sensor_adelante",          0) ;
+       datos.set_val("robot.sensor_atras",             0) ;
+       datos.set_val("robot.sensor_derecha",           0) ;
+       datos.set_val("robot.sensor_izquierda",         1) ;
+       datos.set_val("robot.avanzo_adelante",          1) ;
+       datos.set_val("robot.avanzo_atras",             0) ;
+       datos.set_val("robot.avanzo_derecha",           0) ;
+       datos.set_val("robot.avanzo_izquierda",         0) ;

 }
 
 }
 

-struct CMiTeoria1: CTeoria< CMiEntorno >
-{
-       CMiTeoria1(CMiEntorno& e):
-               CTeoria< CMiEntorno >("Avanzar_X_1", 1, 1, e)
-       {
-               datos_iniciales.add ("robot.sensor_1", 0) ;
-               datos_finales.add ("robot.avanzo_en_x", 1) ;
-       }
-       double funcion()
-       {
-               entorno.avanzo_en_x = true ;
-               return 0 ;
-       }
-};
-
-struct CMiTeoria2: CTeoria< CMiEntorno >
-{
-       CMiTeoria2(CMiEntorno& e):
-               CTeoria< CMiEntorno >("Avanzar_Y_1", 1, 1, e)
-       {
-               datos_iniciales.add ("robot.sensor_2", 0) ;
-               datos_finales.add ("robot.avanzo_en_y", 1) ;
-       }
-       double funcion()
-       {
-               entorno.avanzo_en_y = true ;
-               return 0 ;
-       }
-};

 
 

-struct CMiTeoria3: CTeoria< CMiEntorno >
-{
-       CMiTeoria3(CMiEntorno& e):
-               CTeoria< CMiEntorno >("Avanzar_Z_1", 1, 1, e)
-       {
-               datos_iniciales.add ("robot.sensor_3", 0) ;
-               datos_finales.add ("robot.avanzo_en_z", 1) ;
-       }
-       double funcion()
-       {
-               entorno.avanzo_en_z = true ;
-               return 0 ;
-       }
-};

 
 //
 
 //

-int main(int argc, char** argv)
+int main(int argc, char* argv[])

 {
        //
 {
        //

-       CMiEntorno                     e ;
-       CSistemaAutonomo< CMiEntorno > a(e) ;
+       CMiEntorno*                     e = new CMiEntorno;
+       CSistemaAutonomo                a ;

 
 

+       e->inicializar() ;

 
        // Inicializo las teorias
 
        // Inicializo las teorias

-       a.teorias.add("teoria1", new CMiTeoria1(e)) ;
-       a.teorias.add("teoria2", new CMiTeoria2(e)) ;
-       a.teorias.add("teoria3", new CMiTeoria3(e)) ;
-
+       CTeoria* pt1 = new CTeoria("Avanzar", "avanzar", 1, 1) ;
+       CTeoria& t1 = *pt1;
+       t1.datos_iniciales.add ("robot.sensor_adelante",        0) ;
+       t1.datos_iniciales.add ("robot.sensor_atras",           ANY) ;
+       t1.datos_iniciales.add ("robot.sensor_derecha",         ANY) ;
+       t1.datos_iniciales.add ("robot.sensor_izquierda",       ANY) ;
+       t1.datos_iniciales.add ("robot.avanzo_adelante",        ANY) ;
+       t1.datos_iniciales.add ("robot.avanzo_atras",           ANY) ;
+       t1.datos_iniciales.add ("robot.avanzo_derecha",         ANY) ;
+       t1.datos_iniciales.add ("robot.avanzo_izquierda",       ANY) ;  
+       t1.datos_finales.add ("robot.sensor_adelante",          ANY) ;
+       t1.datos_finales.add ("robot.sensor_atras",             ANY) ;
+       t1.datos_finales.add ("robot.sensor_derecha",           ANY) ;
+       t1.datos_finales.add ("robot.sensor_izquierda",         ANY) ;
+       t1.datos_finales.add ("robot.avanzo_adelante",          1) ;
+       t1.datos_finales.add ("robot.avanzo_atras",             0) ;
+       t1.datos_finales.add ("robot.avanzo_derecha",           0) ;
+       t1.datos_finales.add ("robot.avanzo_izquierda",         0) ;
+
+       CTeoria* pt2 = new CTeoria("Retroceder", "retroceder", 1, 1) ;
+       CTeoria& t2 = *pt2;
+       t2.datos_iniciales.add ("robot.sensor_adelante",        ANY) ;
+       t2.datos_iniciales.add ("robot.sensor_atras",           0) ;
+       t2.datos_iniciales.add ("robot.sensor_derecha",         ANY) ;
+       t2.datos_iniciales.add ("robot.sensor_izquierda",       ANY) ;
+       t2.datos_iniciales.add ("robot.avanzo_adelante",        ANY) ;
+       t2.datos_iniciales.add ("robot.avanzo_atras",           ANY) ;
+       t2.datos_iniciales.add ("robot.avanzo_derecha",         ANY) ;
+       t2.datos_iniciales.add ("robot.avanzo_izquierda",       ANY) ;  
+       t2.datos_finales.add ("robot.sensor_adelante",          ANY) ;
+       t2.datos_finales.add ("robot.sensor_atras",             ANY) ;
+       t2.datos_finales.add ("robot.sensor_derecha",           ANY) ;
+       t2.datos_finales.add ("robot.sensor_izquierda",         ANY) ;
+       t2.datos_finales.add ("robot.avanzo_adelante",          0) ;
+       t2.datos_finales.add ("robot.avanzo_atras",             1) ;
+       t2.datos_finales.add ("robot.avanzo_derecha",           0) ;
+       t2.datos_finales.add ("robot.avanzo_izquierda",         0) ;
+
+
+       CTeoria* pt3 = new CTeoria("Derecha", "derecha", 1, 1) ;
+       CTeoria& t3 = *pt3;
+       t3.datos_iniciales.add ("robot.sensor_adelante",        ANY) ;
+       t3.datos_iniciales.add ("robot.sensor_atras",           ANY) ;
+       t3.datos_iniciales.add ("robot.sensor_derecha",         0) ;
+       t3.datos_iniciales.add ("robot.sensor_izquierda",       ANY) ;
+       t3.datos_iniciales.add ("robot.avanzo_adelante",        ANY) ;
+       t3.datos_iniciales.add ("robot.avanzo_atras",           ANY) ;
+       t3.datos_iniciales.add ("robot.avanzo_derecha",         ANY) ;
+       t3.datos_iniciales.add ("robot.avanzo_izquierda",       ANY) ;  
+       t3.datos_finales.add ("robot.sensor_adelante",          ANY) ;
+       t3.datos_finales.add ("robot.sensor_atras",             ANY) ;
+       t3.datos_finales.add ("robot.sensor_derecha",           ANY) ;
+       t3.datos_finales.add ("robot.sensor_izquierda",         ANY) ;
+       t3.datos_finales.add ("robot.avanzo_adelante",          0) ;
+       t3.datos_finales.add ("robot.avanzo_atras",             0) ;
+       t3.datos_finales.add ("robot.avanzo_derecha",           1) ;
+       t3.datos_finales.add ("robot.avanzo_izquierda",         0) ;
+
+
+       CTeoria* pt4 = new CTeoria("Eludir.1", "derecha", 1, 1) ;
+       CTeoria& t4 = *pt4;
+       t4.datos_iniciales.add ("robot.sensor_adelante",        1) ;
+       t4.datos_iniciales.add ("robot.sensor_atras",           ANY) ;
+       t4.datos_iniciales.add ("robot.sensor_derecha",         0) ;
+       t4.datos_iniciales.add ("robot.sensor_izquierda",       ANY) ;
+       t4.datos_iniciales.add ("robot.avanzo_adelante",        ANY) ;
+       t4.datos_iniciales.add ("robot.avanzo_atras",           ANY) ;
+       t4.datos_iniciales.add ("robot.avanzo_derecha",         ANY) ;
+       t4.datos_iniciales.add ("robot.avanzo_izquierda",       ANY) ;  
+       t4.datos_finales.add ("robot.sensor_adelante",          0) ;
+       t4.datos_finales.add ("robot.sensor_atras",             ANY) ;
+       t4.datos_finales.add ("robot.sensor_derecha",           ANY) ;
+       t4.datos_finales.add ("robot.sensor_izquierda",         ANY) ;
+       t4.datos_finales.add ("robot.avanzo_adelante",          0) ;
+       t4.datos_finales.add ("robot.avanzo_atras",             ANY) ;
+       t4.datos_finales.add ("robot.avanzo_derecha",           1) ;
+       t4.datos_finales.add ("robot.avanzo_izquierda",         ANY) ;
+
+
+       a.teorias.add(t1.nombre, pt1) ;
+       a.teorias.add(t2.nombre, pt2) ;
+       a.teorias.add(t3.nombre, pt3) ;
+       a.teorias.add(t4.nombre, pt4) ;
+#ifdef DEBUG
+       std::cout << "Agrega teoria: " << t1 << "\n";
+       std::cout << "\tdatos_iniciales:\n" << t1.datos_iniciales << "\n";
+       std::cout << "\tdatos_finales:\n" << t1.datos_finales << "\n";
+       std::cout << "Agrega teoria: " << t2 << "\n";
+       std::cout << "\tdatos_iniciales:\n" << t2.datos_iniciales << "\n";
+       std::cout << "\tdatos_finales:\n" << t2.datos_finales << "\n";
+       std::cout << "Agrega teoria: " << t3 << "\n";
+       std::cout << "\tdatos_iniciales:\n" << t3.datos_iniciales << "\n";
+       std::cout << "\tdatos_finales:\n" << t3.datos_finales << "\n";
+       std::cout << "Agrega teoria: " << t4 << "\n";
+       std::cout << "\tdatos_iniciales:\n" << t4.datos_iniciales << "\n";
+       std::cout << "\tdatos_finales:\n" << t4.datos_finales << "\n";
+#endif // DEBUG
+
+       // Inicializo el SA
+       delete a.p_entorno;
+       a.p_entorno = e;

 
        // Obtengo un plan
 
        // Obtengo un plan

-       double p = 1 ;
-       CIndiceMagico<CTeoria< CMiEntorno >* >* p_plan ;
-       CIndiceMagico<t_dato> datos_finales ;
-
-       datos_finales.add ("robot.avanzo_en_x", 1) ;
-
-       p_plan = a.new_plan(datos_finales, p) ;
+       CIndiceMagico<t_dato> datos_finales;

 
 

-       for (int i=0; i<p_plan->count(); i++)
-               std::cout << (*p_plan)[i]->nombre << std::endl ;
+       a.m_datos_finales.add ("robot.avanzo_adelante", 1) ;
+       //a.m_datos_finales.add ("robot.avanzo_en_x", 1) ;

 
 

+       for (int i = 0; i < 3; ++i)
+       {
+               a.plan();
+               while (a.has_next_theory())
+               {
+                       CTeoria* t = a.get_next_theory();
+                       // Deberia ejecutar accion y actualizar entorno
+                       if (a.validate_theory(t))
+                       {
+                               std::cout << "Valida\n";
+                       }
+                       else
+                       {
+                               std::cout << "No valida, planificamos de nuevo\n";
+                               break;
+                       }
+               }
+       }

 
        return 0 ;
 }
 
        return 0 ;
 }