[Aporte] El juego de la vida (librería winbgim)

[carlmycol]

Aquí posteo el código de un juego de la vida que hice hace unos días por mero ocio.

Es simple, no tiene ningún menú ni nada por el estilo, lo abres y te aparece el tablero cuadriculado, te vas moviendo con las flechas y con la tecla de espacio la dejas viva o muerta, con la tecla ESC comienzas el juego.

Si se quiere cambiar el tamaño del tablero basta con cambiar las constantes "filas" y "columnas", y igual manera si se quiere cambiar el tamaño de los lados de las células se cambia la constante "lado" (es necesario re-compilar obviamente)

La modalidad es la clásica: si una célula muerta tiene 3 celulas vecinas vivas, vivirá en el siguiente turno, si una célula viva tiene 2 o 3 celulas vivas vecinas ésta seguirá viva, de lo contrario, morirá en el próximo turno.

Es bastante sencillo, puede que a alguien por allí le sirva

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <winbgim.h>
#include<time.h>

#define ESC 27
#define KEY_SPACE 32

#define lado 20
#define columnas 11
#define filas 38
#define ancho filas*lado+filas
#define alto columnas*lado+columnas
#define viva 1
#define muerta 0
struct celula
{
    int x, y;
};
struct tablero
{
    int fichas[filas][columnas];
    int vivas=0;
};
void imprimir_celula(celula celula);
void borrar_celula(celula celula);
void rayado();
tablero crear_tablero();
void mostrar_tablero(tablero tablero);
int main()
{
    celula celula;
    int i, z, vivas, m, n, h1, h2;
    tablero tablero, alpha;
    initwindow (ancho, alto);
    rayado();
    tablero = crear_tablero();
    alpha=tablero;
    cleardevice();
    mostrar_tablero(tablero);
    rayado();
    /* Algoritmo del juego
        Recorre todas las celulas:
        Si está muerta y tiene extactamente 3 celulas vecinas vivas, esta nace al siguiente turno
        Si está viva:
            y tiene 2 o 3 celulas vivas sigue viva
            en otro caso, muere al siguiente turno
     */
     //Recordar: la matriz del tablero está ordenada en filas->columnas
    while (tablero.vivas > 0)
    {
        for (i=0; i<columnas; i++)
        {
            for (z=0; z<filas; z++)
            {
                vivas=0; //Contador de celulas vivas vecinas
                for(m=i-1; m<=i+1; m++)
                {
                    for(n=z-1; n<=z+1; n++)
                    {
                        if (n<0) {
                            h1=filas-1;
                        } else if(n>filas-1)
                        {
                            h1=0;
                        } else {
                            h1=n;
                        }
                        if (m<0) {
                            h2=columnas-1;
                        } else if(m>columnas-1)
                        {
                            h2=0;
                        } else {
                            h2=m;
                        }
                        if (tablero.fichas[h1][h2]==viva && (z!=h1 || i!=h2)) vivas++;
                    }
                }
                if (tablero.fichas[z][i]==muerta)
                {
                    if (vivas==3)
                    {
                        alpha.fichas[z][i]=viva;
                        alpha.vivas++;
                    }
                } else {
                    if (!(vivas==3 || vivas==2))
                    {
                        alpha.fichas[z][i]=muerta;
                        alpha.vivas--;
                    }
                }
            }
        }
        tablero = alpha;
        cleardevice();
        mostrar_tablero(tablero);
        rayado();
        delay(300);
    }
    getch();
    closegraph();
    return 0;
}

tablero crear_tablero()
{
    char tecla;
    tablero alpha;
    celula celula;
    int i, z;
    //Inicializa el tablero con todas las celulas muertas
    for (i=0; i<columnas; i++)
    {
        for (z=0; z<filas; z++)
        {
            alpha.fichas[z][i]=muerta;
        }
    }
    celula.x=0;
    celula.y=0;
    imprimir_celula(celula);
    do
    {
            cleardevice();
            mostrar_tablero(alpha);
            if (alpha.fichas[celula.x][celula.y] == muerta)
            {
                imprimir_celula(celula);
            } else {
                borrar_celula(celula);
            }
            rayado();
            if (kbhit())
            {
                tecla=getch();
                switch(tecla)
                {
                    case KEY_LEFT:
                        if (celula.x>0) celula.x--;
                    break;

                    case KEY_RIGHT:
                        if (celula.x<filas-1) celula.x++;
                    break;

                    case KEY_UP:
                        if (celula.y>0) celula.y--;
                    break;

                    case KEY_DOWN:
                        if (celula.y<columnas-1) celula.y++;
                    break;

                    case ESC:
                        return alpha;
                    break;

                    case KEY_SPACE:
                        if (alpha.fichas[celula.x][celula.y] == muerta)
                        {
                            alpha.fichas[celula.x][celula.y]=viva;
                            alpha.vivas++;
                        } else {
                            alpha.fichas[celula.x][celula.y]=muerta;
                            alpha.vivas--;
                        }
                    break;
                }
            }
        delay(30);
    } while(1);
}
void mostrar_tablero(tablero tablero)
{
    int i=0, z=0;
    celula celula;
    for (i=0; i<columnas; i++)
    {
        for (z=0; z<filas; z++)
        {
            if (tablero.fichas[z][i]==viva)
            {
                celula.x=z;
                celula.y=i;
                imprimir_celula(celula);
            }
        }
    }

}
void imprimir_celula(celula celula)
{
    int x1, x2, y1, y2;
    x1=celula.x*(1+lado);
    y1=celula.y*(1+lado);
    x2=x1+lado+1;
    y2=y1+lado+1;
    setcolor(COLOR(255, 255, 255));
    setfillstyle(SOLID_FILL, COLOR(255, 255, 255));
    bar(x1, y1, x2, y2);
}
void borrar_celula(celula celula)
{
    int x1, x2, y1, y2;
    x1=celula.x*(1+lado);
    y1=celula.y*(1+lado);
    x2=x1+lado+1;
    y2=y1+lado+1;
    setcolor(COLOR(0, 0, 0));
    setfillstyle(SOLID_FILL, COLOR(0, 0, 0));
    bar(x1, y1, x2, y2);
}
void rayado()
{
    int i, cont=0;
    setcolor(COLOR(100, 100, 100));
    for (i=1; i<columnas; i++)
    {
        cont+=lado+1;
        line(0, cont, ancho, cont);
    }
    cont=0;
    for (i=1; i<filas; i++)
    {
        cont+=lado+1;
        line(cont, 0, cont, alto);
    }
}




Un saludo

[NeoB]

Hostias! este juego lo vi yo en el libro de stephen hawking y pensé en implementarlo pero me daba pereza ajajaja. Que pena que sea para windows. Aún está muy interesante, espero probarlo pronto