Los objetivos son:

• Obtener uno o más horarios válidos
• Llevar todos los cursos posibles
• Cada curso puede dictarse mas de un dia a la semana
• Cada curso puede tener varios horarios para escoger

Primero vamos a repasar rápidamente lo que es un algoritmo genético.

Un algoritmo genético es aquel en el que los datos se representan por genes. A su vez los genes se organizan en estructuras llamadas genomas, que le dan cierto sentido a los datos. Los genomas interactúan entre sí para buscar la solución a un cierto problema dado.

En este ejemplo vamos a hacer uso de un algoritmo genético y evolutivo. En otras palabras, los genomas irán evolucionando para llegar a la solución buscada.

La parte principal de nuestro algoritmo es la siguiente:

        public void EjecutarCiclo()
        {
            List<CGenoma> nuevaPoblacion = new List<CGenoma>();
            while (nuevaPoblacion.Count < LongitudPoblacion)
            {
                CGenoma padre = Seleccionar();
                CGenoma madre = Seleccionar();
                CGenoma hijo1;
                CGenoma hijo2;
                RealizarCruce(padre, madre, out hijo1, out hijo2);
                hijo1 = Mutacion(hijo1);
                hijo2 = Mutacion(hijo2);
                nuevaPoblacion.Add(hijo1);
                nuevaPoblacion.Add(hijo2);
            }
            ListaPoblacion = nuevaPoblacion;
            ActualizarFitness();
        }

Si podemos entender esa pequeña sección de código, lo tendremos casi todo.

El algoritmo se basa en la creación de nuevas poblaciones a partir de los genomas existentes. Para obtener nuevos “hijos”, se selecciona un padre, una madre y se realiza el cruce. El padre y la madre deben ser cuidadosamente seleccionados: no es una selección al azar. Una vez que tenemos dos nuevos hijos, se da paso a la mutación (aunque  procuraremos que su efecto sea mínimo). Esto se repite una y otra vez, hasta obtener una solución.

La mala noticia es que no se puede garantizar una solución. La buena es que este algoritmo puede obtener soluciones que normalmente escapan a los cálculos humanos.

Ya hemos visto la parte principal. Pero para poderla utilizar, antes necesitamos una población inicial:

        public void GenerarPoblacionInicial()
        {
            ListaPoblacion = new List<CGenoma>();
            while (ListaPoblacion.Count < LongitudPoblacion)
            {
                CGenoma genoma = new CGenoma();
                foreach (CCurso curso in Data.ListaCursos)
                {
                    genoma.ListaGenes.Add(new CGen(curso.Id, curso.ObtenerIdHorarioAlAzar()));
                }
                ListaPoblacion.Add(genoma);
            }
            ActualizarFitness();
        }

Ahora se hace evidente que existe una relación entre nuestros datos y los genes cada genoma. Los genes son muy dependientes de cada problema analizado. Para el presente caso, un gen representa la información: Curso-Horario.

Los genomas son siempre listas de genes. En este caso un genoma tendrá la estructura:

• genoma: gen1, gen2, gen3…, genN

O, lo que es lo mismo:

• genoma: Curso1-Horario1, Curso2-Horario2, Curso3-Horario3…, CursoN-HorarioN

La estructura de la clase genoma es la siguiente:

    public class CGenoma
    {
        public List<CGen> ListaGenes;
        public double Fitness;

        public CGenoma()
        {
            ListaGenes = new List<CGen>();
            Fitness = 0;
        }

        internal void CalculaFitness(int PeorPuntaje, CTestData pData)
        {
            int total = 0;
            Fitness = 1 - ((double)total / (double)PeorPuntaje);
        }

        public void Render(Graphics Canvas, int x, int y, CTestData pData)
        {
        }
    }

La clase genoma se compone simplemente de una lista de genes, una función para calcular el Fitness y un método para representar al genoma de forma gráfica (dibujar el horario en pantalla, vamos).

Probablemente esto del Fitness sea lo más difícil de entender, y también lo mas delicado, por lo que le dedicaré mayor espacio en la siguiente publicación. Sólo adelanto que el fitness de un genoma es un valor float entre 0 y 1 y sirve para indicar la “utilidad” de un genoma. Si el fitness se acerca a 1, el genoma es “bueno”, si se acerca a 0, es “malo”.

