Example #1
0
        public void terminarPoligono()
        {
            poligonoTerminado = true;
            Poligono pol = listaDePoligonos.Last();

            pol.setNombre("poligono" + listaDePoligonos.Count.ToString());
        }
Example #2
0
        public void pintar()
        {
            pintarEje();
            Punto punto, puntoAnterior;
            int   cantidadPoligonos = objeto.listaDePoligonos.Count;

            for (int i = 1; i <= cantidadPoligonos; i++)
            {
                Poligono poligono = objeto.listaDePoligonos.First();
                objeto.listaDePoligonos.RemoveFirst();
                objeto.listaDePoligonos.AddLast(poligono);
                int cantidadPuntos = poligono.listaDePuntos.Count;
                for (int j = 2; j <= cantidadPuntos; j++)
                {
                    puntoAnterior = (Punto)poligono.listaDePuntos.First();
                    poligono.listaDePuntos.RemoveFirst();
                    poligono.listaDePuntos.AddLast(puntoAnterior);
                    punto = (Punto)poligono.listaDePuntos.First();
                    Punto nuevoPA = getPuntoEnDescoordenadas(puntoAnterior.x, puntoAnterior.y);
                    Punto nuevoP  = getPuntoEnDescoordenadas(punto.x, punto.y);
                    papel.DrawLine(
                        lapiz,
                        nuevoPA.x, nuevoPA.y,
                        nuevoP.x, nuevoP.y);
                }
                puntoAnterior = (Punto)poligono.listaDePuntos.First();
                poligono.listaDePuntos.RemoveFirst();
                poligono.listaDePuntos.AddLast(puntoAnterior);
                punto         = null;
                puntoAnterior = null;
            }
            objeto.setPuntoEnCentro();
        }
Example #3
0
 public Efecto(string nombre, Poligono poligono, Punto punto, float numero, LinkedList <int> indice, bool ejeX)
 {
     this.nombre   = nombre;
     this.poligono = poligono;
     this.punto    = punto;
     this.numero   = numero;
     this.indices  = indice;
     this.ejeX     = ejeX;
 }
Example #4
0
 public void rotarPunto(double angulo)
 {
     if (indices.Contains(-1))
     {
         foreach (Poligono pol in listaDePoligonos)
         {
             pol.rotar(angulo);
         }
     }
     else
     {
         foreach (int indice in indices)
         {
             Poligono pol = listaDePoligonos.ElementAt(indice);
             pol.rotar(angulo);
         }
     }
 }
Example #5
0
 public void escalarPunto(Punto punto)
 {
     if (indices.Contains(-1))
     {
         foreach (Poligono pol in listaDePoligonos)
         {
             pol.setPuntoReferencia(punto);
         }
     }
     else
     {
         foreach (int indice in indices)
         {
             Poligono pol = listaDePoligonos.ElementAt(indice);
             pol.setPuntoReferencia(punto);
         }
     }
 }
Example #6
0
 public void escalarPunto(float constante)
 {
     if (indices.Contains(-1))
     {
         foreach (Poligono pol in listaDePoligonos)
         {
             pol.escalar(constante);
         }
     }
     else
     {
         foreach (int indice in indices)
         {
             Poligono pol = listaDePoligonos.ElementAt(indice);
             pol.escalar(constante);
         }
     }
 }
Example #7
0
 public void reflexionRecta(Poligono recta)
 {
     if (indices.Contains(-1))
     {
         foreach (Poligono pol in listaDePoligonos)
         {
             pol.reflexionRecta(recta);
         }
     }
     else
     {
         foreach (int indice in indices)
         {
             Poligono pol = listaDePoligonos.ElementAt(indice);
             pol.reflexionRecta(recta);
         }
     }
 }
Example #8
0
        public void reflexionRecta(Poligono recta)
        {
            float x1 = recta.listaDePuntos.First().x;
            float y1 = recta.listaDePuntos.First().y;
            float x2 = recta.listaDePuntos.Last().x;
            float y2 = recta.listaDePuntos.Last().y;

            setPuntoReferenciaEnCentro();
            float xc = puntoReferencia.x;
            float yc = puntoReferencia.y;
            float m = (y2 - y1) / (x2 - x1);
            float m2 = (-1) / m;
            float a = m2;
            float b = (m2 * xc) - yc;
            float c = m;
            float d = (m * x1) - y1;
            float x = (b - d) / (a - c);
            float y = (((a * b) - (a * d)) / (a - c)) - b;
            Punto punto, nuevoPunto;

            for (int i = 1; i <= listaDePuntos.Count; i++)
            {
                punto = listaDePuntos.First();
                listaDePuntos.RemoveFirst();
                nuevoPunto = new Punto(
                    punto.x - (2 * (punto.x - x)), //punto.x - x,
                    punto.y - (2 * (punto.y - y)), //punto.y - y,
                    1);
                listaDePuntos.AddLast(nuevoPunto);
            }

            /*reflexion(true);
             * setPuntoReferenciaEnCentro();
             * for (int i = 1; i <= listaDePuntos.Count; i++)
             * {
             *  punto = listaDePuntos.First();
             *  listaDePuntos.RemoveFirst();
             *  nuevoPunto = new Punto(
             *      punto.x + x,
             *      punto.y + y,
             *      1);
             *  listaDePuntos.AddLast(nuevoPunto);
             * }*/
        }
