//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;
}
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;
}
//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;
}
// Recibe un string de forma "Producto,Producto,Producto" (o sin los corchetes) y devuelve Secuencia<Producto>
Secuencia<Producto> splitProductos(const std::string &productos){
// MEJORA: Si viene con espacios se rompe
std::string parseado = productos;
int sep = parseado.find(',');
Secuencia<Producto> resultado;
while (sep != std::string::npos) {
Producto producto = aProducto(parseado.substr(0, sep));
resultado.push_back(producto);
parseado = parseado.substr(sep + 1, -1);
sep = parseado.find(',');
}
resultado.push_back(aProducto(parseado.substr(0,-1)));
return resultado;
}
//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;
}
//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;
}
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++;
}
}
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;
}
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;
}
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;
}
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 << "]}";
}
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 :)
}