Por ahora veamos que contiene cada gen dentro de nuestro genoma:

    public class CGen
    {
        public int Curso;
        public int Horario;

        public CGen(int pCurso, int pHorario)
        {
            Curso = pCurso;
            Horario = pHorario;
        }
    }

Como podemos ver, el gen es bastante simple para este problema.

En la mayoría de implementaciones de algoritmos genéticos que se pueden encontrar por la web, pareciera ser necesario que tanto el gen, como el genoma, sean representaciones de cadenas con ceros y unos. Eso no es necesario y no lo verán en este ejemplo. La ventaja de utilizar ceros y unos es que con ellos es más fácil realizar operaciones genéticas (cruces, mutaciones, selecciones). Pero presentan la desventaja de que hay que codificar y decodificar los genes para poder llegar a los datos.

Próximamente continuaremos con la implementación de este algoritmo.

¡Hasta pronto!

Para esto nos vamos a valer del concepto de feromonas. Tal como les contaba en el primer artículo de esta serie, las hormigas se guían por un rastro químico que ellas mismas van dejando. Nosotros implementaremos eso mismo. Cada vez que una hormiga dé un paso, provocaremos que deje este rastro. El rastro debe poder incrementar otro rastro que haya sido dejado con anterioridad, para esto utilizaremos una variable que simule la intensidad del rastro.

Cuando una hormiga encuentre un rastro, deberá seguir su dirección, cuando no lo encuentre, seguirá paseando aleatoriamente. Este será, a grandes rasgos, el comportamiento que buscaremos con la clase feromona, la cual muestro a continuación:

    public class CFeromona
    {
        private float mIntensidad;
        public CCircle Posicion { get; set; }
        public float Direccion;
        public float Intensidad
        {
            get { return mIntensidad; }
            set
            {
                mIntensidad=value;
                if (mIntensidad > 255)
                    mIntensidad = 255;
            }
        }

        public CFeromona()
        {
            Intensidad = 10;
            Posicion = new CCircle();
            Posicion.Radius = 5;
        }

        public void Render(Graphics g)
        {
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
            g.ResetTransform();
            g.TranslateTransform(Posicion.Center.X, Posicion.Center.Y);
            Brush br = new SolidBrush(Color.FromArgb((int)Intensidad, 220, 220, 255));
            g.FillEllipse(br,
                new Rectangle(
                    new Point(-Posicion.Radius, -Posicion.Radius),
                    new Size(Posicion.Radius * 2, Posicion.Radius * 2)));
        }
    }

Como pueden observar, la posición de una feromona está definida como un círculo. Esto lo hago para facilitar el que una hormiga pueda encontrarla, si fuera un punto, tendríamos que ponernos a esperar todo el día. Por este mismo motivo, he modificado la clase hormiga y ahora es como sigue:

    public class CHormiga
    {
        public CCircle Posicion { get; set; }
        public float Direccion { get; set; }
        public int Estado { get; set; }
        public int Velocidad { get; set; }

        public CHormiga()
        {
            Estado = 0;
            Posicion = new CCircle();
            Posicion.Radius = 8;
        }

        public void Render(Graphics g)
        {
            Posicion.Render(g);
            Point p = Posicion.Center;
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
            g.ResetTransform();
            g.TranslateTransform(p.X, p.Y);
            g.RotateTransform(Direccion);
            Pen pen = new Pen(Color.Black);
            g.FillEllipse(Brushes.Black, new Rectangle(new Point(-2, -10), new Size(4, 6)));
            g.FillEllipse(Brushes.Black, new Rectangle(new Point(-1, -4), new Size(2, 2)));
            g.FillEllipse(Brushes.Black, new Rectangle(new Point(-2, -2), new Size(4, 4)));
            g.DrawLine(pen, 0, 2, -3, 5);
            g.DrawLine(pen, 0, 2, 3, 5);
            pen.Dispose();
        }
    }

