void test_restriccion() {
Rest rojo("rojo");
Rest amarillo("Amarillo");
Rest verde("VERDE");
Rest res1((rojo.OR(amarillo)).AND(verde.NOT()));
// Rest res1("(rojo | Amarillo) & !VERDE");
Conj<Caracteristica> carac;
carac.Agregar("Amarillo");
// ASSERT(res1 -> Verifica(carac));
ASSERT(res1.Verifica(carac));
Rest coso("Coso");
Rest noCoso(coso.NOT());
Rest res2 = res1.AND(noCoso);
carac.Agregar("Coso");
ASSERT(res1.Verifica(carac));
ASSERT(!res2.Verifica(carac));
Conj<Caracteristica> carac2;
carac2.Agregar("Coso");
Rest siCoso = noCoso.NOT();
ASSERT(siCoso.Verifica(carac2));
}
void test_inspeccion_con_empate() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","ca");
Conj<Caracteristica> cs1;
cs1.Agregar("cb");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Retiro");
ASSERT_EQ(d.CantidadRobotsActivos(),4);
d.Mover(0, "Retiro");
d.Mover(1, "Retiro");
d.Mover(2, "Retiro");
d.Inspeccion("Retiro"); // debe volar un solo RUR del conj {0,1,2}
ASSERT_EQ(d.CantidadRobotsActivos(),3);
infoRobots info = getDatosRobotsActivos(d);
// Chequeo que los que quedan están ok
// Alguno de los primeros RURs tuvo que desaparecer
ASSERT(!(info.estaciones.Definido(0) && info.estaciones.Definido(1) && info.estaciones.Definido(2)));
ASSERT_EQ(info.estaciones.Significado(3),"Retiro");
ASSERT_EQ(info.infracciones.Significado(3),0);
}
void test_el_mas_infractor() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","ca");
Conj<Caracteristica> cs1;
cs1.Agregar("cb");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Retiro");
ASSERT_EQ(d.CantidadRobotsActivos(),4);
d.Mover(0, "Retiro");
d.Mover(1, "Retiro");
d.Mover(2, "Retiro");
d.Mover(0, "Belgrano");
d.Mover(1, "Belgrano");
Conj<RUR> peores; // {0,1} con 2 infracciones
peores.Agregar(0);
peores.Agregar(1);
ASSERT(peores.Pertenece(d.ElMasInfractor()));
d.Mover(0,"Retiro"); // Ahora el RUR 0 es el más infractor
ASSERT_EQ(d.ElMasInfractor(),0);
}
void test_el_mas_infractor_e_inspeccion() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","ca");
Conj<Caracteristica> cs1;
cs1.Agregar("cb");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Retiro");
ASSERT_EQ(d.CantidadRobotsActivos(),4);
d.Mover(0, "Retiro");
d.Mover(1, "Retiro");
d.Mover(2, "Retiro");
d.Mover(0, "Belgrano");
d.Mover(1, "Belgrano");
Conj<RUR> peores; // {0,1} con 2 infracciones
peores.Agregar(0);
peores.Agregar(1);
d.Inspeccion("Retiro"); // No debe volar a ninguno de los mas infractores
ASSERT(peores.Pertenece(d.ElMasInfractor()));
infoRobots info = getDatosRobotsActivos(d);
ASSERT(info.caracteristicas.Definido(0) && info.caracteristicas.Definido(1));
d.Inspeccion("Belgrano"); // Debe volar a uno de los dos mas infractores
ASSERT(peores.Pertenece(d.ElMasInfractor()));
info = getDatosRobotsActivos(d);
ASSERT(!(info.caracteristicas.Definido(0) && info.caracteristicas.Definido(1)));
}
Conj<Posicion> Campus::IngresosMasCercanos(Posicion pos) {
Conj<Posicion> conjunto = Conj<Posicion>();
Posicion superior = Posicion(pos.x, 0);
Posicion inferior = Posicion(pos.x, Filas()-1);
if (Distancia(pos, superior) <= Distancia(pos, inferior))
conjunto.Agregar(superior);
if (Distancia(pos, superior) >= Distancia(pos, inferior))
conjunto.Agregar(inferior);
return conjunto;
}
/**
* Ejemplo de caso de test, con llamadas a las rutinas de aserción
* definidas en mini_test.h
*/
void test_ciudad_simple()
{
Conj<Estacion> estaciones;
estaciones.Agregar("Belgrano");
estaciones.Agregar("Retiro");
estaciones.Agregar("Martinez");
Driver caba(estaciones);
caba.AgregarSenda("Belgrano", "Retiro", "(trenDePasajeros | trenDeCarga) & !trenDeLaAlegria");
caba.AgregarSenda("Martinez", "Retiro", "trenDeLaAlegria");
caba.AgregarSenda("Martinez", "Belgrano", "trenDePasajeros");
Conj<Caracteristica> r1, r2, r3;
r1.Agregar("trenDePasajeros");
r2.Agregar("trenDeCarga");
r3.Agregar("trenDeLaAlegria");
caba.Entrar(r1,"Belgrano"); // RUR 0
caba.Entrar(r2,"Retiro"); // RUR 1
caba.Entrar(r3,"Martinez"); // RUR 2
ASSERT_EQ(caba.CantidadEstaciones(), 3);
ASSERT_EQ(caba.CantidadRobotsActivos(), 3);
ASSERT_EQ(caba.CantidadDeSendasParaEstacion("Belgrano"), 2);
caba.Mover(0,"Retiro"); // RUR 0: 0 infracciones
caba.Mover(0,"Martinez"); // RUR 0: 1 infracciones
caba.Mover(1,"Belgrano"); // RUR 1: 0 infracciones
caba.Mover(1,"Martinez"); // RUR 1: 1 infracciones
caba.Mover(2,"Belgrano"); // RUR 2: 1 infracciones
caba.Mover(2,"Retiro"); // RUR 2: 2 infracciones
Dicc<RUR,Nat> infraccionesRobots;
// Chequeo infracciones iterando los robots
for (Nat i = 0; i< caba.CantidadRobotsActivos(); ++i)
infraccionesRobots.Definir(caba.IesimoRobotActivo(i),caba.CantInfraccionesIesimoRobotActivo(i));
ASSERT_EQ(infraccionesRobots.Significado(0), 1);
ASSERT_EQ(infraccionesRobots.Significado(1), 1);
ASSERT_EQ(infraccionesRobots.Significado(2), 2);
ASSERT_EQ(caba.ElMasInfractor(),2);
// Vuela un robot
caba.Inspeccion("Retiro");
ASSERT_EQ(caba.CantidadRobotsActivos(),2);
}
void test_prefijos() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
es.Agregar("Martinez");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","a|ab|abcd|abcdef");
d.AgregarSenda("Martinez","Retiro","abcd");
Conj<Caracteristica> cs1,cs2,cs3,cs4,cs5,cs6;
cs1.Agregar("a");
d.Entrar(cs1,"Belgrano"); //
cs2.Agregar("abc");
d.Entrar(cs2,"Belgrano");
cs3.Agregar("abcdef");
d.Entrar(cs3,"Belgrano");
cs4.Agregar("abcdefg");
d.Entrar(cs4,"Belgrano");
cs5.Agregar("a");
cs5.Agregar("ab");
cs5.Agregar("abc");
cs5.Agregar("abcde");
cs5.Agregar("abcdef");
cs5.Agregar("abcdefg");
d.Entrar(cs5,"Retiro");
cs6.Agregar("a");
cs6.Agregar("abcd");
cs6.Agregar("abcdefg");
d.Entrar(cs6,"Retiro");
for (RUR i=0; i < 4; ++i)
d.Mover(i,"Retiro");
d.Mover(4,"Martinez");
d.Mover(5,"Martinez");
infoRobots info = getDatosRobotsActivos(d);
ASSERT_EQ(info.infracciones.Significado(0),0);
ASSERT_EQ(info.infracciones.Significado(1),1);
ASSERT_EQ(info.infracciones.Significado(2),0);
ASSERT_EQ(info.infracciones.Significado(3),1);
ASSERT_EQ(info.infracciones.Significado(4),1);
ASSERT_EQ(info.infracciones.Significado(5),0);
}
void test_ciudad_simple()
{
Conj<Estacion> estaciones;
estaciones.Agregar("Belgrano");
estaciones.Agregar("Retiro");
estaciones.Agregar("Martinez");
Driver caba(estaciones);
caba.AgregarSenda("Belgrano", "Retiro", "(trenDePasajeros | trenDeCarga) & !trenDeLaAlegria");
caba.AgregarSenda("Martinez", "Retiro", "trenDeLaAlegria");
caba.AgregarSenda("Martinez", "Belgrano", "trenDePasajeros");
Conj<Caracteristica> r1, r2, r3;
r1.Agregar("trenDePasajeros");
r2.Agregar("trenDeCarga");
r3.Agregar("trenDeLaAlegria");
caba.Entrar(r1,"Belgrano"); // RUR 0
caba.Entrar(r2,"Retiro"); // RUR 1
caba.Entrar(r3,"Martinez"); // RUR 2
ASSERT_EQ(caba.CantidadEstaciones(), 3);
ASSERT_EQ(caba.CantidadRobotsActivos(), 3);
ASSERT_EQ(caba.CantidadDeSendasParaEstacion("Belgrano"), 2);
caba.Mover(0,"Retiro"); // RUR 0: 0 infracciones
caba.Mover(0,"Martinez"); // RUR 0: 1 infracciones
caba.Mover(1,"Belgrano"); // RUR 1: 0 infracciones
caba.Mover(1,"Martinez"); // RUR 1: 1 infracciones
caba.Mover(2,"Belgrano"); // RUR 2: 1 infracciones
caba.Mover(2,"Retiro"); // RUR 2: 2 infracciones
infoRobots info = getDatosRobotsActivos(caba);
ASSERT_EQ(info.infracciones.Significado(0), 1);
ASSERT_EQ(info.infracciones.Significado(1), 1);
ASSERT_EQ(info.infracciones.Significado(2), 2);
ASSERT_EQ(caba.ElMasInfractor(),2);
// Vuela un robot
caba.Inspeccion("Retiro");
ASSERT_EQ(caba.CantidadRobotsActivos(),2);
}
const Conj<Posicion> Campus::IngresosMasCercanos(const Posicion& p) const {
assert(PosValida(p));
Conj<Posicion> res;
Posicion p1(p.x, 0);
Posicion p2(p.x, filas - 1);
if( Distancia(p, p1) < Distancia(p, p2) ) {
res.Agregar(p1);
} else if( Distancia(p, p1) > Distancia(p, p2) ) {
res.Agregar(p2);
} else {
res.Agregar(p1);
res.Agregar(p2);
}
return res;
}
// Mover robots
void test_mover_robots() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","ca");
Conj<Caracteristica> cs1,cs2;
cs1.Agregar("ca");
cs2.Agregar("cb");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs2,"Retiro");
d.Mover(0,"Retiro");
d.Mover(1,"Belgrano");
infoRobots info = getDatosRobotsActivos(d);
ASSERT_EQ(info.estaciones.Significado(0),"Retiro");
ASSERT_EQ(info.estaciones.Significado(1),"Belgrano");
}
void test_no_sumar_infracciones() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","ca");
Conj<Caracteristica> cs1;
cs1.Agregar("ca");
d.Entrar(cs1,"Belgrano");
// Hago varios mover ida y vuelta: no debe sumar infracciones
for (int i = 0; i < 10; ++i)
d.Mover(0, i%2 == 0 ? "Retiro" : "Belgrano");
infoRobots info = getDatosRobotsActivos(d);
ASSERT_EQ(info.estaciones.Significado(0),"Belgrano");
ASSERT_EQ(info.infracciones.Significado(0),0);
}
Conj<Compu> Red::Computadoras(){
vector<string> vec = vecinos.claves();
Conj<Compu> con;
for(unsigned int i = 0; i<vec.size(); i++){
con.Agregar(vec[i]);
}
return con;
}
Conj<Compu> Red::Vecinos(Compu c){
DiccString<unsigned int> * x = vecinos.obtener(c);
vector<string> vec = x->claves();
Conj<Compu> con;
for(unsigned int i = 0; i<vec.size(); i++){
con.Agregar(vec[i]);
}
return con;
}
void test_restriccion_tautologia_contradiccion() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
es.Agregar("Martinez");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","ser|!ser");
d.AgregarSenda("Retiro","Martinez","casa&!casa");
Conj<Caracteristica> cs1;
cs1.Agregar("cb");
d.Entrar(cs1,"Belgrano");
d.Mover(0,"Retiro");
// El mover no sumo
ASSERT_EQ(d.CantInfraccionesIesimoRobotActivo(0),0);
d.Mover(0,"Martinez");
// El mover si sumo
ASSERT_EQ(d.CantInfraccionesIesimoRobotActivo(0),1);
}
aed2::Conj<Driver::Registro> Driver::vistaJoin(const NombreTabla& tabla1, const NombreTabla& tabla2)
{
Conj<Driver::Registro> res;
Conj<modulos::Registro> cr = b.VistaJoin(tabla1,tabla2).Siguiente().Registros();
typename Conj<modulos::Registro>::Iterador itr = cr.CrearIt();
while(itr.HaySiguiente()){
res.Agregar(RNRS(itr.Siguiente()));
itr.Avanzar();
}
return res;
//assert(false);
}
// Entrar robots
void test_entrar() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
Driver d(es);
Conj<Caracteristica> cs1,cs2,cs3;
cs1.Agregar("ca");
cs2.Agregar("ca");
cs2.Agregar("cb");
cs3.Agregar("cc");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs2,"Retiro");
d.Entrar(cs3,"Retiro");
ASSERT_EQ(d.CantidadRobotsActivos(),3);
infoRobots info = getDatosRobotsActivos(d);
ASSERT_EQ(info.estaciones.Significado(0),"Belgrano");
ASSERT_EQ(info.estaciones.Significado(1),"Retiro");
ASSERT_EQ(info.estaciones.Significado(2),"Retiro");
}
void test_mapa() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
es.Agregar("Olivos");
es.Agregar("Martinez");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","ca");
d.AgregarSenda("Retiro","Olivos","cb");
d.AgregarSenda("Retiro","Martinez","cc");
d.AgregarSenda("Belgrano","Martinez","cc");
// Verifica # estaciones
ASSERT_EQ(d.CantidadEstaciones(),4);
// Verifica # sendas x estacion
ASSERT_EQ(d.CantidadDeSendasParaEstacion("Retiro"),3);
ASSERT_EQ(d.CantidadDeSendasParaEstacion("Belgrano"),2);
ASSERT_EQ(d.CantidadDeSendasParaEstacion("Olivos"),1);
ASSERT_EQ(d.CantidadDeSendasParaEstacion("Martinez"),2);
}
aed2::Conj<Driver::Registro> Driver::buscar(const NombreTabla& tabla, const aed2::Driver::Registro& criterio) const
{
Conj<Driver::Registro> res;
modulos::Registro crit = RSRN(criterio);
Conj<modulos::Registro> cr = b.DameTabla(tabla).BuscarT(crit);
typename Conj<modulos::Registro>::Iterador itr = cr.CrearIt();
while(itr.HaySiguiente()){
res.Agregar(RNRS(itr.Siguiente()));
itr.Avanzar();
}
return res;
//assert(false);
}
void test_restriccion_compleja() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
es.Agregar("Martinez");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","(ca&!cb) | (!cc | (unaCaracteristicaDeCasiCasiCasiCincuentaYNueveCaracteres & ce))");
Conj<Caracteristica> cs1,cs2,cs3,cs4;
cs1.Agregar("ca");
d.Entrar(cs1,"Belgrano"); //
cs2.Agregar("ca");
cs2.Agregar("cb");
cs2.Agregar("cc");
d.Entrar(cs2,"Belgrano");
cs3.Agregar("ca");
cs3.Agregar("cb");
cs3.Agregar("cc");
cs3.Agregar("unaCaracteristicaDeCasiCasiCasiCincuentaYNueveCaracteres");
cs3.Agregar("ce");
d.Entrar(cs3,"Belgrano");
cs4.Agregar("ca");
cs4.Agregar("cb");
cs4.Agregar("cc");
cs4.Agregar("unaCaracteristicaDeCasiCasiCasiCincuentaYNueveCaracteres");
d.Entrar(cs4,"Belgrano");
for (RUR i=0; i < 4; ++i)
d.Mover(i,"Retiro");
infoRobots info = getDatosRobotsActivos(d);
ASSERT_EQ(info.infracciones.Significado(0),0);
ASSERT_EQ(info.infracciones.Significado(1),1);
ASSERT_EQ(info.infracciones.Significado(2),0);
ASSERT_EQ(info.infracciones.Significado(3),1);
}
void test_inspeccion_simple() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","ca");
Conj<Caracteristica> cs1;
cs1.Agregar("cb");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Retiro");
ASSERT_EQ(d.CantidadRobotsActivos(),2);
d.Mover(0, "Retiro");
d.Inspeccion("Retiro"); // debe volar el RUR 0
ASSERT_EQ(d.CantidadRobotsActivos(),1);
infoRobots info = getDatosRobotsActivos(d);
// Chequeo que el que queda no fue modificado
ASSERT_EQ(info.estaciones.Significado(1),"Retiro");
ASSERT_EQ(info.infracciones.Significado(1),0);
}
void test_no_reusa_RURs() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","ca");
Conj<Caracteristica> cs1;
cs1.Agregar("cb");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Retiro");
d.Mover(0, "Retiro");
d.Inspeccion("Retiro"); // debe volar el RUR 0
infoRobots info = getDatosRobotsActivos(d);
ASSERT(!info.infracciones.Definido(0));
d.Entrar(cs1,"Belgrano"); // no debe reusar RUR 0
info = getDatosRobotsActivos(d);
ASSERT(!info.infracciones.Definido(0)); // RUR 0 tiene que seguir inactivo
}
void test_mapa() {
Mapa mapa1;
mapa1.Agregar("Hola");
mapa1.Agregar("Coso");
mapa1.Agregar("Cafe");
Rest res1("(rojo | Amarillo) & !VERDE");
Rest res2("Amarillo");
mapa1.Conectar("Hola", "Coso", res1);
mapa1.Conectar("Hola", "Cafe", res2);
ASSERT(mapa1.Conectadas("Hola", "Coso"));
ASSERT(mapa1.Conectadas("Hola", "Cafe"));
ASSERT(!mapa1.Conectadas("Coso", "Cafe"));
ASSERT_EQ(mapa1.NroConexion("Hola", "Coso"), 0);
ASSERT_EQ(mapa1.NroConexion("Coso", "Hola"), 0);
ASSERT_EQ(mapa1.NroConexion("Hola", "Cafe"), 1);
ASSERT_EQ(mapa1.NroConexion("Cafe", "Hola"), 1);
Conj<Caracteristica> carac;
carac.Agregar("Amarillo");
carac.Agregar("VERDE");
Arreglo<bool> sendas = mapa1.EvaluarSendas(carac);
ASSERT(!sendas[0]);
ASSERT(sendas[1]);
Mapa mapa2(mapa1);
mapa2.Conectar("Coso","Cafe", res1);
ASSERT_EQ(mapa2.NroConexion("Coso", "Cafe"), 2);
ASSERT_EQ(mapa2.NroConexion("Cafe", "Coso"), 2);
ASSERT(mapa2.Conectadas("Coso", "Cafe"));
ASSERT(!mapa1.Conectadas("Coso", "Cafe"));
}
Conj<Posicion> Campus::Vecinos(const Posicion& p) const {
assert(PosValida(p));
Conj<Posicion> res;
if(p.x > 0) {
res.Agregar(Posicion(p.x - 1, p.y));
}
if(p.y > 0) {
res.Agregar(Posicion(p.x, p.y - 1));
}
if(p.y < filas - 1) {
res.Agregar(Posicion(p.x, p.y + 1));
}
if(p.x < columnas - 1) {
res.Agregar(Posicion(p.x + 1, p.y));
}
return res;
}
void test_inspeccion_orden_prioridades() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","ca");
Conj<Caracteristica> cs1;
cs1.Agregar("cb");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Retiro");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Retiro");
d.Entrar(cs1,"Retiro");
d.Mover(2, "Retiro");
d.Mover(2, "Belgrano");
d.Mover(2, "Retiro");
d.Mover(1, "Belgrano");
d.Mover(1, "Retiro");
d.Mover(0, "Retiro");
ASSERT_EQ(d.CantidadRobotsActivos(),5);
d.Inspeccion("Retiro"); // debe volar RUR 2
ASSERT_EQ(d.CantidadRobotsActivos(),4);
ASSERT(!getDatosRobotsActivos(d).infracciones.Definido(2));
d.Inspeccion("Retiro"); // debe volar RUR 1
ASSERT_EQ(d.CantidadRobotsActivos(),3);
ASSERT(!getDatosRobotsActivos(d).infracciones.Definido(1));
d.Inspeccion("Retiro"); // debe volar RUR 0
ASSERT_EQ(d.CantidadRobotsActivos(),2);
ASSERT(!getDatosRobotsActivos(d).infracciones.Definido(0));
d.Inspeccion("Retiro"); // no debe volar nadie
ASSERT_EQ(d.CantidadRobotsActivos(),2);
ASSERT(getDatosRobotsActivos(d).infracciones.Definido(3));
}
void campusSeguro::moverAgente(Agente a)
{
Posicion posActual = posAgente(a);
//Conj<campus::Posicion>::Iterador itPos = _hippies.Claves();
DiccPalabra<Posicion>::itDiccP itPos = _hippies.Claves();
Posicion nuevaPos = proxPosicion(posActual, itPos );
if( !(posActual == nuevaPos) )
{
grilla.Obtener( nuevaPos ).tag = grilla.Obtener( posActual ).tag;
grilla.Obtener( nuevaPos ).id = grilla.Obtener( posActual ).id;
grilla.Obtener( posActual).id = 4;
grilla.Obtener( nuevaPos ).placa = grilla.Obtener( posActual ).placa;
grilla.Obtener( nuevaPos ).datosAgente = grilla.Obtener( posActual ).datosAgente;
Conj<Posicion> c;
c.Agregar(nuevaPos);
actualizarDatosAgentes(c);
actualizarEstYHippie(_campus.Vecinos(nuevaPos));// en el diseño aca hay un Siguiente(itVecinos) que esta demas.
actualizarVecinos(nuevaPos);
}
}
Conj<Lista<Compu> > Red::CaminosDeLargoN(Compu c1, Compu c2, Nat n){
Conj<Lista<Compu> > caminos;
if(n == 0){
Lista<Compu> camino;
camino.AgregarAtras(c1);
caminos.AgregarRapido(camino);
} else {
Conj<Compu> vec = this->Vecinos(c1);
Conj<Compu>::Iterador itVecinos(vec);
while(itVecinos.HaySiguiente()){
Compu v = itVecinos.Siguiente();
Conj<Lista<Compu> > cams = this->CaminosDeLargoN(v, c2, n-1);
Conj<Lista<Compu> >::Iterador itCaminos(cams);
while(itCaminos.HaySiguiente()){
Lista<Compu> camino = itCaminos.Siguiente();
if(camino.Ultimo() == c2){
Lista<Compu> camino2 = camino;
camino2.AgregarAdelante(c1);
caminos.Agregar(camino2);
}
itCaminos.Avanzar();
}
itVecinos.Avanzar();
}
}
Conj<Lista<Compu> >::Iterador itCaminos2(caminos);
while(itCaminos2.HaySiguiente()){
if(itCaminos2.Siguiente().Ultimo() != c2){
itCaminos2.EliminarSiguiente();
}
if(itCaminos2.HaySiguiente()) itCaminos2.Avanzar(); //esta linea faltaba en el tp
}
return caminos;
}
