void modificar(Producto miProducto[], int auxCodigo[])
{
char titulo[150];
char autor[150];
int i;
int a = 0;
int codigo;
printf("\nIngrese el codigo del Libro a modificar: ");
scanf("%d", &codigo);
if(validar_existeCodigo(auxCodigo, codigo) != 0)//corregido (debo buscar la pocision en la que se encuentra el codigo)
{
for(i = 0; i < TAMANIO; i++)//busco el codigo
{
if(miProducto[i].codigo == codigo)
break;
}
pedirCadena("Titulo", titulo);
pedirCadena("Autor", autor);
do
{
a = 0;
if(validar_cadena(titulo, 80) != 0)
{
if(validar_cadena(autor, 50) != 0)
{
strcpy(miProducto[i].titulo, titulo);//corregido la posicion
strcpy(miProducto[i].autor, autor);//corregido la posicion
}
else
{
printf("\nERROR, supera los caracteres establecidos\n");
pedirCadena("Autor", autor);
a = 1;
}
}
else
{
printf("\nERROR, supera los caracteres establecidos\n");
pedirCadena("Titulo", titulo);
a = 1;
}
}while(a == 1);
}
else
printf("\nEl codigo del Libro no existe\n");
printf("\n\n");
}
int jugar(tPartida partida){
tMovimiento mov;
char nombre[MAX_NOM];
tFlag quiereGuardar=0, quiereCambiar, quiereUndo, hayGanador=0, calcularEstado=1;
enum tJugada jugada = START;
int captura;
imprimirTablero(partida);
while (!hayGanador && jugada != QUIT) {
if (calcularEstado) {
hayGanador = estadoJuego(partida);
calcularEstado = 0;
}
if (!hayGanador) {
if ( hayCadena(partida) && ( jugadorActual(partida) == BLANCO || modoJuego(partida) == PVP))
/* si hay cadena y no es la computadora */
mov = pedirCadena(partida);
else if (jugadorActual(partida) == BLANCO || modoJuego(partida) == PVP){
/* si no es la computadora */
printf("\nTurno del jugador %s\n", jugadorActual(partida) ? "negro" : "blanco");
jugada = pedirJugada(&mov, nombre);
}
else{
/*Mueve la computadora */
printf("\nMueve la computadora:");
if(calcularMovCompu(&mov, partida) != 0){
imprimirError(ERR_MEM_COMPU);
exit(1);
}
}
if (jugada == MOV) {
captura = mover(partida, &mov);
if (captura == AMBIGUO) {
/*Hay que pedirle que especifique*/
mov.tipoMov = pedirCaptura();
captura = mover (partida, &mov);
}
if (captura >= 0) { /* si el movimiento fue válido */
imprimirMov (&mov);
imprimirTablero(partida);
if (!hayCadena(partida)) { /* cambiamos de turno */
cambiarTurno (partida);
calcularEstado=1;
}
}
else
imprimirError(captura);
}
else if (jugada == UNDO) {
quiereUndo = undo(partida);
if( quiereUndo == OK ){
imprimirTablero(partida);
calcularEstado = 1; /*Tiene que volver a chequear el tablero */
}
else
imprimirError(quiereUndo);
}
else if (jugada == QUIT) {
printf("Desea guardar su juego antes de salir?\n");
quiereGuardar = leerSN();
if (quiereGuardar)
pedirNombre(nombre);
}
if (jugada == SAVE || quiereGuardar) {
do {
printf("Desea guardar su juego con el nombre '%s'?\n", nombre);
quiereCambiar = !leerSN();
if (quiereCambiar)
pedirNombre(nombre);
} while (quiereCambiar);
if (guardarPartida(partida, nombre) != ERROR)
printf("Se ha guardado su juego con el nombre '%s'\n", nombre);
else
imprimirError(ERR_SAVE);
}
}
}
return hayGanador; /* si se salió por QUIT, hayGanador vale 0 */
}
int main(int argc, char **argv)
{
int m = 0, n = 0; // m para filas, n para columnas
char ** tablero; // Tablero de juego
char ** tableroCopia; // Tablero de Copia
char ** auxiliar; // Apuntador Auxiliar
int i = 0, j = 0, k = 0; // Variables auxiliares
int conejosIniciales = 0; // Se almacenaran los conejos ingresados por el usuario
int puntaje = 0, nivel = 0, conejosVivos = 0; // Estado del juego
float trampolines = 0; // Se llevara la cantidad de trampolines
int coordZF = 0, coordZC = 0;
int siguienteMovimiento = 0;
Bool gameOver = False;
Bool movValido = False;
FILE *fp = NULL;
Bool recuperarPartida = False;
ItemRanking ranking[RANKING_NUM];
ItemRanking paso;
TipoNodoNombre *lista_partidas;
int lista_partidas_num;
char partida_ruta[50];
char partida_nombre[NODO_NOMBRE_MAX_LENGTH + 1];
// Inicializo la lista
lista_partidas = lista_vacia();
// Cargo el Ranking
inicializarRanking(ranking, RANKING_NUM);
cargarRanking(ranking, RANKING_NUM);
// Doy la bienvenida
clearScr();
printZanahoria();
pausa();
clearScr();
// Instrucciones del Juego
if(!preguntayn("Conoces las reglas del juego?")){
mostrarAyuda();
}
// Lista de Partidas
lista_partidas = generar_lista_partidas();
if(lista_partidas != NULL){
clearScr();
recuperarPartida = False;
recuperarPartida = (Bool)preguntayn("Existen partidas guardadas, quieres cargar una?");
if(recuperarPartida)
{
lista_partidas_num = longitud_lista(lista_partidas);
clearScr();
printf("Se encontraron %i partida(s):\n\n", lista_partidas_num);
mostrar_lista(lista_partidas);
do{
i = 0;
printf("\nSelecciona una partida: ");
clearStdin();
scanf("%i", &i);
if(i < 1 || i > lista_partidas_num) printMsjError("Partida no valida!");
}while(i < 1 || i > lista_partidas_num);
sprintf(partida_ruta, "%s%s%i%s", FOLDER_PARTIDAS, FILE_PARTIDA_PREFIX, i - 1, FILE_PARTIDA_EXT);
tablero = cargarPartida(partida_ruta, &m, &n, &conejosIniciales, &conejosVivos, &nivel, &puntaje, &trampolines);
if(tablero == NULL){
printMsjError("Error: No se logro conseguir memoria para el tablero!");
return 1;
}
}
}
// // Verifico si existe una partida guardada
// fp = fopen(FILE_PARTIDA, "r");
// // Existe una partida guardada
// if(fp != NULL){
// // Cierro el fichero para poder abrirlo desde la funcion
// fclose(fp);
// fp = NULL;
// clearScr();
// recuperarPartida = False;
// recuperarPartida = (Bool)preguntayn("Existe una partida guardada, desea cargarla?");
// // Si la respuesta fue afirmativa recupero el estado del juego
// if(recuperarPartida)
// tablero = cargarPartida(FILE_PARTIDA, &m, &n, &conejosIniciales, &conejosVivos, &nivel, &puntaje);
// }
if(!recuperarPartida){
// Preguntamos el tamano del tablero
clearScr();
pedirDimensionTablero(&m, &n);
// Preguntamos los conejos iniciales
clearScr();
pedirConejosIniciales(&m, &n, &conejosIniciales);
conejosVivos = conejosIniciales;
// Reservo memoria para el tablero
tablero = (char **)pedirMemoriaMatriz(m, n, 'c');
if(tablero == NULL)
{
printMsjError("Error: No se logro conseguir memoria para el tablero!");
return 1;
}
tablero_ini(tablero, m , n);
// Ubico la zanahoria
ubicarZanahoriaInicial(tablero, m, n);
// Ubico los conejos iniciales
ubicarConejosIniciales(tablero, m, n, conejosVivos);
}
// Reservo la memoria para una copia del tablero
tableroCopia = (char **)pedirMemoriaMatriz(m, n, 'c');
if(tableroCopia == NULL){
printMsjError("Error: No se logro conseguir memoria para el tablero!");
return 1;
}
// Doy valores iniciales al tablero
tablero_ini(tableroCopia, m, n);
// Comienza el Ciclo de Juego
for(;;){
clearScr();
// Muestro el tablero
tablero_pretty_view(tablero, m , n);
// Muestro el estado del juego
//println("Conejos Vivos: %i - Nivel: %i - Puntaje: %i", conejosVivos, nivel + 1, puntaje);
printf("%sConejos Vivos: %i%s", COLOR_ROJO_CLARO_S, conejosVivos, ESTILO_NORMAL_S);
printf(" - %sNivel: %i%s", COLOR_VERDE_CLARO_S, nivel + 1, ESTILO_NORMAL_S);
printf(" - %sPuntaje: %i%s\n", COLOR_MARRON_CLARO_S, puntaje, ESTILO_NORMAL_S);
// Pido movimiento al usuario
siguienteMovimiento = pedirSiguienteMovimiento();
// Establesco el movimiento como no valido hasta que se demuestre lo contrario
movValido = False;
// Realizo el siguiente movimiento si es posible
if(siguienteMovimiento >= 1 && siguienteMovimiento <= 9){
// Verificamos si el movimiento ingresado se puede realizar
// Si es asi movemos la zanahoria
movValido = ejecutarMovimientoZanahoria(siguienteMovimiento, tablero, m, n, nivel) ? True : False;
if(!movValido){
printMsjErrorPausa("Movimiento no valido!");
}else{
gameOver = (ejecutarMovimientoConejos(tablero, tableroCopia, m, n, &conejosVivos, &puntaje) == 0) ? True : False;
}
}else if(siguienteMovimiento == MOVE_TRANSPORT){
// Ejecutamos la teletransportacion y movemos a los conejos
movValido = True;
ejecutarTeletransportacion(tablero, m , n);
gameOver = (ejecutarMovimientoConejos(tablero, tableroCopia, m, n, &conejosVivos, &puntaje) == 0) ? True : False;
}else if(siguienteMovimiento == ACTION_SAVE){
lista_partidas_num = longitud_lista(lista_partidas);
clearScr();
if(lista_partidas_num) printf("Puedes guardar unar partida nueva o sobreescribir una existente.\n\n");
if(lista_partidas_num && preguntayn("Deseas sobreescribir una partida?")){
clearScr();
printf("Hay %i Partida(s) Disponibles:\n\n", lista_partidas_num);
mostrar_lista(lista_partidas);
do{
i = 0;
printf("\nIngresa el numero de la que deseas sobreescribir: ");
clearStdin();
scanf("%i", &i);
if(i < 1 || i > lista_partidas_num) printMsjError("Partida no valida!");
}while(i < 1 || i > lista_partidas_num);
// Sobreescribir una partida
sprintf(partida_ruta, "%s%s%i%s", FOLDER_PARTIDAS, FILE_PARTIDA_PREFIX, i - 1, FILE_PARTIDA_EXT);
pedirCadena("\nBreve descripcion partida", partida_nombre, NODO_NOMBRE_MAX_LENGTH);
if(guardarPartida(partida_ruta, tablero, m, n, partida_nombre, conejosIniciales, conejosVivos, nivel, puntaje, trampolines)){
modificar_valor_posicion(lista_partidas, i - 1, partida_nombre);
printMsjOkPausa("Partida Guardada!");
}
}else{
// Guardar Partida Nueva
sprintf(partida_ruta, "%s%s%i%s", FOLDER_PARTIDAS, FILE_PARTIDA_PREFIX, lista_partidas_num, FILE_PARTIDA_EXT);
clearScr();
pedirCadena("Breve descripcion partida", partida_nombre, NODO_NOMBRE_MAX_LENGTH);
if(guardarPartida(partida_ruta, tablero, m, n, partida_nombre, conejosIniciales, conejosVivos, nivel, puntaje, trampolines)){
lista_partidas = insertar_por_cola(lista_partidas, partida_nombre);
printMsjOkPausa("Partida Guardada!");
}
}
// // Verficamos si ya existe una partida guardada
// fp = fopen(FILE_PARTIDA, "r");
// if(fp != NULL){
// fclose(fp);
// fp = NULL;
// // Preguntamos si desea sobreescribir la partida existe
// if(preguntayn("Ya existe una partida guardada, desea sobreescribirla?")){
// if(guardarPartida(FILE_PARTIDA, tablero, m, n, conejosIniciales, conejosVivos, nivel, puntaje))
// printMsjOkPausa("Partida Guardada!");
// }
// }else{
// if(guardarPartida(FILE_PARTIDA, tablero, m, n, conejosIniciales, conejosVivos, nivel, puntaje))
// printMsjOkPausa("Partida Guardada!");
// }
}else if(siguienteMovimiento == ACTION_QUIT){
clearScr();
//println("Gracias por jugar!");
printGraciasPorJugar();
break;
}
if(movValido){
puntaje += PUNTAJE_MOV;
// Intercambio los tableros
auxiliar = tablero;
tablero = tableroCopia;
tableroCopia = auxiliar;
// Paso de Nivel
if(conejosVivos == 0){
// Inicializo el Tablero
posicionZanahoria(tablero, m, n, &coordZF, &coordZC);
tablero_ini(tablero, m , n);
tablero[coordZF][coordZC] = ZANAHORIA;
// Aumento el nivel en una unidad
nivel++;
// Aumento el puntaje
puntaje += PUNTAJE_NIVEL;
// Incremento los conejos
conejosVivos = conejosIniciales + (redondeoEntero(conejosIniciales * TASA_AUMENTO_CONEJOS) * nivel);
ubicarConejosIniciales(tablero, m , n, conejosVivos);
// Ubico los Trampolines
if(nivel >= NIVEL_TRAMPOLINES_START){
trampolines += nivel == NIVEL_TRAMPOLINES_START ? TRAMPOLINES_INICIALES : trampolines * TASA_AUMENTO_TRAMPOLINES;
ubicarTrampolines(tablero, m, n, (int)trampolines);
}
}
}
// Acciones en caso de Perder el Juego
if(gameOver){
clearScr();
// tablero_view(tablero, m, n);
printConejoGameOver();
// Verificamos si puede entrar al ranking
if(puntaje > ranking[0].puntaje){
paso.puntaje = puntaje;
pedirCadena("\nFelicidades has ingresado al ranking!!\n\nDate tu nombre", paso.nombre, MAX_SIZE_NAME);
i = ingresarRanking(ranking, RANKING_NUM, &paso);
clearScr();
mostrarRankingDestacado(ranking, RANKING_NUM, i);
}
break;
}
} // for - ciclo de juego
// Libero la memoria otorgada para el tablero
liberarMemoriaMatriz((void **)tablero);
liberarMemoriaMatriz((void **)tableroCopia);
tablero = tableroCopia = NULL;
// Guarda el Ranking en el disco
guardarRanking(ranking, RANKING_NUM);
return 0;
}
void altas(Producto miProducto[], int auxCodigo[])
{
int posicion;
char titulo[100];
char autor[100];
int i;
int a = 0;
posicion = pedirNumero("codigo");
pedirCadena("Titulo", titulo);
pedirCadena("Autor", autor);
for(i = 0; i < TAMANIO; i++)//corregido (busco la posicion )
{
if(miProducto[i].codigo == -1)
break;
}
do
{
a = 0;
if(validar_codigo(posicion) != 0)
{
if(validar_cadena(titulo, 80) != 0)
{
if(validar_cadena(autor, 50) != 0)
{
if(validar_repeticion(auxCodigo, posicion) != 0)//corrregido (para que se guarde la posicion a lo ultimo)
{
miProducto[i].codigo = posicion;
strcpy(miProducto[i].titulo, titulo);
strcpy(miProducto[i].autor, autor);
}
else
{
printf("\nError, codigo ya ingresado\n");
printf("\nVuelva a seleccionar una opcion del menu\n");
a = 0;
}
}
else
{
printf("\nERROR,supera los caracteres establecidos\n");
pedirCadena("autor", autor);
a = 1;
}
}
else
{
printf("\nERROR,supera los caracteres establecidos\n");
pedirCadena("titulo", titulo);
a = 1;
}
}
else
{
printf("\nERROR, codigo inexistente\n");
posicion = pedirNumero("codigo");
a = 1;
}
}while(a == 1);
printf("\n");
}
int jugar2(tTablero tablero, int modo, int jugador){
enum tDireccion dir=NULA;
tMovimiento mov;
char nombre[MAX_NOM];
tFlag jugada=START, quiereGuardar=0, hayCadena=0, quiereCambiar, hayGanador=0, calcularGanador=1, primerUndo=1;
int captura;
int a,b; /*TEMP*/
int estado = SEGUIR;
tFlag hayPaika;
tCasilla ** tableroAuxiliar;
if(modo==PVE){
tableroAuxiliar = generarMatrizTablero(tablero.filas, tablero.cols);
copiarTablero(&tablero, tableroAuxiliar);
}
imprimirTablero(&tablero);
while (!hayGanador && jugada != QUIT) {
if (calcularGanador) {
hayGanador = estadoPostJugada(&tablero, jugador, &hayPaika);
calcularGanador = 0;
}
if (!hayGanador) {
if (hayCadena && (jugador == BLANCO || modo == PVP)) /* si hay cadena y no es la computadora */
pedirCadena(&mov);
else if (jugador == BLANCO || modo == PVP) /* si no es la computadora */
jugada = pedirJugada(&mov, nombre);
else{
/*Mueve la computadora */
if(calcularMovCompu(&mov, &tablero, hayPaika, hayCadena, dir) != 0){
imprimirError(ERR_MEM_COMPU);
exit(1);
}
}
if (jugada == MOV) {
captura = mover(jugador, modo, &tablero, tableroAuxiliar, &mov, &dir, hayPaika, &hayCadena);
if (captura == AMBOS) {
/*Hay que pedirle que especifique*/
mov.tipoMov = pedirCaptura();
captura = mover (jugador, modo, &tablero, tableroAuxiliar, &mov, &dir, hayPaika, &hayCadena);
}
if (captura >= 0) { /* si el movimiento fue válido */
imprimirTablero(&tablero);
if (!hayCadena) { /* cambiamos de turno */
cambiarTurno (&jugador, &tablero, &dir);
primerUndo=1;
calcularGanador=1;
printf("Cambio!\nLe toca al jugador %s\n", jugador ? "negro" : "blanco");
}
}
else
imprimirError(captura);
}
else if (jugada == UNDO) {
if (modo == PVE) {
if(primerUndo){
intercambiarTableros(&tablero, &tableroAuxiliar);
imprimirTablero(&tablero);
primerUndo=0;
calcularGanador = 1; /*Tiene que volver a chequear el tablero */
}
else
imprimirError(ERR_UNDO_DOBLE);
}
else
imprimirError(ERR_UNDO);
/* aca va lo del error del undo */
}
else if (jugada == QUIT) {
printf("Desea guardar su juego antes de salir?\n");
quiereGuardar = leerSN();
if (quiereGuardar)
pedirNombre(nombre);
}
if (jugada == SAVE || quiereGuardar) {
do {
printf("Desea guardar su juego con el nombre '%s'?\n", nombre);
quiereCambiar = !leerSN();
if (quiereCambiar)
pedirNombre(nombre);
} while (quiereCambiar);
if (guardarPartida(&tablero, modo, jugador, nombre) != ERROR)
printf("Se ha guardado su juego con el nombre '%s'\n", nombre);
else
printf("Error: no se ha podido guardar su juego.\n");
}
}
}
return hayGanador; /* si se salió por QUIT, hayGanador vale 0 */
}
int jugar(tTablero tablero, int modo, int jugador){
enum tDireccion dir=NULA;
tMovimiento mov;
char nombre[MAX_NOM];
tFlag jugada=START, quiereGuardar=0, hayCadena=0, quiereCambiar, hayGanador=0, calcularGanador=1, primerUndo=1;
int captura;
int a,b; /*TEMP*/
int estado = SEGUIR;
tFlag hayPaika;
tCasilla ** tableroAuxiliar;
if(modo==PVE)
tableroAuxiliar = generarMatrizTablero(tablero.filas, tablero.cols);
imprimirTablero(&tablero);
while (!hayGanador && jugada != QUIT) {
if (calcularGanador) {
hayGanador = estadoPostJugada(&tablero, jugador, &hayPaika);
calcularGanador = 0;
}
if (!hayGanador) {
if (hayCadena && (jugador == BLANCO || modo == PVP)) /* si hay cadena y no es la computadora */
pedirCadena(&mov);
else if (jugador == BLANCO || modo == PVP) /* si no es la computadora */
jugada = pedirJugada(&mov, nombre);
else{
/*Mueve la computadora */
jugada=MOV;
if(calcularMovCompu(&mov, &tablero, hayPaika, hayCadena, dir) != 0){
imprimirError(ERR_MEM_COMPU);
exit(1);
}
}
if (jugada == MOV) {
if(modo==PVE && jugador==BLANCO){
/*Copia el tablero al auxiliar solo antes de que juegue el usuario
** (siempre es BLANCO) y solo si el juego es vs. Computadora*/
copiarTablero(&tablero, tableroAuxiliar);
primerUndo=1;
}
if (jugador == BLANCO || jugador == NEGRO) {
captura = validarMovimiento(jugador, &tablero, mov, &dir, hayPaika);
if (captura == AMBOS) /* ambiguedad en la jugada*/
mov.tipoMov = pedirCaptura();
else if (captura == APPROACH || captura == WITHDRAWAL)
mov.tipoMov = captura;
imprimirError(captura); /* en caso de movimiento valido, no imprime nada */
}
if (captura >= 0) { /* el movimiento es válido */
actualizarTablero(&tablero, dir, mov);
imprimirTablero(&tablero);
hayCadena = 0;
if (captura != NINGUNO) /* si no fue PAIKA, busca una posible cadena */
hayCadena = jugadaObligada(&tablero, jugador, mov.coordDest, dir);
if (hayCadena) {
/* al haber cadena, el origen es el nuevo destino */
mov.coordOrig.fil = mov.coordDest.fil;
mov.coordOrig.col = mov.coordDest.col;
}
else { /* cambio de turno */
printf("Cambio!\n");
jugador = !jugador; /* Cambia */
printf("\nLe toca al jugador %s\n", jugador ? "negro" : "blanco");
dir = NULA; /* Ninguna */
calcularGanador = 1; /* calculamos un posible ganador */
limpiarTocadas(&tablero);
}
}
}
else if (jugada == UNDO) {
if (modo == PVE) {
if(primerUndo){
intercambiarTableros(&tablero, &tableroAuxiliar);
primerUndo=0;
}
else
imprimirError(ERR_UNDO_DOBLE);
imprimirTablero(&tablero);
}
else
imprimirError(ERR_UNDO);
/* aca va lo del error del undo */
}
else if (jugada == QUIT) {
printf("Desea guardar su juego antes de salir?\n");
quiereGuardar = leerSN();
if (quiereGuardar)
pedirNombre(nombre);
}
if (jugada == SAVE || quiereGuardar) {
do {
printf("Desea guardar su juego con el nombre '%s'?\n", nombre);
quiereCambiar = !leerSN();
if (quiereCambiar)
pedirNombre(nombre);
} while (quiereCambiar);
guardarPartida(&tablero, modo, jugador, nombre);
printf("Se ha guardado su juego con el nombre '%s'\n", nombre);
}
}
}
return hayGanador; /* si se salió por QUIT, hayGanador vale 0 */
}