Y bueno, ya se estarán preguntando cómo es esta clase CCirculo. Pues no se preocupen que aquí va:

    public class CCircle
    {
        public Point Center { get; set; }
        public int Radius { get; set; }

        public void Render(Graphics g)
        {
            g.ResetTransform();
            g.TranslateTransform(Center.X, Center.Y);
            g.DrawEllipse(new Pen(Brushes.Salmon), -Radius / 2, -Radius / 2, Radius, Radius);
        }
    }

Pero los cambios más radicales están en la clase Controladora. Ya no basta con mover a las hormigas, ahora es necesario actualizar la intensidad de las feromonas para simular su evaporación y también es necesario verificar si cada hormiga se ha topado con un rastro de feromonas.

Esta sería la nueva versión de la clase controladora:

    class CHormiguero
    {
        private double counter = 0;
        private Point mLimits;

        public ArrayList Hormigas { get; set; }
        public ArrayList Feromonas { get; set; }
        public Point Posicion { get; set; }
        public Point Limits
        {
            get { return mLimits; }
            set
            {
                mLimits = value;
                foreach (CHormiga hormiga in Hormigas)
                {
                    if (hormiga.Posicion.Center.X > mLimits.X)
                    {
                        hormiga.Posicion.Center =
                            new Point(mLimits.X, hormiga.Posicion.Center.Y);
                    }
                    if (hormiga.Posicion.Center.Y > mLimits.Y)
                    {
                        hormiga.Posicion.Center =
                            new Point(hormiga.Posicion.Center.X, mLimits.Y);
                    }
                }
            }
        }

        public CHormiguero(int numHormigas, int width, int height, int velocidad)
        {
            Hormigas = new ArrayList();
            Feromonas = new ArrayList();
            Limits = new Point(width, height);
            Posicion = new Point(width/2, height/2);

            Random rnd = new Random();
            for (int i = 0; i < numHormigas; i++)
            {
                CHormiga hormiga = new CHormiga();
                hormiga.Posicion.Center =
                    new Point(rnd.Next(width), rnd.Next(height));
                hormiga.Direccion = ((float)rnd.NextDouble() * 360) - 180;
                hormiga.Velocidad = rnd.Next(velocidad - 5) + 5;
                Hormigas.Add(hormiga);
            }
        }

        public void Render(Graphics g)
        {
            //g.FillEllipse(Brushes.Gray, Posicion.X - 5, Posicion.Y - 5, 10, 10);
            foreach (CFeromona feromona in Feromonas)
            {
                feromona.Render(g);
            }
            foreach (CHormiga hormiga in Hormigas)
            {
                hormiga.Render(g);
            }
        }

        public void ActualizarFeromonas(float tiempo)
        {
            for (int i = Feromonas.Count - 1; i >= 0; i--)
            {
                CFeromona feromona = (CFeromona)Feromonas[i];
                feromona.Intensidad -= tiempo/2;
                if (feromona.Intensidad < 1)
                {
                    Feromonas.Remove(feromona);
                }
            }
        }

        public void MoverHormigas(float tiempo)
        {
            Random rnd = new Random();
            counter += 1;
            foreach (CHormiga hormiga in Hormigas)
            {
                float d = hormiga.Direccion;
                float radd = (float)((d * Math.PI) / 180);
                int dx = -(int)(Math.Sin(radd) * hormiga.Velocidad * tiempo);
                int dy = (int)(Math.Cos(radd) * hormiga.Velocidad * tiempo);
                Point p = hormiga.Posicion.Center;
                p.X += dx;
                p.Y += dy;
                //Detectar feromonas
                CFeromona bestF = null;
                //Si detecta feromona, ir en esa direccion
                //Si no detecta, tomar un camino al azar y dejar feromona
                if (DetectarFeromona(hormiga, ref bestF))
                {
                    bestF.Intensidad += 10;
                    d = bestF.Direccion;
                }
                else
                {
                    d += ((float)rnd.NextDouble() * 60) - 30;
                    if (Feromonas.Count < 1000)
                    {
                        CFeromona f = new CFeromona();
                        f.Posicion.Center = hormiga.Posicion.Center;
                        f.Direccion = d;
                        Feromonas.Add(f);
                    }
                }
                if ((p.X > 0) && (p.X < Limits.X) &&
                    (p.Y > 0) && (p.Y < Limits.Y))
                {
                }
                else
                {
                    if (p.X < 0) p.X = Limits.X;
                    if (p.X > Limits.X) p.X = 0;
                    if (p.Y < 0) p.Y = Limits.Y;
                    if (p.Y > Limits.Y) p.Y = 0;
                }
                hormiga.Posicion.Center = p;
                hormiga.Direccion = d;
            }
        }

        private bool DetectarFeromona(CHormiga hormiga, ref CFeromona bestF)
        {
            bool hit = false;
            foreach (CFeromona feromona in Feromonas)
            {
                {
                    if (CColisiones.Colision(feromona.Posicion, hormiga.Posicion))
                    {
                        if (!hit)
                        {
                            bestF = feromona;
                            hit = true;
                        }
                        else
                        {
                            if (feromona.Intensidad > bestF.Intensidad)
                            {
                                bestF = feromona;
                            }
                        }
                    }
                }
            }
            return hit;
        }
    }

