virtual public void apagarIncendio(ILugar lugar)
{
if (sucesor != null)
{
sucesor.apagarIncendio(lugar);
}
}
override public void apagarIncendio(ILugar lugar, Calle calle)
{
ISector[,] matrizLugar = lugar.getSectores();
int caudalAgua = calle.CaudalAgua;
int lugarCantFilas = matrizLugar.GetLength(0);
int lugarCantColumnas = matrizLugar.GetLength(1);
for (int fila = 0; fila < lugarCantFilas; fila++)
{
if ((fila % 2) == 0)
{
//Console.WriteLine("La fila es par, recorrido --> ");
for (int columna = 0; columna < lugarCantColumnas; columna++)
{
ApagarSector(fila, columna, matrizLugar, caudalAgua);
}
}
else
{
//Console.WriteLine("La fila es impar, recorrido <-- ");
for (int columna = lugarCantColumnas - 1; columna >= 0; columna--)
{
ApagarSector(fila, columna, matrizLugar, caudalAgua);
}
}
}
// Creo mensajes de finalización en consola
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(" ¡¡¡¡¡¡¡ El fuego de {0} fue extinguido en su totalidad!!!!!! \n", lugar);
Console.ResetColor();
}
// GET: api/Lugar/5
public Pr_Lugares_Consultar_Result Get(int id)
{
ILugar lugar = new ILugar();
return(lugar.getLugar(id));
}
//METODO QUE UTILIZA EL METODO DE GETSECTORES DE LA PLAZA QUE RECIBE UN CONSTRUCTOR CONCRETO
public void ApagarIncendio(ILugar pLugar, Calle pCalle)
{
int intAguaDisponible = pCalle.GetCaudalAguaPorMinuto();
ISector[,] matrizLugar = pLugar.getSectores();
for (int fila = 0; fila < matrizLugar.GetLength(0); fila++)
{
for (int columnas = 0; columnas < matrizLugar.GetLength(1); columnas++)
{
//CUANDO EL NUMERO DE FILA SEA IMPAR (SE TENDRA QUE RECORRER AL REVES PARA DAR EL EFECTO ESCALERA)
if (fila % 2 != 0)
{
for (int columna = matrizLugar.GetLength(1) - 1; columna >= 0; columna--)
{
DeterminarApagado(matrizLugar, fila, columna, intAguaDisponible);
}
break;
}
DeterminarApagado(matrizLugar, fila, columnas, intAguaDisponible);
}
}
Console.WriteLine("EL FUEGO DE LUGAR FUE EXTINGUIDO EN SU TOTALIDAD");
}
public void ApagarIncendio(ILugar l, Calle c)
{
Sector[][] mapa = l.GetSectores();
int N = mapa.Length;
for (int x = 0; x < N; x++)
{
for (int y = 0; y < N; y++)
{
Sector actual = mapa[x][y];
Console.Write("({0},{1})", x + 1, y + 1);
while (!actual.estaApagado())
{
//mapa[x][y] = new Sector((mapa[x][y].afectacionDelFuego - c.CantidadDeCaudalPorMinuto).afectacionDelFuego >= 0 ? (mapa[x][y].afectacionDelFuego - c.CantidadDeCaudalPorMinuto) : 0);
Console.Write("->" + actual.afectacionDelFuego);
mapa[x][y] = new Sector(mapa[x][y].afectacionDelFuego - c.CantidadDeCaudalPorMinuto);
actual = mapa[x][y];
}
Console.WriteLine("");
}
}
Console.WriteLine("¡¡¡¡¡¡¡ El fuego de {0} fue extinguido en su totalidad !!!!!!", l.ToString());
}
public virtual void apagarIncendio(ILugar lugar, Calle calle)
{
if (this.sucesor != null)
{
this.sucesor.apagarIncendio(lugar, calle);
}
}
public virtual void ApagarIncendio2(ILugar pLugar, Calle pCalle)
{
if (this.manejador != null)
{
this.manejador.ApagarIncendio2(pLugar, pCalle);
}
}
public void apagarIncendio(ILugar lugar, Calle calle)
{
Console.WriteLine("Un bombero esta apagando el incendio con el metodo Escalera en la " + lugar.ToString() + "\n");
Console.WriteLine("\nEl fuego de la " + lugar.ToString() + " fue extinguido en su totalidad!!");
//Algoritmo Escalera
}
public override void apagarIncendio(ILugar lugar, Calle calle)
{
if (bomberoReal == null)
{
bomberoReal = new Bombero();
}
bomberoReal.setHerramienta(herramienta);
bomberoReal.setVehiculo(vehiculo);
bomberoReal.apagarIncendio(lugar, calle);
}
public virtual void ApagarIncendio(ILugar lugar, Calle calle)
{
if (siguiente != null)
{
siguiente.ApagarIncendio(lugar, calle);
}
else
{
Console.WriteLine("El problema no se pudo solucionar");
}
}
override public void apagarIncendio(ILugar lugar, Calle calle)
{
ISector[,] matrizLugar = lugar.getSectores();
int caudalAgua = calle.CaudalAgua;
int CantFilas = matrizLugar.GetLength(0);
int CantColumnas = matrizLugar.GetLength(1);
int aux = CantColumnas - 1;
int fila, columna;
for (int i = 0; i < CantFilas; i++)
{
// a derecha
for (int j = i; j < aux; j++)
{
fila = CantFilas - (aux + 1);
columna = j;
ApagarSector(fila, columna, matrizLugar, caudalAgua);
}
// a abajo
for (int j = i; j < aux; j++)
{
fila = j;
columna = aux;
ApagarSector(fila, columna, matrizLugar, caudalAgua);
}
// a izquierda
for (int j = aux; j > (i - 1); j--)
{
fila = aux;
columna = j;
ApagarSector(fila, columna, matrizLugar, caudalAgua);
}
// increento aux
aux--;
// hacia arriba
for (int j = aux; j > i; j--)
{
fila = j;
columna = CantFilas - (aux + 2);
ApagarSector(fila, columna, matrizLugar, caudalAgua);
}
}
// Creo mensajes de finalización en consola
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(" ¡¡¡¡¡¡¡ El fuego de {0} fue extinguido en su totalidad!!!!!! \n", lugar);
Console.ResetColor();
}
//METODOS
public void actualizar(Observado o)
{
ILugar lugar = (ILugar)o;
if (lugar is Casa)
{
estrategia = new EstrategiaEscalera();
}
if (lugar is Plaza)
{
estrategia = new EstrategiaEspiral();
}
this.apagarIncendio(lugar, lugar.Calle);
}
public override void apagarIncendio(ILugar lugar, Calle calle)
{
if (fabrica == null)
{
fabrica = new FabricaDeBombero();
}
Bombero bombero = (Bombero)fabrica.crearHeroe();
bombero.Herramienta = fabrica.crearHerramienta();
bombero.Vehiculo = fabrica.crearVehiculo();
bombero.apagarIncendio(lugar, calle);
}
//*************************************************************************************************************************
//METODOS
//METODO APAGARINCENDIO MODIFICADO POR EL PATRON ABSTRACT FACTORY
public override void ApagarIncendio2(ILugar pLugar, Calle pCalle)
{
this.vehiculo.encenderSirena();
if (this.vehiculo.conducir())
{
this.herramienta.usar();
this.estrategia.ApagarIncendio(pLugar, pCalle);
this.herramienta.guardar();
Console.WriteLine();
}
else
{
Console.WriteLine("NO PUEDO LLEGAR A PAGAR EL INCENDIO. SE ME HA ROTO LA AUTOBOMBA");
}
}
// Métodos
override public void apagarIncendio(ILugar lugar)
{
// Creo mensajes de inicialización de apagado en consola
Console.BackgroundColor = ConsoleColor.DarkRed;
Console.WriteLine(" [BOMBERO] ");
Console.ResetColor();
vehiculo.encenderSirena();
vehiculo.conducir();
herramienta.usar();
Console.WriteLine("# [Apagando Incendio] [Lugar: {0}] [Estrategia: {1}]", lugar, estrategiaApagado);
// dejo a cargo MI Strategy de recorrer la matriz
estrategiaApagado.apagarIncendio(lugar);
// herramientas
herramienta.guardar();
Console.WriteLine("_______________________________________________ \n ");
}
public override void apagarIncendio(ILugar lugar, Calle calle)
{
if (kit == true)
{
vehiculo.encenderSirena();
vehiculo.conducir();
herramienta.usar();
}
estrategia.apagarIncendio(lugar, calle);
if (kit == true)
{
herramienta.guardar();
}
}
public void ApagarIncendio(ILugar pLugar, Calle pCalle)
{
int intAguaDisponible = pCalle.GetCaudalAguaPorMinuto();
ISector [,] matrizLugar = pLugar.getSectores();
for (int filas = 0; filas < matrizLugar.GetLength(0); filas++)
{
for (int columnas = 0; columnas < matrizLugar.GetLength(1); columnas++)
{
//SE LE PASA DIRECTAMENTE LA MATRIZ, EL NUMERO DE FILA Y COLUMNA DE CADA SECTOR PARA QUE SE EVALUE LA SITUACION DEL SECTOR
DeterminarApagado(matrizLugar, filas, columnas, intAguaDisponible);
}
}
Console.WriteLine("EL FUEGO DE LUGAR FUE EXTINGUIDO EN SU TOTALIDAD");
}
override public void apagarIncendio(ILugar lugar)
{
if (heroeReal == null)
{
heroeReal = fabrica.crearHeroe(); // casteo para poder setear estrategia (propia de un bombero)
heroeReal.setHerramienta(fabrica.crearHerramienta());
heroeReal.setVehiculo(fabrica.crearVehiculo());
// seteo la estrategia de apagado, pero antes creo un aux de tipo Bombero para poder setear apagado
Bombero aux = (Bombero)heroeReal;
Console.WriteLine("[BOMBERO] Elegir estrategia de apagado (ingresar número):");
Console.WriteLine(" 1. Apagado Secuencial");
Console.WriteLine(" 2. Apagado Escalera");
Console.WriteLine(" 3. Apagado Espiral");
bool opcionvalida = false;
while (!opcionvalida)
{
char op = Console.ReadKey().KeyChar;
switch (op)
{
case '1':
aux.setEstrategiaApagado(new ApagadoSecuencial());
opcionvalida = true;
break;
case '2':
aux.setEstrategiaApagado(new ApagadoEscalera());
opcionvalida = true;
break;
case '3':
aux.setEstrategiaApagado(new ApagadoEspiral());
opcionvalida = true;
break;
default:
Console.WriteLine(" \n ERROR: Por favor, ingrese una opción correcta: ");
break;
}
}
}
heroeReal.apagarIncendio(lugar);
// devuelvo el bombero creado al cuartel
fabrica.crearCuartel().agregarPersonal(heroeReal);
fabrica.crearCuartel().agregarVehiculo(heroeReal.getVehiculo());
fabrica.crearCuartel().agregarHerramienta(heroeReal.getHerramienta());
}
public void apagarIncendio(ILugar lugar, int caudal)
{
Console.WriteLine("Apagando el incendio con la estrategia escalera en " + lugar.ToString());
ISector [][] sectores = lugar.getSectores();
int fin = sectores.Length - 1;
int cont = 0;
int indicador = 0;
while (cont <= fin)
{
switch (indicador)
{
case 0:
for (int i = 0; i <= fin; i++)
{
Console.Write("({0},{1})", cont, i);
Console.Write(sectores[cont][i]);
sectores[cont][i].mojar(caudal);
}
indicador = 1;
break;
case 1:
for (int j = fin; j >= 0; j--)
{
Console.Write("({0},{1})", cont, j);
Console.Write(sectores[cont][j]);
sectores[cont][j].mojar(caudal);
}
indicador = 0;
break;
}
Console.WriteLine();
cont++;
}
Console.WriteLine("!!!!!El fuego de " + lugar.ToString() + " fue extinguido en su totalidad¡¡¡¡¡¡");
}
public void apagarIncendio(ILugar lugar, int caudal)
{
Console.WriteLine("Apagando el incendio con la estrategia espiral");
ISector [][] sectores = lugar.getSectores();
int fin = sectores.GetLength(0) - 1;
int iteraciones = sectores.GetLength(0) * 4;
int inicio = 0;
for (int j = 0; j < sectores.Length; j++)
{
for (int i = inicio; i <= fin; i++)
{
Console.Write("({0},{1})", inicio, i);
Console.Write(sectores[inicio][i]);
sectores[inicio][i].mojar(caudal);
}
for (int i = inicio + 1; i <= fin; i++)
{
Console.Write("({0},{1})", i, fin);
Console.Write(sectores[i][fin]);
sectores[i][fin].mojar(caudal);
}
for (int i = fin - 1; i >= inicio; i--)
{
Console.Write("({0},{1})", fin, i);
Console.Write(sectores[fin][i]);
sectores[fin][i].mojar(caudal);
}
for (int i = fin - 1; i > inicio; i--)
{
Console.Write("({0},{1})", i, inicio);
Console.Write(sectores[i][inicio]);
sectores[i][inicio].mojar(caudal);
}
inicio++;
fin--;
}
Console.WriteLine("El fuego de" + lugar.ToString() + " fue extinguido en su totalidad");
}
//debería poder verse:
//(1, 1)-> 45-> 0
public void ApagarIncendio(ILugar pLugar, Calle pCalle)
{
int intAguaDisponible = pCalle.GetCaudalAguaPorMinuto();
int[,] matrizLugar = pLugar.getSectores();
for (int filas = 0; filas < matrizLugar.GetLength(0); filas++)
{
for (int columnas = 0; columnas < matrizLugar.GetLength(1); columnas++)
{
int intSector = matrizLugar[filas, columnas];
int intResultadoSector = intSector - intAguaDisponible;
string strResultado = "(" + filas + " , " + columnas + ") --> " + intSector;
if (intResultadoSector < 0)
{
strResultado += " --> 0";
Console.WriteLine(strResultado);
}
//SI EL RESULTADO DEL SECTOR ES MAYOR SIGNIFICA QUE NO SE APAGO
else
{
strResultado += " --> " + intResultadoSector;
Boolean boolEntrar = true;
while (boolEntrar)
{
int intTerminarApagar = intResultadoSector - intAguaDisponible;
if (intTerminarApagar < 0)
{
strResultado += "--> 0";
Console.WriteLine(strResultado);
boolEntrar = false;
}
else
{
strResultado += " --> " + intTerminarApagar;
}
}
}
}
}
Console.WriteLine("EL FUEGO DE LUGAR FUE EXTINGUIDO EN SU TOTALIDAD");
}
public void apagarIncendio(ILugar lugar, int caudal)
{
Console.WriteLine("Apagando el incendio con la estrategia secuencial en " + lugar.ToString());
ISector [][] sectores = lugar.getSectores();
int tamaño = sectores.GetLength(0);
for (int i = 0; i < tamaño; i++)
{
for (int j = 0; j < tamaño; j++)
{
Console.Write("({0},{1})", i, j);
Console.Write(" -- ({0})", sectores[i][j].ToString());
sectores[i][j].mojar(caudal);
}
}
Console.WriteLine("!!!!!El fuego de " + lugar.ToString() + " fue extinguido en su totalidad¡¡¡¡¡¡");
}
public void ApagarIncendio(ILugar pLugar, Calle pCalle)
{
int intAguaDisponible = pCalle.GetCaudalAguaPorMinuto();
int[,] matrizLugar = pLugar.getSectores();
int intInicio = 0;
int intLimiteColumna = matrizLugar.GetLength(1) - 1;
int intLimiteFila = matrizLugar.GetLength(0) - 1;
int intCantidadElementos = matrizLugar.GetLength(1) * matrizLugar.GetLength(0);
int intContador = 0;
while (intContador < intCantidadElementos)
{
for (int columnas = intInicio; columnas <= intLimiteColumna; columnas++)
{
DeterminarApagado(matrizLugar, intInicio, columnas, intAguaDisponible);
intContador++;
}
for (int filas = intInicio + 1; filas <= intLimiteFila; filas++)
{
DeterminarApagado(matrizLugar, filas, intLimiteFila, intAguaDisponible);
intContador++;
}
for (int columnasReversa = intLimiteColumna - 1; columnasReversa >= intInicio; columnasReversa--)
{
DeterminarApagado(matrizLugar, intLimiteColumna, columnasReversa, intAguaDisponible);
intContador++;
}
for (int i = intLimiteFila - 1; i > intInicio; i--)
{
DeterminarApagado(matrizLugar, i, intInicio, intAguaDisponible);
intContador++;
}
intInicio = intInicio + 1;
intLimiteColumna = intLimiteColumna - 1;
intLimiteFila = intLimiteFila - 1;
}
Console.WriteLine("EL FUEGO DE LUGAR FUE EXTINGUIDO EN SU TOTALIDAD");
}
override public void apagarIncendio(ILugar lugar, Calle calle)
{
// Obtengo las dimensiones de lugar
ISector[,] matrizLugar = lugar.getSectores();
int caudalAgua = calle.CaudalAgua;
int lugarFilas = matrizLugar.GetLength(0);
int lugarColumnas = matrizLugar.GetLength(1);
for (int fila = 0; fila < lugarFilas; fila++)
{
for (int columna = 0; columna < lugarColumnas; columna++)
{
ApagarSector(fila, columna, matrizLugar, caudalAgua);
}
}
// Creo mensajes de finalización en consola
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(" ¡¡¡¡¡¡¡ El fuego de {0} fue extinguido en su totalidad!!!!!! \n", lugar);
Console.ResetColor();
}
//SOBREESCRIBIENDO EL METODO APAGAR INCENDIO
public override void ApagarIncendio2(ILugar pLugar, Calle pCalle)
{
IResponsable bombero = fabrica.crearHeroe();
IHerramienta manguera = fabrica.crearHerramienta();
IVehiculo autobomba = fabrica.crearVehiculo();
//USO DE PATRON SINGLETON
CuartelDeBomberos cuartel = CuartelDeBomberos.getCuartelBombero();
//SE AGREGA AL CUARTEL
cuartel.agregarPersonal(bombero);
cuartel.agregarHerramienta(manguera);
cuartel.agregarVehiculo(autobomba);
//OBTENGO EL BOMBERO RESPONSABLE
Bombero bomberoResponsable = (Bombero)cuartel.getPersonal();
//LE ASIGNO UNA ESTRATEGIA
bomberoResponsable.setEstrategia(new Escalera());
//DELEGO LA TAREA AL VERDADERO BOMBERO, PASANDO EL ILUGAR Y LA CALLE
bomberoResponsable.ApagarIncendio2(pLugar, pCalle);
}
public void ApagarIncendio(ILugar pLugar, Calle pCalle)
{
int intAguaDisponible = pCalle.GetCaudalAguaPorMinuto();
int[,] matrizLugar = pLugar.getSectores();
for (int filas = 0; filas < matrizLugar.GetLength(0); filas++)
{
for (int columnas = 0; columnas < matrizLugar.GetLength(1); columnas++)
{
if (filas % 2 != 0)
{
for (int columna = matrizLugar.GetLength(1) - 1; columna >= 0; columna--)
{
DeterminarApagado(matrizLugar, filas, columna, intAguaDisponible);
}
break;
}
DeterminarApagado(matrizLugar, filas, columnas, intAguaDisponible);
}
}
Console.WriteLine("EL FUEGO DE LUGAR FUE EXTINGUIDO EN SU TOTALIDAD");
}
public override void apagarIncendio(ILugar lugar, Calle calle)
{
if (vehiculo == null && herramienta == null)
{
herramienta = new Manguera();
vehiculo = new Autobomba();
}
vehiculo.encenderSirena();
vehiculo.conducir();
if (this.vehiculo.getEstado() is Roto)
{
Console.WriteLine("autobomba se rompio, el policia no pudo completar su tarea");
}
else
{
this.apagarVehiculo();
herramienta.usar();
estrategia.apagarIncendio(lugar, calle.Caudal);
herramienta.guardar();
}
}
public void apagarIncendio(ILugar lugar, Calle calle)
{
ISector [][] sectores = lugar.getSectores();
int longitud = sectores.GetLength(0);
int caudal = calle.getCaudal();
Console.WriteLine("Un bombero esta apagando el incendio con el metodo Secuencial en la " + lugar.ToString() + "\n");
Console.WriteLine("Matriz de sectores de la " + lugar.ToString() + " (" + longitud + "x" + longitud + "):");
for (int i = 0; i < longitud; i++)
{
for (int j = 0; j < longitud; j++)
{
var fuegoRestante = new List <double>(); //Lista que va a ir añadiendo valores del caudal a medida que se va apagando el fuego.
fuegoRestante.Add(sectores[i][j].getAfeccion());
while (!sectores[i][j].estaApagado())
{
sectores[i][j].mojar(caudal);
if (sectores[i][j].estaApagado())
{
fuegoRestante.Add(0); //Se añade 0 en caso de que el caudal sea menor o igual a 0.
}
else
{
fuegoRestante.Add(sectores[i][j].getAfeccion());
}
}
Console.WriteLine("(" + i + "," + j + ") - " + "(" + sectores[i][j].ToString() + ") -> " + string.Join(" -> ", fuegoRestante));
}
}
Console.WriteLine("\nEl fuego de " + lugar.ToString() + " fue extinguido en su totalidad!!");
}
//METODO ACTUALIZAR CORRESPONDIENTE AL PATRON OBSERVER. BOMBERO DEBE IMPLEMENTAR ESTE METODO PORQUE EXTIENDE DE IOBSERVADOR, CUANDO SE PRODUCE UN CAMBIO DE ESTADO SE LLAMA A ESTE
public void Actualizar(ILugar pObservado, Calle pCalle)
{
ApagarIncendio(pObservado, pCalle);
}
//METODO APAGAR INCENDIO INICIAL, SEGUN LA ESTRATEGIA, DELEGA LA RESPONSABILIDAD A UN ALGORITMO DE LA CLASE DEL PATRON STRATEGY
public void ApagarIncendio(ILugar pLugar, Calle pCalle)
{
this.estrategia.ApagarIncendio(pLugar, pCalle);
}
