int imprInvM(dTrioVet *vector, char *erro){
int x=0;
dTrioVet *teste;
if(vector != NULL){
printf("\n\n\n\n\n\n\n\n\n\n\nInversos Modulares em Z%d:\n--\n|----------------------------------------------------------------------|", vector->n);
for (teste = vector; teste!=NULL ; teste=teste->prox , x++){
if((x%2)==0){
printf("\n| Inverso modular de %5.d = %5.d", teste->x, teste->y );
}else{
printf(" Inverso modular de %5.d = %5.d |", teste->x, teste->y );
}
}
printf("\n|----------------------------------------------------------------------|\n--\n");
if(x==0){
printf("\n\nImpressao nao execultada");
return 1;
}
free(vector);
pausa("\n\n Digire qualquer tecla para continuar: ");
return 0;
}else{
pausa(erro);
return 0;
}
}
//----------------------------------------------------------------------------
int main(void) {
int i;
int x,y;
glcd_inicializar(); // preparar el hardware
// rejilla
/*
for (y=0;y<64;y++) {
for (x=0;x<128;x++) {
if (((x+y)%2) == 0) {
glcd_putpixel(x,y,1);
} else {
glcd_putpixel(x,y,0);
}
}
}
*/
// apagar y encender la pantalla
pausa(20000);
glcd_display_off();
pausa(20000);
glcd_display_on();
// mostrar una imagen en las coordenadas (1,1)
glcd_putxbitmap(1,1,0,med_sim2);
// hacer un triangulo a base de pixels
for (y=0;y<10;y++) {
for (x=0;x<y;x++) {
glcd_putpixel(85+x,y,1);
glcd_putpixel(85-x,y,1);
glcd_putpixel(85+x,63-y,1);
glcd_putpixel(85-x,63-y,1);
}
}
// sacar un texto con el font por defecto
glcd_font_puts(&font5x7,57,20,"Hola GLCD!");
// dibujar un par de rectángulos
glcd_rectangle(50,30,120,50,1);
glcd_rectangle(55,35,115,45,1);
// probar la redirección de printf()
glcd_putchar_setxy(57,37);
printf("Cont=");
while (1) {
for(i=0;i<10000;i++) {
glcd_putchar_setxy(90,37);
printf("%04d",i);
}
}
}
int start()
{
int opcion = 0;
ArrayList *calendario = al_newArrayList();
cargarEventosDeArchivo(calendario);
do
{
system("cls");
printMenu();
pedirInt(&opcion,"Ingrese una opcion:\n",7,1,"Ingrese una opcion valida. Entre 1 y 6\n");
switch(opcion)
{
case NUEVO:
if(crearNuevoEvento(calendario))
printf("Hubo un error al intentar crear el evento\n");
pausa("Presione una tecla para volver\n");
break;
case CONSULTAR_DIA:
if(consultarFecha(calendario))
printf("Hubo un error con la consulta\n");
pausa("Presione una tecla para volver\n");
break;
case MODIFICAR:
if(modificarEvento(calendario))
printf("No se pudo completar la modificacion\n");
break;
case ELIMINAR:
if(eliminarEvento(calendario))
printf("No fue posible eliminar el evento\n");
pausa("Presione una tecla para volver\n");
break;
case EXPORTAR:
if(exportarCalendario(calendario))
printf("Hubo un error al intentar exportar el calendario\n");
pausa("Presione una tecla para volver\n");
break;
case LIMPIAR:
if(limpiarCalendario(calendario))
printf("No se pudo completar la operacion\n");
pausa("Presione una tecla para volver\n");
break;
}
}while( opcion != SALIR);
guardarEventosEnArchivo(calendario);
limpiarMemoria(calendario);
calendario->deleteArrayList(calendario);
return 0;
}
int main ()
{
FILE *pf;
int mat[TAM][TAM]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
t_lista lista;
t_dato dato;
dato.clave=-1;
pf=fopen("archivo.bin","rb+");
if(!pf)
{
printf("No se pudo abrir el archivo.");
exit(1);
}
printf("Los montos del arch. son: \n");
mostrarArch(pf);
pausa();
system("cls");
crearLista(&lista);
printf("Ingrese clave y monto (clave=0 para salir): \n");
scanf("%d %d",&dato.clave,&dato.monto);
while(dato.clave!=0)
{
if(!insertarEnLO(&lista,&dato))
printf("\nNo se pudo insertar.\n");
printf("\nIngrese clave y monto (clave=0 para dejar de cargar): \n");
scanf("%d %d",&dato.clave,&dato.monto);
}
system("cls");
printf("La lista es: \n\n");
mostrarLista(&lista);
pausa();
if(!elimSumarRepeLO(&lista))
{
printf("\nLista vacia. Cerrando Programa.");
pausa();
exit(1);
}
system("cls");
printf("Tras eliminar repetidos, la lista es: \n\n");
mostrarLista(&lista);
pausa();
buscarEnMat(mat,&lista,pf);
system("cls");
printf("Tras actualizar, el archivo queda: \n\n");
mostrarArch(pf);
fclose(pf);
pausa();
return 0;
}
int imprVet(dVector *vet, char *titulo, char *erro){
dVector *teste;
if (vet !=NULL){
printf("%s", titulo);
for (teste = vet; teste!=NULL ; teste=teste->prox){
printf("\n| %5.d |", teste->x);
}
free(vet);
pausa("\n\n\n\nDigite qualquer tecla pra continuar: ");
return 0;
}else{
pausa(erro);
return 0;
}
}
int menu(){
int op;
fflush(stdin);
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n-----------MENU-----------\n1-Frase para ASCII\n2-ASCII para Frase\n3-Verificaçao de Inversos Modulares\n4-Raizes Modulares\n0-Sair do programa\n--------------------------\n\n\nDigite sua opçao: ");
scanf(" %d", &op);
switch (op){
case 1:
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
return imprInt(entradaString("\n--------ASCII para Decimal------\n\nDigite a String: "), "\n\n\nASC II: ");
break;
case 2:
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
return imprChar(entradaASCII("\n--------Decimal para ASCII------\n\nDigite a String ASCII separando por Espaços e digitando 0 no fim: "),"\n\n\nConversao do codigo ASCII: ", "\n\nErro: string nao recebida\nDigite qualquer tecla para continuar: ");
break;
case 3:
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
return imprInvM( invMod(entradaInt("\n\n\n\nDigite o tamanho do conjunto ( Zn ) a ser analizado: ")), "\n\nNao ha inversos modulares neste conjunto Zn\nDigite qualquer tecla para continuar: ");
break;
case 4:
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
return imprVet(raizMod(entradaInt("\n\n\n\nDigite o tamanho do conjunto ( Zn ) a ser analizado: "), entradaInt("\n\n\n\nDigite o Radicando n da raiz √n: ")), "\n\n\n Raizes Modulares: ", "\n\nNao ha raizes deste numero nesse conjunto Zn\nDigite qualquer tecla para continuar: ") ;
break;
case 0:
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nObrigado por usar o programa.\n\n ");
return 1;
break;
default:
pausa("\n\n\nOpçao incorreta. Digite qualquer tecla para continuar");
return 0;
}
return 0;
}
int main(){
LinkedList<string> miArchivo;
bool bandera = false;
do{
char miOpcion;
system("cls");
misOpciones();
cout << "Seleccione una opcion: ";
cin >> miOpcion;
if (miOpcion == 'I' || miOpcion == 'i'){
system("cls");
string tiraUsuario;
cout << "Digite la tira que desea ingresar a la Maquina: ";
cin >> tiraUsuario;
cout << "Cargando Maquina de Turing...\n";
lectorArchivoTxt();
maquinaTuring maquinaUpLoad = predibujo();
ejecutarTuring miTuring = miTuring(tiraUsuario, maquinaTuring)
}
if (miOpcion == 'M' || miOpcion == 'm'){
mainG();
system("cls");}
if (miOpcion == 'S' || miOpcion == 's'){
bandera = true;
break;}
else{pausa();}
system("cls");
misOpciones();
}
void funcion_vectores()
{
const char opcionesNumero[][30]={"123V",
"ejercicio22",
"ejercicio ",
"ejercicio",
"Volver"
};
char op;
do{
op=menu(opcionesNumero, "Menu de ejercicios con fechas del TP1");
switch(op){
case '1': ejercicio22(); pausa(""); break;
}
} while(op!='V');
pausa("Menu principal");
}
int imprInt(char *cripto, char *titulo){
printf("%s", titulo);
for(int x=0; x<(strlen(cripto)*sizeof(char)); x++){
printf(" %d", *(cripto+x));
}
free(cripto);
pausa("\n\nDigite qualquer tecla pra continuar: ");
return 0;
}
void funcion_fechas()
{
const char opcionesNumero[][30]={"123V",
"ejercicio14",
"ejercicio15",
"ejercicio16",
"Volver"
};
char op;
do{
op=menu(opcionesNumero, "Menu de ejercicios con fechas del TP1");
switch(op){
case '1': ejercicio14(); pausa(""); break;
case '2': ejercicio15(); pausa(""); break;
case '3': ejercicio16(); pausa(""); break;
}
} while(op!='V');
pausa("Menu principal");
}
int main()
{
const char opciones[][30]={"NFVMQ",
"Numeros",
"Fechas",
"Vectores",
"Matrices",
"Salir"};
char op;
do{
op=menu(opciones, "Programa de Prueba del TP1");
switch(op){
case 'N': funcion_numeros(); pausa(""); break;
case 'F': funcion_fechas(); pausa(""); break;
case 'V': funcion_vectores(); pausa(""); break;
case 'M': printf("\nEligio opcion M"); pausa(""); break;
}
} while(op!='Q');
pausa("fin del programa");
return 0;
}
void funcion_numeros()
{
const char opcionesNumero[][30]={"1234V",
"ejercicio1",
"ejercicio2",
"ejercicio3",
"ejercicio4",
"Volver"
};
char op;
do{
op=menu(opcionesNumero, "Menu de ejercicios numericos del TP1");
switch(op){
case '1': ejercicio1(); pausa(""); break;
case '2': ejercicio2(); pausa(""); break;
case '3': ejercicio3(); pausa(""); break;
case '4': ejercicio4(); pausa(""); break;
}
} while(op!='V');
pausa("Menu principal");
}
// mostra os comandos do jogo
void ajuda_comandos(){
char buffer[255] = {'\0'};
FILE *fd = fopen("comandos.txt", "r");
zenter_cls(AJUDA_NOME);
putz("[Comandos]", 11);
if(fd == NULL) return;
while(fgets(buffer, 255, fd) != NULL) {
if(buffer[0] == ' ') printz(7, "%s", buffer);
else printz(15, "%s", buffer);
}
fclose(fd);
pausa();
}
int main()
{
char opcion;
char mOpciones[][30] = {"ABVLS", "Alta", "Baja", "Ver Archivo", "Ver Arbol", "Salir"};
char titulo[] = "ABM Socios";
FILE* archSocios;
t_arbol indice;
archSocios = fopen("../Archivos_ABMArbol/Socios.dat", "r+b");
if(!archSocios)
{
puts("Error abriendo el archivo");
return ERROR_ARCHIVO;
}
crear_arbol_res(&indice);
cargar_arbol_de_archivo_ordenado_res(&indice, "../Archivos_ABMArbol/Socios.idx", /*cmp_ind*/cmp_ind_res);
opcion = menu(mOpciones, titulo);
while(opcion != 'S')
{
system("cls");
switch(opcion)
{
case 'A': opcAlta(archSocios, &indice); break;
case 'B': opcBaja(archSocios, &indice); break;
case 'V': opcVer(archSocios, &indice); break;
case 'L': opcVerArbol(&indice); break;
}
pausa("");
opcion = menu(mOpciones, titulo);
}
grabar_arbol_en_archivo_ordenado_res(&indice, "../Archivos_ABMArbol/Socios.idx");
///vaciar_arbol(&indice);
vaciar_arbol_res(&indice);
return 0;
}
/*
* Legge la mossa del giocatore
*/
void leggi_mossa(){
int x, y, m;
printf("%s%s%s", VERDE, "(x,y,m): ", BIANCO);
scanf("%d,%d,%d", &x, &y, &m);
if(!sudoku[x][y][1])
printf("%-50sNon puoi cambiare il numero in (%d,%d)",ROSSO, x, y);
else if(!(0 < m < 10))
printf("%-45sSolo numeri tra 1 e 9 estremi inclusi.", ROSSO);
else if(!(0 < x < 10) || !(0 < y < 10))
printf("%.45sLe cordinate sono tra 1 e 9 estremi inclusi.", ROSSO);
else{
sudoku[x][y][0] = m;
return;
}
pausa();
}
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;
}
Window::Window(QWidget *parent)
{
chek = false;
quadro = new Board(0);
if(quadro == NULL){
qDebug() << "quadro Falhou!";
chek = true;
}else{
qDebug() << "quadro Sucesso!";
}
layout = new QGridLayout;
if(layout == NULL){
qDebug() << "layout Falhou!";
chek = true;
}else{
qDebug() << "layout Sucesso!";
}
file = new QFile();
if(file == NULL){
qDebug() << "file Falhou!";
chek = true;
}else{
qDebug() << "file Sucesso!";
}
lcdLevel = new QLCDNumber();
if(lcdLevel == NULL){
qDebug() << "lcdLevel Falhou!";
chek = true;
}else{
qDebug() << "lcdLevel Sucesso!";
}
lcdScore = new QLCDNumber();
if(lcdScore == NULL){
qDebug() << "lcdScore Falhou!";
chek = true;
}else{
qDebug() << "lcdScore Sucesso!";
}
labelLevel = new QLabel("Level:",this);
if(labelLevel == NULL){
qDebug() << "labelLevel Falhou!";
chek = true;
}else{
qDebug() << "labelLevel Sucesso!";
}
labelScore = new QLabel("Score:",this);
if(labelScore == NULL){
qDebug() << "labelScore Falhou!";
chek = true;
}else{
qDebug() << "labelScore Sucesso!";
}
labelLife = new QLabel("Vida:",this);
if(labelLife == NULL){
qDebug() << "labelLife Falhou!";
chek = true;
}else{
qDebug() << "labelLife Sucesso!";
}
botaoStart = new QPushButton("Start");
if(botaoStart == NULL){
qDebug() << "botaoStart Falhou!";
chek = true;
}else{
qDebug() << "botaoStart Sucesso!";
}
botaoPause = new QPushButton("Pause");
if(botaoPause == NULL){
qDebug() << "botaoPause Falhou!";
chek = true;
}else{
qDebug() << "botaoPause Sucesso!";
}
botaoReset = new QPushButton("Reset");
if(botaoReset == NULL){
qDebug() << "botaoReset Falhou!";
chek = true;
}else{
qDebug() << "botaoReset Sucesso!";
}
menuBar = new QMenuBar;
if(menuBar == NULL){
qDebug() << "menuBar Falhou!";
chek = true;
}else{
qDebug() << "menuBar Sucesso!";
}
fileMenu = new QMenu(tr("&File"), this);
if(fileMenu == NULL){
qDebug() << "fileMenu Falhou!";
chek = true;
}else{
qDebug() << "fileMenu Sucesso!";
}
barraProgresso = new QProgressBar();
if(barraProgresso == NULL){
qDebug() << "barraProgresso Falhou!";
chek = true;
}else{
qDebug() << "barraProgresso Sucesso!";
}
barraVida = new QProgressBar();
if(barraVida == NULL){
qDebug() << "barraVida Falhou!";
chek = true;
}else{
qDebug() << "barraVida Sucesso!";
}
tempo = new QTimer(this);
if(tempo == NULL){
qDebug() << "tempo Falhou!";
chek = true;
}else{
qDebug() << "tempo Sucesso!";
}
contadorBarra = 1;
baseScore =5;
tamInicioBarra = 0;
tamFimBarra = baseScore;
barraVida->setMaximum(3);
contadorVida = 0;
aboutAct = new QAction(tr("&About"), this);
if(aboutAct == NULL){
qDebug() << "aboutAct Falhou!";
chek = true;
}else{
qDebug() << "aboutAct Sucesso!";
}
aboutAct->setStatusTip(tr("Show the application's About box"));
connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));
connect(botaoStart, SIGNAL(clicked()), quadro, SLOT(inicio()));
connect(botaoPause, SIGNAL(clicked()), quadro, SLOT(pausa()));
connect(botaoReset, SIGNAL(clicked()), quadro, SLOT(reset()));
connect(quadro, SIGNAL(nivelDificuldade(int)), lcdLevel, SLOT(display(int)));
connect(quadro, SIGNAL(pontosGanho(int)), lcdScore, SLOT(display(int)));
connect(quadro, SIGNAL(barra_Progresso()), this, SLOT(barraDeProgresso()));
connect(quadro, SIGNAL(barra_Vida()), this, SLOT(barraDeVida()));
connect(quadro, SIGNAL(sinalReset()), this, SLOT(resetJogo()));
connect(quadro, SIGNAL(salvaScore()), this, SLOT(save()));
this->resize(304,400);
this->setMaximumSize(304,400);
quadro->setMinimumSize(104,200);
quadro->setMaximumSize(304,400);
createMenu();
layout->addWidget(menuBar);
layout->addWidget(quadro,3,0,10,3);
layout->addWidget(labelLevel, 3, 4);
layout->addWidget(lcdLevel,4,4);
layout->addWidget(labelScore, 5,4);
layout->addWidget(lcdScore,6,4);
layout->addWidget(botaoStart,7,4);
layout->addWidget(botaoPause,8,4);
layout->addWidget(botaoReset,9,4);
layout->addWidget(barraProgresso);
layout->addWidget(labelLife);
layout->addWidget(barraVida);
this->setLayout(layout);
this->show();
if(chek == true)
{
falhaCritica();
}
}
int main(int argc, char**argv) {
int diasMeses[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
CUMPLES cump[]={
{"PAPA",{12,11,2006},'C'},
{"MAMA",{14,1,2007},'C'},
{"PAQUI",{1,11,1958},'C'},
{"ANTONIO",{22,3,1960},'C'},
{"JUAN",{6,6,1963},'C'},
{"FRANC",{6,8,1965},'C'},
{"MARI",{21,10,1969},'C'},
{"JORGE",{30,9,1975},'C'},
{"RAFA",{21,9,1987},'C'},
{"ALBERTO",{9,8,2006},'C'},
{"DAVID",{13,5,2006},'C'},
{"LAURA",{20,4,1996},'C'},
{"ANTOÑIN",{26,4,1994},'C'},
{"ESTHER",{20,2,2007},'C'},
{"CRISTINA",{7,3,2007},'C'},
{"PAPA, ANTONIO, CHICO RICO",{13,6,2006},'S'},
{"MAMA, MARI",{12,9,2006},'S'},
{"PAQUI",{4,10,2006},'S'},
{"JUAN",{24,6,2006},'S'},
{"FRANC",{3,12,2006},'S'},
{"JORGE",{23,4,2006},'S'},
{"RAFA",{24,10,2006},'S'},
{"DIA DEL PADRE",{19,3,2007},'S'},
{"DIA DE LA MADRE",{6,5,2006},'S'},
{"ESTHER",{1,7,2006},'S'},
{"CRISTINA",{24,7,2006},'S'},
{"JUAN JOSÉ",{5,7,1958},'C'},
{"MARÍA",{8,9,2006},'S'},
{"FÁTIMA",{17,12,2006},'C'},
{"JUAN JOSÉ",{19,3,2007},'S'},
{"RENOVACIÓN CERTIFICADO FNMT",{25,4,2006},'C'}
};
FECHA actual=fechaActual();
int hayCumples=0, dias,i,j;
setlocale(LC_ALL,"spanish_spain.1252"); //poner teclado español
if (argc>1) {
for(i=1; i<argc; i++) {
if (argv[i][0]=='-' || argv[i][0]=='/') {
for(j=1;argv[i][j];j++) {
switch(argv[i][j]) {
case 'l': case 'L':
printf("\n\n");
listarCumples(cump,sizeof(cump)/sizeof(CUMPLES));
printf("\n\n");
break;
case 'h': case 'H': case '?':
printf("\n\nUso %s [opcion].",argv[0]);
printf("\nOpcion: -l -> listar cumples");
printf("\n -h -> esta ayuda");
printf("\nSi se omite opción se listarán los cumples o santos a menos de 5 días vista.\n\n");
break;
}
}
}
}
exit(0);
}
for(int i=0; i<sizeof(cump)/sizeof(CUMPLES); i++) {
if (cump[i].cumple.dia>5 && actual.mes==cump[i].cumple.mes) {
dias=cump[i].cumple.dia-actual.dia;
} else if (actual.mes+1==cump[i].cumple.mes) {
dias=diasMeses[actual.mes]-actual.dia+cump[i].cumple.dia;
} else {
dias=-1;
}
if (dias<=5 && dias >=0) {
hayCumples=1;
if (dias==0) {
printf("\n* Hoy es ");
} else {
printf("\n* Faltan %d días para ",dias);
}
if (cump[i].tipo=='C') {
printf("el Cumpleaños de: %s->%02d/%02d/%04d.\n",cump[i].nombre,cump[i].cumple.dia,cump[i].cumple.mes,cump[i].cumple.anio);
} else {
printf("el Santo de: %s.\n",cump[i].nombre);
}
}
}
if (hayCumples) {
pausa();
}
return 0;
}
void main(){
//mostramos una imagen super fancy
imprimeImagenPrincipal(" ");
printf("\n\n\tPulsa [ENTER] para comenzar!\n");
pausa();
//srand(time(NULL));
char opcion[STRING_MAX];
char opcionJuego[STRING_MAX];
boolean menu = TRUE; //variable del bucle del menu de opciones inicial
boolean juego = FALSE; //variable del bucle del juego
boolean buclePreJuego = FALSE; //variable del bucle de las opciones del juego
boolean bucleTurnosJuego = FALSE; //variable del bucle de las jugadas
//============================================
// BUCLE MENU PRINCIPAL
//--------------------------------------------
while(menu){
//limpia la consola
limpiar();
imprimeMenuPrincipal();
fflush(stdin); //limpia buffer entrada
fgets(opcion, STRING_MAX, stdin);
//Opciones de entrada
//opcion 1: entrar a un juego nuevo.
if(atoi(opcion) == 1){
buclePreJuego = TRUE;
}
//opcion 2: salir
if(atoi(opcion) == 2){
menu = FALSE;
}
//====================================================
// BUCLE PRE-JUEGO
//----------------------------------------------------
char cantidadJugadores[STRING_MAX];
nodo* jugadores = NULL; //jugadores
nodo* mazo = NULL; //mazo del juego
nodo* pozo = NULL; //donde se tiran las cartas
nodo** manos = NULL; // cartas de los jugadores (puntero doble porque es un malloc de nodo*)
while(buclePreJuego){
//====================================================
// CONDICIONES PRE-JUEGO
//----------------------------------------------------
limpiar();
printf("Condiciones pre-juego.\n");
//cuantos jugadores (incluyendo el humano)
printf("ingrese la cantidad de jugadores [2-10]: ");
fflush(stdin);
fgets(cantidadJugadores,STRING_MAX, stdin);
printf("jugadores: %d\n", atoi(cantidadJugadores));
if(atoi(cantidadJugadores) < 2){
buclePreJuego = FALSE;
}
else{
//hacemos un arreglo de listas enlazadas que seran las manos.
manos = (nodo**)malloc(sizeof(nodo*)*atoi(cantidadJugadores));
//generamos el mazo del juego con orden aleatorio
mazo = crearMazo();
//colocamos una carta del mazo en el pozo.
nodo* cartaInicial = obtener(mazo,0); //sacamos la primera carta
pozo = push(pozo, cartaInicial->dato, cartaInicial->dato2);
mazo = borrarTipo(mazo, cartaInicial->dato,cartaInicial->dato2);
//agrega los jugadores a una lista...
//...los CPU...
int t;
for(t=0;t<atoi(cantidadJugadores)-1;t++)
{
jugadores = push(jugadores, JUGADOR_CPU,-1);
}
//...y al humano.
jugadores = push(jugadores, JUGADOR_HUMANO,-1);
//agregamos las manos
int j,m;
for(j=0;j<atoi(cantidadJugadores);j++){
manos[j] = NULL;
for(m=0; m<MANO_INICIAL;m++){
//numero random
//vemos una carta
cartaInicial = obtener(mazo,0); //sacamos la primera carta
//se coloca en la mano
manos[j]= push(manos[j],cartaInicial->dato,cartaInicial->dato2);
//se borra del mazo
mazo = borrarTipo(mazo, cartaInicial->dato,cartaInicial->dato2);
}
}
//muestra los turnos del juego antes de comenzar.
muestraTurnos(jugadores);
//borrar
//printf("largo del mazo: %d\n", largo(mazo));
//listarCartas(mazo);
//fin borrar
printf("\nPresione ENTER para comenzar la partida...");
pausa();
//terminamos condiciones pre-juego
buclePreJuego = FALSE;
//y vamos al bucle de turnos...
bucleTurnosJuego = TRUE;
}
}
//----------------------------------------------------------
// FIN bucle pre-juego
//==========================================================
//==========================================================
// BUCLE TURNOS DEL JUEGO
//----------------------------------------------------------
limpiar();
int turno=-1; //turno actual
char opcionJuego[STRING_MAX]; //entrada por teclado
char sentido = 1; //sentido de los turnos (para cartas invertir)
nodo* jugadorActual; //jugador que le toca turno
while(bucleTurnosJuego){
//verifica si quedan cartas en el mazo
if(largo(mazo)<1){
//si no hay cartas voltea el pozo
mazo = volteaPozo(&mazo,&pozo);
}
turno = estableceTurno(atoi(cantidadJugadores),turno, sentido);
//imprime estado del juego
imprimeEstadoJuego(mazo,pozo);
//obtiene el jugador que le corresponde el turno.
jugadorActual = obtener(jugadores,turno);
if( jugadorActual->dato == JUGADOR_HUMANO){
printf("Tu turno!\n");
//muestra la mano del jugador
mostrarMano(manos[turno]," ");
//imprimirCartitas(largo(manos[turno]));
//interaccion en turno
printf(" Botar carta: ");
fflush(stdin);
fgets(opcionJuego,STRING_MAX,stdin);
//reaccion a la opcion
//==================================================
// JUGADA DEL JUGADOR HUMANO
//--------------------------------------------------
//si el turno no es exitoso, no se avanza al siguiente jugador...
if(!logicaTurno(&manos[turno], &mazo, &pozo, &turno, opcionJuego)){
if(sentido){
turno--;
}
else
turno++;
}
else{
if(largo(manos[turno])==0){
limpiar();
printf("\n\t\aFELICIDADES, HAS GANADO!!!\n\n");
imprimeEstadoJugadores(jugadores,manos);
printf("\n\t\aFELICIDADES, HAS GANADO!!!\n\n");
bucleTurnosJuego = FALSE;
printf("Presione [ENTER] para ontinuar...");
pausa();
}
}
//para salir
if(atoi(opcionJuego) == -1){
bucleTurnosJuego = FALSE;
}
//--------------------------------------------------
// FIN jugada del jugador humano
//==================================================
//este "limpiar" permite que se vean solo las jugadas
//de las CPU que se hacen hasta que le toca al usuario.
limpiar();
}
else{
//==========================================================
//JUGADA AUTOMATICA DE COMPUTADORAS
//----------------------------------------------------------
printf("Turno Computadora %d, mano:", turno+1);
imprimirCartitas(largo(manos[turno]));
//si el turno no es exitoso, no se avanza al siguiente jugador...
if(!jugadaAutomatica(&manos[turno], &mazo, &pozo, &turno)){
if(sentido){
turno--;
}
else
turno++;
}
else{
if(largo(manos[turno])==0){
limpiar();
imprimeEstadoJuego(mazo,pozo);
printf("\n\t\aLA COMPUTADORA %d, HA GANADO!\n",turno+1);
imprimeEstadoJugadores(jugadores,manos);
printf("\n\t\aLA COMPUTADORA %d, HA GANADO!\n",turno+1);
bucleTurnosJuego = FALSE;
printf("Presione [ENTER] para continuar...");
pausa();
}
}
//-----------------------------------------------------------
// FIN jugada automatica de computadoras
//===========================================================
}
}
//--------------------------------------------------------------
// FIN bucle turnos juego
//==============================================================
//======================================
// LIBERACION DE MEMORIA
//--------------------------------------
//liberamos lista de jugadores
jugadores = anular(jugadores);
//libera el mazo
mazo = anular(mazo);
//libarar el pozo
pozo = anular(pozo);
//libramos manos
if(manos != NULL){
int d;
for(d=0; d < atoi(cantidadJugadores);d++){
manos[d] = anular(manos[d]);
}
free(manos);
}
//-------------------------------------
// FIN liberacion memoria
//=====================================
}
//--------------------------------
// FIN bucle menu principal
//================================
}
void main (void)
{
TRISC0=0; // Led Amar
TRISC1=0; // Led Verd
TRISC2=0; // LED Verm
TRISC6=0; // saida TX EUSART
ADCON1=0x0F; // coloca pinos I/O em modo digital (nao analogico)
acordar();
unsigned int D0, D1, D2, D3, minAnterior, contador, segInicial;
char msg[30];
LED_VERM=1;
// inicia porta serial com 9600 bps @ 8mhz
initExt7SegLCD(); // inicia barramento I2C e escreve ".12:34."
pausa(1); piscaSeg(0);
// Inicio do Relogio e Display
contador=0; // o contador esta acima do limite (59)
minAnterior=10; // o minuto nunca chegaria a 10 (forca display)
while (1)
{
getDS1307();
sprintf(msg," _[%x:%x:%x]_", hora, minuto, segundo );
while(BusyUSART());
putsUSART( msg );
D0 = (hora & 0b00110000) >> 4; // utiliza somente 2 bits da nibble esq
D1 = hora & 0b00001111; // utiliza somente 4 bits da nibble dir
D2 = (minuto & 0b11110000) >> 4;// utiliza somente 4 bits da nibble esq
D3 = minuto & 0b00001111; // utiliza somente 4 bits da nibble dir
/*
sprintf(msg,"___ %d%d:%d%d ...%xseg_ \r\n",
D0, D1, D2, D3 ,segundo);
while(BusyUSART());
putsUSART( msg );
*/
if (D3 != minAnterior) // se mudou o minuto, entao mostre novo horario
{
StartI2C();
__delay_us(16); // delay experimental
WriteI2C(HT16K33_ADDR << 1);
WriteI2C(0x00);
WriteI2C(numbertable[D0] & 0xff ); // preenche todos os bits
WriteI2C(numbertable[D0] >> 8); // qualquer byte
// obs: acima como foram usados somente 2 bits, alguma "sujeira"
// poderia ter ficado escrita no registrador, por isso a necessidade
// de "preencher" os outros bits com & 0xff
WriteI2C(numbertable[ D1 ] & 0xFF ); // preenche todos os bits
WriteI2C(numbertable[ D1 ] >> 8); // qualquer byte
WriteI2C(0xFF); // escreve ":" sempre no segundo 0 de mostrar
WriteI2C(0xFF >> 8); // qualquer byte
WriteI2C(numbertable[ D2 ] & 0xFF );// preenche todos os bits
WriteI2C(numbertable[ D2 ] >> 8); // qualquer byte
WriteI2C(numbertable[ D3 ] & 0xFF );// preenche todos os bits
WriteI2C(numbertable[ D3 ] >> 8); // qualquer byte
NotAckI2C(); // encerra envio
__delay_us(16); // delay experimental
StopI2C();
minAnterior=D3; // variavel para proxima checagem e mudanca
}
pausa(1); // utiliza TIMER0 para realizar contagem precisa de 1 seg
if ( (contador % 2) == 0) piscaSeg(1); // gera a piscada ":" par
else piscaSeg(0); // ou impar " ", a cada mudanca de contador (seg)
sprintf(msg,"\r\nSeg=%d, Cont=%d", segundo, contador );
while(BusyUSART());
putsUSART( msg );
// rotina abaixo de calculo de desvio de segundos
// ainda deve ser corrigida para o algoritmo correto
if (contador >= 2 ) // cont >= 40+10
{
dormir();
sprintf(msg,"\r\nSeg=%d, Cont=%d (volta do sleep)", segundo, contador );
while(BusyUSART());
putsUSART( msg );
contador=0;
}
contador++; // incrementa controle de contagem de segundos
}
void main(void)
{
// Configuracao das portas com LEDs
TRISCbits.TRISC0=0; // LED Amarelo para simples sinalizacao
TRISCbits.TRISC1=0; // LED Verde para simples sinalizacao
TRISCbits.TRISC2=0; // LED Vermelho para simples sinalizacao
// Configuracao do pino TX da porta serial EUSART / para RS232
TRISCbits.TRISC6=1; // TX da EUSART
// O programa ira informar na porta serial o status
// e logs de funcionamento da coleta de dados I2C
// agora a CHAMADA para configuracao GLOBAL da PIC
configuracao_PIC();
// Preparacao para configuracao do modulo MSSP I2C (com Errata aplicada)
/* 17. Module: MSSP (ERRATA for PIC18F4550 and PIC18F2525, etc)
* ================
*
* It has been observed that following a Power-on Reset, I2C mode may not
* initialize properly by just configuring the SCL and SDA pins as either
* inputs or outputs. This has only been seen in a few unique system
* environments. A test of a statistically significant sample of pre-
* production systems, across the voltage and current range of the
* application's power supply, should indicate if a system is
* susceptible to this issue.
*
* Work around = Before configuring the module for I2C operation:
* 1. Configure the SCL and SDA pins as outputs by clearing
* their corresponding TRIS bits.
* 2. Force SCL and SDA low by clearing the corresponding LAT bits.
* 3. While keeping the LAT bits clear, configure SCL and SDA as
* inputs by setting their TRIS bits.
*
* Once this is done, use the SSPCON1 and SSPCON2 registers to
* configure the proper I2C mode as before.
*/
TRISCbits.TRISC3=0; // SCL do I2C colocado como saida por causa de bug*
TRISCbits.TRISC4=0; // SDA do I2C colocado como saida por causa de bug*
LATC3=0; // bug* pede que zere-se o LAT das portas SCL e SDA
LATC4=0; // durante inicializacao do I2C para evitar flutuacoes
// eletricas que ficariam nas portas antes de liga-las
Delay10KTCYx(10); // simples pausa para troca de estado na SDA e SCL
TRISCbits.TRISC3=1; // SCL do I2C, agora corretamente como saida
TRISCbits.TRISC4=1; // SDA do I2C, agora corretamente como saida
// here ends "errata workaround"
// entao a CHAMADA para diversas configuracoes referentes ao I2C (MSSP)
configuracao_I2C();
// e a inicializacao da porta serial EUSART
configuracao_EUSART();
while(BusyUSART());
putrsUSART("\n\r_INIT SERIAL.\n\r");
/*************************
*
* INICIO DO PROGRAMA
*
*************************/
LED_AMAR=0;
LED_VERM=1;
LED_VERD=0;
// Inicializacao do MSSP I2C
CloseI2C(); // simplesmente fechando qualquer possibilidade de I2C anterior
// comando nao necessario no boot da PIC
//macro = #define CloseI2C() SSPCON1 &=0xDF
while(BusyUSART());
putrsUSART("SSPAD=");
putsUSART( itoa(NULL,SSPADD,10) );
putrsUSART(" (hex=0x");
putrsUSART( itoa(NULL,SSPADD,16) );
putrsUSART("); Abrindo MSSP I2C (Master,Slew_off)\n\r");
OpenI2C(MASTER,SLEW_OFF); // configuracao implicita da SSPCON1 e SSPSTAT
while (1)
{
testaColisao();
getDS1307();
//testaColisao();
getTemperaturaHumidade();
pausa(10);
}
}
