예제 #1
0
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 */
}
예제 #2
0
파일: main.c 프로젝트: jesusgoku/Zanahoria
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;
}
예제 #3
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 */
}
예제 #4
0
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 */
}
예제 #5
0
파일: sudoku.cpp 프로젝트: luifevas/Sudoku
void sudoku::on_pushButton_clicked()
{
    guardarOriginal();
    guardarPartida();
    guardarSolucion();
}