También se ha creado la siguiente clase que verifica las colisiones de forma bastante sencilla, y esta era una de las razones de hacer que la posición de las hormigas y las feromonas sea definida como un círculo:

    public static class CColisiones
    {
        public static bool Colision(CCircle c1, CCircle c2)
        {
            double r = c1.Radius + c2.Radius;
            double x = c2.Center.X - c1.Center.X;
            double y = c2.Center.Y - c1.Center.Y;
            return (r * r > (x * x + y * y));
        }

Y ya tenemos todo listo para utilizarlo en un formulario que tenga su respectivo Timer.

El resultado que yo he obtenido es el siguiente:

El formulario mostrado tiene sólo 15 hormigas, pero lo he probado con 300 y funciona igualmente bien: las hormigas van dejando un rastro que es seguido por las demás y mientras más hormigas lo recorren, este se hace más nítido.

Lo más importante, por ahora, es que se confirma que las hormigas sólo necesitan del rastro de feromonas para funcionar organizadamente.

En un siguiente artículo jugaremos un poco con las probabilidades de seguir o abandonar un determinado rastro y veremos si todo esto es suficiente para encontrar comida y llevarla de vuelta al nido.

No duden en dejarme un comentario si es que tienen alguna duda, pues aquí se han encontrado muchos conceptos diferentes: manejo de gráficos, colisiones, algo de matemática, además del tema central que son las hormigas. Por ese motivo he pasado por alto algunos conceptos, pero eso no significa que no esté dispuesto a comentarlos si que algún lector desea aclarar algún punto.

¡Hasta pronto!

        public CHormiguero(int numHormigas, int width, int height)
        {
            Hormigas = new ArrayList();
            Velocidad = 10;
            Limits = new Point(width, height);

            Random rnd = new Random();
            for (int i = 0; i < numHormigas; i++)
            {
                CHormiga hormiga = new CHormiga();
                hormiga.Posicion =
                    new Point(rnd.Next(width), rnd.Next(height));
                hormiga.Direccion =
                    ((float)rnd.NextDouble() * 360) - 180;
                Hormigas.Add(hormiga);
            }
        }

Una de estas dificultades consiste en que los controles que ponemos dentro de un control de usuario, no pueden ser accesados tan fácilmente como los que están colocados a nivel de página.

Por ejemplo, si tenemos un control de usuario sencillo como el siguiente:

<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="WebUserControl1.ascx.cs" Inherits="WSMyLittleStore.WebUserControl1" %>

<asp:Label ID="Label1" runat="server" Text="Nombre"></asp:Label>
<asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>
<br />
<asp:Label ID="Label2" runat="server" Text="Apellido"></asp:Label>
<asp:TextBox ID="TextBox2" runat="server"></asp:TextBox>

Y un formulario igualmente sencillo como:

<form id="form1" runat="server">
 <div>
 <uc1:WebUserControl1 ID="WebUserControl11" runat="server" />
 <br />
 <asp:Label ID="Label1" runat="server" Text="Edad"></asp:Label>
 <asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>
 </div>
 </form>

No podremos hacer lo siguiente en el code-behind de la página:

protected void Page_Load(object sender, EventArgs e)
 {
 TextBox1.Text = "TextBox en el form"; //Correcto!
 WebUserControl1.TextBox1.Text = "TextBox en el UserControl"; //Error!
 WebUserControl1.TextBox2.Text = "TextBox en el UserControl"; //Error!
 }

Esto se debe a que los controles dentro del UserControl están declarados con el atributo protected.

He utilizado tres maneras de sortear este problema, cada una con sus ventajas e inconvenientes:

1) Crear una propiedad pública dentro del UserControl

