Ejemplo n.º 1
0
        //depredadoras
        void ButtonDepreClick(object sender, EventArgs e)
        {
            int selecciono = (int)numericUpDepre.Value;             //Numero de depredadoras a insertar

            numericUpDepre.Maximum = g.getLV().Count;
            Random r = new Random();
            int    posParticula;

            if (selecciono <= totalVertices && selecciono <= disponibles)
            {
                disponibles = disponibles - selecciono;
                if (disponibles >= 0)
                {
                    for (int i = 0; i < selecciono; i++)
                    {
                        // Creo una posicion random para insertar la particula siempre y cuando no este ocupada ya
                        posParticula = r.Next(0, g.getLV().Count);
                        while (vOcupados.Contains(posParticula))
                        {
                            posParticula = r.Next(0, g.getLV().Count);
                        }
                        vOcupados.Add(posParticula);

                        //Inserto el recorrido
                        RecorridosGrafo rg  = new RecorridosGrafo(g);
                        List <Vertice>  rec = new List <Vertice>();
                        rec = rg.getRecorridoAmplitud(g.getLV()[posParticula]);
                        //
                        Particula p = new Particula(posParticula, rec, true);
                        lParticulas.Add(p);
                    }

                    dibujaParticulas();
                    buttonAnimar.Visible = true;
                }
                else
                {
                    MessageBox.Show("No hay más lugares disponibles.");
                }
            }
            else
            {
                MessageBox.Show("No puedes insertar más particulas que los vertives disponibles.");
            }
        }
