Tema: Juego de la vida - en C - Completo
Ver Mensaje Individual
  #1 (permalink)  
Antiguo 12/01/2012, 22:37
Avatar de AlmaVagabunda
AlmaVagabunda
 
Fecha de Ingreso: noviembre-2011
Ubicación: San Juan De Alicante, Valenciana, Spain, Spain
Mensajes: 20
Antigüedad: 13 años, 2 meses
Puntos: 1
De acuerdo Juego de la vida - en C - Completo
Hola!

He terminado ahora mismo una de las tantas versiones del juego de la vida. Soy un principiante en esto de la programacion, asi que seguro que habran cosas que se pueden mejorar.
Por el momento solo le he introducido un patro de todos los que hay.
Dejo aqui el codigo, y si ven alguna posible mejora, compartan ;)

Código C: 
Ver original
  1. //Se incluyen las librerias necesarias
  2. #include<stdio.h>
  3. #include<conio.h>
  4. #include<string.h>
  5. #include<stdlib.h>
  6. #include<time.h>
  7. /*Definimos las constantes, numero de filas y numero de columnas
  8.     Gracias a ello, se puede montar una tabla de cualquier tamaño,
  9.     manteniendo totalmente operativo el programa.
  10.     Ademas definimos el porcentaje de poblacion como constante para
  11.     modificarlo en cualquier momento*/
  12.  
  13. #define NFIL 20
  14. #define NCOL 20
  15. #define DISPERSA 10
  16. #define NORMAL 25
  17. #define DENSA 50
  18. #define MASIFICADA 75
  19.  
  20. void Imprimir(int Matriz[NFIL][NCOL]){
  21.     //Declaración de variables
  22.     int i,j;
  23.     //Recorremos la matriz
  24.     for(i=0;i<NFIL;i++){
  25.         for(j=0;j<NCOL;j++){
  26.             //Si es 0 la celula esta muerta, por lo que se imprime un punto
  27.             if(Matriz[i][j]==0){
  28.                 printf(". ");
  29.             }
  30.             //Si no, esta viva, por lo que se imprime un asterisco
  31.             else{
  32.                 printf("* ");
  33.             }
  34.         }
  35.         //Salto de linea al llegar al final de la fila
  36.         printf("\n");
  37.     }
  38. }
  39. void Duplicar(int ori[NFIL][NCOL], int dest[NFIL][NCOL]){
  40.     //Recorremos la matriz
  41.     for(int i=0;i<NFIL;i++)
  42.         for(int j=0;j<NCOL;j++)
  43.             //Copiamos la matriz origen en destino
  44.             dest[i][j]=ori[i][j];
  45. }
  46. void Refrescar(int Matriz[NFIL][NCOL]){
  47.     //Declaracion las variables
  48.     int copiamatriz[NFIL][NCOL];
  49.     int NUMcelulasvivas=0,i,j;
  50.     //Copiamos la matriz en una copia auxiliar
  51.     Duplicar(Matriz, copiamatriz);
  52.     for(i=0;i<NFIL;i++){
  53.         for(j=0;j<NCOL;j++){
  54.             //Control de las celulas vecinas vivas
  55.             if(i>0 && j>0 && Matriz[i-1][j-1]==1){
  56.                 NUMcelulasvivas++;
  57.             }
  58.             if(i>0 && Matriz[i-1][j]==1){
  59.                 NUMcelulasvivas++;
  60.             }
  61.             if(i>0 && j<NCOL && Matriz[i-1][j+1]==1){
  62.                 NUMcelulasvivas++;
  63.             }
  64.             if(j>0 && Matriz[i][j-1]==1){
  65.                 NUMcelulasvivas++;
  66.             }
  67.             if(j<NCOL && Matriz[i][j+1]==1){
  68.                 NUMcelulasvivas++;
  69.             }
  70.             if(i<NFIL && j>0 && Matriz[i+1][j-1]==1){
  71.                 NUMcelulasvivas++;
  72.             }
  73.             if(i<NFIL && Matriz[i+1][j]==1){
  74.                 NUMcelulasvivas++;
  75.             }
  76.             if(i<NFIL && j<NCOL && Matriz[i+1][j+1]==1){
  77.                 NUMcelulasvivas++;
  78.             }
  79.  
  80.             //Actuamos sobre las celulas en la copia de la matriz
  81.             if(Matriz[i][j]==1){
  82.                 //La celulas vivas con 2 o 3 celulas vivas pegadas, se mantiene vivas.
  83.                 if(NUMcelulasvivas==2 || NUMcelulasvivas==3){
  84.                     copiamatriz[i][j]=1;
  85.                 }
  86.                 //Si no se cumple la condicion, mueren.
  87.                 else{
  88.                     copiamatriz[i][j]=0;
  89.                 }
  90.             }
  91.             else{
  92.                 //Las celulas muertas con 3 celulas vivas pegadas, resucitan.
  93.                 if(NUMcelulasvivas==3){
  94.                     copiamatriz[i][j]=1;
  95.                 }
  96.             }
  97.             //Ponemos a 0 el contador
  98.             NUMcelulasvivas=0;
  99.         }
  100.     }
  101.     //Devolvemos los nuevos datos a la matriz original
  102.     Duplicar(copiamatriz, Matriz);
  103. }
  104. void Resucitar(int Matriz[NFIL][NCOL]){
  105.     //Declaración de variables
  106.     int i,j,a,b;
  107.     do{
  108.         printf("Introduce fila <1-%d>: ", NFIL);
  109.         i=getche()-48;
  110.         fflush(stdin);
  111.     }while(i<1 || i>NFIL);
  112.     do{
  113.         printf("\nIntroduce columna <1-%d>: ", NCOL);
  114.         j=getche()-48;
  115.         fflush(stdin);
  116.     }while(j<1 || j>NCOL);
  117.     //Copiamos la el valor de la celula, para poder revertir el cambio
  118.     a=Matriz[i-1][j-1];
  119.     //Resucitamos la celula seleccionada
  120.     Matriz[i-1][j-1]=1;
  121.     system("cls");
  122.     Imprimir(Matriz);
  123.     //Preguntamos si se desea mantener la seleccion
  124.     printf("\nCompruebe la seleccion, desea mantenerla? [s/n]");
  125.     b=getch();
  126.     //Limpiamos el buffer
  127.     fflush(stdin);
  128.     //Si no se mantiene, se devuelve el valor de la celula copiada anteriormente
  129.     if(b=='n') Matriz[i-1][j-1]=a;
  130. }
  131. void Patron(int Matriz[NFIL][NCOL]){
  132.  
  133.     //Se imprime el patron "Barco" (Boat)
  134.     //Las posiciones se interpretan: Primer numero--> Fila, Segundo numero-->Columna
  135.  
  136.     Matriz[NFIL-(NFIL/2+1)][NCOL-(NCOL/2+1)]=1; //1 Posicion (1,1) del patron
  137.     Matriz[NFIL-(NFIL/2+1)][NCOL-(NCOL/2)]=1;   //2 Posicion (1,2) del patron
  138.     Matriz[NFIL-(NFIL/2+1)][NCOL-(NCOL/2-1)]=0; //3 Posicion (1,3) del patron
  139.     Matriz[NFIL-NFIL/2][NCOL-(NCOL/2+1)]=1;     //4 Posicion (2,1) del patron
  140.     Matriz[NFIL-(NFIL/2)][NCOL-(NCOL/2)]=0;     //5 Posicion (2,2) del patron
  141.     Matriz[NFIL-(NFIL/2)][NCOL-(NCOL/2-1)]=1;   //6 Posicion (2,3) del patron
  142.     Matriz[NFIL-(NFIL/2-1)][NCOL-(NCOL/2+1)]=0; //7 Posicion (3,1) del patron
  143.     Matriz[NFIL-(NFIL/2-1)][NCOL-(NCOL/2)]=1;   //8 Posicion (3,2) del patron
  144.     Matriz[NFIL-(NFIL/2-1)][NCOL-(NCOL/2-1)]=0; //9 Posicion (3,3) del patron
  145.  
  146.  
  147.  
  148. }
  149. void Juego(){
  150.     //Declaración de variables
  151.     int poblacion,i,j,filas,columnas,repetir,confirmar;
  152.     int Matriz [NFIL][NCOL];
  153.     //Menu inicial
  154.     do{
  155.         system("cls");
  156.         do{
  157.             printf("\n\tNivel de poblacion:\n");
  158.             printf("\n\t1-Dispersa\n");
  159.             printf("\t2-Normal\n");
  160.             printf("\t3-Densa\n");
  161.             printf("\t4-Maificada\n");
  162.             poblacion=getch();
  163.             //Limpiamos el buffer
  164.             fflush(stdin);
  165.             //Limpiamos pantalla
  166.             system ("cls");
  167.         }
  168.         //Solo son validos los valores correspondientes a las opciones del menu
  169.         while(!(poblacion=='1' || poblacion=='2' || poblacion=='3' || poblacion=='4'));
  170.         //Ponemos todas las celulas muertas inicialmente
  171.         for(i=0;i<NFIL;i++){
  172.             for(j=0;j<NCOL;j++){
  173.                 Matriz [i][j]=0;
  174.             }
  175.         }
  176.         //Aplicamos los porcentajes de poblacion sobre el total de celulas
  177.         if(poblacion=='1'){
  178.             poblacion=(((NFIL*NCOL)/100)*DISPERSA);
  179.         }
  180.         else if(poblacion=='2'){
  181.             poblacion=(((NFIL*NCOL)/100)*NORMAL);
  182.         }
  183.         else if(poblacion=='3'){
  184.             poblacion=(((NFIL*NCOL)/100)*DENSA);
  185.         }
  186.         else poblacion=(((NFIL*NCOL)/100)*MASIFICADA);
  187.  
  188.  
  189.         //Modo aleatorio
  190.         srand(time(0));
  191.         for(i=0;i<poblacion;i++){
  192.             filas=rand()%20;
  193.             columnas=rand()%20;
  194.             //Si la celula esta muerta, la resucita
  195.             if(Matriz [filas][columnas]==0){
  196.                 Matriz[filas][columnas]=1;
  197.             }
  198.             /*Si ya estaba viva se mantiene, y no lo contamos como
  199.             una posicion añadida, asi aseguramos que se impriman el
  200.             numero de celulas vivas seleccionado. Por ello restamos uno
  201.             al contador*/
  202.  
  203.             else
  204.                 i--;
  205.         }
  206.         char letra;
  207.         do{
  208.             do
  209.             {
  210.                 system("cls");
  211.                 Imprimir(Matriz);
  212.                 printf("\nPulse una tecla: \n[s] para salir \n[c] para revivir celula \n[f] para introducir forma");
  213.  
  214.                 //Opciones en el juego
  215.                 letra=getch();
  216.                 //Limpiamos el buffer
  217.                 fflush(stdin);
  218.                 if(letra=='s'){
  219.                     system("cls");
  220.                     Imprimir(Matriz);
  221.                     printf("\nFin del juego");
  222.                 }
  223.                 else if(letra=='f'){
  224.                     Patron(Matriz);
  225.                 }
  226.                 else if(letra=='c'){
  227.                     system("cls");
  228.                     Imprimir(Matriz);
  229.                     Resucitar(Matriz);
  230.                 }
  231.                 else{
  232.                     Refrescar(Matriz);
  233.                 }
  234.             }while(letra!='s');
  235.  
  236.             //Confirmacion de salida, para prevenir equivocaciones
  237.             system("cls");
  238.             printf("\n\n\n\n%20cSeguro que quieres salir? [s/n]", ' ');
  239.             confirmar=getch();
  240.             fflush(stdin);
  241.  
  242.         }while(confirmar=='n');
  243.         system("cls");
  244.  
  245.         //Opcion para volver a empezar, asi no hace falta salir del programa y volver a ejecutar
  246.         printf("\n\n\n\n%20cVolver a empezar? [s/n]", ' ');
  247.         repetir=getch();
  248.         //Limpiamos el buffer
  249.         fflush(stdin);
  250.  
  251.     }while(repetir=='s');
  252.  
  253.  
  254. }
  255. int main(){
  256.     //Iniciamos el juego
  257.     Juego();
  258. }

Un saludo