SHARE
TWEET

putogordo.c

a guest Jun 25th, 2019 53 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //LIBRERIAS
  2.  
  3. #include <stdio.h>
  4.  
  5. #include <stdlib.h>
  6.  
  7. #include <time.h>
  8.  
  9. #include<string.h>
  10.  
  11. //DIMENSIONES TABLERO
  12. #define FILAS 17
  13.  
  14. #define COLUMNAS 17
  15.  
  16. int menu(void); //Función principal
  17.  
  18. //Funciones
  19. void jugar_ordenador(int tablero_partida);
  20. void inicializar_tablero(int tablero[FILAS][COLUMNAS]);
  21. void imprimir_matriz(int tablero[FILAS][COLUMNAS]);
  22. void manzana(int tablero[FILAS][COLUMNAS]);
  23. void seteo_serpiente1(int tablero[FILAS][COLUMNAS]);
  24. void seteo_serpiente2(int tablero[FILAS][COLUMNAS]);
  25. int selecciona_casilla(int tablero[FILAS][COLUMNAS], int fila, int columna);
  26. int comprobar_casilla1(int tablero [FILAS] [COLUMNAS], int fila, int columna);
  27. int comprobar_casilla2(int tablero [FILAS] [COLUMNAS], int fila, int columna);
  28. int jugar_contra_otro(void);
  29.  
  30.  
  31. void comprobacion(int tablero_partida);
  32.  
  33. FILE *archivo;  //Puntero
  34.  
  35. int main(int argc, char* argv[]){
  36.         srand(time(NULL));
  37.  
  38.         int tablero[FILAS][COLUMNAS];  
  39.  
  40.         if ((argc != 2) && (argc !=3)){         //Comprobará si el número de argumentos introducidos es correcto
  41.             printf("El número de argumentos introducidos es incorrecto\n");
  42.             return -1;
  43.         }
  44.         else {
  45.             archivo = fopen (argv[1], "w");     //Abrirá el fichero
  46.             if(archivo == NULL){        //comprobará si el fichero se ha abierto satisfactoriamente
  47.                     printf("No se ha abierto el archivo\n");
  48.                     return -1;
  49.             }
  50.             else{
  51.                     menu();
  52.  
  53.                     fclose(archivo);    //Cierra el fichero
  54.                     return 0;
  55.             }  
  56.         }
  57. }
  58.  
  59. int menu(void){     //Menú con los 3 diferentes tipos de juego
  60.         int juego = 0;
  61.         int tablero_partida = 0;
  62.  
  63.         do{
  64.             printf("BIENVENIDO A SNAKE REVOLUTION \n \n \n ");
  65.             fprintf(archivo, "BIENVENIDO A SNAKE REVOLUTION \n \n \n ");
  66.  
  67.             printf("Pulse una opción: 1)Jugador vs ordenador  2)Jugador  vs Jugador  3)Salir del Juego\n ");
  68.             scanf("%d",&juego);
  69.            
  70.         switch(juego){  //Dependiendo del tipo de juego requerido
  71.  
  72.                 case 1:
  73.                     printf("Ha elegido Jugador vs ordenador\n");
  74.                     fprintf(archivo, "Ha elegido Jugador vs ordenador\n");
  75.                     jugar_ordenador(tablero_partida);
  76.                 break;
  77.  
  78.                 case 2:
  79.                     printf("Ha elegido Jugador vs Jugador\n");
  80.                     fprintf(archivo, "Ha elegido Jugador vs Jugador\n");
  81.                     jugar_contra_otro();
  82.                     break;
  83.  
  84.                 case 3:
  85.                     printf("Saliendo...\n");
  86.                     fprintf(archivo, "Saliendo...\n");
  87.                    
  88.                 case 4:
  89.                     printf("Ha elegido comprobar casillas\n");
  90.                     comprobacion(tablero_partida);
  91.                     break; 
  92.                 break;
  93.  
  94.                 default:
  95.                     printf("ERROR\n");
  96.                     break;
  97.             }
  98.         }
  99.  
  100.         while (juego != 3);
  101.         return juego;
  102. }
  103.  
  104. void jugar_ordenador(int tablero_partida){  //Función que permitirá al usuario jugar contra el ordenador
  105.  
  106.         int fila1;
  107.         int columna1;
  108.         int acabar1 = 0;
  109.         int coordenadas1 = 0;
  110.  
  111.         int tablero[FILAS][COLUMNAS];
  112.         inicializar_tablero(tablero);   //Se llamará a todas las funciones relevantes antes de imprimir la matriz
  113.         seteo_serpiente1(tablero);
  114.         manzana(tablero);
  115.        
  116.  
  117.         do{     //Bucle que se repetirá hasta que se pierda el juego
  118.  
  119.             do{
  120.  
  121.                     imprimir_matriz(tablero);
  122.                     printf("Indique a que coordenada desea mover la serpiente:\n  Escriba primero la columna y luego la fila\n No tenga en cuenta los 1, empieze a contar desde los 0.\n");
  123.                     scanf("%d", &columna1);
  124.                     scanf("%d", &fila1);
  125.  
  126.                     printf("Ha seleccionado moverse a la posición (%d, %d) \n",columna1,fila1);
  127.                     fprintf(archivo,"Ha seleccionado moverse a la posición %d %d \n",columna1,fila1);
  128.  
  129.                     acabar1 = comprobar_casilla1(tablero, fila1, columna1);
  130.                     coordenadas1 = selecciona_casilla(tablero, fila1, columna1);
  131.             }
  132.  
  133.             while(coordenadas1 != 1);
  134.             if(acabar1 == 0){
  135.                     printf("El juego ha terminado\n");
  136.             }
  137.         }
  138.         while ( acabar1 != 0);
  139.  
  140. }
  141.  
  142.  
  143. int jugar_contra_otro(void){ //Funcion que permite a dos personas jugar a la vez(todavia está en desarrollo, nuestra idea era hacer 2 variables de cada,una para cada serpiente.
  144.  
  145.         int fila1;
  146.         int columna1;
  147.        
  148.         int fila2;
  149.         int columna2;
  150.        
  151.     int acabar1 = 0;
  152.     int acabar2 = 0;
  153.    
  154.         int coordenadas1 = 0;
  155.         int coordenadas2 = 0;
  156.  
  157.         int tablero[FILAS][COLUMNAS];
  158.        
  159.         inicializar_tablero(tablero);
  160.        
  161.         seteo_serpiente1(tablero);
  162.         seteo_serpiente2(tablero);
  163.        
  164.         manzana(tablero);
  165.        
  166.  
  167.         do{
  168.  
  169.             do{
  170.  
  171.                     imprimir_matriz(tablero);   //Imprimirá los seteos de las serpientes y demás y mas adelante el de la segunda serpiente
  172.                
  173.                     printf("Indique a que coordenada desea mover la serpiente 1\n");
  174.                     scanf("%d", &columna1);
  175.                     scanf("%d", &fila1);
  176.                
  177.                
  178.  
  179.                     printf("Ha seleccionado moverse a la posición (%d, %d) \n",columna1,fila1);
  180.                     fprintf(archivo,"Ha seleccionado moverse a la posición (%d, %d) \n",columna1,fila1);
  181.  
  182.                
  183.  
  184.                     acabar1 = comprobar_casilla1(tablero, fila1, columna1);
  185.                     coordenadas1 = selecciona_casilla(tablero, fila1, columna1);
  186.                    
  187.                     imprimir_matriz(tablero);   //Imprimirá el movimiento de la primera serpiente 
  188.                
  189.                
  190.                
  191.                     printf("Indique a que coordenada desea mover la serpiente 2\n");
  192.                     scanf("%d", &columna2);
  193.                     scanf("%d", &fila2);
  194.                
  195.                     printf("Ha seleccionado moverse a la posición (%d, %d) \n",columna2,fila2);
  196.                     fprintf(archivo,"Ha seleccionado moverse a la posición (%d, %d) \n",columna2,fila2);
  197.                
  198.                
  199.                     acabar2 = comprobar_casilla2(tablero, fila2, columna2);
  200.                     coordenadas2 = selecciona_casilla(tablero, fila2, columna2);
  201.             }
  202.  
  203.             while(coordenadas1 != 1);
  204.             if((acabar1 == 0)||(acabar2 == 0)){
  205.                     printf("El juego ha terminado\n");
  206.             }
  207.         }
  208.         while ( (acabar1 != 0)||(acabar2 != 0));
  209.  
  210. }
  211.  
  212.  
  213. void inicializar_tablero(int tablero[FILAS][COLUMNAS]){   //Función que inicializará el tablero  
  214.         int i;
  215.         int j;
  216.  
  217.         for (i=0;i<FILAS; i++){
  218.             for (j=0; j<COLUMNAS; j++){
  219.  
  220.  
  221.                     if (i == 0 || i == FILAS-1){
  222.                         tablero [i][j] =1;
  223.                     }
  224.                     else if (j == 0 || j == COLUMNAS-1){
  225.                         tablero [i][j] =1;
  226.                     }
  227.                     else{
  228.                         tablero[i][j]=0;
  229.                     }
  230.             }  
  231.         }
  232.  
  233. }
  234.  
  235. void imprimir_matriz (int tablero[FILAS][COLUMNAS]){    //Imprime la matriz que le pasan como argumento
  236.         int i,j;
  237.         printf("\n");
  238.         for (i=0;i<FILAS;i++){  
  239.             for (j=0;j<COLUMNAS;j++){  
  240.                 printf("%d ",tablero[i][j]);
  241.                 fprintf(archivo,"%d ",tablero[i][j]);                  
  242.             }
  243.             printf("\n");
  244.             fprintf(archivo,"\n");
  245.         }
  246.  
  247.         printf("\n\n\n");
  248. }
  249.  
  250. void manzana (int tablero[FILAS][COLUMNAS]){    //Función que seteará una manzana al principio en un punto y luego será randomizada.
  251.    
  252.         int manz=9;
  253.         int max=(FILAS-2);
  254.     int min=1;
  255.         int manx=0;
  256.         int many=0;
  257.         int fila = 8, columna = 8;  //Seteará la manzana en el punto (8,8)
  258.  
  259.         if((fila == 8)&&(columna == 8)){
  260.             tablero[8][13] = 9;
  261.         }
  262.         else{
  263.             do{
  264.                 manx = rand() % (max - min + 1) + min;      //Randomizador
  265.                 many = rand() % (max - min + 1) + min;
  266.             }
  267.             while(tablero[manx][many] !=0);
  268.             if(tablero[manx][many] == 0){
  269.                 tablero[manx][many] = manz;
  270.        
  271.             }  
  272.         }
  273.  
  274. }
  275. void seteo_serpiente1(int tablero[FILAS][COLUMNAS]){
  276.  
  277.         int i;
  278.         int columna = 4;
  279.         int fila = 8;
  280.    
  281.         tablero[fila][columna]=8;
  282.    
  283.         for(i = columna - 1; i > 1; i--) {  //Bucle para que la serpiente salga en el medio y mirando hacia la derecha
  284.             tablero[fila][i] = 5;
  285.         }
  286. }
  287.  
  288. void seteo_serpiente2(int tablero[FILAS][COLUMNAS]){
  289.  
  290.         int i;
  291.         int columna = 12;
  292.         int fila = 8;
  293.    
  294.         tablero[fila][columna]=7;
  295.    
  296.         for(i = columna + 1; i < 15; i++) {  //Bucle para que la serpiente salga en el medio y mirando hacia la derecha
  297.          tablero[fila][i] = 5;
  298.         }
  299.  
  300.  
  301.  
  302. }
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309. int selecciona_casilla(int tablero[FILAS][COLUMNAS], int fila, int columna){    /*Funcion que recibe como parámetros el tablero y las coordenadas a la que moveremos la serpiente
  310.                                         y devolverá un 0 o 1 en función de la validez del movimiento*/
  311.  
  312.         int i;      //Coordenadas x
  313.         int j;      //Coordenadas y
  314.    
  315.         int longitud = 0;   //Longitud de la serpiente
  316.    
  317.    
  318.         int cabezaX;    //Coordenadas x de la cabeza
  319.         int cabezaY;    //Coordenadas y de la cabeza
  320.    
  321.    
  322.    
  323.    
  324.         for(i = 0; i < FILAS; i++){     //Bucle para localizar la cabeza de la serpiente
  325.        
  326.             for(j = 0; j < COLUMNAS; j++){
  327.  
  328.                     if (tablero[i][j] == 8){
  329.                         cabezaX = j;
  330.                         cabezaY = i;
  331.                 }
  332.            
  333.                 if((tablero[i][j] == 8)||(tablero[i][j] == 5)){     //Recorrerá la matriz entera para saber la longitud de la serpiente en cada momento
  334.                     longitud = longitud + 1;
  335.                
  336.  
  337.  
  338.                     }
  339.             }
  340.         }
  341.     printf("Ahora mismo su puntuación es de %d puntos\n",longitud);
  342.         fprintf(archivo,"Ahora mismo su puntuación es de %d puntos\n",longitud);
  343.    
  344.  
  345.         if((fila == cabezaY) && (columna == cabezaX + 1 )){     //Movimiento a la DERECHA: la coordenada Y no cariará pero la x sumará 1
  346.  
  347.             if(tablero[fila][columna] == 9){    //La longitud sumará una casilla al comer la manzana
  348.                 longitud = longitud + 1;
  349.                 manzana(tablero);
  350.             }
  351.        
  352.             tablero[fila][columna] = 8; //Impondrá un 8(cabeza) en la coordenada solicitada
  353.  
  354.        
  355.             for(i = columna - 1; i > columna - longitud; i--){  //Al moverse la serpiente correctamente dejará tras ella un 0 que es un lugar vacío en el tablero
  356.                 tablero[fila][i] = 5;
  357.             }
  358.             tablero[fila][columna-longitud] = 0;
  359.             return 1;
  360.         }
  361.    
  362.         else if((fila == cabezaY + 1 ) && (columna == cabezaX )){   //Movimiento hacia ARRIBA
  363.  
  364.         }
  365.    
  366.         else if((fila == cabezaY -1 ) && (columna == cabezaX )){    //Movimiento hacia ABAJO
  367.             tablero[fila][columna] = 8;
  368.         }
  369.         else if((fila == cabezaY ) && (columna == cabezaX -1 )){    //Movimiento hacia la IZQUIERDA
  370.  
  371.             if(tablero[fila][columna] == 9){        //La longitud sumará una casilla al comer la manzana
  372.                     longitud = longitud + 1;
  373.                     manzana(tablero);       //Vuelve a llamar a la funcion manzana para que aparezca otra vez
  374.             }
  375.  
  376.             tablero[fila][columna] = 8;
  377.        
  378.             for(i = columna + 1; i < columna + longitud; i++){
  379.                     tablero[fila][i] = 5;
  380.             }
  381.             tablero[fila][columna+longitud] = 0;
  382.             return 1;  
  383.         }
  384.         else{
  385.             printf("Coordenadas inválidas\n"); //El usuarió introdujo coordenadas inválidas
  386.             return 0;  
  387.         }
  388. }
  389.  
  390. int comprobar_casilla1(int tablero [FILAS][COLUMNAS], int fila1, int columna1){     //Función que comprobará si la casilla a la que se mueve la serpiente 1 es válida
  391.         if (tablero [fila1] [columna1] == 1){
  392.             printf("Se ha chocado contra la pared\n");
  393.             fprintf(archivo,"Se ha chocado contra la pared\n");
  394.             return 0;
  395.         }
  396.     else if(tablero[fila1] [columna1] == 5){
  397.             printf("Se ha comido la cola\n");
  398.             fprintf(archivo,"Se ha comido la cola\n");
  399.             return 0;
  400.         }
  401.     else{
  402.             return 1;
  403.         }
  404. }
  405.  
  406. int comprobar_casilla2(int tablero [FILAS][COLUMNAS], int fila2, int columna2){     //Función que comprobará si la casilla a la que se mueve la serpiente 2 es válida
  407.         if (tablero [fila2] [columna2] == 1){
  408.             printf("Se ha chocado contra la pared\n");
  409.             fprintf(archivo,"Se ha chocado contra la pared\n");
  410.             return 0;
  411.         }
  412.     else if(tablero[fila2] [columna2] == 5){
  413.             printf("Se ha comido la cola\n");
  414.             fprintf(archivo,"Se ha comido la cola\n");
  415.             return 0;
  416.         }
  417.     else{
  418.             return 1;
  419.         }
  420. }
  421.  
  422.  
  423.  
  424.  
  425. void comprobacion(int tablero_partida){
  426.     int x1,x2,x3,x4,y1,y2,y3,y4;
  427.     int tablero[FILAS][COLUMNAS];
  428.    
  429.     inicializar_tablero(tablero);
  430.     seteo_serpiente1(tablero);
  431.         manzana(tablero);
  432.         imprimir_matriz(tablero);
  433.     printf("Introduzca 4 puntos para decirle que hay\n");
  434.    
  435.     scanf("%d",&x1);
  436.     scanf("%d",&y1);
  437.    
  438.     scanf("%d",&x2);
  439.     scanf("%d",&y2);
  440.    
  441.     scanf("%d",&x3);
  442.     scanf("%d",&y3);
  443.    
  444.     scanf("%d",&x4);
  445.     scanf("%d",&y4);
  446.    
  447.    
  448.     if(tablero[x1][y1]==8){
  449.         printf("En la posición %d %d está la cabeza",x1,y1);
  450.    
  451.     }
  452.    
  453.    
  454.    
  455.    
  456.    
  457.    
  458.    
  459.    
  460.    
  461.    
  462.    
  463.    
  464.    
  465. }
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top