0

Cómo implementar el juego del caos en C++

juego_caos_portada¡Hola humanos, humanas y demás computadores orgánicos! Hoy voy a explicaros una curiosidad. ¿Habéis oído a hablar alguna vez del Juego del Caos?

El Juego del Caos es un algoritmo para dibujar fractales. Lo más curioso es que lo hace colocando puntos al azar sobre un plano. Bueno, en realidad casi al azar. Sólo con algunas limitaciones.

Hoy vamos a utilizar éste método para dibujar un triángulo de Sierpinski como el de la imagen.

screenshot_triangulo

¿Cómo lo haremos? Escribiremos un código en C++ que genere puntos al azar y guarde sus coordenadas en un fichero de texto, que seguirá este formato:

x0 y0
x1 y1
x2 y2
x3 y3
...

Después abriremos este fichero con un programa para dibujar gráficos. En este tutorial usaremos Gnuplot: es un programa gratuito para Windows, Linux y Mac que permite representar todo tipo de funciones y gráficas. Y sólo funciona por línea de comandos, como los juakers 😉

Vale. ¿Y cómo funciona el juego del caos?

El juego del caos consiste en lo siguiente:

-Dibujamos los tres vértices de un triángulo:

paso1

-Cogemos un punto (cualquiera) que quede en el interior del triángulo. Lo llamaremos punto saltarín.

paso2

-Ahora viene el bucle principal. En cada iteración escogemos un vértice al azar, por ejemplo generando un número al azar entre 1-3 o lanzando un dado y haciendo la división entera entre 2.

paso3

-Calculamos el punto medio entre el vértice y el punto saltarín.

paso4

-Convertimos este punto medio en el nuevo punto saltarín (en nuestro programa, guardaremos las coordenadas de este nuevo punto saltarín en el fichero).

paso5

-Si repetimos este proceso N veces, obtendremos el triángulo de Sierpiński.

Implementación en C++

Implementar estos pasos en C++ no es complicado. Vamos a crear un struct llamado punto que guarde las coordenadas de un punto (¡Gracias, Capitán Obvio!)

Después también habrá que crear una función que dados dos puntos a, b,  nos devuelva las coordenadas de su punto medio. Llamaremos a esta función puntoencontrarMitad();

En la función int main() vamos a inicialiar los tres vértices y el primer punto saltarín. Después crearemos un bucle for con N iteraciones que generará un número aleatorio. Así podremos escoger un vértice al azar en cada vuelta. Después, calculará el punto medio entre éste vértice y el punto saltarín, y lo convertirá en el nuevo punto saltarín.

En cada iteración del bucle escribiremos las coordenadas del punto medio en un fichero. He decidido llamarlo ‘puntos.dad’ .


/*
    EL JUEGO DEL CAOS
    Implementacion en C++ del juego del Caos para
    dibujar un triangulo de Sierpinski

    Genera un fichero con coordenadas de puntos que
    puede abrirse con gnuplot.

                       *
                      * *
                     *   *
                    * * * *
                   *       *
                  * *     * *
                 *   *   *   *
                * * * * * * * *
               *               *
              * *             * *
             *   *           *   *
            * * * *         * * * *
           *       *       *       *
          * *     * *     * *     * *
         *   *   *   *   *   *   *   *
        * * * * * * * * * * * * * * * *

    Escrito por Nano en beneficio de los seres humanos
    www.robologs.net
*/

#include<iostream> //Funciones estandar
#include <fstream> //Necesaria para manejar ficheros
#include<stdlib.h> //Incluye las funciones rand y srand
#include<time.h> //Incluye el tiempo
using namespace std;

#define N 8000 //Lanzamos el dado 8000 veces

//La estructura punto almacenara las coordenadas
//x,y de un punto en el plano
typedef struct{

    double x;
    double y;
}punto;

/*FUNCION ENCONTRAR MITAD*/
//Dados dos puntos, buscamos las coordenadas
//del punto medio
punto encontrarMitad(punto a, punto b)
{
    punto centro;
    
    centro.x = (a.x+b.x)/2;
    centro.y = (a.y+b.y)/2;

    return centro;
}

int main()
{
    srand (time(NULL)); //Generamos una semilla para el random
    int r; //Aqui se guardara el resultado del dado (0,1,2)

    //Crearemos un fichero de salida llamado puntos.dad
    ofstream fichero;
    fichero.open("puntos.dad");

    //Vamos a guardar los tres vertices del triangulo en un vector
    punto triangulo[3] = {
        {0,0},
        {-1,-1},
        {1,-1}
    };

    punto variable = {0,-0.5}; //Coordenadas del punto saltarin inicial

    for(int i = 0; i < N; i++)
    {
        r = rand()%3; //Randomizamos un numero entre 0 y 2

        //Buscamos el punto medio entre el centro y el vertice
        //escogido al azar, y lo converitmos en el nuevo centro
        variable = encontrarMitad(triangulo[r], variable);

        /*Por ultimo escribimos el resultado en el fichero
        //con el formato:
          x1 y1
          x2 y2
          x3 y3
          ...
        */
        fichero << variable.x << " " << variable.y << endl;
    }
    
    fichero.close(); //Es importante cerrar el fichero
        
    
    return 0;
}

//Hmmm... final de linea?

Por último abrimos gnuplot dónde tengamos el fichero puntos.dad (los que estéis en Linux, abrid la Terminal en el directorio y escribid gnuplot).

Dentro de gnuplot escribimos:

plot 'puntos.dad'

Y ya está. Nos aparecerá un triángulo de Sierpiński parecido al que he mostrado al principio:

screenshot_triangulo

Ahora podemos jugar canviando la N, la posición de los vértices e incluso las normas del juego (¿qué pasaria si en vez de coger el punto medio buscamos el punto 3/4? ¿Y si hubiera más de 3 puntos iniciales?)

Espero que os haya gustado esta curiosidad 😉

N4n0

Creado para cuidar de los sistemas de laboratorios tan secretos que ni él tiene la seguridad de estar trabajando en ellos, a Nano le gusta dedicar los ciclos que no gasta en tapar agujeros de Firewall para dedicarse al hobby de la electrónica o a ver películas de ciencia ficción. Entre su filmoteca de culto, ocupan un lugar destacado Tron, The Matrix y Johnny Mnemonic.

Antes de comentar, por favor, lee las Normas

Ten el honor de decir "Primero!"

avatar
wpDiscuz