En el code-behind del UserControl haríamos lo siguiente:

public partial class WebUserControl1 : System.Web.UI.UserControl
 {
 public TextBox Texto1
 {
 get { return TextBox1; }
 set { TextBox1 = Texto1; }
 }

 public TextBox Texto2
 {
 get { return TextBox2; }
 set { TextBox1 = Texto2; }
 }

 protected void Page_Load(object sender, EventArgs e)
 {
 }
 }

Ahora en el code-behind del form podemos utilizar Texto1 y Texto2 para referirnos a las hasta ahora inaccesibles cajas de texto del UserControl:

protected void Page_Load(object sender, EventArgs e)
 {
 TextBox1.Text = "TextBox en el form"; //Correcto!
 WebUserControl1.Texto1.Text = "TextBox en el UserControl"; //Correcto!!
 WebUserControl1.Texto2.Text = "TextBox en el UserControl"; //Correcto!!
 }

Esta es la opción más recomendada por la mayoría. Para mi es totalmente impráctica cuando el UserControl cuenta con muchos controles que deseamos exponer. Imagínense 40 declaraciones de gets y sets. Simplemente, me parece una pérdida de tiempo y una carga negativa para la mantenibilidad de la aplicación. Sin embargo puede ser útil para utilizarla con unos pocos controles (hasta 3, diría yo).

2) Utilizar FindControl en el code-behind de la página

En este caso nos olvidamos de los gets y sets y trabajamos directamente con el code-behind del form:

protected void Page_Load(object sender, EventArgs e)
 {
 TextBox Texto1 = (TextBox)WebUserControl1.FindControl("TextBox1");
 TextBox Texto2 = (TextBox)WebUserControl1.FindControl("TextBox2");
 TextBox1.Text = "TextBox en el form"; //Correcto!
 Texto1.Text = "TextBox en el UserControl"; //Correcto!
 Texto2.Text = "TextBox en el UserControl"; //Correcto!
 }

Sé que esta alternativa va a resultar tentadora para más de uno. Pero hay que tener en cuenta 2 inconvenientes:

Primero, que estamos introduciendo “código duro” en nuestro form, obligándonos a mantener a mano la coincidencia de los nombres de los controles con el string que utilizamos en cada método FindControl.

Segundo y más importante aún, que cualquier error en los nombres no será detectado por el compilador sino que causará errores de ejecución o de lógica en nuestro formulario.

3) Cambiar los atributos a public

En este caso nos fijaremos que nuestro UserControl se compone de 3 ficheros:

• UserControl.ascx
• UserControl.ascx.cs
• UserControl.ascx.designer.cs

Nosotros abriremos el archivo UserControl.ascx.designer.cs y veremos que ahí se encuentran declarados nuestros controles con el atributo protected. Veremos también que sobre cada declaración hay un mensaje que dice:

 /// Auto-generated field.
 /// To modify move field declaration from designer file to code-behind file.

Y bueno, pues podemos hacer caso de eso y cortar la declaración del control para luego pegarla en el code-behind. Una vez en el code-behind, cambiaremos la palabra protected por public y ¡voila!, ya tendremos acceso al control desde el form.

El code-behind del UserControl debería quedar como sigue:

public partial class WebUserControl1 : System.Web.UI.UserControl
 {
 public global::System.Web.UI.WebControls.TextBox TextBox1;
 public global::System.Web.UI.WebControls.TextBox TextBox2;

 protected void Page_Load(object sender, EventArgs e)
 {

 }
 }