Example #9
0
        public Graphics getPoligonoDibujado(int indice)
        {
            Punto    punto, puntoAnterior;
            Poligono poligono       = objeto.getPoligono(indice);
            int      cantidadPuntos = poligono.listaDePuntos.Count;

            for (int j = 0; j < cantidadPuntos - 1; j++)
            {
                puntoAnterior = (Punto)poligono.listaDePuntos.ElementAt(j);
                punto         = (Punto)poligono.listaDePuntos.ElementAt(j + 1);
                Punto nuevoPA = getPuntoEnDescoordenadas(puntoAnterior.x, puntoAnterior.y);
                Punto nuevoP  = getPuntoEnDescoordenadas(punto.x, punto.y);
                papel.DrawLine(
                    lapiz,
                    nuevoPA.x, nuevoPA.y,
                    nuevoP.x, nuevoP.y);
            }
            return(papel);
        }
Example #10
0
 public Objeto(Objeto obj)
 {
     listaDePoligonos  = new LinkedList <Poligono>();
     poligonoTerminado = true;
     indices           = new LinkedList <int>();
     for (int i = 1; i <= obj.listaDePoligonos.Count; i++)
     {
         Poligono pol = obj.listaDePoligonos.ElementAt(i - 1);
         for (int j = 1; j <= pol.listaDePuntos.Count; j++)
         {
             Punto pun = pol.listaDePuntos.ElementAt(j - 1);
             float x   = pun.x;
             float y   = pun.y;
             float z   = pun.z;
             añadirPunto(new Punto(x, y, z));
         }
         terminarPoligono();
         listaDePoligonos.Last().setNombre(pol.nombre);
     }
 }
Example #11
0
 public void escalarEje(float constante)
 {
     if (indices.Contains(-1))
     {
         foreach (Poligono pol in listaDePoligonos)
         {
             pol.setPuntoReferencia(puntoCentral);
             pol.escalar(constante);
         }
     }
     else
     {
         foreach (int indice in indices)
         {
             Poligono pol = listaDePoligonos.ElementAt(indice);
             pol.setPuntoReferenciaEnCentro();
             pol.escalar(constante);
         }
     }
 }
Example #12
0
 public void rotarEje(double angulo)
 {
     if (indices.Contains(-1))
     {
         foreach (Poligono pol in listaDePoligonos)
         {
             pol.setPuntoReferencia(puntoCentral);
             pol.rotar(angulo);
         }
     }
     else
     {
         foreach (int indice in indices)
         {
             Poligono pol = listaDePoligonos.ElementAt(indice);
             pol.setPuntoReferenciaEnCentro();
             pol.rotar(angulo);
         }
     }
 }
Example #13
0
 public bool puntoReflexionRecta(bool ya)
 {
     objeto.añadirPunto(new Punto(x, y, 1));
     if (objeto.listaDePoligonos.Last().listaDePuntos.Count <= 2 || ya)
     {
         if (ya)
         {
             borrarUltimoPunto();
             poligonoAux = objeto.listaDePoligonos.Last();
             poligonoAux.setNombre("recta");
             objeto.eliminarPoligono(objeto.listaDePoligonos.Count - 1);
             objeto.poligonoTerminado = true;
             objeto.reflexionRecta(poligonoAux);
             return(true);
         }
         return(objeto.listaDePoligonos.Last().listaDePuntos.Count == 2);
     }
     else
     {
         borrarUltimoPunto();
         return(true);
     }
 }
Example #14
0
 public Efecto(string nombre, Poligono poligono, LinkedList <int> indice)
 {
     this.nombre   = nombre;
     this.poligono = poligono;
     this.indices  = indice;
 }
Example #15
0
 public void añadirPoligono(Poligono poligono) => listaDePoligonos.AddLast(poligono);
Example #16
0
 public void añadirACola(string efecto, Poligono poligono)
 {
     listaDeEfectos.AddLast(new Efecto(efecto, poligono, objeto.indices));
 }
Example #17
0
        public void eliminarPoligono(int indice)
        {
            Poligono pol = listaDePoligonos.ElementAt(indice);

            listaDePoligonos.Remove(pol);
        }