SHARE
TWEET

Conecta4

a guest Sep 22nd, 2019 78 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*   Universidad de La Frontera
  2.  *   Ingeniería Civil Electrónica
  3.  *
  4.  *   ICC-202 PROGRAMACION DE COMPUTADORES
  5.  *
  6.  *   Tarea 1
  7.  *   Autores: Cristian Pinoleo Jara (c.pinoleo01@ufromail.cl)
  8.  *            Max Cortés Torres (m.cortes09@gmail.com)
  9.  *
  10.  *   Fecha: 22-09-19
  11.  *
  12.  *   Descripción general del programa: El programa consiste en un tablero de seis filas y siete columnas, donde se deben introducir fichas (indicadas con las
  13.  *   letras A y R de amarillo y rojo). Gana el primer jugador en conseguir alinear cuatro de sus fichas en una línea, ya sea horizontal, vertical u diagonal.
  14.  */
  15.  
  16. #include<stdio.h>
  17. #include<stdlib.h>
  18.  
  19. int main(){
  20.    
  21.     int tablero[7][7] = {{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0}};    
  22.      /* Declaración e inicialización del arreglo tipo matriz "tablero" de seis filas por siete columnas (la declaración de siete filas se hizo para evitar
  23.        que las jugadas se sobrescribieran en la primera fila, es decir, que la fila cero actúa como borde del tablero, donde existen sobrescrituras pero
  24.        no se muestran a los jugadores) */  
  25.                            
  26.     int fila, ficha;
  27.     char scanColumna[20]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};                  //Declaración de variables fila, ficha y columna que más adelante permitirán cambiar el valor de un elemento específico del tablero para introducir fichas. Luego se declararán variables dependientes de scanColumna para evitar dobles jugadas y filtrar las entradas.
  28.     int jugador = 0;                                                                 //Declaración de la variable jugador, que indica el turno del jugador presente, comienza en "0", que indica el jugador 1 y más adelante cambia a "1" que indica el jugador 2, y alterna entre estos dos números durante el resto del programa
  29.     int ganador = 0;                                                                 //Delaración de la variable ganador, que indica si existe un ganador en el juego
  30.    
  31.  
  32.     for(int i=0; i < 6; i++){            
  33.             for(int j=0; j < 7; j++){
  34.                
  35.                 printf("%i ");
  36.                
  37.             }
  38.             printf("\n");
  39.            
  40.     }
  41.     system("CLS"); //Limpia la pantalla de código basura generado al compilar el programa.
  42.     printf("Conecta 4\n \n");
  43.     printf("Bienvenido a Conecta 4.\nEl primer jugador en conseguir que cuatro de sus fichas formen una linea, gana.\n");
  44.     printf("Este es su tablero:\n \n");
  45.    
  46.     for(int i=0; i < 6; i++){            
  47.             for(int j=0; j < 7; j++){
  48.                
  49.                 printf("<O> ");
  50.                
  51.             }
  52.             printf("\n");
  53.             } /* Código que imprime por pantalla el tablero vacío que será usado en el juego. Consiste en un conjunto de bucles "for", el interior imprime un elemento
  54.                  por columna espaciado para cada valor de "j" que varía desde cero hasta seis, en el bucle exterior, bajo el bucle interior, hay un salto de espacio para
  55.                  que el la impresión salte un espacio cada vez que se completa una fila para cada valor de "i". */
  56.                  
  57.     printf("\nEl jugador 1 tendra las fichas amarillas, el jugador 2 las rojas.\n");
  58.    
  59. while(ganador == 0){  //Inicio de bucle principal del juego, que continúa hasta que el valor de ganador sea distinto a cero.
  60.    
  61.     printf("Turno: jugador %i \n", jugador+1);    
  62.                
  63.     printf("Elija una columna (del 1 al 7): \n");
  64.     scanf("%s", &scanColumna);  //Petición al usuario( puede ser jugador 1 o jugador 2, según corresponda) que ingrese una columna.
  65.    
  66.     int k=0;
  67.     while(k == 0){  //En caso de que el usuario ingrese una columna no perteneciente al tablero (ya sea un numero o letra) , el programa pedirá que se ingrese otra.
  68.    
  69.         int column = (int)scanColumna[0];
  70.  
  71.             if(((column < 56) && (column > 48))){
  72.                while(scanColumna[1]!=0){
  73.                 printf("El dato digitado no es un valor correcto. Ingrese un valor numerico correspondiente a alguna columna.\n");
  74.                 fflush(stdin);
  75.                 scanf("%s",&scanColumna);
  76.                 }
  77.                 k=1;
  78.                 break;
  79.             }
  80.                else{
  81.                 printf("El dato digitado no es un valor correcto. Ingrese un valor numerico correspondiente a alguna columna.\n");
  82.                 fflush(stdin);
  83.                 scanf("%s",&scanColumna);
  84.                 }
  85.            }
  86.  
  87.  
  88.      
  89.     int columna = (int)scanColumna[0];
  90.     columna -=49 ;   // A la variable columna se le resta 48 (para utilizarlo como un número de 0 al 7), y una unidad para facilitar su uso más adelante
  91.    
  92.     switch(jugador){
  93.         case 0:
  94.             ficha = 1;
  95.             break;
  96.            
  97.         case 1:
  98.             ficha = 2;
  99.             break;
  100.     }
  101.    
  102.     int l = 1;  //   Las funciones que implican la variable L están destinadas a indicar al jugador cuando la columna seleccionada está llena, conservando su turno
  103.     for (int i = 1; i <7 ; i++){
  104.         if (tablero[i][columna] == 0)
  105.         {
  106.             tablero[i][columna]= ficha;
  107.             l = 0;
  108.             fila = i;
  109.             break;
  110.         }
  111.  
  112.     }
  113.    
  114.     if(l == 1){
  115.         printf("Columna %i llena \n",columna+1);
  116.     }
  117.    
  118.     switch(jugador){  // Condicional Switch que permite introducir distintos números al tablero, dependiendo de cual es el jugador que las introduce.
  119.         case 0:
  120.             //tablero[fila][columna]=1;
  121.             ficha = 1;
  122.            
  123.             break;
  124.        
  125.         case 1:
  126.             //tablero[fila][columna]=2;
  127.             ficha = 2;
  128.            
  129.             break;
  130.        
  131.     }
  132.    
  133.     for(int i=6; i>=1; i--){
  134.         for(int j=0; j<7; j++ ){
  135.             if(tablero[i][j] == 1){
  136.                 printf("<A> ", tablero[i][j]);
  137.             }
  138.             else if(tablero[i][j] == 2){
  139.                 printf("<R> ", tablero[i][j]);
  140.             }
  141.             else{
  142.                 printf("<O> ", tablero[i][j]);
  143.             }   /*  Conjunto de bucles que imprimen el tablero por pantalla, se basa en el conjunto al inicio del programa, pero el bucle interior, posee un condicional
  144.                    "if" que pregunta si algún espacio tiene los valores uno o dos, si se cumple cualquiera de estas condiciones, la ficha impresa tendrá la letra "R"
  145.                     para el color rojo asignado al jugador 1 o la letra "A" para el color amarillo asignado al jugador 2. Si la condiciónes no se cumplen se imprime un
  146.                     espacio vacío, que indica que no hay ficha en aquel lugar. */
  147.            
  148.  
  149.         }
  150.         printf("\n");
  151.        
  152.     }
  153.            
  154.     if(l == 1){
  155.        
  156.         switch(jugador){
  157.             case 0:
  158.                     jugador = 0;
  159.                 break;
  160.                
  161.             case 1:
  162.                     jugador = 1;
  163.                 break;
  164.         }    
  165.        
  166.     }
  167.     else{
  168.         switch(jugador){
  169.             case 0:
  170.                 jugador = 1;
  171.             break;
  172.                
  173.             case 1:
  174.                 jugador = 0;
  175.             break;
  176.         }
  177.        
  178.        
  179.     }  // Condicional que permite alternar los turnos de los jugadores. Toma en cuenta si el turno utilizado por el jugador se "perdió" por una columna llena.
  180.    
  181.     int segundobreak=0; //Variable que permite terminar el bucle siguiente después de cumplirse la condición en el bucle anidado inicializada en cero.
  182.        
  183.     for(int j=0; j<7; j++){
  184.        
  185.        
  186.         for(int i=6; i>0; i--){
  187.            
  188.            
  189.             if((tablero[i][j]==tablero[i-1][j]) && (tablero[i-1][j]==tablero[i-2][j]) && (tablero[i-2][j]==tablero[i-3][j]) && (tablero[i][j]!= 0)){
  190.                 if(tablero[i][j]==1){
  191.                 ganador = 1;
  192.                 segundobreak = 1;
  193.                 break;    
  194.                 }
  195.                 else{
  196.                     ganador = 2;
  197.                     segundobreak = 1;
  198.                     break;
  199.                 }
  200.                
  201.             }
  202.         }
  203.        
  204.         if(segundobreak == 1){
  205.             break;
  206.         }
  207.        
  208.     } /*   Conjunto de bucles "for" que permiten encontrar un ganador verticalmente. El bucle interior se guía por la variable "i" que indica las filas del elemento
  209.            del tablero, y la función de este es evaluar la condición "si existen cuatro elementos iguales, consecutivos y distintos de cero" (de esta manera se
  210.            verifica que los elementos deben ser una ficha, ya que cero es el estado vacío), si la condición se cumple entonces se evalúa si el elemento también es uno
  211.            si esto se cumple, entonces ganador será igual a uno, si no se cumple, ganador será igual a dos, la variable segundobreak igual a uno (que influye en el bucle exterior) y un break(que detiene el bucle interior), si no se cumple, el
  212.            bucle continúa sin ejecutar instrucciones. El bucle exterior se guía por la variable "j" que indica la columna del elemento del tablero contiene
  213.            un condicional "if" que pregunta si el valor de la variable "segundobreak" es uno, si la condición se cumple, se detiene el bucle interior. Si no
  214.            se cumple, el bucle continúa sin ejecutar instrucciones.   */
  215.  
  216.     for(int i=1; i<7; i++){
  217.        
  218.        
  219.         for(int j=0; j<5; j++){
  220.            
  221.            
  222.             if((tablero[i][j]==tablero[i][j+1]) && (tablero[i][j+1]==tablero[i][j+2]) && (tablero[i][j+2]==tablero[i][j+3]) && (tablero[i][j]!= 0)){
  223.                 if(tablero[i][j]==1){
  224.                     ganador = 1;
  225.                     segundobreak = 1;
  226.                     break;    
  227.                 }
  228.                 else{
  229.                     ganador = 2;
  230.                     segundobreak = 1;
  231.                     break;
  232.                 }
  233.             }
  234.         }
  235.        
  236.         if(segundobreak == 1){
  237.             break;
  238.         }
  239.        
  240.     } /*   Conjunto de bucles "for", encargados de verificar si existe un ganador horizontalmente. El sistema es muy similar al verificador vertical.
  241.            El bucle revisa cada posición en el tablero, y compara las posiciones a la derecha para revisar si son iguales. De ser asi (y no ser ceros,
  242.            para eso la ultima condición), se declara ganador al jugador cuyas fichas forman horizontalmente una línea de cuatro. Si no se cumple, no
  243.            se ejecuntan las instrucciones del bucle, y se continúa con el programa. */
  244.    
  245.     for(int i=1; i<5; i++){
  246.        
  247.        
  248.         for(int j=0; j<5; j++){
  249.            
  250.            
  251.             if((tablero[i][j]==tablero[i+1][j+1]) && (tablero[i+1][j+1]==tablero[i+2][j+2]) && (tablero[i+2][j+2]==tablero[i+3][j+3]) && (tablero[i][j]!=0)){
  252.                 if(tablero[i][j]==1){
  253.                     ganador = 1;
  254.                     segundobreak = 1;
  255.                     break;    
  256.                 }
  257.                 else{
  258.                     ganador = 2;
  259.                     segundobreak = 1;
  260.                     break;
  261.                 }
  262.             }
  263.         }
  264.        
  265.         if(segundobreak == 1){
  266.             break;
  267.         }
  268.     }
  269.    
  270.     for(int i=7; i>3; i--){
  271.        
  272.        
  273.         for(int j=0; j<5; j++){
  274.            
  275.            
  276.             if((tablero[i][j]==tablero[i-1][j+1]) && (tablero[i-1][j+1]==tablero[i-2][j+2]) && (tablero[i-2][j+2]==tablero[i-3][j+3]) && (tablero[i][j]!=0)){
  277.                 if(tablero[i][j]==1){
  278.                     ganador = 1;
  279.                     segundobreak = 1;
  280.                     break;    
  281.                 }
  282.                 else{
  283.                     ganador = 2;
  284.                     segundobreak = 1;
  285.                     break;
  286.                 }
  287.             }
  288.         }
  289.        
  290.         if(segundobreak == 1){
  291.             break;
  292.         }
  293.     }  /* Par de bucles "for" que revisan diagonalmente si existe un ganador. El sistema de revisión es similar a los anteriores,
  294.           se compara cada ficha con la ficha diagonal superior derecha, luego estas se comparan con su respectiva diagonal superior derecha,
  295.           y finalmente se compara esta última con su diagonal superior derecha. Si todas son iguales, y todas son distintas a 0, se declara
  296.           un ganador (el jugador cuyas fichas forman la diagonal). Para las diagonales hacia abajo se realiza el mismo procedimiento pero con
  297.           las diagonales inferiores izquierdas.*/
  298.  
  299. }
  300.     printf("Tenemos un ganador!! El jugador %i es el vencedor.", ganador);
  301.  
  302.     return 0;
  303. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top