Ejemplo n.º 2
0
        void animarParticulas()
        {
            if (!esDijk)
            {
                bool     vuelta   = false;
                int      vueltas  = 0;
                Graphics graphics = Graphics.FromImage(iTransp);
                Brush    brochaP  = new SolidBrush(Color.BlueViolet);
                Brush    brochaD  = new SolidBrush(Color.Gold);
                Point    point    = new Point();

                Particula p = new Particula();
                while (lParticulas.Count > 0)
                {
                    if (vueltas == 2)
                    {
                        vuelta = true;
                    }
                    for (int i = 0; i < lParticulas.Count; i++)
                    {
                        p = lParticulas[i];
                        p.setIndPos(p.getContador());

                        Arista  a   = new Arista();
                        Vertice ori = p.getLVertices()[p.getCOri()];
                        Vertice des = p.getLVertices()[p.getCDes()];
                        for (int j = 0; j < ori.getLA().Count; j++)
                        {
                            if (ori.getLA()[j].getDestino().getId() == des.getId())
                            {
                                a = ori.getLA()[j];
                                break;
                            }
                        }

                        if (p.getIndPos() < a.getListaP().Count)                         //Si la particula no ha terminado los puntos en la arista donde esta
                        {
                            Point po = a.getListaP()[p.getIndPos()];
                            if (p.esDepre() == true)
                            {
                                point.X = po.X;
                                point.Y = po.Y;
                                p.setPosActual(point);
                                graphics.FillEllipse(brochaD, po.X - p.getR(), po.Y - p.getR(), 2 * p.getR(), 2 * p.getR());
                            }
                            else
                            {
                                point.X = po.X;
                                point.Y = po.Y;
                                p.setPosActual(point);
                                graphics.FillEllipse(brochaP, po.X - p.getR(), po.Y - p.getR(), 2 * p.getR(), 2 * p.getR());
                            }
                            //COMPROBAR COLISIONES
                            if (vuelta)
                            {
                                Particula p1 = new Particula();
                                Particula p2 = new Particula();

                                for (int z = 0; z < lParticulas.Count; z++)
                                {
                                    for (int x = 0; x < lParticulas.Count; x++)
                                    {
                                        if (z < lParticulas.Count && x < lParticulas.Count)
                                        {
                                            p1 = lParticulas[z];                                             // Es depredadora
                                            p2 = lParticulas[x];                                             // Es presa
                                        }

                                        if (p1.esDepre() && !p2.esDepre())
                                        {
                                            if (p1.getPosActual() == p2.getPosActual() ||
                                                (p1.getPosActual().X - 3 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X + 3 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X + 2 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X - 2 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||                                           //Aqui ya captura en x lineal
                                                (p1.getPosActual().X - 4 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X + 4 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X + 1 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X - 1 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||

                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y + 1 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y + 2 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y + 3 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y + 4 == p2.getPosActual().Y) ||                                           //Aqui ya captura en Y lineal
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y - 1 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y - 2 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y - 3 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y - 4 == p2.getPosActual().Y) ||

                                                (p1.getPosActual().Y + 1 == p2.getPosActual().Y&& p1.getPosActual().X - 1 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 2 == p2.getPosActual().Y&& p1.getPosActual().X - 2 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 3 == p2.getPosActual().Y&& p1.getPosActual().X - 3 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 4 == p2.getPosActual().Y&& p1.getPosActual().X - 4 == p2.getPosActual().X) ||

                                                (p1.getPosActual().Y - 1 == p2.getPosActual().Y&& p1.getPosActual().X + 1 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 2 == p2.getPosActual().Y&& p1.getPosActual().X + 2 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 3 == p2.getPosActual().Y&& p1.getPosActual().X + 3 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 4 == p2.getPosActual().Y&& p1.getPosActual().X + 4 == p2.getPosActual().X) ||

                                                (p1.getPosActual().Y + 1 == p2.getPosActual().Y&& p1.getPosActual().X + 1 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 2 == p2.getPosActual().Y&& p1.getPosActual().X + 2 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 3 == p2.getPosActual().Y&& p1.getPosActual().X + 3 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 4 == p2.getPosActual().Y&& p1.getPosActual().X + 4 == p2.getPosActual().X) ||

                                                (p1.getPosActual().Y - 1 == p2.getPosActual().Y&& p1.getPosActual().X - 1 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 2 == p2.getPosActual().Y&& p1.getPosActual().X - 2 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 3 == p2.getPosActual().Y&& p1.getPosActual().X - 3 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 4 == p2.getPosActual().Y&& p1.getPosActual().X - 4 == p2.getPosActual().X) ||

                                                (p1.getPosActual().Y - 1 == p2.getPosActual().Y&& p1.getPosActual().X - 1 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 2 == p2.getPosActual().Y&& p1.getPosActual().X - 2 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 3 == p2.getPosActual().Y&& p1.getPosActual().X - 3 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 4 == p2.getPosActual().Y&& p1.getPosActual().X - 4 == p2.getPosActual().X)
                                                )
                                            {
                                                p1.setR(p1.getR() + 5);
                                                lParticulas.Remove(p2);
                                                //i--;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        else                           //si ya termino cambio el origen
                        {
                            p.setCOri(p.getCOri() + 1);
                            p.setCDes(p.getCDes() + 1);
                            p.setContador(0);
                            if (p.getCDes() == p.getLVertices().Count)                             //Si el destino es el ultimo en la lista elimino la particula
                            {
                                point.X = 0;
                                point.Y = 0;
                                p.setPosActual(point);
                                lParticulas.Remove(p);
                                i--;
                            }
                        }
                        p.setContador(p.getContador() + 5);
                    }
                    pictureImageGrafo.Refresh();
                    graphics.Clear(Color.Transparent);
                    vueltas++;
                }
                totalVertices = disponibles = g.getLV().Count;                 //< Reinicio el contador para insertar más
                vOcupados.Clear();
            }
            else
            {
                bool vuelta  = false;
                bool viva    = true;
                bool refresh = true;
                int  vueltas = 0;
                //labelLlego.Text = "--";
                Graphics graphics = Graphics.FromImage(iTransp);
                Brush    brochaP  = new SolidBrush(Color.BlueViolet);
                Brush    brochaD  = new SolidBrush(Color.Gold);
                Point    point    = new Point();

                Particula p = new Particula();
                while (lParticulas.Count > 0)
                {
                    if (vueltas == 2)
                    {
                        vuelta = true;
                    }
                    if (!viva)
                    {
                        MessageBox.Show("-=LA PARTICULA FUE DEVORADA=-");
                        totalVertices = disponibles = g.getLV().Count;                         //< Reinicio el contador para insertar más
                        vOcupados.Clear();
                        break;
                    }
                    for (int i = 0; i < lParticulas.Count; i++)
                    {
                        p = lParticulas[i];
                        p.setIndPos(p.getContador());

                        Arista  a   = new Arista(null, null, double.MaxValue, null);
                        Vertice ori = p.getLVertices()[p.getCOri()];
                        Vertice des = p.getLVertices()[p.getCDes()];

                        for (int j = 0; j < ori.getLA().Count; j++)
                        {
                            if (ori.getLA()[j].getDestino() == des)
                            {
                                a = ori.getLA()[j];
                                break;
                            }
                        }

                        if (p.getIndPos() < a.getListaP().Count)                         //Si la particula no ha terminado los puntos en la arista donde esta
                        {
                            Point po = a.getListaP()[p.getIndPos()];
                            if (p.esDepre() == true)
                            {
                                point.X = po.X;
                                point.Y = po.Y;
                                p.setPosActual(point);
                                graphics.FillEllipse(brochaD, po.X - p.getR(), po.Y - p.getR(), 2 * p.getR(), 2 * p.getR());
                            }
                            else
                            {
                                point.X = po.X;
                                point.Y = po.Y;
                                p.setPosActual(point);
                                graphics.FillEllipse(brochaP, po.X - p.getR(), po.Y - p.getR(), 2 * p.getR(), 2 * p.getR());
                            }
                            //COMPROBAR COLISIONES
                            if (vuelta)
                            {
                                Particula p1 = new Particula();
                                Particula p2 = new Particula();

                                for (int z = 0; z < lParticulas.Count; z++)
                                {
                                    for (int x = 0; x < lParticulas.Count; x++)
                                    {
                                        if (z < lParticulas.Count && x < lParticulas.Count)
                                        {
                                            p1 = lParticulas[z];                                             // Es depredadora
                                            p2 = lParticulas[x];                                             // Es presa
                                        }

                                        if (p1.esDepre() && !p2.esDepre())
                                        {
                                            if (p1.getPosActual() == p2.getPosActual() ||
                                                (p1.getPosActual().X - 3 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X + 3 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X + 2 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X - 2 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||                                           //Aqui ya captura en x lineal
                                                (p1.getPosActual().X - 4 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X + 4 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X + 1 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X - 1 == p2.getPosActual().X&& p1.getPosActual().Y == p2.getPosActual().Y) ||

                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y + 1 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y + 2 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y + 3 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y + 4 == p2.getPosActual().Y) ||                                           //Aqui ya captura en Y lineal
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y - 1 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y - 2 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y - 3 == p2.getPosActual().Y) ||
                                                (p1.getPosActual().X == p2.getPosActual().X&& p1.getPosActual().Y - 4 == p2.getPosActual().Y) ||

                                                (p1.getPosActual().Y + 1 == p2.getPosActual().Y&& p1.getPosActual().X - 1 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 2 == p2.getPosActual().Y&& p1.getPosActual().X - 2 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 3 == p2.getPosActual().Y&& p1.getPosActual().X - 3 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 4 == p2.getPosActual().Y&& p1.getPosActual().X - 4 == p2.getPosActual().X) ||

                                                (p1.getPosActual().Y - 1 == p2.getPosActual().Y&& p1.getPosActual().X + 1 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 2 == p2.getPosActual().Y&& p1.getPosActual().X + 2 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 3 == p2.getPosActual().Y&& p1.getPosActual().X + 3 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 4 == p2.getPosActual().Y&& p1.getPosActual().X + 4 == p2.getPosActual().X) ||

                                                (p1.getPosActual().Y + 1 == p2.getPosActual().Y&& p1.getPosActual().X + 1 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 2 == p2.getPosActual().Y&& p1.getPosActual().X + 2 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 3 == p2.getPosActual().Y&& p1.getPosActual().X + 3 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y + 4 == p2.getPosActual().Y&& p1.getPosActual().X + 4 == p2.getPosActual().X) ||

                                                (p1.getPosActual().Y - 1 == p2.getPosActual().Y&& p1.getPosActual().X - 1 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 2 == p2.getPosActual().Y&& p1.getPosActual().X - 2 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 3 == p2.getPosActual().Y&& p1.getPosActual().X - 3 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 4 == p2.getPosActual().Y&& p1.getPosActual().X - 4 == p2.getPosActual().X) ||

                                                (p1.getPosActual().Y - 1 == p2.getPosActual().Y&& p1.getPosActual().X - 1 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 2 == p2.getPosActual().Y&& p1.getPosActual().X - 2 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 3 == p2.getPosActual().Y&& p1.getPosActual().X - 3 == p2.getPosActual().X) ||
                                                (p1.getPosActual().Y - 4 == p2.getPosActual().Y&& p1.getPosActual().X - 4 == p2.getPosActual().X))
                                            {
                                                p1.setR(p1.getR() + 5);
                                                lParticulas.Clear();
                                                //TODO: Si se comieron la presa detengo todo el proceso
                                                numericUpPosPresa.Enabled = true;
                                                viva = false;
                                                MessageBox.Show("-=LA PARTICULA FUE DEVORADA=-");
                                                totalVertices = disponibles = g.getLV().Count;                                                 //< Reinicio el contador para insertar más
                                                vOcupados.Clear();
                                                pictureImageGrafo.Refresh();
                                                graphics.Clear(Color.Transparent);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        else                           //si ya termino cambio el origen
                        {
                            p.setCOri(p.getCOri() + 1);
                            p.setCDes(p.getCDes() + 1);
                            p.setContador(0);
                            int auxPos = p.getLVertices()[p.getCDes() - 1].getId();
                            if (p.getCDes() == p.getLVertices().Count)                             //Si el destino es el ultimo en la lista elimino la particula
                            {
                                point.X = 0;
                                point.Y = 0;
                                p.setPosActual(point);
                                lParticulas.Clear();

                                //TODO: Si llego al final el vertice final será el nuevo origen, deberia cambiar los numericUp
                                viva = false;
                                //MessageBox.Show("La presa llego a su destino, seleccione uno nuevo");
                                numericUpPosPresa.Value   = auxPos;
                                numericUpPosPresa.Enabled = false;
                                refresh = false;
                                MessageBox.Show("-=LA PARTICULA LLEGO A SU DESTINO=-");
                                totalVertices = disponibles = g.getLV().Count;                                 //< Reinicio el contador para insertar más
                                vOcupados.Clear();

                                buttonDepre.Enabled = false;
                            }
                        }
                        p.setContador(p.getContador() + 5);
                    }
                    if (refresh)
                    {
                        pictureImageGrafo.Refresh();
                        graphics.Clear(Color.Transparent);
                    }
                    vueltas++;
                }
            }
        }
Ejemplo n.º 3
0
        ///Particulas presa
        void ButtonPresaNormalClick(object sender, EventArgs e)
        {
            if (!esDijk)
            {
                buttonDepre.Enabled = true;
                int selecciono = (int)numericUpNPresa.Value;
                numericUpPosPresa.Maximum = g.getLV().Count;                 //< Para poner una particula en una pos especifica
                numericUpPosDest.Maximum  = g.getLV().Count;
                if (selecciono <= totalVertices && selecciono <= disponibles)
                {
                    disponibles = disponibles - selecciono;
                    if (disponibles >= 0)
                    {
                        if ((int)numericUpPosDest.Value == 0 && (int)numericUpPosPresa.Value == 0 && (int)numericUpNPresa.Value > 0)
                        {
                            //TODO: INSERTO ALEATORIAMENTE
                            Random r = new Random();
                            int    posParticula;
                            for (int i = 0; i < selecciono; i++)
                            {
                                posParticula = r.Next(0, g.getLV().Count);
                                while (vOcupados.Contains(posParticula))
                                {
                                    posParticula = r.Next(0, g.getLV().Count);
                                }
                                vOcupados.Add(posParticula);

                                //Inserto recorrido en profundidad
                                RecorridosGrafo rg  = new RecorridosGrafo(g);
                                List <Vertice>  rec = new List <Vertice>();

                                rec = rg.getRecorridoProfundidad(g.getLV()[posParticula]);

                                Particula p = new Particula(posParticula, rec, false);
                                lParticulas.Add(p);
                            }
                        }
                        else if ((int)numericUpPosPresa.Value != 0 && (int)numericUpPosDest.Value == 0 && (int)numericUpNPresa.Value == 1)
                        {
                            //TODO: INSERTO EN EL ORIGEN SELECCIONADO
                            int posP = (int)numericUpPosPresa.Value - 1;
                            if (vOcupados.Contains(posP))
                            {
                                MessageBox.Show("Ese vértice origen ya esta ocupado");
                                return;
                            }
                            vOcupados.Add(posP);
                            RecorridosGrafo rg  = new RecorridosGrafo(g);
                            List <Vertice>  rec = new List <Vertice>();

                            rec = rg.getRecorridoProfundidad(g.getLV()[posP]);
                            Particula p = new Particula(posP, rec, false);

                            lParticulas.Add(p);
                        }
                        else if ((int)numericUpPosPresa.Value != 0 && (int)numericUpNPresa.Value > 0)
                        {
                            disponibles = disponibles + selecciono;
                            MessageBox.Show("No puedes insertar multiples particulas en el mismo vértice");
                        }
                    }
                    else
                    {
                        MessageBox.Show("No hay más lugares disponibles.");
                    }
                    dibujaParticulas();
                    buttonAnimar.Visible = true;
                }
                else
                {
                    MessageBox.Show("No puedes insertar más particulas que los vértices disponibles.");
                }
            }
            else
            {
                buttonAnimar.Visible = true;

                int posO, posD, posParticula;
                posO = (int)numericUpPosPresa.Value - 1;
                posD = (int)numericUpPosDest.Value - 1;

                if (posD == posO)
                {
                    MessageBox.Show("El origen no puede ser igual al actual destino");
                    return;
                }

                Dijkstra dij = new Dijkstra(g, g.getLV()[posO], g.getLV()[posD]);

                disponibles--;
                posParticula = posO;
                if (vOcupados.Contains(posParticula))
                {
                    MessageBox.Show("Ese vertice ya pertenece a un depredador");
                }
                else
                {
                    vOcupados.Add(posParticula);
                    Particula p = new Particula(posParticula, dij.getLCamino(), false);
                    lParticulas.Add(p);
                    buttonDepre.Enabled = true;
                }
                dibujaParticulas();

                listBoxCamino.DataSource = dij.getLCamino();
            }
        }