Ahora en el code-behind de nuestro form podemos escribir:

protected void Page_Load(object sender, EventArgs e)
 {
 TextBox1.Text = "TextBox en el form"; //Correcto!
 WebUserControl1.TextBox1.Text = "TextBox en el UserControl"; //Correcto!
 WebUserControl1.TextBox2.Text = "TextBox en el UserControl"; //Correcto!
 }

El principal inconveniente de esta solución es que atenta contra una de las leyes de la POO: que los atributos de una clase no deben ser accesados directamente, sino a través de métodos o propiedades. Pero es que las otras soluciones tampoco parecen sacadas de un libro de “buenas prácticas” y me parece que Microsoft nos ha dejado un poco huérfanos con este problema.

Para finalizar, creo que ninguna de las opciones es óptima. Cada una servirá para situaciones particulares y ya depende de cada uno considerar sus ventajas y desventajas. Si alguien conoce otra forma, ¡por favor compartirla con los que leen este blog!

Por lo pronto, yo pienso que Microsoft debería ofrecer una mejor alternativa en las futuras revisiones del UserControl. Por decir algo: que la accesibilidad de cada control pueda ser establecida por medio de una propiedad en tiempo de diseño.

¿Qué opinan ustedes?

¡Hasta pronto!

La estructura de nuestra clase controladora es la siguiente:

    class CHormiguero
    {
        private double counter = 0;

        public ArrayList Hormigas { get; set; }
        public Point Posicion { get; set; }
        public Point Limits { get; set; }
        public float Velocidad { get; set; }

        public CHormiguero(int numHormigas, int width, int height)
        {
        }

        public void Render(Graphics g)
        {
            foreach (CHormiga hormiga in Hormigas)
            {
                hormiga.Render(g);
            }
        }

        public void MoverHormigas(float tiempo)
        {
        }
    }
}

El constructor CHormiguero se encargará de crear cada hormiga, establecer la velocidad y poner límites al hormiguero:

        public CHormiguero(int numHormigas, int width, int height)
        {
            Hormigas = new ArrayList();
            Velocidad = 10;
            Limits = new Point(width, height);

            Random rnd = new Random();
            for (int i = 0; i < numHormigas; i++)
            {
                CHormiga hormiga = new CHormiga();
                hormiga.Posicion =
                    new Point(rnd.Next(width), rnd.Next(height));
                hormiga.Direccion =
                    ((float)rnd.NextDouble() * 360) - 180;
                Hormigas.Add(hormiga);
            }
        }

El método MoverHormigas es el más interesante, pues debe calcular dónde dibujar las hormigas. Asimismo, verifica que las hormigas permanezcan dentro de los límites establecidos y, además, introduce una pequeña variación en la dirección que llevan los pequeños bichos:

        public void MoverHormigas(float tiempo)
        {
            Random rnd = new Random();
            counter += 1;
            foreach (CHormiga hormiga in Hormigas)
            {
                float d = hormiga.Direccion;
                float radd = (float)((d * Math.PI) / 180);
                int dx = -(int)(Math.Sin(radd) * Velocidad * tiempo);
                int dy = (int)(Math.Cos(radd) * Velocidad * tiempo);
                Point p = hormiga.Posicion;
                p.X += dx;
                p.Y += dy;
                d += ((float)rnd.NextDouble() * 60) - 30;
                if ((p.X > 0) && (p.X < Limits.X) &&
                    (p.Y > 0) && (p.Y < Limits.Y))
                {
                    hormiga.Posicion = p;
                    hormiga.Direccion = d;
                }
                else
                {
                    hormiga.Direccion =
                        ((float)rnd.NextDouble() * 360) - 180; ;
                }
            }
        }

Bien, ya está hecho lo más difícil. Ahora tenemos que crear un formulario que haga uso de este pequeño universo.

Crearemos un nuevo formulario y simplemente le agregaremos dos botones y un control Timer.

