elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Curso de javascript por TickTack


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  [Aporte] El juego de la vida (librería winbgim)
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: [Aporte] El juego de la vida (librería winbgim)  (Leído 2,385 veces)
carlmycol

Desconectado Desconectado

Mensajes: 21



Ver Perfil
[Aporte] El juego de la vida (librería winbgim)
« en: 4 Abril 2013, 17:13 pm »

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 ;D

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <winbgim.h>
  4. #include<time.h>
  5.  
  6. #define ESC 27
  7. #define KEY_SPACE 32
  8.  
  9. #define lado 20
  10. #define columnas 11
  11. #define filas 38
  12. #define ancho filas*lado+filas
  13. #define alto columnas*lado+columnas
  14. #define viva 1
  15. #define muerta 0
  16. struct celula
  17. {
  18.    int x, y;
  19. };
  20. struct tablero
  21. {
  22.    int fichas[filas][columnas];
  23.    int vivas=0;
  24. };
  25. void imprimir_celula(celula celula);
  26. void borrar_celula(celula celula);
  27. void rayado();
  28. tablero crear_tablero();
  29. void mostrar_tablero(tablero tablero);
  30. int main()
  31. {
  32.    celula celula;
  33.    int i, z, vivas, m, n, h1, h2;
  34.    tablero tablero, alpha;
  35.    initwindow (ancho, alto);
  36.    rayado();
  37.    tablero = crear_tablero();
  38.    alpha=tablero;
  39.    cleardevice();
  40.    mostrar_tablero(tablero);
  41.    rayado();
  42.    /* Algoritmo del juego
  43.         Recorre todas las celulas:
  44.         Si está muerta y tiene extactamente 3 celulas vecinas vivas, esta nace al siguiente turno
  45.         Si está viva:
  46.             y tiene 2 o 3 celulas vivas sigue viva
  47.             en otro caso, muere al siguiente turno
  48.      */
  49.     //Recordar: la matriz del tablero está ordenada en filas->columnas
  50.    while (tablero.vivas > 0)
  51.    {
  52.        for (i=0; i<columnas; i++)
  53.        {
  54.            for (z=0; z<filas; z++)
  55.            {
  56.                vivas=0; //Contador de celulas vivas vecinas
  57.                for(m=i-1; m<=i+1; m++)
  58.                {
  59.                    for(n=z-1; n<=z+1; n++)
  60.                    {
  61.                        if (n<0) {
  62.                            h1=filas-1;
  63.                        } else if(n>filas-1)
  64.                        {
  65.                            h1=0;
  66.                        } else {
  67.                            h1=n;
  68.                        }
  69.                        if (m<0) {
  70.                            h2=columnas-1;
  71.                        } else if(m>columnas-1)
  72.                        {
  73.                            h2=0;
  74.                        } else {
  75.                            h2=m;
  76.                        }
  77.                        if (tablero.fichas[h1][h2]==viva && (z!=h1 || i!=h2)) vivas++;
  78.                    }
  79.                }
  80.                if (tablero.fichas[z][i]==muerta)
  81.                {
  82.                    if (vivas==3)
  83.                    {
  84.                        alpha.fichas[z][i]=viva;
  85.                        alpha.vivas++;
  86.                    }
  87.                } else {
  88.                    if (!(vivas==3 || vivas==2))
  89.                    {
  90.                        alpha.fichas[z][i]=muerta;
  91.                        alpha.vivas--;
  92.                    }
  93.                }
  94.            }
  95.        }
  96.        tablero = alpha;
  97.        cleardevice();
  98.        mostrar_tablero(tablero);
  99.        rayado();
  100.        delay(300);
  101.    }
  102.    getch();
  103.    closegraph();
  104.    return 0;
  105. }
  106.  
  107. tablero crear_tablero()
  108. {
  109.    char tecla;
  110.    tablero alpha;
  111.    celula celula;
  112.    int i, z;
  113.    //Inicializa el tablero con todas las celulas muertas
  114.    for (i=0; i<columnas; i++)
  115.    {
  116.        for (z=0; z<filas; z++)
  117.        {
  118.            alpha.fichas[z][i]=muerta;
  119.        }
  120.    }
  121.    celula.x=0;
  122.    celula.y=0;
  123.    imprimir_celula(celula);
  124.    do
  125.    {
  126.            cleardevice();
  127.            mostrar_tablero(alpha);
  128.            if (alpha.fichas[celula.x][celula.y] == muerta)
  129.            {
  130.                imprimir_celula(celula);
  131.            } else {
  132.                borrar_celula(celula);
  133.            }
  134.            rayado();
  135.            if (kbhit())
  136.            {
  137.                tecla=getch();
  138.                switch(tecla)
  139.                {
  140.                    case KEY_LEFT:
  141.                        if (celula.x>0) celula.x--;
  142.                    break;
  143.  
  144.                    case KEY_RIGHT:
  145.                        if (celula.x<filas-1) celula.x++;
  146.                    break;
  147.  
  148.                    case KEY_UP:
  149.                        if (celula.y>0) celula.y--;
  150.                    break;
  151.  
  152.                    case KEY_DOWN:
  153.                        if (celula.y<columnas-1) celula.y++;
  154.                    break;
  155.  
  156.                    case ESC:
  157.                        return alpha;
  158.                    break;
  159.  
  160.                    case KEY_SPACE:
  161.                        if (alpha.fichas[celula.x][celula.y] == muerta)
  162.                        {
  163.                            alpha.fichas[celula.x][celula.y]=viva;
  164.                            alpha.vivas++;
  165.                        } else {
  166.                            alpha.fichas[celula.x][celula.y]=muerta;
  167.                            alpha.vivas--;
  168.                        }
  169.                    break;
  170.                }
  171.            }
  172.        delay(30);
  173.    } while(1);
  174. }
  175. void mostrar_tablero(tablero tablero)
  176. {
  177.    int i=0, z=0;
  178.    celula celula;
  179.    for (i=0; i<columnas; i++)
  180.    {
  181.        for (z=0; z<filas; z++)
  182.        {
  183.            if (tablero.fichas[z][i]==viva)
  184.            {
  185.                celula.x=z;
  186.                celula.y=i;
  187.                imprimir_celula(celula);
  188.            }
  189.        }
  190.    }
  191.  
  192. }
  193. void imprimir_celula(celula celula)
  194. {
  195.    int x1, x2, y1, y2;
  196.    x1=celula.x*(1+lado);
  197.    y1=celula.y*(1+lado);
  198.    x2=x1+lado+1;
  199.    y2=y1+lado+1;
  200.    setcolor(COLOR(255, 255, 255));
  201.    setfillstyle(SOLID_FILL, COLOR(255, 255, 255));
  202.    bar(x1, y1, x2, y2);
  203. }
  204. void borrar_celula(celula celula)
  205. {
  206.    int x1, x2, y1, y2;
  207.    x1=celula.x*(1+lado);
  208.    y1=celula.y*(1+lado);
  209.    x2=x1+lado+1;
  210.    y2=y1+lado+1;
  211.    setcolor(COLOR(0, 0, 0));
  212.    setfillstyle(SOLID_FILL, COLOR(0, 0, 0));
  213.    bar(x1, y1, x2, y2);
  214. }
  215. void rayado()
  216. {
  217.    int i, cont=0;
  218.    setcolor(COLOR(100, 100, 100));
  219.    for (i=1; i<columnas; i++)
  220.    {
  221.        cont+=lado+1;
  222.        line(0, cont, ancho, cont);
  223.    }
  224.    cont=0;
  225.    for (i=1; i<filas; i++)
  226.    {
  227.        cont+=lado+1;
  228.        line(cont, 0, cont, alto);
  229.    }
  230. }




Un saludo


En línea

NeoB

Desconectado Desconectado

Mensajes: 69


Ver Perfil
Re: [Aporte] El juego de la vida (librería winbgim)
« Respuesta #1 en: 4 Abril 2013, 21:18 pm »

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


En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Juego de la vida en Python
Scripting
SirLanceCC 1 5,484 Último mensaje 9 Diciembre 2006, 14:39 pm
por SirLanceCC
APORTE - Juego vibora VB « 1 2 »
Programación Visual Basic
rob1104 10 8,454 Último mensaje 6 Enero 2009, 20:00 pm
por rockernault
Ayuda Juego de la Vida en C
Programación C/C++
neji8 0 2,843 Último mensaje 21 Agosto 2011, 01:25 am
por neji8
Fps de un juego, aporte
Programación C/C++
anonimo12121 5 1,996 Último mensaje 11 Mayo 2012, 01:16 am
por anonimo12121
El Juego de la vida de John Horton
Juegos y Consolas
emmHB 0 2,368 Último mensaje 15 Octubre 2012, 20:46 pm
por emmHB
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines