int main (int argc, char *argv[])
{
int *reinas; // Vector con las posiciones de las reinas de cada fila
int nreinas; // Número de reinas
int i; // Contador
bool todas = false;
// Leer número de reinas
// (parámetro del programa)
nreinas = -1;
if (argc == 2)
nreinas = atoi(argv[1]);
// Colocar las reinas en el tablero
if (nreinas > 0) {
// Crear vector dinámicamente
reinas = (int*) malloc ( nreinas*sizeof(int) );
// Inicializar vector:
// (inicialmente, ninguna reina está colocada)
for (i=0; i<nreinas; i++){
reinas[i] = -1;
}
// Colocar reinas (algoritmo recursivo)
colocarReina(0, reinas, nreinas, todas);
// Liberar memoria
free (reinas);
} else {
mostrarAyuda(argv[0]);
}
}
/*!
\fn EAyuda::mostrarIndice()
Muestra la pagina inicial de la documentación de usuario
*/
void EAyuda::mostrarIndice()
{
if( hayAyuda( "indice" ) )
{
mostrarAyuda( "indice" );
}
}
int main(){
char * razonamiento = NULL;
//PILA DONDE SE ALMACENARÁN LAS OPERACIONES A RESOLVER
pNode primero = NULL, ultimo=NULL;
int vFlag = 1; //Bandera que verifica si un razonamiento es valido o no
int validez, invalidos=0, validos=0, total=0, Bool=1;
int cuenta=0; //
int verific=0, z=0, contadorValidos=0; //Funciona como bandera para verificar
char * razonamientoEnCola; //Variable que saca un razonamiento de la cola
char ** rCola; //Mostrara el razonamiento que esta en la cola
char * rInvalido = NULL, **rInvalidoAux=NULL; //Para mostrar el ultimo razonamiento invalido
//VARIABLE QUE SEPARAMOS EN ANTECEDENTE Y CONSECUENTE EL RAZONAMIENTO AUXILIAR PARA
//MOSTRARLO EN PANTALLA AL FINAL
char ** rAux;
char ** rAux2;
char ** comas; //Contendra todos los razonamientos separados con comas
//Variables para la verificacion de la cadena:
char * aParentesis=NULL;
int parentesisValidos=0, cadenaValidaA=0, cadenaValidaB=0;
printf("==================================================\n");
printf("\tPrueba Automatica de Teoremas (PAT)\n");
printf("==================================================\n");
simbologia();
printf("Para mostrar la ayuda escriba el comando \"a\" o \"ayuda\"\n");
printf("\nIntroduce el razonamiento a verificar:\n");
while(Bool==1){
//MENU
consola(cuenta);
//INGRESAR LA CADENA
razonamiento = readString();
rAux = split(razonamiento,"="); //Para verificar
rAux2 = split(razonamiento,"=");//Para mostrar
//Si es un comando
if(esComando(razonamiento)==1){
if(strncmp("s",razonamiento,1)==0 || strncmp("salir",razonamiento,5)==0){
//printf("[-] Saliendo del programa\n");
Bool = 0;
}
else if(strncmp("a",razonamiento,1)==0 || strncmp("ayuda",razonamiento,5)==0){
mostrarAyuda();
}
else if(strncmp("i",razonamiento,1)==0 || strncmp("invalido",razonamiento,8)==0){
if(rInvalido!=NULL){
rInvalidoAux = split(rInvalido,"=");
printf("[+] Ultimo razonamiento invalido\n");
mostrarRazonamiento(rInvalidoAux[0],rInvalidoAux[1]);
}else{
printf("[!] No existe algun razonamiento invalido\n");
}
}
else if(strncmp("l",razonamiento,1)==0 || strncmp("limpiar",razonamiento,7)==0){
system("clear");
}
else if(strncmp("v",razonamiento,1)==0 || strncmp("version",razonamiento,7)==0){
version();
}
}
else if(stringArraySize(rAux)<2){
printf("[Error] Falta el operador '=>'\n");
}else if (stringArraySize(rAux)>2){
printf("[Error] El operador '=>' encontrado mas de una vez\n");
}
else{
//Eliminar espacios en blanco de la expresión
quitarEspaciosBlanco(razonamiento);
//Pasamos a minusculas el razonamiento
strlwr(razonamiento);
//Verificamos la cadena (Parentesis)
aParentesis = obtenerParentesis(razonamiento);
parentesisValidos = verificaParentesis(aParentesis);
if(parentesisValidos==0){
printf("[Error] Razonamiento no valido: Parentesis no validos\n");
}
//Para verificar el antecedente y el consecuente
strlwr(rAux[0]);
strlwr(rAux[1]);
quitarEspaciosBlanco(rAux[0]); //Quita espacios en blanco de antecedente
quitarEspaciosBlanco(rAux[1]); //Quita espacios en blanco de consecuente
comas = split(rAux[0],",");
for(verific=0;verific<stringArraySize(comas);verific++){
z = verificaCadena(comas[verific]);
if(z==1) contadorValidos++;
}
if(contadorValidos==stringArraySize(comas)){
//Si son iguales quiere decir queno hay errores
cadenaValidaA=1;
}else{
printf("[Error] Razonamiento no valido: Error de sintaxis en el Antecedente\n");
cadenaValidaA=0;
}
comas = split(rAux[1],",");
contadorValidos =0;
for(verific=0;verific<stringArraySize(comas);verific++){
z = verificaCadena(comas[verific]);
if(z==1) contadorValidos++;
}
if(contadorValidos==stringArraySize(comas)){
//Si son iguales quiere decir queno hay errores
cadenaValidaB=1;
}else{
printf("[Error] Razonamiento no valido: Error de sintaxis en el Consecuente\n");
cadenaValidaB=0;
}
//Si no hay errores entonces hace el procedimiento
if(parentesisValidos==1 && cadenaValidaA==1 && cadenaValidaB==1){
//AGREGAMOS A LA COLA EL RAZONAIENTO INGRESADO
add(&primero,&ultimo,razonamiento);
//LEEMOS EL RAZONAMIENTO INGRESADO DE LA COLA
razonamientoEnCola = read(&primero,&ultimo);
//MIENTRAS QUE EXISTAN RAZONAMIENTOS:
do{
validez = PAT(razonamientoEnCola,&primero,&ultimo);
if(validez!=0){
//Mientras sea valido el razonamiento
razonamientoEnCola = read(&primero,&ultimo);
if(razonamientoEnCola!=NULL){
rCola = split(razonamientoEnCola,"=");
printf("\n[+] Analizando el siguiente razonamiento en espera: %s => %s \n",rCola[0],rCola[1]);
}
vFlag = 1;
}else{
//Si existe algun razonamiento invalido lo copiamos a rInvalido
rInvalido = (char*)calloc(strlen(razonamientoEnCola)+1,sizeof(char));
strncpy(rInvalido,razonamientoEnCola,strlen(razonamientoEnCola)+1);
vFlag = 0;
break;
}
}while(razonamientoEnCola!=NULL);
if (vFlag == 1){
printf("\n[VALIDO] El Razonamiento : %s => %s es valido\n\n",rAux2[0],rAux2[1]);
return 0;
}else{
printf("\n[INVALIDO] El Razonamiento : %s => %s es invalido\n\n",rAux2[0],rAux2[1]);
return 0;
}
//VACIAMOS LA COLA
primero=ultimo=NULL;
}
}
cuenta++;
verific=0, z=0, contadorValidos=0; //Resetamos las banderas
parentesisValidos=0;
}
return 0;
}
// PUNTO DE EJECUCIÓN.
int main(int argc, char *argv[])
{
// Obtenemos el nombre del programa para tenerlo globalmente.
NOMBRE_PROGRAMA = argv[0];
// Verificamos si el usuario solicító ayuda mediante cualquiera de las siguientes opciones en el primer parámetro.
if(argc > 1 && (strcmp(argv[1], "--help") == 0 ||
strcmp(argv[1], "-h") == 0 ||
strcmp(argv[1], "-?") == 0))
{
// En dicho caso, mostramos la ayuda y finalizamos el programa.
mostrarAyuda();
}
/*
* El programa necesita como parámetro el número de procesos a crear, pero ARGC cuenta también el nombre del
* programa como parámetro, por consiguiente esto verifica que al menos sean esos dos (pero no verifica si se pasan
* parámetros demás). Caso contrario mostramos un error, y salimos.
*/
if(argc < 2) {
return errorMessage("Debe ingresar parámetros.");
}
/*
* Por otro lado, el programa necesita que el primer parámetro, la cantidad de procesos, sea un número mayor que
* cero. Otra vez, no verifica que sea realmente un número, solamente que si es un número, sea entero positivo. En
* caso que no sea un número 'atoi' devuelve cero, y la condición falla de todas formas.
*/
if(atoi(argv[1]) < 0) {
return errorMessage("Error en la cantidad de procesos a crear.");
}
// Creamos una variable para guardar el PID del proceso.
pid_t pid;
/*
* A continuación el programa entra en el ciclo principal de creación de procesos. Se crearán mediante 'fork' N
* ('argv[1]') procesos. Los procesos hijos imprimen un mensaje y esperan 1 segundo para seguir ciclando, mientras
* que el proceso padre también imprime un mensaje pero inmediatamente deja de iterar (y crear hijos).
*/
for(int x = 0; x < atoi(argv[1]); x++) {
pid = fork();
if (pid == -1) {
// Si hubo un error al tratar de hacer el 'fork', mostramos un error y salimos.
return errorMessage("Error en la creación del proceso.");
} else {
// Caso contrario separamos el punto de ejecución del proceso padre y el hijo.
if (pid == 0) {
// En el proceso hijo mostramos su PID, y esperamos 1 segundo.
printf("Soy el proceso hijo con pid %d.\n", getpid());
sleep(1);
} else {
// En el proceso padre mostramos su PID, su PPID y salimos del ciclo.
printf("Soy el proceso padre %d con padre %d.\n", getpid(), getppid());
break;
}
}
}
/*
* Llegados este punto, cada proceso creó un hijo y llegó aquí. Los hijos a su vez, hicieron lo mismo aunque
* adicionalmente hayan esperado 1 segundo. Sin embargo, se espera "en cadena" la terminación de cada proceso hijo.
* Es decir, el primer proceso creó un hijo, y espera que éste termine, pero a su vez, el hijo creó otro proceso
* hijo, y al llegar aquí debe esperar que termine éste. Cuando no hay hijos a los que esperar 'wait' no bloquea al
* proceso y devuelve -1. Aquí se cumple con avisarle al kernel que ya no necesita las estructuras residuales de la
* ejecución de los hijos y puede descartarlas cuando considere necesario.
*/
for(int x = 0; x < atoi(argv[1]); x++) {
wait(NULL);
}
}
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;
}
