Advertisement
c_pinoleo01

mainv3

Jan 25th, 2020
272
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.41 KB | None | 0 0
  1. /* Universidad de La Frontera
  2. * Ingeniería Civil Electrónica
  3. *
  4. * ICC-202 PROGRAMACION DE COMPUTADORES
  5. *
  6. * Tarea 2
  7. *
  8. * Autores: Cristian Pinoleo Jara. (c.pinoleo01@ufromail.cl)
  9. * Max Cortés Torres. (m.cortes09@ufromail.cl)
  10. *
  11. * Fecha: 26 de Enero, 2020
  12. *
  13. * El programa main integra tres juegos previamente diseñados por los estudiantes del curso de Programación de Computadores
  14. * en distintas ocasiones, "Conecta 4", "Gato" y "Toque y Fama". El programa provee un menú interactivo en donde el usuario tiene la opción
  15. * de escoger entre los tres juegos y, además, se le ofrece una cuarta opción, salir, que automáticamente cierra el menú por completo.
  16. *
  17. * El primer juego disponible es llamado "Conecta 4". En este juego participan dos jugadores, a cada uno se le asigna una ficha de un color distinto,
  18. * y luego, entre ellos, deben llenar cuatro espacios con sus respectivas fichas, formando una línea en el tablero de siete por séis espacios. La línea puede ser vertical, horizontal o diagonal,
  19. * el jugador que obtenga el "cuatro en línea" primero, ganará la partida.
  20. *
  21. * El segundo juego es llamado "Gato". En este, al igual que Conecta 4, parcitipan dos jugadores, a cada uno se le asigna un símbolo distinto,
  22. * cada jugador debe llenar tres espacios seguidos, sean estos horizontal, vertical o diagonalmente. El primer juegador en completar esta tarea, ganará la partida.
  23. *
  24. * El tercer y último juego es llamado "Toque y Fama". Por lo general es jugado entre dos o más participantes, pero en el caso de este programa, participa solamente el usuario
  25. * y el computador. El juego consiste en que el usuario escoge una dificultad, que varía entre dos y cinco, siendo esta la cantidad de dígitos que tienen los números incógnitos que
  26. * cada contrincante debe adivinar, es decir, tanto el usuario como el computador deben pensar (o generar, en el caso del computador), un número de una cantidad de dígitos equivalentes
  27. * a la dificultad elegida por el usuario, estos dígitos no deben repetirse. El usuario y el computador deben entonces "adivinar" los números del otro, por cada turno un paricipante
  28. * entrega un dígito y una posición. Si no acierta ningún dato, se cambia de turno; si acierta en el dígito, se le agrega un "toque" al jugador y se cambia de turno, y si acierta en el dígito y
  29. * posición, se le agrega una "fama" al jugador, y se cambia de turno. El jugador que logre obtener la máxima cantidad de famas ganará el juego, indicando esto que le acertó a todos los dígitos y sus posiciones.
  30. */
  31. #include<stdio.h>
  32. #include<stdlib.h>
  33. #include<cstdlib>
  34. #include<time.h> //declaración de librerías usadas por las distintas funciones de las librerías de juegos
  35. #include"conecta4.h"
  36. #include"juegoGato.h"
  37. #include"toqueYFama.h" //declaración de librerías que continen las funciones usadas en el programa main
  38.  
  39. static int dificultad = 0;
  40. static int toqueUsuario, famaUsuario, toquePC, famaPC;
  41. static int numeroPC, posicionPC, numeroUsuario, posicionUsuario;
  42. static int memoriaPC1 = 0;
  43. static int memoriaPC2 = 0;
  44. static int vectorPC[5] = {10,10,10,10,10};
  45. static int vectorUsuario[5] = {30,30,30,30,30};
  46. static int vectorPCused[5] = {50,50,50,50,50};
  47. static int vectorUsuarioUsed[5] = {70,70,70,70,70}; //declaración de las variables del juego toque y fama, que serán usadas por sus respectivas funciones
  48.  
  49. static int tablero_gato[3][3] = {{0,0,0},{0,0,0},{0,0,0}};
  50. static int fila_gato;
  51. static int columna_gato;
  52. static int jugador_gato=1;
  53. static int ganador_gato=0; //declaración de las variables del juego gato, que serán usadas por sus respectivas funciones
  54.  
  55. static int tablero_c4[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}};
  56. static int ficha_c4;
  57. static int jugador_c4 = 0;
  58. static int ganador_c4 = 0;
  59. static int columna_c4;
  60. static char scanColumna[20];
  61. static int victoria_tf = 0; //declaración de las variables del juego conecta 4, que serán usadas por sus respectivas funciones
  62.  
  63. int menuIce();
  64.  
  65. int opcion=0; //declaración de variable "opcion" que indica la opción que escogerá el usuario
  66.  
  67. int main(){
  68.  
  69. while(opcion != 4){ //inicion del bucle del menú, opcion debe ser distinta de 4, ya que 4 indica la opción de salida y terminaría el programa
  70.  
  71. opcion = menuIce(); //se le asigna el valor de el resultado de la funcion menuIce a opcion
  72.  
  73. while(opcion < 1 || opcion > 4){
  74. printf("La opcion elegida no es valida, por favor ingresar otra opcion");
  75. scanf("%i",&opcion);
  76. } //bucle while que valida la entrada de la variable opción
  77.  
  78.  
  79.  
  80. switch(opcion){ //condicional switch que posee casos dependiendo del valor de opcion, provee tres casos, cada uno correspondiente a uno de los juegos
  81.  
  82. case 1: //caso 1, incluye las funciones del juego Conecta 4, y lleva a cabo su ejecución en orden
  83.  
  84. inicializar_juego_c4(); //se inicializa el juego Conecta 4, se le da la bienvenida al o los usuarios y se imprimen las instrucciones por pantalla
  85.  
  86. while(ganador_c4 == 0){ //bucle while que permite que la partida se lleve a cabo hasta que halla un ganador
  87.  
  88. char *column = pedirColumna_c4(scanColumna); //se crea un puntero de tipo char llamado column que recibe la columna pedida al usuario
  89.  
  90. columna_c4 = filtroLetras_c4(column); //la columna previamente pedida, es filtrada y validada
  91.  
  92. ficha_jugador_c4(columna_c4); //se genera y posiciona una ficha en el tablero que depende del turno del jugador
  93.  
  94. imprimir_tablero_c4(); //se imprime el tablero con sus fichas por pantalla
  95.  
  96. ganador_c4 = verificar_ganador_c4(ganador_c4); //se verifica la existencia de un ganador en el turno
  97.  
  98.  
  99. }
  100.  
  101. declarar_ganador_c4(ganador_c4); //si existe un ganador, se terminará el bucle y se usará esta funcion para declararlo
  102.  
  103. break;
  104.  
  105. case 2: //caso 2, incluye las funciones del juego Gato, y lleva a cabo su ejecución en orden
  106.  
  107. inicializar_gato(); //se inicializa el juego Gato,se le da la bienvenida a el o los jugadores y se imprimen las instrucciones por pantalla
  108.  
  109. while(ganador_gato == 0){
  110.  
  111. fila_gato = pedir_fila_gato(); //se le pide a uno de los jugadores que ingrese una fila
  112.  
  113. columna_gato = pedir_columna_gato(); //se le pide al mismo jugador que ingrese una columna
  114.  
  115. ficha_jugador_gato(fila_gato, columna_gato); //se hace uso tanto de la fila como la columna para posicionar una ficha (símbolo) en el tablero
  116.  
  117. imprimir_tablero_gato(); //se imprime el tablero con sus fichas por pantalla
  118.  
  119. ganador_gato = verificar_ganador_gato(); //se verifica la existencia de un ganador en el turno
  120.  
  121. }
  122.  
  123. declarar_ganador_gato(ganador_gato); //si existe un ganador, se terminará el bucle y se declarará dicho ganador
  124.  
  125. break;
  126.  
  127. case 3: //caso 3, incluye las funciones del juego Toque y Fama, y lleva a cabo su ejecución en orden
  128.  
  129. bienvenida_tf(); //Imprime por pantalla un mensaje de bienvenida y de qué trata el juego
  130. dificultad = selectorDificultad_tf(); //Se pide por la consola al usuario que indique en que nivel de dificultad desea jugar. El valor se guarda en la variable dificultad
  131. generadorNumeroPC_tf(vectorPC,dificultad); //Se genera un número aleatorio para el computador, de cifras distintas y del tamaño que indique la dificultad. Se guarda en el vectorPC
  132. seleccionNumero_tf(vectorUsuario,dificultad); /*Se solicita al usuario ingresar un número de la cantidad de cifras que indique la dificultad. Dentro de la función se comprueba que el
  133. número sea válido, y si es necesario se pedirá denuevo el número hasta que el ingreso sea correcto. Finalmente se guarda el número en el vectorUsuario*/
  134.  
  135. while(((famaUsuario != dificultad) && (famaPC != dificultad)) && victoria_tf == 0){ //Se inicia el bucle principal del juego, que terminará cuando el usuario o el PC gane el juego
  136. numeroUsuario = adivinarNumero_tf(); //Se pide al usuario que ingrese un digito que este crea está en el numero del PC. Se comprueba que el número sea válido y se guarda en la variable numeroUsuario.
  137. posicionUsuario = adivinarPosicion_tf(dificultad);//Se pide al usuario ingresar la posición en que este cree está el dígito antes escrito. Se comprueba que el ingreso sea válido, y se guarda el dato en la variable posicionUsuario.
  138.  
  139. if(memoriaPC1 == 1){ //Si el PC ha conseguido un toque en el turno anterior, el PC repetirá el número del turno anterior.
  140. numeroPC = memoriaPC2;
  141. printf("\n El PC eligio el numero %i, ", numeroPC);
  142. }
  143. else{ //Si el PC no consiguió un toque en el turno anterior, se generará un número aleatorio entre 0 y 9
  144. numeroPC = pcNumberGuess_tf();
  145. }
  146. posicionPC = pcPositionGuess_tf(dificultad); //Se genera una posición aleatoria para el PC, que irá de 1 hasta el número definido por la dificultad.
  147. scanToqueFama_tf(vectorPC, vectorUsuario, numeroUsuario, posicionUsuario, numeroPC, posicionPC, dificultad); /*Se comprueba si existen toques y famas en el turno recién jugado. Si existen se agregan al contador correspondiente, ya sea del
  148. usuario o del PC. Si el PC consigue un toque, recordará que número usó e intentará una posición aleatoria con el mismo número en la jugada siguiente. */
  149.  
  150. victoria_tf = scanVictoria_tf(famaUsuario, famaPC, dificultad, vectorPC); // Si el usuario o el PC consiguen el número máximo de famas, definido por la dificultad del juego, el juego finalizará, se imprimirá por pantalla el ganador y se mostrará por pantalla el número completo del PC.
  151. }
  152.  
  153. break;
  154.  
  155.  
  156.  
  157.  
  158. }
  159.  
  160.  
  161.  
  162. } /*bucle while restringido por el valor de opcion, mientras esta sea distinta de 4, el contenido del bucle continuará.
  163. Así asegurando que solamente termina el bucle cuando se escoga la opción 4, la salida del menú de juegos y permite
  164. volver al menú de juegos al finalizarlos
  165. */
  166.  
  167.  
  168.  
  169. return 0;
  170. }
  171.  
  172. int menuIce(){ //función menuIce, que imprime por pantalla la bienvenida al usuario, y sus opciones dentro del menú
  173. int a;
  174.  
  175. printf("JUEGOS ICE \n");
  176. printf("Bienvenido, usuario, a juegos ICE \n En este menu tiene acceso a tres juegos \n");
  177. printf(" 1.- Conecta 4 \n 2.- Gato \n 3.- Toque Y Fama \n 4.- Salir \n");
  178. printf("Ingrese el numero de la opcion que desee: \n");
  179. scanf("%i", &a);
  180.  
  181. return a;
  182. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement