Esempio n. 1
0
Secuencia<InfoVueloCruzado> Drone::vuelosCruzados(const Secuencia<Drone>& ds)
{//requiere que todos los drones tengan la misma longitud de vueloRealizado
	if(ds.size()==0) return {};
	//el if es por que si me dan una secuencia vacia se rompe al pedir abajo, ds[0]..-
	Secuencia<InfoVueloCruzado> infoVuelos = {};
	Posicion p = {};
	Secuencia<Posicion> todasLasPos = todasLasPosSinRepetir(ds);
	int cantDrones = 0;
	int momento = 0;
	while(momento < ds[0].vueloRealizado().size()){
		for(int i = 0; i < todasLasPos.size(); i++){
			//miro todasLasPos de los drones que me pasen y me voy fijando cuantos drones en el momento "k" estuvieron en esa posicion.
			//Siempre habra al menos uno, si hay mas de uno, es un cruce.
			for(int j = 0; j < ds.size(); ++j){
				if(ds[j].vueloRealizado()[momento] == todasLasPos[i]){
					cantDrones++;
				}
			}
			if(cantDrones > 1){
				//InfoVueloCruzado es un struct definido en tipos.h
				InfoVueloCruzado info;
				info.posicion =  todasLasPos[i];
				info.cantidadCruces = cantDrones;
				infoVuelos.push_back(info);
			}
			cantDrones = 0;
		}
		momento++;
	}
	return infoVuelos;
}
Esempio n. 2
0
void Sistema::cargar(std::istream & is)
{
  std::string non;
  //adelanto hasta el campo
  getline(is, non, '{');
  getline(is, non, '{');
  is.putback('{');
  //cargo el campo
  _campo.cargar(is);

  // cargo todos los drones
  // adelanto hasta encontrar donde empieza cada drone ({) o hasta llegar al ] que
  // es donde termina la lista de drones
  char c;
  while (c != ']') {
    is.get(c);
    if (c == '{') {
      is.putback('{');
      Drone d;
      d.cargar(is);
      _enjambre.push_back(d);
    }
  }

  // despues de los drones obtengo todo hasta el final que son los estados de cultivos
  getline(is, non);
  Secuencia<std::string> estadosCultivosFilas;
  // con el substr saco el " " inicial y el } final!
  estadosCultivosFilas = cargarLista(non.substr(1, non.length()-2), "[", "]");

  // este vector va a tener todos los estados pero "aplanado", todos en hilera
  // y cuando los asigne voy accediendolo como todosEstadosCultivos[n_fila*ancho + posicion en Y]
  Secuencia<std::string> todosEstadosCultivos;

  int n = 0;
  while (n < estadosCultivosFilas.size()) {
    Secuencia<string> tmp = splitBy(estadosCultivosFilas[n].substr(1, estadosCultivosFilas[n].length() - 2), ",");
    todosEstadosCultivos.insert(todosEstadosCultivos.end(), tmp.begin(), tmp.end());
    n++;
  }

  // creo la grilla de estados con las dimensiones correctas
  Dimension dim;
  dim.ancho = estadosCultivosFilas.size();
  dim.largo = todosEstadosCultivos.size() / estadosCultivosFilas.size();
  _estado = Grilla<EstadoCultivo>(dim);

  // asigno todos los estados dentro de la grilla
  int x = 0;
  while (x < dim.ancho) {
    int y = 0;
    while (y < dim.largo) {
      _estado.parcelas[x][y] = dameEstadoCultivoDesdeString(todosEstadosCultivos[x*dim.ancho+y]);
      y++;
    }
    x++;
  }
  //gane :)
}
Esempio n. 3
0
//AUXILIARES
bool mismosProductos(const Secuencia<Producto> & productos1, const Secuencia<Producto> & productos2) {
	if (productos1.size() != productos2.size()) return false;
	for (int i = 0; i < productos1.size(); i++) {
		Producto producto = productos1[i];
		if (cantidadProducto(productos1, producto) != cantidadProducto(productos2, producto)) return false;
	}
	return true;
}
Esempio n. 4
0
bool Sistema::mismosDrones(const Secuencia<Drone> & ds1, const Secuencia<Drone> & ds2) {
  bool res = ds1.size() == ds2.size();
  unsigned int n = 0;
  while (res && n < ds1.size()) {
    res = res && (cantidadDrones(ds1, ds1[n]) == cantidadDrones(ds2, ds1[n]));
    res = res && (cantidadDrones(ds1, ds2[n]) == cantidadDrones(ds2, ds2[n]));
    n++;
  }
  return res;
}
Esempio n. 5
0
//AUXILIARES
int cantidadProducto (const Secuencia<Producto> & productos, const Producto & producto) {
	int cont = 0;
  for (int i = 0; i < productos.size(); i++) {
  	if (productos[i] == producto) cont++;
  }
	return cont;
}
Esempio n. 6
0
//AUXILIARES
bool noPertenece(Posicion p, Secuencia<Posicion> ps){
	bool noPert = true;
	for(int i = 0; i < ps.size(); ++i){
		if(ps[i] == p) return false;
	}
	return noPert;
}
Esempio n. 7
0
void Sistema::seVinoLaMaleza(const Secuencia<Posicion>& ps)
{
  /*Por requiere deben ser todas posiciones validas, entonces no hace falta 
  chequear nada*/
  unsigned int i = 0;
  while(i < ps.size()){
    _estado.parcelas[ps[i].x][ps[i].y] = ConMaleza;
    i++;
  }
}
Esempio n. 8
0
int Sistema::cantidadDrones(const Secuencia<Drone> & ds, const Drone & d) {
  unsigned int n = 0;
  int cant = 0;
  while (n < ds.size()) {
    if (ds[n] == d) {
      cant++;
    }
    n++;
  }
  return cant;
}
Esempio n. 9
0
bool Sistema::tieneUnProducto(const Secuencia<Producto> &ps, const Producto &productoABuscar){
  unsigned int i = 0;
  bool res = false;

  while (i < ps.size()){
    res = res || ps[i] == productoABuscar;
    i++;
  }

  return res;
}
Esempio n. 10
0
//AUXILIARES
Secuencia<Posicion> todasLasPosSinRepetir(const Secuencia<Drone> &ds)
{
	Secuencia<Posicion> todas = {};
	for(int i = 0; i < ds.size(); ++i){
		for(int j = 0; j < ds[0].vueloRealizado().size(); ++j){
			if(noPertenece(ds[i].vueloRealizado()[j], todas)){
				Posicion pos = ds[i].vueloRealizado()[j];
				todas.push_back(pos);
			}
		}
	}
	return todas;
}
Esempio n. 11
0
void Sistema::guardar(std::ostream & os) const
{
  os << "{ S ";
  campo().guardar(os);
  os << " [";
  unsigned int n = 0;
  Secuencia<Drone> enjambre = enjambreDrones();
  while (n < enjambre.size()) {
    enjambre[n].guardar(os);
    n++;
    if (n < enjambre.size()) {
      os << ",";
    }
  }
  os << "] [";
  int x = 0;
  Dimension dim = campo().dimensiones();
  while (x < dim.ancho) {
    int y = 0;
    os << "[";
    while (y < dim.largo) {
      Posicion p;
      p.x = x;
      p.y = y;
      os << estadoDelCultivo(p);
      y++;
      if (y < dim.largo) {
        os << ",";
      }
    }
    os << "]";
    x++;
    if (x < dim.ancho) {
      os << ",";
    }
  }
  os << "]}";
}