API tools faq
paste
Advertisement
nRikee

Ahorcado v2.2.1

nRikee
Nov 6th, 2011
261
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 14.14 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <conio.h>
  5.  
  6. char cadenas[201][50] ={
  7. "futbol","ordenador","onomatopeya","trigonometria","televisor","locura","fiesta","musica","edificio","ballesta","galera","fotosintesis",
  8. "pinza","subnormal","arbol","piscina","vacaciones","libro","ciclomotor","camping","precipitacion","integral","fisica","convento","cerebro",
  9. "silla","ventana","iconoclasta","mitocondria","piscina","telediario","maletin","invisible","atomo","armario","temporal","elemento",
  10. "centimetro","esdrujula","imagen","tarantula","fantastico","subterraneo","detergente","infraestructura","fructifero","codigo","maquina",
  11. "remunerado","administracion","fragmento","llave","dureza","calma","caos","presente","estomago","papel","techo","indigente","inocuo","vacuo",
  12. "vacuno","frase","ahorcado","botella","alcohol","murcielago","satisfaccion","programador","esperpento","odio","farola","republica","monarquia",
  13. "paralelipedo","confianza","vida","mecenas","acampada","envidia","cerrojo","cartas","amor","placer","sonrisa","victoria","pasado","destino",
  14. "hambre","matematicas","cuantica","metafisico","renacimiento","mamifero","alegria","agua","magnifico","maravilla","universidad","polivalente",
  15. "oceano","asiduidad","perfectamente","flexo","indeciso","papiroflexia","portaaviones","patibulo","hipertension","informacion","paraguas",
  16. "antinuclear","metafisica","nocturno","inteligencia","conocimiento","naturaleza","sintonizar","amplitud","frecuencia","inmutabilidad","humanidad",
  17. "anticlericalismo","cosquilleo","especulacion","discipulo","cientifico","ordinariedad","continuidad","unanime","fenomeno","cardiovasculatorio",
  18. "veridico","periodico","geografia","prohibicion","estupidez","inauguracion","domestico","artificial","inhospito","antaño","fotografia","transcurrir",
  19. "perenne","establecer","iluminado","atormentado","sospechoso","silenciosamente","humillacion","necesidad","retorcido","inflexible","enfermedad",
  20. "enmascarado",  "azulado","comercial","anuncio","socialismo","autarquia","temblor","iniciativa","realidad","espiritualidad","despota","triunfador",
  21. "fantasma","garbanzo","estabilidad","mausoleo","explicacion","disimuladamente","catalizador","recomendado","desayuno","furtivo","hospital","inquilino",
  22. "consecuencia","administrador","funcionario","becario","licenciatura","pronunciamiento","manifiesto","soldado","congreso","constitucion","liberalismo",
  23. "constancia","fortaleza","aguardiente","juventud","levitacion","manuscrito","profundidad","incomodidad","establo","espiritu"
  24. };
  25.  
  26.  
  27. char patibulo[100][30] ={
  28. " ||===========",
  29. " ||          |",
  30. " ||                 ",
  31. " ||                   ",
  32. " ||      ________   ",
  33. " ||       |    |    ",
  34. " ||       |    |   ",
  35. "//\\\\______|____|__"
  36. };
  37.  
  38. char historial[100][60]; // Aqui se almacena el historial de letras utilizada
  39. char resultado[100][50]; // Aqui se almacena lo descubierto en el ahorcado (re_ul__do)
  40. char cadena[100][50]; // Aqui se copia la palabra con la que se juega
  41. int w=-1; // Es el valor que toma cada iteracion del juego. Así coje una fila diferente de historial,resultado,cadena
  42. int pos_historial; // Historial (-2=vacio) (-1=nueva) (2=repetida)
  43. int existe_;
  44.  
  45. /* Imagen final */
  46. void patibulofin()
  47. {
  48.     int n,m;
  49.         /** Limpiar patibulo **/
  50.         for (n=2;n<7;n++)
  51.         {
  52.             for (m=6;m<20;m++)
  53.             {patibulo[n][m] = ' ';};
  54.         };
  55.     patibulo[2][13] = '|';
  56.     patibulo[3][13] = '|';
  57.     patibulo[4][13] = '@';
  58.     patibulo[5][12] = '/';
  59.     patibulo[5][13] = '|';
  60.     patibulo[5][14] = '\\';
  61.     patibulo[6][12] = '/';
  62.     patibulo[6][14] = '\\';
  63.     patibulo[7][10] = '_';
  64.     patibulo[7][15] = '_';
  65. }
  66.  
  67. /* Imagen ganar */
  68. void patibulowin()
  69. {
  70.     int n,m;
  71.     /** Limpiar patibulo **/
  72.         for (n=2;n<7;n++)
  73.         {
  74.             for (m=6;m<20;m++)
  75.             {patibulo[n][m] = ' ';};
  76.         };
  77.     patibulo[5][13] = '@';
  78.     patibulo[6][12] = '/';
  79.     patibulo[6][13] = '|';
  80.     patibulo[6][14] = '\\';
  81.     patibulo[7][12] = '/';
  82.     patibulo[7][14] = '\\';
  83.     patibulo[7][10] = '_';
  84.     patibulo[7][8] = '_';
  85.     patibulo[7][15] = '_';
  86. }
  87.  
  88. /* ___Imprimir cadena de carácteres___ */
  89. imprimir (char cadena_[])
  90. {
  91.     int n_letras, n;
  92.     if (cadena_[0]=='.')
  93.     { return; }
  94.     n_letras = strlen(cadena_);
  95.     for (n=0;n<n_letras;n++)
  96.     { printf("%c|",cadena_[n]); }
  97. }
  98.  
  99. /* ___Devuelve el valor con la posicion___ */
  100. int determinar_posicion(char letra, char cadena_[], int inicio)
  101. {
  102.     int x,n;
  103.     n=strlen(cadena_)-1;
  104.     if (n==-1)
  105.     {return -2;} // Esto es para el historial
  106.  
  107.     for (x=0+inicio;x<=n;x++)
  108.     {
  109.         if(letra==cadena_[x])
  110.         {
  111.             if (inicio!=-1) // inicio=-1 significa que viene del historial. No tiene que asignar la letra.
  112.             {resultado[w][x]=letra;}
  113.             return x;
  114.         }
  115.     }
  116.     existe_ = 0;
  117.     return -1;
  118. }
  119.  
  120. /* ___Determinar si se ha completado: 1 = si, 0 = no___ */
  121. int comprobar (char juego[],char escaneado[50],int inicio)
  122. {
  123.     int n,x,aciertos;
  124.     n = strlen(juego)-inicio;
  125.     aciertos = 0;
  126.  
  127.     for (x=0;x<n;x++)
  128.     {
  129.         if(escaneado[x+inicio]==juego[x])
  130.         {aciertos++;}
  131.     }
  132.     if (aciertos==n) {return 1;}
  133.     else {return 0;}
  134. }
  135.  
  136. /** ____________________JUEGO______________________ **/
  137. int programa()
  138. {
  139.     char escaneado[50]; // Para introducir la palabra entera
  140.     char pos[w][50];  // Posición de la letra escaneada, o -1 si no existe
  141.     int n,m,n_letras,ganar,aciertos,intentos,p,o;
  142.     historial[w][0] = '.';
  143.  
  144.     /* Limpiar patibulo */
  145.     for (p=2;p<7;p++)
  146.     {
  147.         for (o=6;o<20;o++)
  148.         {patibulo[p][o] = ' ';};
  149.     };
  150.     for (p=8;p<18;p++)
  151.     {
  152.         patibulo[4][p] = '_';
  153.         patibulo[7][p] = '_';
  154.     }
  155.     for (p=5;p<8;p++)
  156.     {
  157.         patibulo[p][10] = '|';
  158.         patibulo[p][15] = '|';
  159.     }
  160.     n_letras=strlen(cadena[w]); // Numero de letras
  161.     for (n=0;n<n_letras;n++) // Poner barrabajas en Resultado
  162.     {resultado[w][n]= '_';}
  163.  
  164. /**_________ PROGRAMA EN SI ____________**/
  165.         int contador = 0; // Posicionar la letra escaneada en historial
  166.         int asterisco;
  167.         pos[w][0]=-1;
  168.         intentos = 7;
  169.         aciertos = 0;
  170.  
  171.         /* Imprimir patibulo */
  172.         for (p=0;p<10;p++)
  173.         {printf("%s \n",patibulo[p]);}
  174.         printf("\n  ' %s '   (%d letras)",resultado[w],n_letras);
  175.  
  176.     /**______BUCLE: Escanear letra, comprobar, historial, ¿fin?______**/
  177.         do
  178.         {
  179.             /* Escanear letra */
  180.             printf("\n\nLetra: ");
  181.             fflush(stdin);
  182.             scanf("%s",escaneado);
  183.             /* Escanear palabra entera */
  184.             if (escaneado[0] == '*')
  185.             {
  186.                 if (escaneado[1] == '*') {exit(0);}
  187.  
  188.                 asterisco = 1;
  189.                 for(p=0;p<n_letras;p++)
  190.                 {
  191.                     if (escaneado[p+1]!=cadena[w][p])
  192.                     {
  193.                         intentos--;
  194.                         intentos--;
  195.                         ganar=0;
  196.                         system("cls");
  197.                         goto continuar;
  198.                     }
  199.                 }
  200.                 ganar = comprobar(cadena[w],escaneado,1);
  201.                 goto i_won;
  202.             } else {asterisco = 0;}
  203.             system("cls");
  204.  
  205.             /* Historial de letras */
  206.             pos_historial = determinar_posicion(escaneado[0],historial[w],-1);
  207.             if (pos_historial != -2 && pos_historial == -1)
  208.             {
  209.                 historial[w][contador] = escaneado[0];
  210.                 contador++;
  211.             }
  212.             else
  213.             {
  214.                 /* Imprimir patibulo */
  215.                 for (p=0;p<10;p++)
  216.                 {printf("%s \n",patibulo[p]);}
  217.                 printf("\n   '  %s  '  ",resultado[w]);
  218.                 printf("\n\nYa has usado esta letra antes.");
  219.                 printf("\n\nLetras utilizadas: \n");
  220.                 imprimir(historial[w]);
  221.                 printf("\n");
  222.                 ganar=0;
  223.                 goto continuar2;
  224.             }
  225.  
  226.             /* Determinar posición */
  227.             n=-1;
  228.             m=0;
  229.             /***___BUCLE: Determinar posicion, ¿ganar?___***/
  230.             do
  231.             {
  232.                 n++;
  233.                 pos[w][n] = determinar_posicion(escaneado[0],cadena[w],m); // Posicion en la cadena. -1 = no existe
  234.                 if (pos[w][n]!=-1)
  235.                 {
  236.                     aciertos++;
  237.                     m = pos[w][n] + 1;
  238.                 }
  239.  
  240.                 /* Comprueba si se ha ganado */
  241.                 ganar = comprobar (cadena[w],resultado[w],0);
  242.                 i_won:
  243.                 if (ganar==1)
  244.                 {
  245.                     system("cls");
  246.                     patibulowin();
  247.                     for (p=0;p<10;p++)
  248.                     {printf("%s \n",patibulo[p]);};
  249.                     if (asterisco==1){printf("\n  ' %s '   ",cadena[w]);}
  250.                     else {printf("\n  ' %s '   ",resultado[w]);}
  251.                     printf ("\n\nEnhorabuena! Has ganado! \1 \n\n");
  252.                     goto continuar2;
  253.                 }
  254.             } while (pos[w][n]!=-1);
  255.             /***___FIN BUCLE___***/
  256.  
  257.  
  258.             /* Comprobacion */
  259.             if (intentos==0)  // Comprueba si ya no quedan más intentos.
  260.             {
  261.                 patibulofin();
  262.                 for (n=0;n<10;n++)
  263.                 {printf("%s \n",patibulo[p]);};
  264.                 printf("\nOhh...No te quedan mas intentos!  La palabra era: %s\n",cadena[w]);
  265.                 break;
  266.             }
  267.  
  268.             if(pos[w][0]==-1)  // Analiza la primera posicion: si es -1, no aparece. Si es !=, si aparece. Patíbulo.
  269.             {
  270.                 intentos--;
  271.                 continuar:
  272.                 switch (intentos)
  273.                 {
  274.                     case 1 : patibulo[4][14] = '\\';
  275.                     case 2 : patibulo[4][12] = '/';
  276.                     case 3 : patibulo[3][14] = '\\';
  277.                     case 4 : patibulo[3][12] = '/';
  278.                     case 5 : patibulo[3][13] = '|';
  279.                     case 6 : patibulo[2][13] = 1;
  280.                             break;
  281.                     case 0 : patibulofin();
  282.                             for (n=0;n<10;n++)
  283.                             {printf("%s \n",patibulo[n]);};
  284.                             printf("\nOhh...No te quedan mas intentos!  La palabra era: %s\n",cadena[w]);
  285.                             ganar=1;
  286.                             getch();
  287.                             goto continuar2;
  288.                 }
  289.             }
  290.             else
  291.             {
  292.                 for (p=0;p<10;p++) // Imprimir patibulo
  293.                 {printf("%s \n",patibulo[p]);}
  294.  
  295.                 printf("\n   '  %s  '  ",resultado[w]);
  296.                 printf("\nLa letra '%c' SI aparece. (%d intentos restantes)\n",escaneado[0],intentos);
  297.                 goto salto;
  298.             }
  299.         for (p=0;p<10;p++){printf("%s \n",patibulo[p]);} // Imprimir patibulo
  300.         printf("\n   '  %s  '  ",resultado[w]);
  301.         if (asterisco==0)  // Sólo hay que imprimir esto si no se ha escaneado la palabra entera (asterisco==0)
  302.         {printf("\nLa letra '%c' NO aparece. (%d intentos restantes)\n",escaneado[0],intentos);}
  303.  
  304.         salto:
  305.         printf("\n\nLetras utilizadas: \n");
  306.         imprimir(historial[w]);
  307.         printf("\n");
  308.  
  309.         continuar2:
  310.         fflush(stdin);
  311.         } while (ganar==0);
  312.     /**______FIN BUCLE______**/
  313. }
  314.  
  315.  
  316. /*_____________________________Menú principal_________________________________________*/
  317. int main()
  318. {
  319.     srand (getpid());
  320.     int n;
  321.     char jugadores[1], salir[10];
  322.  
  323.     do
  324.     {
  325.         fflush(stdin);
  326.         printf("____EL A_ORCADO v2.0____\n\n1.Un jugador\n2.Dos jugadores\n*. Ayuda\n**. Salir\n\n...");
  327.         scanf("%s",&jugadores);
  328.         switch (jugadores[0])
  329.         {
  330.             case '1': do
  331.                     {
  332.                         w++;
  333.                         system("cls");
  334.                         fflush(stdin);
  335.                         n = rand () % (200-1+1) + 1;
  336.                         strcpy(cadena[w],cadenas[n]);
  337.                         system("cls");
  338.                         programa();
  339.                         printf("\nQuieres jugar otra vez?\nSi (s)\nVolver al menu (c)\nNo (n): \n");
  340.                         fflush(stdin);
  341.                         scanf("%s",&salir);
  342.                         system("cls");
  343.  
  344.                         if(salir[1]=='e' && salir[2]=='n')
  345.                         {
  346.                             printf("Jorge, no te cansas tio? NO HAY BUG!!");
  347.                             getch();
  348.                         }
  349.                     } while (salir[0] == 's');
  350.                     break;
  351.  
  352.             case '2': do
  353.                     {
  354.                         w++;
  355.                         system("cls");
  356.                         fflush(stdin);
  357.                         printf("\n\nIntroduzca la palabra: ");
  358.                         scanf("%s", &cadena[w]);
  359.                         system("cls");
  360.                         programa();
  361.                         printf("\nQuieres jugar otra vez?\nSi (s)\nVolver al menu (c)\nNo (n): \n");
  362.                         fflush(stdin);
  363.                         scanf("%s",&salir);
  364.                         system("cls");
  365.  
  366.                     } while (salir[0] == 's');
  367.  
  368.                     break;
  369.  
  370.             case '*' :
  371.                     if (jugadores[1]=='*') {exit(0);}
  372.                     system("cls");
  373.                     printf("\n______AYUDA______\n\n\n- Durante el juego, para salir, introduce '**' (doble asterisco)\n\n- Durante el juego, si sabes la palabra y aun te quedan varias letras puedes\n introducirla con un asterisco (*) delante.\n\nPor ejemplo, tienes: a_o_ca_o   y sabes que la palabra es 'ahorcado',\npuedes escribir:   *ahorcado\nSi fallas, se te restaran dos intentos.");
  374.                     salir[0]='c';
  375.                     getch();
  376.                     system("cls");
  377.                     break;
  378.  
  379.             default: printf("\nIntroduce '1' para un solo jugador, o '2' para el modo multijugador.");
  380.                     getch();
  381.                     salir[0] = 'c';
  382.                     system("cls");
  383.         }
  384.     } while (salir[0] == 'c');
  385. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!