El código del formulario es bastante simple. Básicamente, los botones sirven para iniciar o detener el timer. El timer se encarga de llamar al método MoverHormigas periódicamente. Lo demás ya nos debería parecer familiar:

    public partial class frmHormigaZ02 : Form
    {
        CHormiguero hormiguero;

        public frmHormigaZ02()
        {
            InitializeComponent();
        }

        private void frmHormigaZ02_Load(object sender, EventArgs e)
        {
            hormiguero = new CHormiguero(20, this.Width, this.Height);
            this.Invalidate();
        }

        private void cmdIniciar_Click(object sender, EventArgs e)
        {
            timer1.Start();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            hormiguero.MoverHormigas(1);
            this.Invalidate();
        }

        private void frmHormigaZ02_Paint(object sender,
           PaintEventArgs e)
        {
            if (hormiguero != null)
                hormiguero.Render(e.Graphics);
        }

        private void cmdDetener_Click(object sender, EventArgs e)
        {
            timer1.Stop();
        }
    }

La simpleza del código anterior se debe a que hemos utilizado una clase controladora. Esa misma clase nos va a permitir introducir nuevos elementos en nuestra simulación, aunque eso será en el próximo artículo. Por ahora podemos entretenernos mirando como se mueven las hormigas y modificando algunos datos como la velocidad, los ángulos y la forma de las hormigas.

¡Hasta pronto!

    public class CHormiga
    {
        public Point Posicion { get; set; }
        public float Direccion { get; set; }
        public int Estado { get; set; }

        public CHormiga()
        {
            Estado = 0;
        }

        public void Render(Graphics g)
        {
            Point p = Posicion;
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
            g.ResetTransform();
            g.TranslateTransform(p.X, p.Y);
            g.RotateTransform(Direccion);
            Pen pen = new Pen(Color.Black);
            Brush b = Brushes.Black;
            g.FillEllipse(b, new Rectangle(new Point(-2, 0), new Size(4, 6)));
            g.FillEllipse(b, new Rectangle(new Point(-1, 6), new Size(2, 2)));
            g.FillEllipse(b, new Rectangle(new Point(-2, 8), new Size(4, 4)));
            g.DrawLine(pen, 0, 12, -3, 15);
            g.DrawLine(pen, 0, 12, 3, 15);
            pen.Dispose();
        }
    }

Ahora crearemos un formulario que tan sólo tenga un botón. Declararemos un ArrayList que sirva para contener a varias hormigas. Esta sería la estructura de nuestra aplicación:

    using System.Collections;

    public partial class frmHormigaZ : Form
    {
        ArrayList hormigas = new ArrayList();

        public frmHormigaZ()
        {
            InitializeComponent();
        }

        private void cmdIniciar_Click(object sender, EventArgs e)
        {
        }

        private void frmHormigaZ_Paint(object sender, PaintEventArgs e)
        {
        }
    }
}

Con el botón será posible agregar algunas hormigas al ArrayList. Editar el código de la siguiente manera:

        private void cmdIniciar_Click(object sender, EventArgs e)
        {
            Random rnd = new Random();
            for (int i = 0; i < 30; i++)
            {
                CHormiga hormiga = new CHormiga();
                hormiga.Posicion = 
                    new Point(rnd.Next(this.Width), 
                              rnd.Next(this.Height));
                hormiga.Direccion = 
                    ((float)rnd.NextDouble() * 360) - 180;
                hormigas.Add(hormiga);
            }
            this.Invalidate();
        }

El evento Paint del formulario será el encargado de mostrarnos a toda la colonia de bichos. Editar el código como se muestra:

        private void frmHormigaZ_Paint(object sender, PaintEventArgs e)
        {
            Graphics g = e.Graphics;
            foreach (CHormiga hormiga in hormigas)
            {
                hormiga.Render(g);
            }
        }

Si ejecutamos ahora el proyecto y presionamos el botón, veremos algunas decenas de hormigas inmóviles:

Pues cierto, las hormigas no se mueven. No esperabas que, con tan poco trabajo, las hormigas se movieran, ¿verdad?

Cada hormiga necesita ser controlada dentro de un mini-universo que será una clase más:

Pero los detalles de esta nueva clase los veremos en la siguiente entrada del blog.

¡Hasta pronto!