Beispiel #1
0
        /// <summary>
        /// Constructor para Backups
        /// </summary>
        /// <param name="iClone"></param>
        public Fila(Fila iClone)
        {
            Cod = iClone.Cod;

            Habitaciones = new List <Habitacion>();
            for (int i = 0; i < iClone.Habitaciones.Count; i++)
            {
                Habitaciones.Add(new Habitacion(iClone.Habitaciones[i]));
            }
        }
Beispiel #2
0
        /// <summary>
        /// Genera un laberinto de las dimensiones especificadas
        /// </summary>
        /// <param name="iAncho"></param>
        /// <param name="iAlto"></param>
        public static void Generar()
        {
            Matriz = new List <Fila>();
            int rnd_fila, rnd_col;

            //----- i1. Leer tamaño de la matriz
            //Console.WriteLine("¿Cuánto de ancho?: ");
            //iAncho = Convert.ToInt32(Console.ReadLine());
            //Console.WriteLine("¿Cuánto de alto?: ");
            //iAlto = Convert.ToInt32(Console.ReadLine());
            //if (iAlto < 4 || iAncho < 4) return; //Debe tener más de 4 filas de alto y 4 columnas de ancho
            //Console.Clear();

            //----- i2. Dibuja toda una matriz con espacios US
            for (int j = 0; j < Alto; j++)
            {
                Fila f = new Fila(j + 1); //Crea una nueva fila de habitaciones
                Matriz.Add(f);            //Almacena en la matriz cada fila

                for (int i = 0; i < Ancho; i++)
                {
                    Habitacion h = new Habitacion(i, j, TipoCasilla.US);
                    f.Habitaciones.Add(h); //Almacena la instancia
                    h.Dibujar(true);
                }

                Habitacion.Saltar();
            }

            //----- i3. Seleccion de una coordenada aleatoria
            Random r = new Random(DateTime.Now.Millisecond);

            rnd_fila = r.Next(1, Alto) - 1;
            rnd_col  = r.Next(1, Ancho) - 1;

            //----- i4. Convierte la celda aleatoria a tipo LQ
            Habitacion h_nueva_lq = Matriz[rnd_fila].Habitaciones[rnd_col];

            h_nueva_lq.Tipo = TipoCasilla.LQ;
            h_nueva_lq.Dibujar(true);

            //----- i5. Selecciona las habitaciones alrededor y las vuelve PE
            h_nueva_lq.Alrededor_PE();

            //----- i6. Elegir aleatoriamente una de las PE que haya en la matriz
            bool b_quedan_pe = true;

            while (b_quedan_pe) //Mientras hayan habitaciones PE en la matríz
            {
                //Console.ReadKey();

                //Escoge una fila al azar
                rnd_fila = r.Next(Alto);

                //Selecciona todos los PE en esa fila
                List <Habitacion> ls = Matriz[rnd_fila].Habitaciones.FindAll(t => t.Tipo.Equals(TipoCasilla.PE));

                //Si no encontró PE, continua el ciclo para buscar otra
                if (ls == null || ls.Count == 0)
                {
                    continue;
                }

                Habitacion h_pe = ls[r.Next(ls.Count)]; //Escoge una de las PE al azar
                h_pe.Dibujar(TipoCasilla.LQ);           //Vuelve la PE de tipo LQ
                h_pe.Alrededor_PE();                    //Rodea con PE la nueva LQ. Solo aplica para los US
                h_pe.Conectar_Nueva_LQ();               //Abre las puertas de la habitacion

                for (int i = 0; i < Matriz.Count; i++)  //Valida que no queden PE en la matriz
                {
                    List <Habitacion> tmp = Matriz[i].Habitaciones.FindAll(h => h.Tipo.Equals(TipoCasilla.PE));
                    if (tmp.Count > 0)
                    {
                        b_quedan_pe = true; break;
                    }
                    else
                    {
                        b_quedan_pe = false;
                    }
                }
            }

            //----- i7. Escoge una entrada-salida al azar
            int a = r.Next(Alto);
            int b = r.Next(Alto);
            int c = r.Next(1, Ancho);
            int d = r.Next(Ancho);

            AB = new int[2, 2]; //Aqui almacenará las coordenadas entrada-salida

            switch (Recorrido)
            {
            case Direccion.IzquierdaDerecha:
                Matriz[a].Habitaciones[0].EsLaEntrada        = true; //Marca la entrada
                Matriz[b].Habitaciones[Ancho - 1].EsLaSalida = true; //Marca la salida

                Matriz[a].Habitaciones[0].Puerta_Izq         = true;
                Matriz[b].Habitaciones[Ancho - 1].Puerta_Der = true;

                AB[0, 0] = 0; AB[0, 1] = a;         //A: Coordenada entrada
                AB[1, 0] = Ancho - 1; AB[1, 1] = b; //B: Coordenada salida
                break;

            case Direccion.ArribaAbajo:
                Matriz[0].Habitaciones[c].EsLaEntrada       = true; //Marca la entrada
                Matriz[Alto - 1].Habitaciones[d].EsLaSalida = true; //Marca la salida

                Matriz[0].Habitaciones[c].Puerta_Arr        = true;
                Matriz[Alto - 1].Habitaciones[d].Puerta_Aba = true;

                AB[0, 0] = c; AB[0, 1] = 0;        //A: Coordenada entrada
                AB[1, 0] = d; AB[1, 1] = Alto - 1; //B: Coordenada salida
                break;
            }

            //----- i8. Carga la matriz de colores para los caminos
            ColoresCamino     = new Color[11];
            ColoresCamino[0]  = Color.Yellow;
            ColoresCamino[1]  = Color.Salmon;
            ColoresCamino[2]  = Color.Pink;
            ColoresCamino[3]  = Color.White;
            ColoresCamino[4]  = Color.Blue;
            ColoresCamino[5]  = Color.Turquoise;
            ColoresCamino[6]  = Color.Tomato;
            ColoresCamino[7]  = Color.YellowGreen;
            ColoresCamino[8]  = Color.Thistle;
            ColoresCamino[9]  = Color.Silver;
            ColoresCamino[10] = Color.Orange;
        }