bueno aquí esta, puse en verde lo que le agregue... el problema era que cuando llega al final del archivo, el entra en el ciclo donde se valida que caracter sea distinto de \n... y después de ese ciclo, hay un if que valida el punto y coma, pero como es el final del archivo a caracter en ese momento le agraga '377' porque ya no hay nada en el archivo, y cuando vuelvo a abrir el archivo tengo que limpiar la variable palabra para que no tenga ese '377', solo pasa con la palabra que esta al principio porque para las demás si limpiaba la palabra, pero antes de empezar ese ciclo no la limpiaba, por eso el error... era una tontería jeje, pero bueno suele pasar. acomode las variables, lo tenia así en varios sitios, no me di cuenta.Gracias 
Código PHP:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define SIZE_MAX_PALABRA 30
#define SIZE_MAX_ALFABETO 55
/* DEFINICION DE TIPOS */
struct nodo
{
char palabra[30];
struct nodo*sig;
};
typedef struct nodo listaPalabra;
/* DEFINICION DE VARIABLES GLOBALES */
char variable[30];
int vida =5;
/* PROTOTIPOS DE FUNCIONES */
void menu();
void Jugar();
listaPalabra * crearLista(listaPalabra *inicio);
listaPalabra *insertarEnLista(char palabra[30],listaPalabra *inicio);
listaPalabra *buscarPalabra (listaPalabra *lista);
void desarrollo(int cantidad, int i,listaPalabra *listaAux);
void limpiarCadena(char *cadena,int size);
int validarCantidad(int *cantidad);
char entradaDatos(char palabra[], char introducidas[],char restantes[], int cantidad, int i,char letra);
void interfaz(char palabra[], char introducidas[],char restantes[], int cantidad, int i);
void mensajeGanar(int cantidad,listaPalabra *listaAux);
void mensajePerder(listaPalabra *listaAux);
void modificarArchivo(listaPalabra *listaAux);
/* FUNCION PRINCIPAL */
int main()
{
menu();
return(0);
}
/* FUNCION PARA MOSTRAR EL MENU PRINCIPAL */
void menu()
{char resp;
do
{ system ("color 3");
system("cls");
printf("\n\n\t\t * * * * * MENU DE OPCIONES * * * * *");
printf("\n\t\t---------------------------------------------------");
printf("\n\t\t\t Juego de el ahorcado ");
printf("\n\t\t---------------------------------------------------\n\n\n\n");
printf("\t\t\t\t (1) Jugar \n");
printf("\t\t\t\t (0) salir\n");
do
{
fflush(stdin);
resp=getch();
}while (resp < '0' || resp > '1');
switch(resp)
{
case '1': Jugar();
break;
case '0': system("cls");
printf("\n\n\n\n ** * ***** ****** ** ** ****** ** ** ***** ****** ");
printf(" * * * * * ** ** ** ** * * * * * * ** ");
printf(" * * * * * *** ** ** **** * ** * * * *** ");
printf(" * * * * * *** ** ** ** * * * * *** ");
printf(" * ** ***** ****** *** ****** * * ***** ****** ");
break;
}
}
while(resp!='0');
}
/* FUNCION PARA CARGAR ARCHIVO Y LLENAR LISTA PARA JUGAR */
void Jugar()
{
int cantidad,i,j,aux,x,indice,z,conseguido,listaLlena=0,nuevoNumero,comprobarNumero,continuar=0;
char caracter,palabra[30];
system ("color b");
system("cls");
// PEDIMOS CANTIDAD DE PALABRAS Y SE VALIDA QUE SEA ENTRE 3 Y 10
printf("\n\n\n\n\n\n\t\tCon cuantas palabras desea jugar? (3 a 10)\n");
cantidad=validarCantidad(&cantidad);
// INICIALIZAMOS VARIABLES Y LISTA, Y LIMPIAMOS PALABRA
x=1; j=0; vida=5;
listaPalabra*lista;
listaPalabra*listaAux;
limpiarCadena(palabra,SIZE_MAX_PALABRA);
lista=crearLista(lista);
listaAux=crearLista(listaAux);
//lista=crearLista(listaAux);
// BUCLE QUE RECORRE DEPENDIENDO DE LA CANTIDAD DE PALABRAS QUE EL USUARIO DESEE, Y LAS ALMACENA EN UNA LISTA
for (i=1;i<=cantidad;i++)
{
conseguido=0;
FILE *archivo;
archivo= fopen("listaDePalabras.txt","r");
if (archivo== NULL)
{
printf("El archivo no se encuentra"); // VALIDADACION DE QUE EXISTA EL ARCHIVO
}
else
{ // BUCLE HASTA EL FINAL DEL ARCHIVO
[color="lime"] limpiarCadena(palabra,SIZE_MAX_PALABRA);
j=0;[/color]
while (feof(archivo)==0)
{
do // BUCLE QUE VALIDA QUE EL CARACTER NO SEA UN SALTO DE LINEA
{
caracter=fgetc(archivo);
}while (caracter=='\n');
if (caracter!=';') // CONDICIONAL QUE VALIDA QUE AUN NO SE HA LLEGADO AL PUNTO Y COMA
{
palabra[j]=caracter; // MIENTRAS NO SE LLEGUE AL PUNTO Y COMA, GUARDA EL CARACTER EN PALABRA
j++;
}
else
{
fscanf(archivo,"%d",&aux);
if (aux==i) // SE COMPARA EL NUMERO DE LA PALABRA CON EL NUMERO QUE ESTAMOS BUSCANDO
{
fflush(stdin);
lista=insertarEnLista(palabra,lista); // SI ES EL NUMERO QUE BUSCAMOS, SE GUARDA EN LA LISTA
conseguido=1;
}
if (listaLlena==0) { // ESTE CONDICIONAL LLENA UNA LISTA AUXILIAR QUE SERA USADA PARA LLENAR EL ARCHIVO .TXT
listaAux=insertarEnLista(palabra,listaAux); //ESTE IF SE EJECUTA SOLO LA PRIMERA VEZ DEL CICLO, YA LUEGO NO ENTRA MAS
}
limpiarCadena(palabra,SIZE_MAX_PALABRA); // SE LIMPIA LA PALABRA PARA ASI PODER ALMACENAR LA SIGUIENTE
j=0;
}
}
listaLlena=1; // ESTA ASIGNACION ES PARA QUE NO SE LLENE MAS LA LISTA AUXILIAR
if (conseguido==0) // valida que realmente halla la cantidad de palabras correctas
{
printf("\n Disculpe pero hay menos palabras que las deseadas, verifique el archivo \n\n\n\n"); //se avisa al usuario del error
vida=-1; // se asigna -1 para que no continue con el juego y regrese al menu principal
system ("PAUSE"); // se hace una pausa para que el usuario lea el mensaje
break; // se rompe el ciclo
}
fclose(archivo); // CERRAMOS EL ARCHIVO
}
}
// BUCLE PARA BUSCAR PALABRA POR PALABRA Y LLAMAR A DESARROLLO
for(z = 1; z <=cantidad; z++)
{
lista=buscarPalabra(lista);
desarrollo(cantidad,z,listaAux); //LA VARIABLE Z ES USADA SOLO PARA SABER EN QUE PALABRA ESTAMOS E IMPRIMIRLO POR PANTALLA
}
modificarArchivo(listaAux);
}
/* FUNCION INICIALIZAR LISTA */
listaPalabra * crearLista(listaPalabra *inicio)
{
inicio=NULL;
return inicio;
}
/* FUNCION PARA INSERTAR EN LISTA */
listaPalabra *insertarEnLista(char palabra[30],listaPalabra *inicio)
{
listaPalabra *nuevoNodo;
listaPalabra *aux;
nuevoNodo=(listaPalabra*)malloc(sizeof(listaPalabra));
strcpy(nuevoNodo->palabra,palabra);
nuevoNodo->sig=NULL;
if (inicio == NULL)
{
inicio=nuevoNodo;
}
else
{
aux=inicio;
while (aux->sig !=NULL)
{
aux=aux->sig;
}
aux->sig=nuevoNodo;
}
return inicio;
}
/* FUNCION PARA RECORRER LISTA EN BUSCA DE LA PALABRA */
listaPalabra *buscarPalabra (listaPalabra *lista)
{
if (lista != NULL)
{
char aux[25];
listaPalabra *auxiliar;
auxiliar = lista;
limpiarCadena(variable,SIZE_MAX_PALABRA);
strcpy(variable,lista->palabra);
lista = lista->sig;
}
return lista;
}
/* FUNCION QUE DESARROLLA LA PARTIDA DEL JUEGO */
void desarrollo(int cantidad, int i,listaPalabra *listaAux)
{
int cont=0,indice,contador=0,adivino,encontrada;
char letra,resp,palabra[50],introducidas[55],restantes[55];
char aux[55]="A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z ";
system("color a");
// INICIALIZAR VARIABLES EN SU VALOR ORIGINAL
limpiarCadena(palabra,SIZE_MAX_PALABRA); //PARA ASI INICIAR LA PALABRA NUEVA EN BLANCO
limpiarCadena(introducidas,SIZE_MAX_ALFABETO);//PARA ASI INICIAR LA PALABRA NUEVA EN BLANCO
strcpy(restantes,aux);//PARA ASI INICIAR LA PALABRA NUEVA CON TODAS LAS LETRAS DEL ABECEDARIO
// BUCLE PARA LLENAR LA PALABRA DE RAYAS Y ESPACIOS
for (indice=0;indice < (strlen(variable))*2;indice+=2)
{
palabra[indice]=95; //RAYAS EN CODIGO ASCII
palabra[indice+1]=32; //ESPACIO EN BLANCO EN CODIGO ASCII
}
indice=0;
// BUCLE QUE SE MANTIENE DURATE TODA LA PALABRA O LA PARTIDA, HASTA QUE LA PALABRA NO ACABE O LAS VIDAS NO SE ACABEN
while((vida > 0) && (cont < strlen(variable)))
{
letra=entradaDatos(palabra,introducidas,restantes,cantidad,i,letra); //ENTRADA DE DATOS NOS DEVOLVERA LA LETRA INTRODUCIDA POR EL USUARIO
// BUCLE QUE VALIDA QUE YA HALLAS METIDO ESA LETRA
for (contador=0,encontrada=0;contador<25;contador++)
{
if (letra==introducidas[contador])
{
encontrada=1; //SI ENCONTRADA ES =1 ENTONCES NO SE TE QUITARA UNA VIDA, PORQUE YA METISTE LA LETRA ANTES
break; // Y TAMPOCO SE EJECUTARAN LAS INSTRUCCIONES SIGUIENTES
}
}
// BUCLE QUE ACTUALIZA LAS LETRAS EN RESTANTES
for (contador=0;(contador<52) && (encontrada==0);contador++)
{
if (restantes[contador]==letra)
{
while(contador<52)
{
restantes[contador]=restantes[contador+2];
restantes[contador+1]=restantes[contador+3];
contador++;
}
break;
}
}
// BUCLE QUE INTERCAMBIA LA RAYA POR LA LETRA EN CASO DE QUE SI ADIVINE LA LETRA
for (contador=0,adivino=0;(contador < strlen(variable)) && (encontrada==0);contador++)
{
if(letra==variable[contador])
{
palabra[contador*2]=letra; //ASIGNAMOS LA LETRA EN LA POSICION DE LA PALABRA POR DOS(POR QUE SON DOS CARACTERES POR PALABRA, ESPACIO Y RAYA)
adivino=1; //Y A ADIVINO LE ASIGNAMOS UNO PARA QUE NO RESTE UNA VIDA
cont++;
}
}
// CONDICIONAL QUE AGRAGA LA LETRA A INTRODUCIDAS
if (encontrada==0)
{
introducidas[indice]=letra;
introducidas[indice+1]=45;
indice+=2;
}
// CONDICIONAL QUE QUITA UNA VIDA, SI NO ADIVINO Y SI LA LETRA NO HA SIDO INTRODUCIDA AUN
if ((adivino==0) && (encontrada==0))
{
vida--;
}
}
// CONDICIONAL PARA CUANDO PIERDAS TODDAS LAS VIDAS, MUESTRE MENSAJE
if (vida==0)
{
mensajePerder(listaAux);
}
// CONDICIONAL PARA CUANDO ADIVINES TODAS LAS PALABRAS Y AUN TENGAS VIDAS
if ((i == cantidad) && (vida >0))
{
mensajeGanar(cantidad,listaAux);
}
}
/* FUNCION PARA LIMPIAR LAS CADENAS NECESARIAS */
void limpiarCadena(char *cadena,int size)
{
int indice;
for(indice = 0; indice < size; cadena[indice++] = '\0');
}
/* FUNCION PARA VALIDAR LA CANTIDAD DE PALABRAS INTRODUCIDAS POR EL USUARIO */
int validarCantidad(int *cantidad)
{
int continuar=0;
while (continuar==0)
{
fflush(stdin);
if (scanf("%d",cantidad))
{
if((*cantidad < 3) || (*cantidad > 10))
{
system("cls");
printf("\n\n\n\n\n\n\t\tCon cuantas palabras desea jugar? (3 a 10)");
printf("\n\n\t Debe introducir un numero comprendido entre 3 y 10 \n");
}
else
{
continuar=1;
}
}
else
{
system("cls");
printf("\n\n\n\n\n\n\t\tCon cuantas palabras desea jugar? (3 a 10)");
printf("\n\n\t Debe introducir unicamente numeros \n");
}
}
return *cantidad;
}
/* FUNCION VALIDAR ENTRADA DE DATOS */
char entradaDatos(char palabra[], char introducidas[],char restantes[], int cantidad, int i,char letra)
{
char resp;
do
{
interfaz(palabra,introducidas,restantes,cantidad,i);
fflush(stdin);
letra=getch();
if (letra>=97 && letra<=122)
{
letra-=32;
}
if (letra==48)
{
do
{
fflush(stdin);
printf("\n Esta seguro de abandonar la partida? S/N");
fflush(stdin);
resp=getch();
if (resp>=97 && resp<=122)
{
resp-=32;
}
if (resp=='S')
{
vida=-1;
}
if (resp=='N')
{
letra=00;
}
}
while ((resp>00 && resp<=77) || (resp>=79 && resp<=82)||(resp>=84 && resp<=255));
}
}while((letra>=00 && letra<=47) || (letra>=49 && letra<=64) || (letra>=91 && letra<=255));
return letra;
}
/* FUNCION PARA MOSTRAR INTERFAZ PRINCIPAL DEL JUEGO */
void interfaz(char palabra[], char introducidas[],char restantes[], int cantidad, int i)
{
int contador;
system("cls");
printf("\n\n\n %s \n\n",palabra);
printf("\n\n Letras introducidas= %s",introducidas);
printf("\n\n Letras restantes= %s",restantes);
printf("\n\n palabra %i de %i ",i,cantidad);
printf("\n\n\n Vidas(%i)= ",vida);
contador=0;
while (contador<vida)
{
printf(" %c ",3);
contador++;
}
printf("\n\n\n Salir de la partida tecla(0)");
printf("\n\n\n\n\t Ingrese letra\n");
}
/* FUNCION PARA MOSTRAR MENSAJE POR GANAR */
void mensajeGanar(int cantidad,listaPalabra *listaAux)
{
char resp;
do
{
system("cls");system("color b");
printf("\n\n\n ****** *** *** ** *** ****** ******** ****** ");
printf("\n ** ** ** ** ** ** ** ** *** ** ** ");
printf("\n ** *** ** ** ** ** ** ** ** ** ** *** ");
printf("\n ** * ** *** ** ** **** ** *** ** *** ** ** ");
printf("\n ****** ** ** ** *** ** ** ****** ** ****** ");
printf("\n\n\n FELICIDADES!!! Logro adivinar las %i palabras",cantidad);
printf("\n\n Desea volver a jugar? S/N \n\n");
fflush(stdin);
resp=getch();
fflush(stdin);
if (resp>=97 && resp<=122)
{
resp-=32;
}
}while ((resp>=00 && resp<=77) || (resp>=79 && resp<=82)||(resp>=84 && resp<=255));
switch(resp)
{
case 'S': modificarArchivo(listaAux);
Jugar();
break;
case 'N': vida--;
break;
}
}
/* FUNCION PARA MOSTRAR MENSAJE POR PERDER */
void mensajePerder(listaPalabra *listaAux)
{
char resp;
if(vida!=-1)
{
do
{
system("cls");
printf("\n\n\n\n ****** *** *** *** ****** ******* ** ** ****** ******* ");
printf(" ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ");
printf(" ** *** ** ** ** *** ** **** ** ** ** ** **** ****** ");
printf(" ** * ** *** ** ** ** ** ** ** ** ** ** ** ** ");
printf(" ****** ** ** ** ** ****** ******* *** ****** ** **");
printf("\n\n lo siento! mejor suerte para la proxima ;) \n\n");
printf("\n\n Desea volver a jugar? S/N \n\n");
fflush(stdin);
resp=getch();
fflush(stdin);
if (resp>=97 && resp<=122)
{
resp-=32;
}
}while ((resp>=00 && resp<=77) || (resp>=79 && resp<=82)||(resp>=84 && resp<=255));
switch(resp)
{
case 'S': modificarArchivo(listaAux);
Jugar();
break;
case 'N': vida--;
break;
}
}
}
//FUNCION PARA MODIFICAR EL ARCHIVO DE TEXTO
void modificarArchivo(listaPalabra *listaAux)
{
int numeroNuevo,i,continuar=1,j=0,contador;
char numero,comprobarNumero[10];
limpiarCadena(comprobarNumero,10);
FILE *archivo1; //CREAMOS VARIABLE TIPO TEXTO
archivo1= fopen("listaDePalabras.txt","w"); //ABRIMOS EL ARCHIVO EN MODO ESCRITURA
for (contador=0;contador<10; contador++) //CICLO QUE SE EJECUTA 10 VECES(LAS 10 PALABRAS)
{
listaAux=buscarPalabra(listaAux); //BUSCAMOS LA PALABRA EN LA LISTA AUXILIAR
do
{
numeroNuevo=(rand() % 10); //GENERAMOS UN NUMERO ALETROIO MOD 10(ENTRE 0 Y 9)
numero= (char)(numeroNuevo+48); //CAMBIAMOS EL NUMERO A CHAR
continuar=1;
for (i=0; i<strlen(comprobarNumero);i++) //CILO HASTA QUE SE ACABE LA VARIABLE COMPROBARNUMERO(CONTIENE LOS NUMEROS QUE YA SALIERON)
{
if (comprobarNumero[i]==numero) //SI EL NUMERO SE ENCUENTRA EN LA CADENA, ES PORQUE YA SALIO ANTES
{
continuar=0; //COMO YA SALIO ANTES SE ASIGNA CERO A CONTINUAR PARA QUE SE REPITA EL CICLO
}
}
}while(continuar==0); // SE REPITE EL CICLO SOLO SI EL NUMERO YA SALIO
fprintf(archivo1,"%s;%i\n",variable,numeroNuevo+1); //SE ESCRIBE EN EL ARCHIVO LA PALABRA,EL ;, Y EL NUMERO ALETORIO MAS 1(SE SUMA UNO PORQUE EL NUMERO GENERADO ES ENTRE 0 Y 9)
comprobarNumero[j]=numero; //SE GUARDA EL NUMERO GENERADO EN LA VARIABLE
j++; //SE SUMA LA VARIABLE QUE INDICA LA POSICION DE LA VARIABLE COMPROBARNUMERO
}
fclose(archivo1); //CERRAMOS EL ARCHIVO
}
|
05-12-2014
Temas Similares
Modo Híbrido
