/* * The Big Cheese */ int main(int argc, char *argv[]) { scrgame *sg; int c; char *bn = basename(argv[0]); if (!bn || errno) { /* basename can return a NULL pointer, causing a segfault on strncmp below */ errx(errno, "Something went wrong in determining the %s", "filename by which nmm was called."); } if (argc != 1) { errx(EINVAL, "%s doesn't take any arguments.", bn); } if ((sg = malloc(sizeof(*sg)))) { if ((sg->game = malloc(sizeof(*sg->game)))) { point *board; if ((board = calloc(ROWS * COLS, sizeof(*board)))) { int r; for (r = 0; r < ROWS; r++) { for (c = 0; c < COLS; c++) { sg->game->board[r][c] = board++; } } } else { errx(errno, "Unable to allocate memory for the board"); } } else { errx(errno, "Unable to allocate memory for the game"); } } else { errx(errno, "Unable to allocate memory"); } initscr(); cbreak(); keypad(stdscr, TRUE); clear(); printw("Display instructions? (y/n) "); refresh(); c = getch(); c = tolower(c); if (c == 'y') { printinstrs(sg); } clear(); noecho(); refresh(); if (strncmp("tmm", bn, 3) == 0) { c = TMM; } else if (strncmp("twmm", bn, 4) == 0) { c = TWMM; } else { c = NMM; } for (;;) { initall(sg, c); refresh(); phaseone(sg); phasetwothree(sg); if (!gameend(sg)) { break; } } refresh(); endwin(); return 0; }
int cargaNivel(int n_nivel, Nivel *nivel) { int error = 1; char ruta_nivel[255]; FILE *f_niveles; sprintf(ruta_nivel, "nivel%d.txt", n_nivel); printw("Cargando nivel: %s\n", ruta_nivel); f_niveles = fopen(ruta_nivel, "r"); if(f_niveles != NULL) { int i = 0; void *mas_piedras; nivel->numero_nivel = n_nivel; nivel->piedras.lista = NULL; nivel->piedras.elementos = 0; nivel->diamantes.lista = NULL; nivel->diamantes.elementos = 0; void *mas_diamantes; fscanf(f_niveles,"posInicial_x = %4d", &nivel->posicioInicial.fila); fgetc(f_niveles); //Obtenemos el final de linea fscanf(f_niveles,"posInicial_y = %4d", &nivel->posicioInicial.columna); fgetc(f_niveles); //Obtenemos el final de linea fscanf(f_niveles,"diamantes_necesarios = %4d", &nivel->diamantes.elementos_necesarios); fgetc(f_niveles); //Obtenemos el final de linea fscanf(f_niveles,"posSalida_x = %4d", &nivel->posicioSortida.fila); fgetc(f_niveles); //Obtenemos el final de linea fscanf(f_niveles,"posSalida_y = %4d", &nivel->posicioSortida.columna); fgetc(f_niveles); //Obtenemos el final de linea fscanf(f_niveles,"puntosPorGanar = %4d", &nivel->puntosPorGanar); fgetc(f_niveles); //Obtenemos el final de linea printw("Posicion Inicial: X:%d Y:%d\n", nivel->posicioInicial.fila, nivel->posicioInicial.columna); while( !feof(f_niveles) ) { fgets(nivel->caracteres[i], NIVEL_COLUMNAS + 1, f_niveles); fgetc(f_niveles); //Obtenemos el final de linea printw("Leido %d: %s\n", i, nivel->caracteres[i]); int j = 0; while(j<=NIVEL_COLUMNAS+1) { if(nivel->caracteres[i][j] == 'O') //Es una pedra. { printw("Piedra leida en la posicion: X:%d, Y:%d\n", i, j); nivel->piedras.elementos++; mas_piedras = realloc(nivel->piedras.lista, sizeof(Lista_Piedras) * (nivel->piedras.elementos) ); if(mas_piedras != NULL) { nivel->piedras.lista = mas_piedras; nivel->piedras.lista[nivel->piedras.elementos-1].posicion.fila = i; nivel->piedras.lista[nivel->piedras.elementos-1].posicion.columna = j; nivel->piedras.lista[nivel->piedras.elementos-1].segunda_oportunidad = 1; nivel->piedras.lista[nivel->piedras.elementos-1].direccion = 0; } else { free(nivel->piedras.lista); printw("Error rehahuecando memoria para las piedras.\n"); exit(1); } } if(nivel->caracteres[i][j] == 'V') //Es un diamant. { printw("Diamante leido en la posicion: X:%d, Y:%d\n", i, j); nivel->diamantes.elementos++; // A1 - Al detectar el diamante se incrementa la cantidad ahora para que el realloc funcione correctamente. mas_diamantes = realloc(nivel->diamantes.lista, sizeof(Lista_Diamantes) * nivel->diamantes.elementos); if(mas_diamantes != NULL) { nivel->diamantes.lista = mas_diamantes; nivel->diamantes.lista[nivel->diamantes.elementos-1].posicion.fila = i; //Ver A1 + y aqui le restamos 1 para que empieze en la posicion 0 del array. nivel->diamantes.lista[nivel->diamantes.elementos-1].posicion.columna = j; nivel->diamantes.lista[nivel->diamantes.elementos-1].eliminado = 0; } else { free(nivel->piedras.lista); printw("Error rehahuecando memoria para los diamantes.\n"); exit(1); } } j++; } i++; } fclose(f_niveles); error = 0; } mostrarDiamantesAlmacenados(nivel); mostrarPiedrasAlmacenadas(nivel); return error; }
int main() { char label_text[LMAX][20] = { "I", "AM", "SAM", "DO", "NOT", "LIKE", "THAT", "SAY", "WOULD", "COULD", "YOU", "GREEN EGGS AND HAM" }; int label,ch; slk_init(2); /* 12 soft labels */ initscr(); noecho(); /* disable key echoing */ keypad(stdscr,TRUE); /* Turn on Fkey reading */ /* display the labels and instructions */ for(label=0;label<LMAX;label++) slk_set(label+1,label_text[label],CENTER); slk_refresh(); addstr("Use the Function Keys to type\n"); addstr("Press '?' or '!' or '.' to end a line\n"); addstr("Press Enter to quit\n\n"); refresh(); /* Process input */ while( (ch=getch()) != '\n') { switch(ch) { case '?': case '!': case '.': addch(ch); addch('\n'); break; case KEY_F(1): printw("%s ",label_text[0]); break; case KEY_F(2): printw("%s ",label_text[1]); break; case KEY_F(3): printw("%s ",label_text[2]); break; case KEY_F(4): printw("%s ",label_text[3]); break; case KEY_F(5): printw("%s ",label_text[4]); break; case KEY_F(6): printw("%s ",label_text[5]); break; case KEY_F(7): printw("%s ",label_text[6]); break; case KEY_F(8): printw("%s ",label_text[7]); break; case KEY_F(9): printw("%s ",label_text[8]); break; case KEY_F(10): printw("%s ",label_text[9]); break; case KEY_F(11): printw("%s ",label_text[10]); break; case KEY_F(12): printw("%s ",label_text[11]); break; default: break; } refresh(); } endwin(); return 0; }
int main (int argc, char **argv) { int i,l; /* non-descript indices */ char c; /* non-descript character storage */ if (pledge("stdio rpath wpath cpath tty exec", NULL) == -1) err(1, "pledge"); signal(SIGINT, getout); /* trap interrupts */ /* use whole screen for text */ begscr = 0; getarg(argc, argv); initcurses(); /* check if restored game and save flag for later */ if ((rfl = rflag)) { if (pledge("stdio rpath wpath cpath tty", NULL) == -1) err(1, "pledge"); wrboard(); /* print board */ /* if new game, pretend to be a non-restored game */ if (cturn == 0) rflag = 0; } else { rscore = wscore = 0; /* zero score */ if (aflag) { /* print rules */ addstr(rules); if (yorn(0)) { endwin(); execl(TEACH, "teachgammon", (char *)NULL); err(1, "%s", noteach); } else {/* if not rules, then instructions */ addstr(need); if (yorn(0)) { /* print instructions */ clear(); text(instruct); } } } if (pledge("stdio rpath wpath cpath tty", NULL) == -1) err(1, "pledge"); init(); /* initialize board */ if (pnum == 2) {/* ask for color(s) */ printw("\n%s", askcol); while (pnum == 2) { c = readc(); switch (c) { case 'R': /* red */ pnum = -1; break; case 'W': /* white */ pnum = 1; break; case 'B': /* both */ pnum = 0; break; case 'P': /* Control the dice */ iroll = 1; addstr("\nDice controlled!\n"); addstr(askcol); break; default: /* error */ beep(); } } } wrboard(); /* print board */ move(18, 0); } /* limit text to bottom of screen */ begscr = 17; for (;;) { /* begin game! */ /* initial roll if needed */ if ((!rflag) || raflag) roll(); /* perform ritual of first roll */ if (!rflag) { move(17, 0); while (D0 == D1) /* no doubles */ roll(); /* print rolls */ printw("%s%d%s%d", rollr, D0, rollw, D1); /* winner goes first */ if (D0 > D1) { addstr(rstart); cturn = 1; } else { addstr(wstart); cturn = -1; } } /* initialize variables according to whose turn it is */ if (cturn == 1) { /* red */ home = 25; bar = 0; inptr = &in[1]; inopp = &in[0]; offptr = &off[1]; offopp = &off[0]; Colorptr = &color[1]; colorptr = &color[3]; colen = 3; } else { /* white */ home = 0; bar = 25; inptr = &in[0]; inopp = &in[1]; offptr = &off[0]; offopp = &off[1]; Colorptr = &color[0]; colorptr = &color[2]; colen = 5; } /* do first move (special case) */ if (!(rflag && raflag)) { if (cturn == pnum) /* computer's move */ domove(0); else { /* player's move */ mvlim = movallow(); /* reprint roll */ move(cturn == -1 ? 18 : 19, 0); proll(); getmove(); /* get player's move */ } } move(17, 0); clrtoeol(); begscr = 18; /* no longer any difference between normal and recovered game. */ rflag = 0; /* move as long as it's someone's turn */ while (cturn == 1 || cturn == -1) { /* board maintainence */ moveplayers(); /* fix board */ /* do computer's move */ if (cturn == pnum) { domove(1); /* see if double refused */ if (cturn == -2 || cturn == 2) break; /* check for winning move */ if (*offopp == 15) { cturn *= -2; break; } continue; } /* (player's move) */ /* clean screen if safe */ if (hflag) { move(20, 0); clrtobot(); hflag = 1; } /* if allowed, give him a chance to double */ if (dflag && dlast != cturn && gvalue < 64) { move(cturn == -1 ? 18: 19, 0); addstr(*Colorptr); c = readc(); /* character cases */ switch (c) { case 'R': /* reprint board */ wrboard(); break; case 'S': /* save game */ raflag = 1; save(1); break; case 'Q': /* quit */ quit(); break; case 'D': /* double */ dble(); break; case ' ': /* roll */ case '\n': roll(); printw(" rolls %d %d. ", D0, D1); /* see if he can move */ if ((mvlim = movallow()) == 0) { /* can't move */ printw("%s%s%s", toobad1, *colorptr, unable); if (pnum) { moveplayers(); sleep(MVPAUSE); } nexturn(); break; } getmove(); /* okay to clean screen */ hflag = 1; break; default: /* invalid character */ /* print help message */ move(20, 0); text(helpm); move(cturn == -1 ? 18 : 19, 0); /* don't erase */ hflag = 0; } } else {/* couldn't double */ /* print roll */ roll(); move(cturn == -1 ? 18: 19, 0); proll(); /* can he move? */ if ((mvlim = movallow()) == 0) { /* he can't */ printw("%s%s%s", toobad2, *colorptr, cantmv); moveplayers(); sleep(MVPAUSE); nexturn(); continue; } getmove(); } } /* don't worry about who won if quit */ if (cturn == 0) break; /* fix cturn = winner */ cturn /= -2; /* final board pos. */ moveplayers(); /* backgammon? */ mflag = 0; l = bar + 7 * cturn; for (i = bar; i != l; i += cturn) if (board[i] * cturn) mflag++; /* compute game value */ move(20, 0); if (*offopp == 15) { if (mflag) { addstr(bgammon); gvalue *= 3; } else if (*offptr <= 0) { addstr(gammon); gvalue *= 2; } } /* report situation */ if (cturn == -1) { addstr("Red wins "); rscore += gvalue; } else { addstr("White wins "); wscore += gvalue; } printw("%d point%s.\n", gvalue, (gvalue > 1) ? "s":""); /* write score */ wrscore(); /* see if he wants another game */ addstr(again); if ((i = yorn('S')) == 0) break; init(); if (i == 2) { addstr(" Save.\n"); cturn = 0; save(0); } /* yes, reset game */ wrboard(); } /* give him a chance to save if game was recovered */ if (rfl && cturn) { addstr(svpromt); if (yorn(0)) { /* re-initialize for recovery */ init(); cturn = 0; save(0); } } /* leave peacefully */ getout(0); /* NOT REACHED */ }
int main(int argc, char *argv[]) { int ch; int which = 0; int last; bool replaying = FALSE; bool done = FALSE; char **files; while ((ch = getopt(argc, argv, "ir")) != -1) { switch (ch) { case 'i': use_init = TRUE; break; case 'r': replaying = TRUE; break; default: usage(); break; } } initscr(); cbreak(); noecho(); keypad(stdscr, TRUE); curs_set(0); if (has_colors()) { start_color(); for (ch = 0; ch < COLOR_PAIRS; ++ch) { short pair = ch % COLOR_PAIRS; init_pair(pair, COLOR_WHITE, ch % COLORS); } } files = argv + optind; last = argc - optind - 1; if (replaying) { /* * Use the last file as the initial/current screen. */ if (last < 0) { endwin(); printf("No screen-dumps given\n"); ExitProgram(EXIT_FAILURE); } which = last; if (load_screen(files[which]) == ERR) { endwin(); printf("Cannot load screen-dump %s\n", files[which]); ExitProgram(EXIT_FAILURE); } after_load(); while (!done && (ch = getch()) != ERR) { switch (ch) { case 'n': /* * If we got a "next" here, skip to the final screen before * moving to the next process. */ setup_next(); which = last; done = TRUE; break; case 'q': endwin(); cleanup(files); done = TRUE; break; case KEY_BACKSPACE: case '\b': if (--which < 0) which = last; break; case ' ': if (++which > last) which = 0; break; default: beep(); continue; } if (ch == 'q') { ; } else if (scr_restore(files[which]) == ERR) { endwin(); printf("Cannot load screen-dump %s\n", files[which]); cleanup(files); ExitProgram(EXIT_FAILURE); } else { wrefresh(curscr); } } } else { int y; int x; move(2, 0); printw("Use h,j,k,l or arrows to move around the screen\n"); printw("Press 'q' to quit, ' ' to dump a screen\n"); printw("When the last screen has been dumped, press 'n' to run the\n"); printw("screen-loader. That allows only 'q', backspace and ' ' for\n"); printw("stepping through the dumped/restored screens.\n"); getyx(stdscr, y, x); while (!done) { switch (ch = get_command(which, last)) { case 'n': setup_next(); done = TRUE; break; case 'q': endwin(); cleanup(files); done = TRUE; break; case ' ': if (files[which] != 0) { show_what(which + 1, last); if (scr_dump(files[which]) == ERR) { endwin(); printf("Cannot write screen-dump %s\n", files[which]); cleanup(files); done = TRUE; break; } ++which; if (has_colors()) { short pair = which % COLOR_PAIRS; bkgd(COLOR_PAIR(pair)); } } else { beep(); } break; case KEY_LEFT: case 'h': if (--x < 0) x = COLS - 1; break; case KEY_DOWN: case 'j': if (++y >= LINES) y = 1; break; case KEY_UP: case 'k': if (--y < 1) y = LINES - 1; break; case KEY_RIGHT: case 'l': if (++x >= COLS) x = 0; break; } if (!done) { time_t now = time((time_t *) 0); move(0, 0); addstr(ctime(&now)); move(y, x); addch('#' | A_REVERSE); move(y, x); } } } ExitProgram(EXIT_SUCCESS); }
void game_loop( RubikCube & cube, std::string & args ) { int ch; bool doSolve = false; // Main loop while (42) { // Read Input (Also calls refresh) // refresh(); ch = getch(); // clear(); // if (ch == KEY_LEFT) { if (ch == 'q' || ch == 'Q') { break; } else if (ch == 'w') { cube[0].rotate_c(); args.append(" U"); // UP C } else if (ch == 'e') { cube[0].rotate_cc(); args.append(" U'"); // UP CC } else if (ch == 'r') { cube[0].rotate_2(); args.append(" U2"); // UP 180 } else if (ch == 'a') { cube[4].rotate_c(); args.append(" F"); // FRONT C } else if (ch == 's') { cube[4].rotate_cc(); args.append(" F'"); // FRONT CC } else if (ch == 'd') { cube[4].rotate_2(); args.append(" F2"); // FRONT 180 } else if (ch == 'z') { cube[3].rotate_c(); args.append(" R"); // RIGHT C } else if (ch == 'x') { cube[3].rotate_cc(); args.append(" R'"); // RIGHT CC } else if (ch == 'c') { cube[3].rotate_2(); args.append(" R2"); // RIGHT 180 } else if (ch == 't') { cube[5].rotate_c(); args.append(" B"); // BACK C } else if (ch == 'y') { cube[5].rotate_cc(); args.append(" B'"); // BACK CC } else if (ch == 'u') { cube[5].rotate_2(); args.append(" B2"); // BACK 180 } else if (ch == 'g') { cube[2].rotate_c(); args.append(" L"); // LEFT C } else if (ch == 'h') { cube[2].rotate_cc(); args.append(" L'"); // LEFT CC } else if (ch == 'j') { cube[2].rotate_2(); args.append(" L2"); // LEFT 180 } else if (ch == 'v') { cube[1].rotate_c(); args.append(" D"); // DOWN C } else if (ch == 'b') { cube[1].rotate_cc(); args.append(" D'"); // DOWN CC } else if (ch == 'n') { cube[1].rotate_2(); args.append(" D2"); // DOWN 180 } else if (ch == ' ') { doSolve = true; break; } draw_screen(args, cube, ""); } if (doSolve) { clock_t loop_time = 400000; clock_t loop_start_time = clockToUseconds(clock()); std::string solution = solve(cube.getMikeFormat()); std::string solution_buffer; std::string cmd; std::size_t pos; while (42) { ch = getch(); if (ch == 'q' || ch == 'Q') break; // Timing if (clockToUseconds(clock()) - loop_start_time < loop_time) continue; loop_start_time = clockToUseconds(clock()); // Solution pos = solution.find_first_of(" \n"); cmd = solution.substr(0, pos); cube.apply(cmd); solution_buffer += ' '; solution_buffer += cmd; if (pos != std::string::npos) ++pos; solution.erase(0, pos); draw_screen(args, cube, solution_buffer); if (solution.size() == 0) break; } attron(COLOR_PAIR(1)); attron(A_BOLD); printw("\nPress Q to Quit"); attroff(A_BOLD); attroff(COLOR_PAIR(1)); while (42) { nodelay(stdscr, FALSE); ch = getch(); if (ch == 'q' || ch == 'Q') break; } } }
int main (int argc, char *argv[]) { setup(); printw("%d row\n%d col\n", row, col); char ch = ' '; int x = 0, y = 0; while(ch != CTRLD) { move(y, x); ch = getch(); switch(ch){ case 27: ch = getch(); ch = getch(); switch(ch){ case 68: // Left x -= 1; break; case 65: // Up y -= 1; break; case 67: // Right x += 1; break; case 66: // Down y += 1; break; } /*printw("TEST", ch);*/ break; case 10: // Newline x = 0; y += 1; break; case 127: // Backspace if (y == 0 && x == 0) { break; } x -= 1; if(x < 0) { x = col - 1; y -= 1; } mvaddch(y, x, ' '); break; default: /*move(0,0);*/ /*printw("%d", ch);*/ /*mvaddch(y, x, ch);*/ mvaddch(y, x, ch); refresh(); x += 1; if( x >= col ) { x = 0; y += 1; } break; } } teardown(); }
static void display_data(int colors) { char cur_time[20]; struct tm *tm_time; time_t epoc_time; size_t counter, line; long long r,w; unsigned long long rt, wt; sg_disk_io_stats *disk_io_stat_ptr; sg_network_io_stats *network_stat_ptr; sg_fs_stats *disk_stat_ptr; /* Size before it will start overwriting "uptime" */ char hostname[15]; char *ptr; if (stats.host_info != NULL) { move(0,12); strncpy(hostname, stats.host_info->hostname, (sizeof(hostname) - 1)); /* strncpy does not NULL terminate.. If only strlcpy was on all platforms :) */ hostname[14] = '\0'; ptr=strchr(hostname, '.'); /* Some hosts give back a FQDN for hostname. To avoid this, we'll * just blank out everything after the first "." */ if (ptr != NULL){ *ptr = '\0'; } if (colors) { attron(COLOR_PAIR(1)); } printw("%s", hostname); move(0,36); printw("%s", hr_uptime(stats.host_info->uptime)); epoc_time=time(NULL); tm_time = localtime(&epoc_time); strftime(cur_time, 20, "%Y-%m-%d %T", tm_time); move(0,61); printw("%s", cur_time); if (colors) { attroff(COLOR_PAIR(1)); } } if (stats.load_stats != NULL) { /* Load */ if (colors) { attron(COLOR_PAIR(6)); } move(2,12); if (colors && fabs(stats.load_stats->min1 - stats.load_stats->min5) > THRESHOLD_LOAD) { attron(A_BOLD); } printw("%6.2f", stats.load_stats->min1); if (colors) { attroff(A_BOLD); } move(3,12); if (colors && fabs(stats.load_stats->min5 - stats.load_stats->min15) > THRESHOLD_LOAD) { attron(A_BOLD); } printw("%6.2f", stats.load_stats->min5); if (colors) { attroff(A_BOLD); } move(4,12); if (colors && fabs(stats.load_stats->min1 - stats.load_stats->min15) > THRESHOLD_LOAD) { attron(A_BOLD); } printw("%6.2f", stats.load_stats->min15); if (colors) { attroff(A_BOLD); } } if (stats.cpu_percents != NULL) { /* CPU */ move(2,33); printw("%6.2f%%", stats.cpu_percents->idle); move(3,33); printw("%6.2f%%", (stats.cpu_percents->kernel + stats.cpu_percents->iowait + stats.cpu_percents->swap)); move(4,33); if (colors && stats.cpu_percents->user + stats.cpu_percents->nice > THRESHOLD_ALERT_CPU) { attron(A_STANDOUT); attron(A_BOLD); } else if (colors && stats.cpu_percents->user + stats.cpu_percents->nice > THRESHOLD_WARN_CPU) { attron(A_BOLD); } printw("%6.2f%%", (stats.cpu_percents->user + stats.cpu_percents->nice)); if(colors) { attroff(A_BOLD); attroff(A_STANDOUT); attron(COLOR_PAIR(6)); } } if (stats.process_count != NULL) { /* Process */ move(2, 54); printw("%5llu", stats.process_count->running); move(2,74); if (colors && stats.process_count->zombie > THRESHOLD_WARN_ZMB) { attron(A_STANDOUT); attron(A_BOLD); } printw("%5llu", stats.process_count->zombie); if(colors) { attroff(A_STANDOUT); attroff(A_BOLD); } move(3, 54); printw("%5llu", stats.process_count->sleeping); move(3, 74); printw("%5llu", stats.process_count->total); move(4, 54); printw("%5llu", stats.process_count->stopped); } if (stats.user_stats != NULL) { move(4,74); printw("%5lu", stats.user_entries); } if(colors) { attroff(COLOR_PAIR(6)); attron(COLOR_PAIR(5)); } if (stats.mem_stats != NULL) { /* Mem */ move(6, 12); printw("%7s", size_conv(stats.mem_stats->total)); move(7, 12); printw("%7s", size_conv(stats.mem_stats->used)); move(8, 12); printw("%7s", size_conv(stats.mem_stats->free)); } if (stats.swap_stats != NULL) { /* Swap */ move(6, 32); printw("%8s", size_conv(stats.swap_stats->total)); move(7, 32); printw("%8s", size_conv(stats.swap_stats->used)); move(8, 32); printw("%8s", size_conv(stats.swap_stats->free)); } /* VM */ if (stats.mem_stats != NULL && stats.mem_stats->total != 0) { float f = 100.00 * (float)(stats.mem_stats->used)/stats.mem_stats->total; if (colors && f > THRESHOLD_ALERT_MEM) { attron(A_STANDOUT); attron(A_BOLD); } else if (colors && f > THRESHOLD_WARN_MEM) { attron(A_BOLD); } move(6, 54); printw("%5.2f%%", f); if (colors) { attroff(A_STANDOUT); attroff(A_BOLD); attron(COLOR_PAIR(5)); } } if (stats.swap_stats != NULL && stats.swap_stats->total != 0) { float f = 100.00 * (float)(stats.swap_stats->used)/stats.swap_stats->total; if (colors && f > THRESHOLD_ALERT_SWAP) { attron(A_STANDOUT); attron(A_BOLD); } else if (colors && f > THRESHOLD_WARN_SWAP) { attron(A_BOLD); } move(7, 54); printw("%5.2f%%", f); if (colors) { attroff(A_STANDOUT); attroff(A_BOLD); attron(COLOR_PAIR(5)); } } if (stats.mem_stats != NULL && stats.swap_stats != NULL && stats.mem_stats->total != 0 && stats.swap_stats->total != 0) { move(8, 54); printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used+stats.swap_stats->used)/(stats.mem_stats->total+stats.swap_stats->total))); } if (stats.page_stats != NULL) { /* Paging */ move(6, 74); printw("%5llu", (stats.page_stats->systime)? (stats.page_stats->pages_pagein / stats.page_stats->systime): stats.page_stats->pages_pagein); move(7, 74); printw("%5llu", (stats.page_stats->systime)? (stats.page_stats->pages_pageout / stats.page_stats->systime) : stats.page_stats->pages_pageout); } if (colors) { attroff(COLOR_PAIR(5)); } line = 11; if (stats.disk_io_stats != NULL) { /* Disk IO */ disk_io_stat_ptr = stats.disk_io_stats; r=0; w=0; for(counter=0;counter<stats.disk_io_entries;counter++){ char name[12]; strncpy(name, disk_io_stat_ptr->disk_name, sizeof(name)); name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */ move(line, 0); printw("%s", name); move(line, 12); rt = (disk_io_stat_ptr->systime)? (disk_io_stat_ptr->read_bytes/disk_io_stat_ptr->systime): disk_io_stat_ptr->read_bytes; if(colors) { attron(COLOR_PAIR(4)); } printw("%7s", size_conv(rt)); r+=rt; move(line, 26); wt = (disk_io_stat_ptr->systime)? (disk_io_stat_ptr->write_bytes/disk_io_stat_ptr->systime): disk_io_stat_ptr->write_bytes; printw("%7s", size_conv(wt)); w+=wt; disk_io_stat_ptr++; line++; if(colors) { attroff(COLOR_PAIR(4)); } } line++; move(line, 0); printw("Total"); move(line, 12); if(colors) { attron(COLOR_PAIR(4)); } printw("%7s", size_conv(r)); move(line, 26); printw("%7s", size_conv(w)); if(colors) { attroff(COLOR_PAIR(4)); } } line = 11; if (stats.network_io_stats != NULL) { /* Network */ network_stat_ptr = stats.network_io_stats; for(counter=0;counter<stats.network_io_entries;counter++){ char name[20]; strncpy(name, network_stat_ptr->interface_name, sizeof(name)); name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */ move(line, 42); printw("%s", name); move(line, 62); rt = (network_stat_ptr->systime)? (network_stat_ptr->rx / network_stat_ptr->systime): network_stat_ptr->rx; if(colors) { attron(COLOR_PAIR(4)); } printw("%7s", size_conv(rt)); move(line, 72); wt = (network_stat_ptr->systime)? (network_stat_ptr->tx / network_stat_ptr->systime): network_stat_ptr->tx; printw("%7s", size_conv(wt)); network_stat_ptr++; line++; if(colors) { attroff(COLOR_PAIR(4)); } } line += 2; } if (stats.fs_stats != NULL) { /* Disk */ disk_stat_ptr = stats.fs_stats; for(counter=0;counter<stats.fs_entries;counter++){ char name[20]; strncpy(name, disk_stat_ptr->mnt_point, sizeof(name)); name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */ move(line, 42); printw("%s", name); move(line, 62); if(colors) { attron(COLOR_PAIR(2)); } printw("%7s", size_conv(disk_stat_ptr->avail)); move(line, 73); if(colors && 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)) > THRESHOLD_ALERT_DISK) { attron(A_STANDOUT); attron(A_BOLD); } else if (colors && 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)) > THRESHOLD_WARN_DISK) { attron(A_BOLD); } printw("%6.2f%%", 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail))); disk_stat_ptr++; line++; if(colors) { attroff(COLOR_PAIR(2)); attroff(A_STANDOUT); attroff(A_BOLD); } } } refresh(); }
void m4_draw_cmd(int xpos, int ypos) { move(ypos,xpos); int x; for(x=0;x<16;x++) printw("%X ",(unsigned int)mfb[x]); }
viewkill() /* Просмотр списка процессов и посылка сигналов /****************************************************************************/ { extern int use_keycap; /* признак использования своей настройки на клавиатуру */ extern int use_colors; /* признак использования цветов */ extern WINDOW *save_scr; /* окно для сохранения экрана */ extern int nosave_ask; /* признак "несохранения" экрана для ask */ extern chtype atr[]; /* раскраска */ extern unsigned char *fnd_str; /* строка для временных данных */ extern size_t fnd_len; /* место, выделенное для fnd_str*/ static char *dmenu="1+ - 2+ - 3+Next - 4+ - 5+ - 6+User - 7+Search- 8+Kill - 9+SigNum- 10+Quit "; static char *name="/tmp/ps_text_XXXXXX"; extern struct win win71; /* окно с запросом */ extern struct win win72; /* окно с ошибкой */ extern struct win win73; /* запрос номера посылаемого сигнала */ extern struct win win75; /* запрос имени пользователя */ extern char user_name[LOGNM_MAX]; /* имя пользователя */ extern uid_t user_eid; /* эффективный UserID или 0, если getuid()==0*/ FILE *file=NULL; int stop=0; /*признак окончания просмотра */ int ch; long nextseek; /* смещение на следующий экран*/ int x; int y; int x_beg=0; /* сдвиг выводимой части текста */ int lines=LINES-3; /* количество строк для вывода */ long firstline=0; /* номер первой выводимой строки файла*/ int find; /* признак поиска */ long srchlnseek; /* смещение до начала строки при поиске*/ long srchseek; /* смещение до символа после первого совпадения*/ long srchseeklast=(-1);/* смещение предыдущего поиска */ int srchln; /* номер строки при поиске */ int old_nosave; /* станое значение nosave_ask */ int i; int fd; /* дескриптор файла со списком процессов */ int len; /* максимальная длина выводимой части имени*/ int need_refr=1; /* признак необходимости перевывода списка*/ char *ptr; /* имя файла для вывода ошибки и для прохода по шаблону */ struct inp_lst inp_lst[2]; /* список ввода для inp_menu()*/ struct inp_lst usr_inp_lst[2]; /* список ввода для inp_menu()*/ extern long linesback(); /* поиск смещения в файле на несколько строк назад */ long *seeks=NULL; /* массив смещений в списке процессов*/ long seeks_len=0; /* количество элементов в seeks */ char *stats=NULL; /* признаки отметки */ int nlines=1; /* количество строк в файле списка процессов*/ int curline=0; /* номер текущей строки */ long nproc; /* номер процесса */ static int sig=15; /* номер сигнала */ static char usr_str[30]={'\0'};/* строка с именем пользователя для ps(1)*/ char *tmp_first; /* для запоминания первой строки*/ int pos; /* для работы с tmp_first */ int next_srch=0; /* признак продолжения поиска без запроса */ /*==========================================================================*/ tmp_first=malloc(COLS); tst_err_malloc(tmp_first,27); /* выполняет exit, если NULL*/ /* обычным пользователям по умолчанию показывать только свои */ if(user_eid && !usr_str[0]){ strncpy(usr_str, user_name, sizeof(usr_str)); usr_str[sizeof(usr_str)-1]='\0'; } usr_inp_lst[0].str=usr_str; /* usr_inp_lst[0].fld_len=...; выставит inp_menu()*/ usr_inp_lst[0].str_len=sizeof(usr_str); usr_inp_lst[0].npunkt=1; usr_inp_lst[1].str=NULL; /* признак конца списка для inp_menu()*/ inp_lst[0].str=(char *)fnd_str; /* inp_lst[0].fld_len=...; выставит inp_menu()*/ inp_lst[0].str_len=fnd_len; inp_lst[0].npunkt=1; inp_lst[1].str=NULL; /* признак конца списка для inp_menu()*/ mktemp(name); old_nosave=nosave_ask; nosave_ask=1; if(old_nosave==0){ delsoob(); overwrite(curscr, save_scr); } attrset(MAIN_PANEL_ATTR); mywbkgd(stdscr, MAIN_PANEL_ATTR); move(0,0); addch(' '); refresh(); clear(); #ifdef NCURSES mywbkgd(stdscr, MAIN_PANEL_ATTR); #endif move(0,0); addch(' '); attrset(MAIN_PANEL_ATTR); mywbkgd(stdscr, MAIN_PANEL_ATTR); refresh(); len=strlen(name); stop=0; while(!stop){ if(need_refr){ need_refr=0; if(file) fclose(file); switch(fork()) { case -1: endwin(); fprintf(stderr, "Can't fork\n"); exit(-1); break; case 0: /* порожденный процесс*/ fd=creat(name, 0777); if(fd<=0){ endwin(); fprintf(stderr, "Can't create file %s\n", name); exit(-1); } dup2(fd, 1); dup2(fd, 2); #ifdef FREEBSD execlp("ps", "ps", "-awwxo", "user pid ppid stat start tty command", NULL); #else if(usr_str[0]) { /* задано имя пользователя для которого смотрятся процессы */ execlp("ps", "ps", "-f", "-u", usr_str, NULL); }else{ execlp("ps", "ps", "-ef", NULL); } #endif fprintf(stderr, "Can't exec to ps\n"); exit(-1); break; default: wait(NULL); break; } if(!(file=fopen(name, "r"))) { /* не открывается файл */ endwin(); fprintf(stderr, "Can't open file %s\n", name); exit(-1); } i=1; pos=0; /* первую строку читаем в tmp_first */ do{ if( (tmp_first[pos] = getc(file)) == '\n') { i++; }else{ if(pos<COLS-1 && !feof(file)) pos++; } }while(i==1 && !feof(file)); tmp_first[pos] = '\0'; while(!feof(file)){ if(getc(file)=='\n') i++; } nlines=i-2; if(i>seeks_len){ if(seeks_len){ free(seeks); free(stats); } seeks_len=i-1; seeks=malloc((i-1)*sizeof(long)); tst_err_malloc(seeks,25); /* выполняет exit, если NULL*/ stats=malloc((i-1)*sizeof(char)); tst_err_malloc(stats,26); /* выполняет exit, если NULL*/ } rewind(file); i=0; while(!feof(file)){ if(getc(file)=='\n'){ seeks[i]=ftell(file); stats[i]='\0'; i++; } } /* проверить корректность текущей строки и первой строки */ if(curline>nlines-1){ curline=nlines-1; if(curline<firstline) firstline=curline; } } mywbkgd(stdscr, MAIN_PANEL_ATTR); /* Заголовок просмотра */ attrset(MAIN_PANEL_TOP_ATTR); move(0,0); if(x_beg){ printw(" Shift: %d", x_beg); } if(firstline>=0) { /* известен номер первой строки*/ printw(" Line: %d", curline+1); }else{ printw(" Line: ?"); } if(usr_str[0]) { /* показываются процессы выбранного пользователя*/ addstr(" User: "******" All users"); } getyx(stdscr, y, x); while(x++<COLS) addch(' '); attrset(MAIN_PANEL_ATTR); /* вывод первой строки */ move(FIRST-1, 0); addstr(tmp_first); fseek(file, seeks[firstline], 0); y=FIRST; while(feof(file)==0 && ferror(file)==0 && y<FIRST+lines){ x=0; if(y-FIRST==curline-firstline) attrset(MAIN_PANEL_PTR_ATTR); do{ ch=getc(file); if(feof(file)==0 && ferror(file)==0){ if((x-x_beg)==COLS) { attrset(MAIN_PANEL_PTR_ATTR); move(y, COLS-1); addch('>'); attrset(MAIN_PANEL_ATTR); }else{ if(ch=='\t'){ x=((x+8)/8)*8-1; ch=' '; } if((x-x_beg)<COLS && ch!='\n'){ if(x>=x_beg){ move(y, (x-x_beg)); if(ch<' ' || ch==0177) { attrset(MAIN_PANEL_PTR_ATTR); ch=CTRL(ch) +'@'; addch(ch); attrset(MAIN_PANEL_ATTR); }else{ addch(ch); } } } } x++; } }while(ch!='\n' && feof(file)==0 && ferror(file)==0); if(y-FIRST==curline-firstline){ /*дописать конец текущей строки*/ if(x) x--; /* при выводе в конце цикла x++ */ if(x<x_beg) { /* эта строка при таком смещении совсем не выводилась*/ x=x_beg; } x-=x_beg; /* теперь это координата в окне */ move(y, x); while(x<COLS){ addch(' '); x++; } attrset(MAIN_PANEL_ATTR); } y++; } /* нарисовать строку с клавишами */ move(LINES-1, 0); attrset(BOTT_LINE_KEYS_ATTR); for(ptr=dmenu;*ptr;ptr++){ switch(*ptr) { case '+': attrset(BOTT_LINE_TEXT_ATTR); break; case '-': attrset(BOTT_LINE_KEYS_ATTR); break; default: addch(*ptr); break; } } refresh(); if(ferror(file)) { /* такое бывает с Symlink на каталог */ ch=ESC; }else{ if(use_keycap) { /*использовать свою настройку на клавиатуру */ ch=getkey_(); }else{ /* использовать стандартные средства curses */ ch=getch(); } } switch(ch) { case K_SD: /*стрелка вниз*/ case KEY_DOWN: /*стрелка вниз*/ srchseeklast=(-1); if(curline<nlines-1){ curline++; if(curline>firstline+lines-1) firstline++; } break; case K_SU: /*стрелка вверх*/ case KEY_UP: /*стрелка вверх*/ srchseeklast=(-1); if(curline>0) curline--; if(curline<firstline) firstline--; break; case K_PAGE_UP: case KEY_PPAGE: srchseeklast=(-1); if(curline>0){ curline-=lines-2; if(curline<0) curline=0; firstline-=lines-2; if(firstline<0) firstline=0; } break; case K_PAGE_DN: case KEY_NPAGE: srchseeklast=(-1); if(curline<nlines-1){ curline+=lines-2; if(curline>nlines-1) curline=nlines-1; firstline+=lines-2; if(firstline>nlines-(lines-2)) firstline=nlines-(lines-2); if(firstline<0) firstline=0; } break; case K_HOME: case KEY_HOME: srchseeklast=(-1); curline=0; firstline=0; break; case K_END: case KEY_END: srchseeklast=(-1); curline=nlines-1; firstline=nlines-(lines-2); if(firstline<0) firstline=0; break; case K_SR: /* Стрелка вправо */ case KEY_RIGHT: /* Стрелка вправо */ srchseeklast=(-1); x_beg++; break; case K_SL: /* Стрелка влево */ case KEY_LEFT: /* Стрелка влево */ srchseeklast=(-1); if(x_beg) x_beg--; break; case K_F6: /* User */ case KEY_F(6): if(inp_menu(usr_inp_lst, &win75, 1, 0)==1 && usr_str[0]) { /* нужно только usr_str[0] */ }else{ usr_str[0] = '\0'; } srchseeklast=(-1); curline=0; firstline=0; need_refr++; break; case K_F3: /* продолжение поиска */ case KEY_F(3): next_srch=1; case K_F7: /* поиск */ case KEY_F(7): if( (next_srch && fnd_str[0]) || (inp_menu(inp_lst, &win71, 1, 0)==1 && fnd_str[0])){ srchlnseek=seeks[curline]; srchln=curline+1; find=0; fseek(file, srchlnseek, 0); while(feof(file)==0 && ferror(file)==0 && find==0){ ch=getc(file); if(!feof(file)){ if(ch=='\n'){ srchln++; srchlnseek=ftell(file); } if( cmp_chrs(ch, fnd_str[0], 0)==0 ){ srchseek=ftell(file); ptr=(char*)fnd_str; if(srchseeklast<srchseek){ /* -1 или предыдущий */ while(feof(file)==0 && *ptr && cmp_chrs(ch, *ptr, 0)==0 ){ ch=getc(file); ptr++; } } if(*ptr=='\0') { /* полное соответствие */ find=1; if(srchseek-srchlnseek>=COLS-2) { /* образец не виден на экране */ x_beg=srchseek-srchlnseek-(COLS/2); }else{ x_beg=0; } srchseeklast=srchseek; curline=srchln-1; if(curline>firstline+lines-1 || curline<firstline) firstline=curline; }else{ /* несоответствие в каком-то (не первом) символе*/ fseek(file, srchseek, 0); /* продолжить поиск с места, где найден совпад.символ*/ } } } } if(!find){ ask(&win72, 2, 0); } } next_srch=0; break; case K_F8: /* посылка сигнала */ case KEY_F(8): need_refr++; fseek(file, seeks[curline], 0); do{ /* пропустить ведущие пробелы*/ ch=getc(file); }while(isspace(ch) && feof(file)==0 && ch!='\n'); /* пропустить имя пользователя */ while(isspace(ch)==0 && feof(file)==0 && ch!='\n'){ ch=getc(file); } /* пропустить пробелы после имени */ while(isspace(ch) && feof(file)==0 && ch!='\n'){ ch=getc(file); } if(isdigit(ch) && feof(file)==0 && ch!='\n') { /* действительно какой-то номер */ fseek(file, -1L, 1); /* вернуться на символ назад */ nproc=(-1); fscanf(file,"%ld", &nproc); if(nproc>=0 && nproc!=getpid()) { if(kill((pid_t)nproc, sig)) beep(); }else{ beep(); beep(); beep(); } }else{ beep(); beep(); beep(); } break; case K_F9: /* посылка сигнала */ case KEY_F(9): if((i=ask(&win73, sig, VERT))>0) sig=i; break; case K_ESC: /*конец работы*/ case ESC: /*конец работы*/ case K_F0: case KEY_F(0): stop++; break; case K_REFRESH: /* клавиша перевывода экрана */ case REFRESH: /* клавиша перевывода экрана */ clearok(stdscr, TRUE); case REREAD: /* клавиша пересчитывания каталога */ case K_REREAD: need_refr++; break; default: beep(); break; } } /* while !stop */ fclose(file); unlink(name); mywbkgd(stdscr, A_NORMAL); wattrset(stdscr, A_NORMAL); /* #ifdef sun */ /* из-зи ошибок в curses или в описании терминала очистка вып-ся не тем цветом*/ move(0,0); addch(' '); refresh(); /* #endif */ clear(); #ifdef NCURSES mywbkgd(stdscr, MAIN_PANEL_ATTR); #endif refresh(); overwrite(save_scr, stdscr); #ifdef FREEBSD touchwin(stdscr); #endif clearok(stdscr, TRUE); refresh(); if(old_nosave==0) nosave_ask=0; if(seeks_len){ free(seeks); free(stats); } free(tmp_first); }
static void display_headings(void) { int line; move(0,0); printw("Hostname :"); move(0,27); printw("Uptime : "); move(0,54); printw("Date : "); /* Load */ move(2,0); printw("Load 1 :"); move(3,0); printw("Load 5 :"); move(4,0); printw("Load 15 :"); /* CPU */ move(2,21); printw("CPU Idle :"); move(3,21); printw("CPU System:"); move(4,21); printw("CPU User :"******"Running :"); move(3, 42); printw("Sleeping :"); move(4, 42); printw("Stopped :"); move(2, 62); printw("Zombie :"); move(3, 62); printw("Total :"); move(4, 62); printw("No. Users :"); /* Mem */ move(6, 0); printw("Mem Total :"); move(7, 0); printw("Mem Used :"); move(8, 0); printw("Mem Free :"); /* Swap */ move(6, 21); printw("Swap Total:"); move(7, 21); printw("Swap Used :"); move(8, 21); printw("Swap Free :"); /* VM */ move(6, 42); printw("Mem Used :"); move(7, 42); printw("Swap Used :"); move(8, 42); printw("Total Used:"); /* Paging */ move(6, 62); printw("Paging in :"); move(7, 62); printw("Paging out:"); /* Disk IO */ move(10,0); printw("Disk Name"); move(10,15); printw("Read"); move(10,28); printw("Write"); line = 10; if (stats.network_io_stats != NULL) { /* Network IO */ move(line, 42); printw("Network Interface"); move(line, 67); printw("rx"); move(line, 77); printw("tx"); line += 2 + stats.network_io_entries; } move(line, 42); printw("Mount Point"); move(line, 65); printw("Free"); move(line, 75); printw("Used"); refresh(); }
int control_orientation_update(desCntrl_T & desCntrl, motInfo & mot, const double & curTime) { //static gazebo::math::Quaternion quarDes; //const gazebo::msgs::IMU & IMU_data_ptr static pidInfo motRoll; // X static pidInfo motYaw; // Z static pidInfo motPitch; // Y static double prevTime = 0; double dt; double tMult; double errYawLim = 0.1; dt = curTime - prevTime; //update_orientation(); //quarDes.SetFromEuler(0,0,0); tMult = std::sqrt( std::pow(desCntrl.thrust,2) + std::pow(body_orientation.x,2) + std::pow(body_orientation.y,2)); desCntrl.errRoll = desCntrl.roll - body_orientation.GetRoll(); desCntrl.errPitch = desCntrl.pitch - body_orientation.GetPitch(); desCntrl.errYaw = desCntrl.yaw - body_orientation.GetYaw(); //#warning "Yaw Hack In Place!" // desCntrl.errYaw = 0; // Yaw Hack if (desCntrl.errYaw > errYawLim) { desCntrl.errYaw = errYawLim; } else if (desCntrl.errYaw < -1*errYawLim) { desCntrl.errYaw = -1*errYawLim; } //clear(); mvprintw(0,0,"Yaw: %f\n",body_orientation.GetYaw()); printw("errYaw: %f\n",desCntrl.errYaw); refresh(); //vecDes. // motRoll.curVal = -1*motRoll.kp*IMU_data_ptr->angular_velocity().x() + // -1*motRoll.ki*(IMU_data_ptr->angular_velocity().x()*dt + motRoll.preVal) + // -1*motRoll.kd*(IMU_data_ptr->angular_velocity().x() - motRoll.preVal)/dt; // motRoll.curVal = 100*motRoll.kp*(desCntrl->errRoll);// + //motRoll.ki*(IMU_data_ptr->angular_velocity().x()*dt + motRoll.preVal) + //motRoll.kd*(IMU_data_ptr->angular_velocity().x() - motRoll.preVal)/dt; // motPitch.curVal = -1*motPitch.kp*IMU_data_ptr->angular_velocity().y() + // -1*motPitch.ki*(IMU_data_ptr->angular_velocity().y()*dt + motPitch.preVal) + // -1*motPitch.kd*(IMU_data_ptr->angular_velocity().y() - motPitch.preVal)/dt; // // motYaw.curVal = -1*motYaw.kp*IMU_data_ptr->angular_velocity().z() + // -1*motYaw.ki*(IMU_data_ptr->angular_velocity().z()*dt + motYaw.preVal) + // -1*motYaw.kd*(IMU_data_ptr->angular_velocity().z() - motYaw.preVal)/dt; // // Calc integral motRoll.intSum = motRoll.intSum + desCntrl.errRoll*dt; motPitch.intSum = motPitch.intSum + desCntrl.errPitch*dt; motYaw.intSum = motYaw.intSum + desCntrl.errYaw*dt; // Calc Derivative motRoll.derDiff = (desCntrl.errRoll - motRoll.preVal)/dt; motPitch.derDiff = (desCntrl.errPitch - motPitch.preVal)/dt; motYaw.derDiff = (desCntrl.errYaw - motYaw.preVal)/dt; motRoll.curVal = 1*0.1*4*(50*motRoll.kp*(desCntrl.errRoll) + 0*10*motRoll.ki*motRoll.intSum + 0*3*10*motRoll.kd*motRoll.derDiff); motPitch.curVal = 1*0.1*4*(50*motPitch.kp*(desCntrl.errPitch) + 0*10*motPitch.ki*motPitch.intSum + 0*3*10*motPitch.kd*motPitch.derDiff); motYaw.curVal = 2*0.1*.05*(50*motYaw.kp*(desCntrl.errYaw) + 0*10*motYaw.ki*motYaw.intSum + 0*10*motYaw.kd*motYaw.derDiff); // Save err values motRoll.preVal = desCntrl.errRoll; motPitch.preVal = desCntrl.errPitch; motYaw.preVal = desCntrl.errYaw; // ^x // | // y <-oz // // 2 // | // 4---+---3 // | // 1 // // + Roll -> -y -> -M3, +M4 // + Pitch -> +x -> -M2, +M1 // + Yaw -> CC mot.mot1 = 1 * tMult + 0 * motRoll.curVal + 1 * motYaw.curVal + 1 * motPitch.curVal; mot.mot3 = 1 * tMult + -1 * motRoll.curVal + -1 * motYaw.curVal + 0 * motPitch.curVal; mot.mot2 = 1 * tMult + 0 * motRoll.curVal + 1 * motYaw.curVal + -1 * motPitch.curVal; mot.mot4 = 1 * tMult + 1 * motRoll.curVal + -1 * motYaw.curVal + 0 * motPitch.curVal; if(mot.mot1 < 0) { mot.mot1 = 0; } if(mot.mot2 < 0) { mot.mot2 = 0; } if(mot.mot3 < 0) { mot.mot3 = 0; } if(mot.mot4 < 0) { mot.mot4 = 0; } return 0; }
void start(std::string filename, bool saveprog, bool savestats,bool usetree) { if(!progrunning) return; clear(); Textstream ts; ts.open_file(filename); if(saveprog) ts.loadposition(); Wordtree errortree; std::string treefilename="wordstat.stat"; if(usetree) errortree.restorefromFile(treefilename); //Variables bool timerunning = false; int keystrokes = 0; int wrongstrokes = 0; std::chrono::high_resolution_clock::time_point starttime; std::chrono::high_resolution_clock::time_point curtime; int elapsedseconds = 0; float keysperminute = 0.0; float errorpercent = 0.0; Intstring line; int clength = 0; int tprog = 0; bool * correctness = new bool; bool lastwordwrong = false; std::string typedword; int yval = 0; std::mutex printingmutex; //Lambdas auto add_widech = [&](int c){ char bytes[5]; for(unsigned char a = 0; a < 5 ; ++a) bytes[a] = 0; felocale::to_utf8(c,bytes); printw(bytes); }; auto updatestates = [&](){ if(timerunning) { curtime = std::chrono::high_resolution_clock::now(); elapsedseconds = std::chrono::duration_cast <std::chrono::seconds> (curtime - starttime) .count(); } if(elapsedseconds > 0) keysperminute = (((double)keystrokes) * 60 / ((double)elapsedseconds)); errorpercent = (float)(wrongstrokes * 100) / (float)keystrokes; }; auto printstatus = [&](){ printingmutex.lock(); if(timerunning) { updatestates(); move(0,0); clrtoeol(); std::string s = "Seconds elapsed: "+std::to_string(elapsedseconds)+" Error Ratio:"+std::to_string(errorpercent)+'%' +" Keystrokes per Minutes:"+std::to_string(keysperminute); mvprintw(0,0,s.c_str()); } else { mvprintw(0,0,"Begin Typing to start the time measurement...."); } refresh(); printingmutex.unlock(); }; auto nextline = [&](){ clear(); std::string tstring = ts.nextline(); line = tstring; if(line.empty()){ clear(); mvprintw(1,0,"You reached The End of the line..."); printstatus(); timerunning = false; progrunning = false; } else { if(clength < line.length()) { delete[] correctness; correctness = new bool [line.length()]; clength = line.length(); } tprog = 0; yval = 2; } }; auto printline = [&](){ if( !progrunning ) return; printingmutex.lock(); move(yval,0); int x; for(x = 0; x < tprog; ++x) { color_set(1,0); if(!correctness[x]) color_set(3,0); add_widech(line.at(x)); } if(x < line.length()) { color_set(2,0); add_widech(line.at(x)); ++x; } color_set(1,0); for(; x < line.length();++x) add_widech(line.at(x)); //Add a pilcrow at the end if(tprog == line.length()) color_set(2,0); add_widech(0xb6); color_set(1,0); printingmutex.unlock(); }; auto doscreen = [&](){ printstatus(); printline(); refresh(); }; auto feedtree = [&](int c){ //Do the wordtree magic if(usetree) { if(line.at(tprog) == ' ' || tprog == line.length()) { Intstring* word = line.getWordBefore(tprog); std::string uword = felocale::convertstring(*word); if(lastwordwrong) errortree.insertError(uword,typedword); else errortree.insert(uword); typedword.clear(); lastwordwrong=false; delete word; } else if(c != 0){ char bytes[5]; for(unsigned char d = 0; d < 5; ++d) bytes[d] = 0; char count = felocale::to_utf8(c,bytes); for(unsigned char a = 0; a < count; ++a) typedword.append(bytes); } } }; auto comparechar = [&](int c){ feedtree(c); ++keystrokes; if(tprog == line.length()) return; if(c == line.at(tprog)) correctness[tprog] = true; else{ lastwordwrong = true; correctness[tprog] = false; ++wrongstrokes; } ++tprog; }; auto get_widech = [&]() { int a = getch(); //UNICODE char! if( (a & 0x80) == 0x80) { int c = 0; char bytecount = 0; char marker = 0x40; while ((a & marker) == marker) { marker >>= 1; ++bytecount; } //move the bits from the first byte over char cm = 1; char mask = 0; while(cm != marker) { mask |= cm; cm <<= 1; } c |= (a & mask); //move the remaining bytes in. //the length is cut appropiately for(int a = 0; a<bytecount; ++a) { c <<= 6; c |= (getch() & 0x3f); } a = c; } return a; };
void playerDie(player* pl, player* w){ printw("You are dead\n"); endGame(pl, w); }
static cb_ret_t layout_callback (struct Dlg_head *h, dlg_msg_t msg, int parm) { switch (msg) { case DLG_DRAW: /*When repainting the whole dialog (e.g. with C-l) we have to update everything*/ common_dialog_repaint (h); old_first_panel_size = -1; old_horizontal_split = -1; old_output_lines = -1; attrset (COLOR_HOT_NORMAL); update_split (); dlg_move (h, 6, 13); addch ('='); if (console_flag){ if (old_output_lines != _output_lines){ old_output_lines = _output_lines; attrset (COLOR_NORMAL); dlg_move (h, 9, 16 + first_width); addstr (output_lines_label); dlg_move (h, 9, 10 + first_width); printw ("%02d", _output_lines); } } return MSG_HANDLED; case DLG_POST_KEY: _filetype_mode = check_options [8].widget->state & C_BOOL; _permission_mode = check_options [7].widget->state & C_BOOL; _equal_split = check_options [6].widget->state & C_BOOL; /* _menubar_visible = check_options [5].widget->state & C_BOOL; */ /* _command_prompt = check_options [4].widget->state & C_BOOL; */ /* _keybar_visible = check_options [2].widget->state & C_BOOL; */ _message_visible = check_options [1].widget->state & C_BOOL; /* _xterm_title = check_options [0].widget->state & C_BOOL; */ if (console_flag){ int minimum; if (_output_lines < 0) _output_lines = 0; height = LINES - _keybar_visible - _command_prompt - _menubar_visible - _output_lines - _message_visible; minimum = MINHEIGHT * (1 + _horizontal_split); if (height < minimum){ _output_lines -= minimum - height; height = minimum; } } else { height = LINES - _keybar_visible - _command_prompt - _menubar_visible - _output_lines - _message_visible; } if (_horizontal_split != radio_widget->sel){ _horizontal_split = radio_widget->sel; if (_horizontal_split) _first_panel_size = height / 2; else _first_panel_size = COLS / 2; } update_split (); if (console_flag){ if (old_output_lines != _output_lines){ old_output_lines = _output_lines; attrset (COLOR_NORMAL); dlg_move (h, 9, 10 + first_width); printw ("%02d", _output_lines); } } return MSG_HANDLED; default: return default_dlg_callback (h, msg, parm); } }
void FileBrowser::FileBrowserWindow::showWelcomeScreen() { move(y / 2, x / 2); printw("WELCOME"); refresh(); }
int main (void) { /* * Defimovanie lokálnych premenných funkcie */ WINDOW *my_win, *info_win, *smyle_win; int startx, starty, w_width, w_height; int width, height; int poloha_x, poloha_y; int old_x, old_y; int oznacil; short zacal; int min; int ch; char *dopln; int i, j, u, z; //long start_time, end_time; /* Inicializovanie/zapnutie curses módu */ initscr(); /* inicializácie konfigurácie */ config_init(); /* Kontrola či terminál podporuje farby */ if (has_colors() == FALSE) { endwin(); printf("Vas terminal nepodporuje farby!\n"); exit(1); } /* * Aktivácia pomocných funkcií pre curses mód * * raw - vypnutie bufferovania riadkov (disable line buffering) * * noecho - po stlačení kláves sa nebudú vypisovať * curs_set - vypnutie kurzoru (schovanie) * start_color - zapnutie podpory farieb * keypad - aktivácia F kláves (F1, F2...) */ raw(); cbreak(); noecho(); //nodelay(stdscr, true); curs_set(0); use_default_colors(); start_color(); keypad(stdscr, TRUE); /* Inicializovanie generátoru náhodných čísel */ srand(time(0)); /* * Inicializovanie párov farieb * * 0 - základný systémový/všeobecný * 1 - zvýraznenie vybraného políčka * 2 - farba neuhádnutej míny * 3 - farba uhádnutej míny * 4 - farba zle označenej míny * * 5 - farba čísla 1 * 6 - farba čísla 2 * 7 - farba čísla 3 * 8 - farba čísla 4 * 9 - farba čísla 5 * 10 - farba čísla 6 * 11 - farba čísla 7 * 12 - farba čísla 8 */ init_pair(1, COLOR_WHITE, COLOR_RED); init_pair(2, COLOR_YELLOW, COLOR_DEFAULT); init_pair(3, COLOR_GREEN, COLOR_DEFAULT); init_pair(4, COLOR_RED, COLOR_DEFAULT); init_pair(5, COLOR_BLUE, COLOR_DEFAULT); init_pair(6, COLOR_GREEN, COLOR_DEFAULT); init_pair(7, COLOR_RED, COLOR_DEFAULT); init_pair(8, COLOR_CYAN, COLOR_DEFAULT); init_pair(9, COLOR_MAGENTA, COLOR_DEFAULT); init_pair(10, COLOR_YELLOW, COLOR_DEFAULT); init_pair(11, COLOR_BLACK, COLOR_DEFAULT); init_pair(12, COLOR_WHITE, COLOR_DEFAULT); /* definícia menovky restart, sem sa presunieme pomocou goto pre reštart hry */ restart: /* Zistí rozmery terminálu */ getmaxyx(stdscr, row, col); /* Priradenie hodnôt premenným */ min = miny_config.miny; width = 30; height = 16; w_height = height + 2; w_width = width + 2; oznacil = 0; poloha_x = 1; poloha_y = 1; zacal = 0; //start_time = time(NULL); //end_time = 0; /* Pridelenie pamate podľa konfigurácie */ pridel_pamet(width, height); /* Vynulovanie hodnôt v poliach... */ for (i = 0; i < width; i++) { for (j = 0; j < height; j++) { min_pole[i][j] = 0; uhadol[i][j] = 0; pole_hodnot[i][j] = 0; } } /* vycentruje hru na obrazovke */ if (miny_config.vycentruj == 1) { starty = (row - w_height) / 2; startx = (col - (w_width * 2 + 2)) / 2; } else { /* položí na ľavú stranu a mierne odsadí od okrajov */ starty = 1; startx = 2; } /* Vypísať na reálnu obrazovku (Print to real screen) */ refresh(); printw("Copyright © 2013 Juraj Oravec\n"); /* Vytvorenie curses "okien" */ my_win = create_newwin(w_height, w_width, starty, startx); info_win = create_newwin(w_height, w_width, starty, startx + 34); smyle_win = create_newwin(6, 10, starty + 11, startx + 34 + 12); /* "odstránenie" rámiku okolo okna so smajlíkom */ wborder(smyle_win, ' ', ' ', ' ',' ',' ',' ',' ',' '); wrefresh(smyle_win); /* Výpis do informačného okna */ mvwprintw(info_win, 1, (w_width - strlen(NAZOV)) / 2, NAZOV); mvwprintw(info_win, 3, 2, "Pocet min: %d", min); wattron(info_win, A_BOLD); mvwprintw(info_win, 3, 25, " 0/%d", min); wattroff(info_win, A_BOLD); mvwprintw(info_win, 4, 2, "Minove pole: %d x %d", width, height); /* vypísať polohu kurzoru len ak je to povolené v konfigurácii */ if (miny_config.info_poloha == 1) mvwprintw(info_win, 5, 2, "Poloha kurzoru: X: %d, Y: %d", poloha_x, poloha_y); /* Refresh/Obnova informačného okna, aby sa zobrazilo čo sme vypoísali */ wrefresh(info_win); /* Zobrazenie smajlíka */ smajlik_init(smyle_win); /* * vyber_min -> Základná poloha kurzoru v ľavom hornom rohu * mini_rozhadz -> Náhodne rozmiestni míny po hracom poli */ vyber_min(my_win, width, height, poloha_x, poloha_y, 0, 0); mini_rozhadz(0, width, height, min); /* * Nekonečný cyklus pre zisťovanie stlačenia kláves * Program sa ukonćí funkciou exit() po stlačení 'q' */ while ( ( ch = getch() ) ) { /* Uloženie starej polohy kurzoru pre ďalśie spracovanie */ old_x = poloha_x; old_y = poloha_y; /* * switch/prepínač pre "kontrolu" stlačených kláves * a podľa toho vykoná nejakú akciu... */ switch (ch) { /* * Stlačenie šípky vľavo, * nasleduje posun kurzoru vľavo, ak je to možné */ case KEY_LEFT: if (hra == 1) { if (poloha_x > 1) poloha_x--; } break; /* * Stlačenie šípky vpravo, * nasleduje posun kurzoru vpravo, ak je to možné */ case KEY_RIGHT: if (hra == 1) { if (poloha_x < width) poloha_x++; } break; /* * Stlačenie šípky hore, * nasleduje posun kurzoru hore, ak je to možné */ case KEY_UP: if (hra == 1) { if (poloha_y > 1) poloha_y--; } break; /* * Stlačenie šípky dole, * nasleduje posun kurzoru dole, ak je to možné */ case KEY_DOWN: if (hra == 1) { if (poloha_y < height) poloha_y++; } break; case 'a': /* * Nástroj pre programátora, testera... * označí všetky prázdne polia v hre */ if (miny_config.vyvojar == 1) { for (u = 0; u < width; u++) for (z = 0; z < height; z++) { if (min_pole[u][z] == 0) vyber_dopln((u + 1), (z + 1), width, height, my_win); } wrefresh(my_win); } break; /* Označenie míny */ case 'm': if (hra == 1) { /* Kontrola neoznaćeného políčka */ if (uhadol[(poloha_x - 1)][(poloha_y - 1)] != 1 && uhadol[(poloha_x - 1)][(poloha_y - 1)] != 2) { /* Vypísanie označenia míny, refresh hracieho poľa, uloženie označenia */ mvwprintw(my_win, poloha_y, poloha_x, "*"); wrefresh(my_win); uhadol[(poloha_x - 1)][(poloha_y - 1)] = 2; oznacil++; vypis_oznacene(info_win, oznacil, min); } else if (uhadol[(poloha_x - 1)][(poloha_y - 1)] == 2) { /* Ak je mína už označená tak bude označenie zrušené */ mvwprintw(my_win, poloha_y, poloha_x, " "); wrefresh(my_win); uhadol[(poloha_x - 1)][(poloha_y - 1)] = 0; oznacil--; vypis_oznacene(info_win, oznacil, min); } } break; /* Ukončenie programu s kódom 0 - správne ukončenie */ case 'q': endwin(); exit(0); break; /* reštartovanie hry */ case 'r': if (miny_config.vyvojar == 1) { /* príprava na reštart... */ restart_prepare (my_win, info_win, smyle_win, width, height); /* prestavenie identifikátoru stavu hry na play/hrať/1/OK... */ hra = 1; /* preskočenie na menovku restart */ goto restart; } break; /* Medzera - Výber políčka na hracom poli */ case ' ': if (hra == 1) { /* * Pokiaľ je aktívna voľba cisty_start tak sa bude mínové pole generovař pokiaľ * na daných súradniciach bude mína, keď nebude, tak prestane. */ if (miny_config.cisty_start == 1 && zacal == 0) { if (miny_config.nulovy_start == 1) { while (TRUE) { for (u = 0; u < width; u++) { for (z = 0; z < height; z++) { /* Vymazanie mín z hracieho poľa */ min_pole[u][z] = 0; } } mini_rozhadz(0, width, height, min); if (min_okolo(poloha_x, poloha_y, width, height) == 0 && min_pole[(poloha_x - 1)][(poloha_y - 1)] == 0) break; } } else if (min_pole[(poloha_x - 1)][(poloha_y - 1)] == 1) { while (TRUE) { for (u = 0; u < width; u++) { for (z = 0; z < height; z++) { /* Vymazanie mín z hracieho poľa */ min_pole[u][z] = 0; } } mini_rozhadz(0, width, height, min); if (min_pole[(poloha_x - 1)][(poloha_y - 1)] == 0) break; } } zacal = 1; } /* Ak trafil na mínu */ if (min_pole[(poloha_x - 1)][(poloha_y - 1)] == 1) { if (uhadol[(poloha_x - 1)][(poloha_y - 1)] == 0) { /* zobrazí všetky míny, vypíše zásah */ mini_zobraz(my_win, width, height); /* Zobrazí smutného smajlíka */ smajlik (smyle_win, 2); /* zastaví hru, teda zmení stav na koniec/stop/KO/... */ hra = 0; } } else { /* * Ak trafil na prázdne pole * vypíše koľko mín sa nachádza v okolí toho poľa */ vyber_dopln(poloha_x, poloha_y, width, height, my_win); /* Refresh okien */ /*wrefresh(info_win);*/ wrefresh(my_win); /* kontrola dokončenia hry */ if (dokoncil(width, height) == 1) { /* ak boli označené všetky "prázdne polia" vypíše všetky míny na zeleno, správne vyplnenie.. */ mini_zobraz(my_win, width, height); oznacil = min; vypis_oznacene(info_win, oznacil, min); //end_time = time(NULL); hra = 0; } } } else if (hra == 0) { /* príprava na reštart... */ restart_prepare (my_win, info_win, smyle_win, width, height); /* prestavenie identifikátoru stavu hry na play/hrať/1/OK... */ hra = 1; zacal = 0; /* preskočenie na menovku restart */ goto restart; } break; } /* Posunutie kurzora, ak sa zmenila jeho poloha */ if (poloha_x != old_x || poloha_y != old_y) vyber_min(my_win, width, height, poloha_x, poloha_y, old_x, old_y); /* pokiaľ je aktívne vypisovanie polohy... */ if (miny_config.info_poloha == 1) { /* Doplnenie prázdneho miesta za súradnice kurzoru */ if (poloha_x < 10 && poloha_y < 10) dopln = " "; else if (poloha_x < 10 || poloha_y < 10) dopln = " "; /* Výpis polohy kurzoru */ mvwprintw(info_win, 5, 2, "Poloha kurzoru: X: %d, Y: %d%s", poloha_x, poloha_y, dopln); } /* refreš info okna */ wrefresh(info_win); } /* Ukončenie curses modu */ endwin(); /* Ukončenie programu */ return 0; }
void resize_handler(int sig) { printw("window resized\n"); refresh(); }
/** * Process events, with optional wait */ static errr Term_xtra_gcu_event(int v) { int i, j, k, mods=0; if (v) { /* Wait for a keypress; use halfdelay(1) so if the user takes more */ /* than 0.2 seconds we get a chance to do updates. */ halfdelay(2); i = getch(); while (i == ERR) { i = getch(); idle_update(); } cbreak(); } else { /* Do not wait for it */ nodelay(stdscr, true); /* Check for keypresses */ i = getch(); /* Wait for it next time */ nodelay(stdscr, false); /* None ready */ if (i == ERR) return (1); if (i == EOF) return (1); } /* Not sure if this is portable to non-ncurses platforms */ #ifdef USE_NCURSES if (i == KEY_RESIZE) { /* wait until we go one second (10 deci-seconds) before actually * doing the resizing. users often end up triggering multiple * KEY_RESIZE events while changing window size. */ halfdelay(10); do { i = getch(); } while (i == KEY_RESIZE); cbreak(); do_gcu_resize(); if (i == ERR) return (1); } #endif /* uncomment to debug keycode issues */ #if 0 printw("key %d", i); wrefresh(stdscr); #endif /* This might be a bad idea, but... * * Here we try to second-guess ncurses. In some cases, keypad() mode will * fail to translate multi-byte escape sequences into things like number- * pad actions, function keys, etc. So we can hardcode a small list of some * of the most common sequences here, just in case. * * Notice that we turn nodelay() on. This means, that we won't accidentally * interpret sequences as valid unless all the bytes are immediately * available; this seems like an acceptable risk to fix problems associated * with various terminal emulators (I'm looking at you PuTTY). */ if (i == 27) { /* ESC */ nodelay(stdscr, true); j = getch(); switch (j) { case 'O': { k = getch(); switch (k) { /* PuTTY number pad */ case 'q': i = '1'; break; case 'r': i = '2'; break; case 's': i = '3'; break; case 't': i = '4'; break; case 'u': i = '5'; break; case 'v': i = '6'; break; case 'w': i = '7'; break; case 'x': i = '8'; break; case 'y': i = '9'; break; /* no match */ case ERR: break; default: ungetch(k); ungetch(j); } break; } /* no match */ case ERR: break; default: ungetch(j); } nodelay(stdscr, false); } #ifdef KEY_DOWN /* Handle arrow keys */ switch (i) { case KEY_DOWN: i = ARROW_DOWN; break; case KEY_UP: i = ARROW_UP; break; case KEY_LEFT: i = ARROW_LEFT; break; case KEY_RIGHT: i = ARROW_RIGHT; break; case KEY_DC: i = KC_DELETE; break; case KEY_BACKSPACE: i = KC_BACKSPACE; break; case KEY_ENTER: i = KC_ENTER; mods |= KC_MOD_KEYPAD; break; case 9: i = KC_TAB; break; case 13: i = KC_ENTER; break; case 27: i = ESCAPE; break; /* keypad keys */ case 0xFC: i = '0'; break; case 0xFD: i = '.'; break; case 0xC0: i = '\b'; break; case 0xDF: i = '1'; break; case 0xF5: i = '3'; break; case 0xE9: i = '5'; break; case 0xC1: i = '7'; break; case 0xF4: i = '9'; break; default: { if (i < KEY_MIN) break; /* Mega-Hack -- Fold, spindle, and mutilate * the keys to fit in 7 bits. */ if (i >= 252) i = KEY_F(63) - (i - 252); if (i >= ARROW_DOWN) i += 4; i = 128 + (i & 127); break; } } #endif /* Enqueue the keypress */ Term_keypress(i, mods); /* Success */ return (0); }
void execution(Commande *commande, Niveau *niveau){ fixDirectory(commande, niveau); insertionString(niveau->history, commande->commande); int nbArgument = nbArg(commande); int ok = 1; int redirect = 1; // printw("nb arg : %d\n", nbArgument); exceptionProcessing(niveau, commande); // Vérifie que la commande ne soit pas vide if (strlen(commande->commande) == 0){} else { // Vérifie si la commande est autorisée dans ce niveau if (!appartient(premierArg(commande->commande), niveau->charAutorise)) { printw("Commande \"%s\" interdite !!\n", premierArg(commande->commande)); printw("Liste des commandes autorisées :\n"); String *temp = niveau->charAutorise->premier; printw("\t %s\n", temp->string); while((temp = temp->suivant) != NULL){ printw("\t %s\n", temp->string); } } else { ListeString *listeArg = malloc(sizeof(ListeString)); buildArgsChain(listeArg, commande); // Gestion particulière du cd if (!strcmp(substr(commande->commande,0,2), "cd")) { // Vérifie qu'il n'y a qu'un seul argument après le cd if (nbArgument == 1) { // Vérifie que le dossier visé existe et qu'il n'est pas un fichier et qu'il n'est pas au-dessus de la racine if (dirExists(listeArg->premier->string) && accessible(commande)) { // Vérifie que ce n'est pas un fichier if(fileExists(listeArg->premier->string)) printw("\"%s\" est un fichier !!\n", listeArg->premier->string); else{ chdir(listeArg->premier->string); fixDirectory(commande, niveau); commande->niveau = commande->niveau + incrementNiveau(commande); } }else printw("Le répertoire \"%s\" n'existe pas !!\n", listeArg->premier->string); }else{ goBackRoot(commande); } } // gestion du pwd else if (!strcmp(substr(commande->commande,0,3), "pwd")) pwd(commande); // Gestion de >> else if((redirect = isRedirector(commande)) > 0) redirection(niveau, commande, redirect); // commandes autres else { printw("%s", exec(listeArg, commande, &(*niveau))); } } } }
void screen(char *source,double *lst_disp,double *utc_disp,double *tjd_disp, double *ra_disp,double *dec_disp, double *ra_cat_disp, double *dec_cat_disp, double *az_disp, double *el_disp,int *icount,double *azoff,double *eloff,int *icflag, double *az_actual_corrected,double *el_actual_disp,double *tiltx, double *tilty,int *initflag,int *pvt,float *pressure, float *temperature, float *humidity, double *az_error, double *el_error,double *scan_unit, char *messg, unsigned short *track_flag, unsigned short *slew_flag,double *focus_counts, double *subx_counts, double *suby_counts,double *subtilt_counts, double *subtilt_arcseconds, double *total_power_disp,double *syncdet_disp, int *integration, float *magnitude, char *sptype, float *windspeed, float *winddirection,float *refraction, float *pmdaz, float *pmdel, double *smoothed_tracking_error, double *tsys, short *errorflag, short *waitflag, unsigned short *pmac_command_flag, int *antennaNumber, int *radio_flag,int *padid,double *planetdistance,double *Az_cmd, double *El_cmd, double *Az_cmd_rate,double *El_cmd_rate,int *milliseconds, int *servomilliseconds,char *m3StateString) { int i,j,l; short az_act_sign,az_sign,el_sign,dec_dum_sign,dec_app_sign,dec_cat_sign; char k; char str[2]; int lsth,lstm,ra_cat_h,ra_cat_m,dec_cat_d,dec_cat_m; int dec_app_d,dec_app_m; int ra_app_h,ra_app_m; int utch,utcm; int epochint; int az_cmd_d,az_cmd_m,el_cmd_d,el_cmd_m; int az_act_d,az_act_m,el_act_d,el_act_m; double ra_cat_s,dec_cat_s,ra_app_s,dec_app_s,lsts,utcs; double az_cmd_s,el_cmd_s,az_act_s,el_act_s; int lstsi,utcsi,az_cmd_si,az_act_si,el_cmd_si,el_act_si; double ha; ha=*lst_disp-*ra_disp; if((*icount%30)==0) initialize(); if(*icount==1) initialize(); /* if((*icount%2)!=0) return; */ *az_disp=*az_disp/0.017453293; *el_disp=*el_disp/0.017453293; hms(ra_disp,&ra_app_h,&ra_app_m,&ra_app_s,&dec_dum_sign); hms(dec_disp,&dec_app_d,&dec_app_m,&dec_app_s,&dec_app_sign); hms(ra_cat_disp,&ra_cat_h,&ra_cat_m,&ra_cat_s,&dec_dum_sign); hms(dec_cat_disp,&dec_cat_d,&dec_cat_m,&dec_cat_s,&dec_cat_sign); hms(lst_disp,&lsth,&lstm,&lsts,&dec_dum_sign); hms(utc_disp,&utch,&utcm,&utcs,&dec_dum_sign); hms(az_disp,&az_cmd_d,&az_cmd_m,&az_cmd_s,&az_sign); hms(el_disp,&el_cmd_d,&el_cmd_m,&el_cmd_s,&el_sign); hms(az_actual_corrected,&az_act_d,&az_act_m,&az_act_s,&az_act_sign); hms(el_actual_disp,&el_act_d,&el_act_m,&el_act_s,&dec_dum_sign); lstsi=(int)lsts; utcsi=(int)utcs; az_cmd_si=(int)az_cmd_s; el_cmd_si=(int)el_cmd_s; az_act_si=(int)az_act_s; el_act_si=(int)el_act_s; box(stdscr, '|','-'); move(1,59); printw("M3:%7s",m3StateString); /* move(1,2); printw("%f %f %f %f %d %d %f",*Az_cmd/3600000.,*El_cmd/3600000.,*Az_cmd_rate/3600000.,*El_cmd_rate/3600000.,*milliseconds,*servomilliseconds,*utc_disp); move(2,2); printw("%f %f %f",*az_disp,*el_disp,*utc_disp); */ move(2,2); if(*antennaNumber==1) addstr("SMA Antenna-1 tracking "); if(*antennaNumber==2) addstr("SMA Antenna-2 tracking "); if(*antennaNumber==3) addstr("SMA Antenna-3 tracking "); if(*antennaNumber==4) addstr("SMA Antenna-4 tracking "); if(*antennaNumber==5) addstr("SMA Antenna-5 tracking "); if(*antennaNumber==6) addstr("SMA Antenna-6 tracking "); if(*antennaNumber==7) addstr("SMA Antenna-7 tracking "); if(*antennaNumber==8) addstr("SMA Antenna-8 tracking "); move(3,2); printw("on pad: %d",*padid); move(4,5); addstr("LST"); move (4,15); addstr("UTC"); move(4,25); addstr("TJD"); /* move(2,25); addstr("SOURCE="); */ move(2,32); addstr(source); move(3,32); addstr(sptype); move(4,32); printw("%3.1f",*magnitude); move (5,3); af(&lsth,str); addch(str[0]); addch(str[1]); move(5,6); af(&lstm,str); addch(str[0]); addch(str[1]); move(5,9); af(&lstsi,str); addch(str[0]); addch(str[1]); move(5,13); af(&utch,str); addch(str[0]); addch(str[1]); move(5,16); af(&utcm,str); addch(str[0]); addch(str[1]); move(5,19); af(&utcsi,str); addch(str[0]); addch(str[1]); move(5,23); printw("%lf",*tjd_disp); move(6,3); printw("%.4f",ha); move(7,14); addstr("RA"); move(7,30); addstr("DEC"); move(9,2); addstr("CATALOG"); move(9,12); af(&ra_cat_h,str); addch(str[0]); addch(str[1]); move(9,15); af(&ra_cat_m,str); addch(str[0]); addch(str[1]); move(9,18); printw("%.3f",ra_cat_s); move(9,27); if (dec_cat_sign>0) addch('+'); if (dec_cat_sign<0) addch('-'); if (dec_cat_sign==0) addch(' '); af(&dec_cat_d,str); addch(str[0]); addch(str[1]); move(9,31); af(&dec_cat_m,str); addch(str[0]); addch(str[1]); move(9,34); printw("%.2f",dec_cat_s); move(11,2); printw("APPARENT"); move(11,12); af(&ra_app_h,str); addch(str[0]); addch(str[1]); move(11,15); af(&ra_app_m,str); addch(str[0]); addch(str[1]); move(11,18); printw("%.3f",ra_app_s); move(11,27); if(dec_app_sign>0)addch('+'); if(dec_app_sign<0)addch('-'); if(dec_app_sign==0)addch(' '); af(&dec_app_d,str); addch(str[0]); addch(str[1]); move(11,31); af(&dec_app_m,str); addch(str[0]); addch(str[1]); move(11,34); printw("%.2f",dec_app_s); move(13,14); addstr("AZ"); move(13,30); addstr("EL"); move(15,2); addstr("CMD"); move(15,9); if((az_sign<0)&&(az_cmd_d==0))addch('-'); move(15,10); printw("%03d",az_cmd_d); move(15,15); af(&az_cmd_m,str); addch(str[0]); addch(str[1]); move(15,18); af(&az_cmd_si,str); addch(str[0]); addch(str[1]); move(15,27); if(el_sign>=0)addch(' '); if(el_sign<0)addch('-'); move(15,28); af(&el_cmd_d,str); addch(str[0]); addch(str[1]); move(15,31); af(&el_cmd_m,str); addch(str[0]); addch(str[1]); move(15,34); af(&el_cmd_si,str); addch(str[0]); addch(str[1]); move(17,2); addstr("ACTUAL"); move(17,9); if((az_act_sign<0)&&(az_act_d==0))addch('-'); move(17,10); printw("%03d",az_act_d); move(17,15); af(&az_act_m,str); addch(str[0]); addch(str[1]); move(17,18); af(&az_act_si,str); addch(str[0]); addch(str[1]); move(17,28); af(&el_act_d,str); addch(str[0]); addch(str[1]); move(17,31); af(&el_act_m,str); addch(str[0]); addch(str[1]); move(17,34); af(&el_act_si,str); addch(str[0]); addch(str[1]); move(19,2); addstr("ERROR"); move(19,11); printw("%7.1f\"",(*az_error*3600.)); move(19,28); printw("%7.1f\"",(*el_error*3600.)); /*move(18,23); printw("(%.1f\")",*smoothed_tracking_error); */ move(20,12); printw("(%6.0f)",*pmdaz); move(20,32); printw("(%6.0f)",*pmdel); move(21,2); addstr("OFFSETS(\")"); move(21,12); printw("%6.0f",*azoff); move(21,32); printw("%6.0f",*eloff); move(22,2); printw("%6.0f",*scan_unit); move(21,42); addstr("TILTS"); move(21,50); printw("%.1f",*tiltx); move(21,63); printw("%.1f",*tilty); move(21,73); printw("%5d",*integration); /* move(22,42); printw("%3d",*errorflag); move(22,50); printw("%3d",*waitflag); move(22,55); printw("%3d",*pmac_command_flag); */ move(22,42); printw("Planet dist.=%.6f AU",*planetdistance); /* move(22,42); addstr("PVT"); move(22,46); printw("%4d",*pvt); move(22,52); addstr("TF="); printw("%1d",*track_flag); move(22,57); addstr("SF="); printw("%1d",*slew_flag); */ move(18,42); addstr("REFRACTION:"); move(18,53); if(*radio_flag==1) printw("%5.1f \" (radio) ",*refraction); if(*radio_flag==0) printw("%5.1f \" (optical) ",*refraction); move(19,42); addstr("WEATHER:"); move(19,51); printw("%4.1f C",*temperature); move(19,59); printw("%5.1f%%",*humidity); move(19,67); printw("%6.1f mbar",*pressure); move(20,51); printw("wind: %4.1f m/s, %5.1f deg",*windspeed,*winddirection); move(2,42); addstr(messg); move(17,42); addstr("SUB_Z:"); move(17,49); printw("%8.0f cts, %4.2f mm ",*focus_counts, (*focus_counts)/2000.); move(13,42); addstr("SUB_X:"); move(13,49); printw("%8.0f cts, %4.2f mm ",*subx_counts, (*subx_counts)/1000.); move(15,42); addstr("SUB_Y:"); move(15,49); printw("%8.0f cts, %4.2f mm ",*suby_counts, (*suby_counts)/500.); move(11,42); addstr("SUB_TILT:"); move(11,52); printw("%8.0f cts, %4.2f \" ",*subtilt_counts, *subtilt_arcseconds); move(9,42); addstr("CONT. DET. O/P:"); move(9,58); printw("%8.2f mV", (*total_power_disp)*1000.); move(7,42); addstr("SYNC. DET. O/P:"); move(7,58); printw("%8.2f mV", (*syncdet_disp)*1000.); move(5,42); addstr("TSYS:"); move(5,48); printw("%05.0f", *tsys); move(5,55); addstr("K"); /* for(l=1;l<23;l++) { move(l,40); addstr("|"); } */ refresh(); }
int main(int argc, char *argv[]) { int continuer = 1; Commande *commande = malloc(sizeof(commande)); initialiseCommande(commande); // signal(SIGINT, interrupt); Niveau *niveau = malloc(sizeof(niveau)); decompression(choixNiveau(argc, argv), commande, niveau); /*** */ struct sigaction act; memset (&act, '\0', sizeof(act)); /* Use the sa_sigaction field because the handles has two additional parameters */ act.sa_sigaction = &hdl; /* The SA_SIGINFO flag tells sigaction() to use the sa_sigaction field, not sa_handler. */ act.sa_flags = SA_SIGINFO; if (sigaction(SIGINT, &act, NULL) < 0) { perror ("sigaction"); return 1; } /**** */ int ch; int finCommande = 0; initscr(); idlok(stdscr, TRUE); scrollok(stdscr, TRUE); cbreak(); noecho(); keypad(stdscr, TRUE); intrflush(stdscr, FALSE); printw("nom : %s\n", niveau->nom); int x, y; int nbAppuiUp = 0; char *saisie; while(continuer){ finCommande = 0; saisie = malloc(TAILLE_MAX_COMMANDE*sizeof(char)); debutLigne(commande, niveau); while(finCommande == 0){ ch = wgetch(stdscr); if(ch != KEY_UP && ch !=KEY_DOWN) nbAppuiUp = 0; if (ch == KEY_BACKSPACE) { getyx(stdscr, y, x); if(x > strlen(commande->directory)+3){ move(y, x-1); delch(); strcpy(saisie, substr(saisie, 0, strlen(saisie)-1)); } } else if(ch == KEY_LEFT){ getyx(stdscr, y, x); move(y, x-1); } else if(ch == KEY_RIGHT){ getyx(stdscr, y, x); move(y, x+1); } else if (ch == KEY_UP) { nbAppuiUp++; String *temp = malloc(sizeof(String)); temp = niveau->history->premier; if (temp->suivant != NULL) { int i = 0; while(i < nbAppuiUp && temp->suivant != NULL){ temp = temp->suivant; i++; } free(saisie); saisie = malloc(sizeof(char)*TAILLE_MAX_COMMANDE); strcpy(saisie, temp->string); effaceCommande(commande); printw("%s", saisie); } } else if (ch == KEY_DOWN) { nbAppuiUp--; String *temp = malloc(sizeof(String)); temp = niveau->history->premier; if (temp->suivant != NULL) { int i = 0; while(i < nbAppuiUp && temp->suivant != NULL){ temp = temp->suivant; i++; } free(saisie); saisie = malloc(sizeof(char)*TAILLE_MAX_COMMANDE); strcpy(saisie, temp->string); effaceCommande(commande); printw("%s", saisie); } } else if(ch == KEY_DC){ delch(); strcpy(saisie, substr(saisie, 0, strlen(saisie)-1)); } else if(ch == '\t'){ effaceCommande(commande); char *essai = malloc(sizeof(char)*TAILLE_MAX_COMMANDE); if(strlen(autoComplete(saisie, niveau)) == 0) finCommande = 1; else{ strcpy(saisie, strcat(saisie, autoComplete(saisie, niveau))); printw("%s", saisie); } } else if(ch == '\n'){ finCommande = 1; printw("\n"); } else{ printw("%c", ch); sprintf(saisie, "%s%c", saisie, ch); } } strcpy(commande->commande, saisie); execution(commande, niveau); // free(saisie); } endwin(); return 0; }
int DisplayUsage( const char **pNULL, ProgramCommands *p_pSelf ) { printw( "USAGE\n" ); return 0; }
int print_it ( ppstat *stats_array, int count ) { int input; int i, j; time_t uptime; time_t t; struct tm *now; char timestring[9]; extern pmstat memory; double total_ticks; MEVENT event; output = &printw; mousemask(ALL_MOUSE_EVENTS, NULL); total_ticks = parametres.ticks_passed * sysconf ( _SC_NPROCESSORS_ONLN ); keypad ( win, TRUE ); erase(); t = time ( NULL ); now = localtime ( &t ); strftime ( timestring, 9, "%H:%M:%S", now ); uptime = time ( NULL ) - parametres.btime; attroff ( A_BOLD ); mvprintw ( 0, 0, "%-6s - %s up %ld days %02ld:%02ld", parametres.progname, timestring, uptime / 86400, ( uptime % 86400 ) / 3600, ( uptime % 3600 ) / 60 ); mvprintw ( 0, 41, "load average: %7.2f %7.2f %7.2f", parametres.loadavg[0], parametres.loadavg[1], parametres.loadavg[2] ); if ( parametres.cpu_stats[1].user != 0 ) { mvprintw ( 2, 0, "Cpu(s):%5.1f us,%5.1f sy,%5.1f ni,%5.1f id,%5.1f wa,%5.1f hi,%5.1f si,%5.1f st", ((parametres.cpu_stats[0].user - parametres.cpu_stats[1].user)/total_ticks) * 100, ((parametres.cpu_stats[0].system - parametres.cpu_stats[1].system)/total_ticks) * 100, ((parametres.cpu_stats[0].nice - parametres.cpu_stats[1].nice)/total_ticks) * 100 , ((parametres.cpu_stats[0].idle - parametres.cpu_stats[1].idle)/total_ticks) * 100 , ((parametres.cpu_stats[0].iowait - parametres.cpu_stats[1].iowait)/total_ticks) * 100, ((parametres.cpu_stats[0].irq - parametres.cpu_stats[1].irq)/total_ticks) * 100, ((parametres.cpu_stats[0].softirq - parametres.cpu_stats[1].softirq)/total_ticks) * 100, ((parametres.cpu_stats[0].steal - parametres.cpu_stats[1].steal)/total_ticks) * 100 ); } else { mvprintw ( 2, 0, "Cpu(s):%5.1f us,%5.1f sy,%5.1f ni,%5.1f id,%5.1f wa,%5.1f hi,%5.1f si,%5.1f st", 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ); } if ( memory->memtotal > 1000000000 ) { mvprintw ( 3, 0, "MiB Mem:%10lu total, %10lu used, %10lu free, %10lu buffers", memory->memtotal / 1024, ( memory->memtotal - memory->memfree ) / 1024, memory->memfree / 1024, memory->buffers / 1024 ); mvprintw ( 4, 0, "MiB Swap:%9lu total, %10lu used, %10lu free, %10lu cached", memory->swaptotal / 1024, ( memory->swaptotal - memory->swapfree ) / 1024, memory->swapfree / 1024, memory->cached / 1024 ); } else { mvprintw ( 3, 0, "KiB Mem:%10lu total, %10lu used, %10lu free, %10lu buffers", memory->memtotal, memory->memtotal - memory->memfree, memory->memfree, memory->buffers ); mvprintw ( 4, 0, "KiB Swap:%9lu total, %10lu used, %10lu free, %10lu cached", memory->swaptotal, memory->swaptotal - memory->swapfree, memory->swapfree, memory->cached ); } mvprintw ( 5, 0, "JKUtop - horrovac invenit et fecit" ); attron ( A_REVERSE ); /* print the header */ move ( 6, 0 ); for ( j = 0; j < FIELDS_AVAILABLE; j++ ) { attroff ( A_BOLD ); if ( display_fields[j] == NULL ) { break; } if ( display_fields[j]->identifier == parametres.sortby ) { attron ( A_BOLD ); } printw ( display_fields[j]->header_format, display_fields[j]->fieldname ); } for ( i = 67; i < col; i++ ) { printw ( " " ); } printw ( "\n" ); attroff ( A_REVERSE ); /* print the data fields */ for ( i = 0; i < count; i++ ) { move ( i + 7, 0 ); { if ( stats_array[i]->state == 'R' ) { attron ( A_BOLD ); } else { attroff ( A_BOLD ); } for ( j = 0; j < FIELDS_AVAILABLE; j++ ) { if ( display_fields[j] == NULL ) { break; } display_fields[j]->printout( stats_array[i], display_fields[j]->identifier ); } printw ( "\n" ); } /* limit output to visible rows */ if ( i + 8 >= row ) { break; } } refresh(); if ( ( input = getch () ) != ERR ) { switch ( input ) { case 'w': /* save current configuration */ save_config(); break; case 'q': endwin(); exit ( 0 ); break; case 'o': case 'O': case 's': case 'S': case 'f': case 'F': modify_display(); break; case KEY_MOUSE: if(getmouse(&event) == OK) { if ( event.bstate & BUTTON1_DOUBLE_CLICKED ) { if ( event.y > 6 ) { show_process_detail ( stats_array, event.y - 7 ); } else if ( event.y == 6 ) { mouse_select_sortfield ( event.x ); } } } break; case 'h': show_help (); break; default: break; } } return ( i + 1 ); }
void TerminalChatConsole::step(int ch) { bool complete_redraw_needed = false; // empty queues while (!m_chat_interface->outgoing_queue.empty()) { ChatEvent *evt = m_chat_interface->outgoing_queue.pop_frontNoEx(); switch (evt->type) { case CET_NICK_REMOVE: m_nicks.remove(((ChatEventNick *)evt)->nick); break; case CET_NICK_ADD: m_nicks.push_back(((ChatEventNick *)evt)->nick); break; case CET_CHAT: complete_redraw_needed = true; // This is only used for direct replies from commands // or for lua's print() functionality m_chat_backend.addMessage(L"", ((ChatEventChat *)evt)->evt_msg); break; case CET_TIME_INFO: ChatEventTimeInfo *tevt = (ChatEventTimeInfo *)evt; m_game_time = tevt->game_time; m_time_of_day = tevt->time; }; delete evt; } while (!m_log_output.queue.empty()) { complete_redraw_needed = true; std::pair<LogLevel, std::string> p = m_log_output.queue.pop_frontNoEx(); if (p.first > m_log_level) continue; m_chat_backend.addMessage( utf8_to_wide(Logger::getLevelLabel(p.first)), utf8_to_wide(p.second)); } // handle input if (!m_esc_mode) { handleInput(ch, complete_redraw_needed); } else { switch (ch) { case ERR: // no input break; case 27: // ESC // Toggle ESC mode m_esc_mode = !m_esc_mode; break; case 'L': m_log_level--; m_log_level = MYMAX(m_log_level, LL_NONE + 1); // LL_NONE isn't accessible break; case 'l': m_log_level++; m_log_level = MYMIN(m_log_level, LL_MAX - 1); break; } } // was there a resize? int xn, yn; getmaxyx(stdscr, yn, xn); if (xn != m_cols || yn != m_rows) { m_cols = xn; m_rows = yn; m_can_draw_text = reformat_backend(&m_chat_backend, m_rows, m_cols); complete_redraw_needed = true; } // draw title move(0, 0); clrtoeol(); addstr(PROJECT_NAME_C); addstr(" "); addstr(g_version_hash); u32 minutes = m_time_of_day % 1000; u32 hours = m_time_of_day / 1000; minutes = (float)minutes / 1000 * 60; if (m_game_time) printw(" | Game %d Time of day %02d:%02d ", m_game_time, hours, minutes); // draw text if (complete_redraw_needed && m_can_draw_text) draw_text(); // draw prompt if (!m_esc_mode) { // normal prompt ChatPrompt& prompt = m_chat_backend.getPrompt(); std::string prompt_text = wide_to_utf8(prompt.getVisiblePortion()); move(m_rows - 1, 0); clrtoeol(); addstr(prompt_text.c_str()); // Draw cursor s32 cursor_pos = prompt.getVisibleCursorPosition(); if (cursor_pos >= 0) { move(m_rows - 1, cursor_pos); } } else { // esc prompt move(m_rows - 1, 0); clrtoeol(); printw("[ESC] Toggle ESC mode |" " [CTRL+C] Shut down |" " (L) in-, (l) decrease loglevel %s", Logger::getLevelLabel((LogLevel) m_log_level).c_str()); } refresh(); }
int main() { int p1[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; int win = 0; int pole, remis, tryb; int ch, x = 2, y = 2, exit = 0; //do operacji na kursorze initscr(); cbreak(); noecho();// ja jeeeeeeeeeeeeeeeeeeeeebie, działa! ;d keypad(stdscr, true); //do zabawy kursorem start_color(); beep(); tryb = menu(); while (remis < 9) { rysuj(p1); exit = 0; // todo: przeniesc to do funkcji wczytaj i zrobic sprawdzanie czy nie jest juz zajete pole while (exit<1) { move(y,x); refresh(); ch = getch(); switch (ch) { case KEY_LEFT: x--; move(y, x); refresh(); break; case KEY_RIGHT: x++; move(y, x); refresh(); break; case KEY_UP: y--; move(y, x); refresh(); break; case KEY_DOWN: y++; move(y, x); refresh(); break; case 0xa: getyx(stdscr, y, x); // y = wiersz kursora y = kolumna kursora if (x == 0 && y == 0) { pole = 1; exit = 1; } else if ((x == 2) && (y == 0)) { pole = 2; exit = 1; } else if (x == 4 && y == 0) { pole = 3; exit = 1; } else if (x == 0 && y == 2) { pole = 4; exit = 1; } else if (x == 2 && y == 2) { pole = 5; exit = 1; } else if (x == 4 && y == 2) { pole = 6; exit = 1; } else if (x == 0 && y == 4) { pole = 7; exit = 1; } else if (x == 2 && y == 4) { pole = 8; exit = 1; } else if (x == 4 && y == 4) { pole = 9; exit = 1; } break; } } wczytaj(1, pole, p1); remis++; if (remis == 9) { printw("Remis\n"); break; } win = test(1, p1); if (win > 0) { break; } /* wybór trybu single/multi */ if (tryb == 2) { rysuj(p1); //rysuje planszę po ruchu pierwszego gracza tylko jak jest multiplayer printw("Gracz 2, podaj pole [1-9]:"); scanw("%d", &pole); wczytaj(2, pole, p1); } if (tryb == 1) { pc1(p1); } win = test(2, p1); remis++; if (remis == 9) { printw("Remis\n"); break; } if (win > 0) { rysuj(p1); break; } refresh(); } if (win == 1) { mvprintw(5,0,"Gratulacje! Gracz 1, wygrałeś.\n"); } if (win == 2) { mvprintw(5,0,"Gratulacje! Gracz 2 wygrywa!\n"); } getch(); endwin(); return 0; }
int main() { std::vector <double> result; double A; double B; double C; initscr(); noecho(); clear(); printw("input A \n"); refresh(); do { clear(); refresh(); printw("input A \n"); refresh(); A = input_double(); printw("input B \n"); refresh(); B = input_double(); printw("input C \n"); refresh(); C = input_double(); if (A == 0) { //handling A = 0 printw("A = 0"); refresh(); continue; } result = hard_solve(A, B, C); if (result[0] == 0) { printw("no solutions"); refresh(); } if (result[0] == 1) { printw("%f", result[1]); refresh(); } if (result[0] == 2) { printw("%f", result[1]); printw(", "); printw("%f", result[2]); refresh(); } printw("\n"); printw("press any key to continue"); printw("\n"); printw("press ESC key to quit"); refresh(); } while (getchar() != 27); endwin(); }
void nperror(const char *s) { if (flag_monitor || flag_monitor_continous) printw("%s:%s", s, strerror(errno)); else perror(s); }
int main(int ac, char *av[]) { bool show_only; extern char *Scorefile; int score_wfd; /* high score writable file descriptor */ int score_err = 0; /* hold errno from score file open */ int ch; extern int optind; gid_t gid; #ifdef FANCY char *sp; #endif if ((score_wfd = open(Scorefile, O_RDWR)) < 0) score_err = errno; /* revoke privs */ gid = getgid(); setresgid(gid, gid, gid); show_only = FALSE; while ((ch = getopt(ac, av, "srajt")) != -1) switch (ch) { case 's': show_only = TRUE; break; case 'r': Real_time = TRUE; /* Could be a command-line option */ tv.tv_sec = 3; tv.tv_usec = 0; FD_ZERO(&rset); break; case 'a': Start_level = 4; break; case 'j': Jump = TRUE; break; case 't': Teleport = TRUE; break; case '?': default: usage(); } ac -= optind; av += optind; if (ac > 1) usage(); if (ac == 1) { Scorefile = av[0]; if (score_wfd >= 0) close(score_wfd); /* This file requires no special privileges. */ if ((score_wfd = open(Scorefile, O_RDWR)) < 0) score_err = errno; #ifdef FANCY sp = strrchr(Scorefile, '/'); if (sp == NULL) sp = Scorefile; if (strcmp(sp, "pattern_roll") == 0) Pattern_roll = TRUE; else if (strcmp(sp, "stand_still") == 0) Stand_still = TRUE; if (Pattern_roll || Stand_still) Teleport = TRUE; #endif } if (show_only) { show_score(); exit(0); } if (score_wfd < 0) { warnx("%s: %s; no scores will be saved", Scorefile, strerror(score_err)); sleep(1); } initscr(); signal(SIGINT, quit); cbreak(); noecho(); nonl(); if (LINES != Y_SIZE || COLS != X_SIZE) { if (LINES < Y_SIZE || COLS < X_SIZE) { endwin(); errx(1, "Need at least a %dx%d screen", Y_SIZE, X_SIZE); } delwin(stdscr); stdscr = newwin(Y_SIZE, X_SIZE, 0, 0); } srandomdev(); do { init_field(); for (Level = Start_level; !Dead; Level++) { make_level(); play_level(); } move(My_pos.y, My_pos.x); printw("AARRrrgghhhh...."); refresh(); score(score_wfd); } while (another()); quit(0); /* NOT REACHED */ }
void show_stats(void) { unsigned val; unsigned lo_addr[8], hi_addr[8]; unsigned i; while (1) { move(5,0); readReg(&nf2, MAC_GRP_0_CONTROL_REG, &val); printw("MAC 0 Control: 0x%08x ", val); if(val&(1<<MAC_GRP_TX_QUEUE_DISABLE_BIT_NUM)) { printw("TX disabled, "); } else { printw("TX enabled, "); } if(val&(1<<MAC_GRP_RX_QUEUE_DISABLE_BIT_NUM)) { printw("RX disabled, "); } else { printw("RX enabled, "); } if(val&(1<<MAC_GRP_RESET_MAC_BIT_NUM)) { printw("reset on, "); } else { printw("reset off, "); } printw("mac config 0x%02x\n", val>>MAC_GRP_MAC_DISABLE_TX_BIT_NUM); readReg(&nf2, MAC_GRP_1_CONTROL_REG, &val); printw("MAC 1 Control: 0x%08x ", val); if(val&(1<<MAC_GRP_TX_QUEUE_DISABLE_BIT_NUM)) { printw("TX disabled, "); } else { printw("TX enabled, "); } if(val&(1<<MAC_GRP_RX_QUEUE_DISABLE_BIT_NUM)) { printw("RX disabled, "); } else { printw("RX enabled, "); } if(val&(1<<MAC_GRP_RESET_MAC_BIT_NUM)) { printw("reset on, "); } else { printw("reset off, "); } printw("mac config 0x%02x\n", val>>MAC_GRP_MAC_DISABLE_TX_BIT_NUM); readReg(&nf2, MAC_GRP_2_CONTROL_REG, &val); printw("MAC 2 Control: 0x%08x ", val); if(val&(1<<MAC_GRP_TX_QUEUE_DISABLE_BIT_NUM)) { printw("TX disabled, "); } else { printw("TX enabled, "); } if(val&(1<<MAC_GRP_RX_QUEUE_DISABLE_BIT_NUM)) { printw("RX disabled, "); } else { printw("RX enabled, "); } if(val&(1<<MAC_GRP_RESET_MAC_BIT_NUM)) { printw("reset on, "); } else { printw("reset off, "); } printw("mac config 0x%02x\n", val>>MAC_GRP_MAC_DISABLE_TX_BIT_NUM); readReg(&nf2, MAC_GRP_3_CONTROL_REG, &val); printw("MAC 3 Control: 0x%08x ", val); if(val&(1<<MAC_GRP_TX_QUEUE_DISABLE_BIT_NUM)) { printw("TX disabled, "); } else { printw("TX enabled, "); } if(val&(1<<MAC_GRP_RX_QUEUE_DISABLE_BIT_NUM)) { printw("RX disabled, "); } else { printw("RX enabled, "); } if(val&(1<<MAC_GRP_RESET_MAC_BIT_NUM)) { printw("reset on, "); } else { printw("reset off, "); } printw("mac config 0x%02x\n", val>>MAC_GRP_MAC_DISABLE_TX_BIT_NUM); move (12,0); printw(" Port 0 CPU 0 Port 1 CPU 1 Port 2 CPU 2 Port 3 CPU 3\n"); printw("Packets Lost:\n"); printw("Packets Stored:\n"); printw("Packets Removed:\n"); printw("Bytes Stored:\n"); printw("Bytes Removed:\n"); printw("Low address:\n"); printw("High address:\n"); printw("Write address:\n"); printw("Read address:\n"); move (13,17); readReg(&nf2, OQ_QUEUE_0_NUM_PKTS_DROPPED_REG, &val); lost[0] = val; printw("%8i", lost[0]); readReg(&nf2, OQ_QUEUE_1_NUM_PKTS_DROPPED_REG, &val);lost[1] = val; printw(" %8i", lost[1]); readReg(&nf2, OQ_QUEUE_2_NUM_PKTS_DROPPED_REG, &val);lost[2] = val; printw(" %8i", lost[2]); readReg(&nf2, OQ_QUEUE_3_NUM_PKTS_DROPPED_REG, &val);lost[3] = val; printw(" %8i", lost[3]); readReg(&nf2, OQ_QUEUE_4_NUM_PKTS_DROPPED_REG, &val);lost[4] = val; printw(" %8i", lost[4]); readReg(&nf2, OQ_QUEUE_5_NUM_PKTS_DROPPED_REG, &val);lost[5] = val; printw(" %8i", lost[5]); readReg(&nf2, OQ_QUEUE_6_NUM_PKTS_DROPPED_REG, &val);lost[6] = val; printw(" %8i", lost[6]); readReg(&nf2, OQ_QUEUE_7_NUM_PKTS_DROPPED_REG, &val);lost[7] = val; printw(" %8i", lost[7]); move (14,17); readReg(&nf2, OQ_QUEUE_0_NUM_PKTS_STORED_REG, &val);stored[0] = val; printw("%8i", stored[0]); readReg(&nf2, OQ_QUEUE_1_NUM_PKTS_STORED_REG, &val);stored[1] = val; printw(" %8i", stored[1]); readReg(&nf2, OQ_QUEUE_2_NUM_PKTS_STORED_REG, &val);stored[2] = val; printw(" %8i", stored[2]); readReg(&nf2, OQ_QUEUE_3_NUM_PKTS_STORED_REG, &val);stored[3] = val; printw(" %8i", stored[3]); readReg(&nf2, OQ_QUEUE_4_NUM_PKTS_STORED_REG, &val);stored[4] = val; printw(" %8i", stored[4]); readReg(&nf2, OQ_QUEUE_5_NUM_PKTS_STORED_REG, &val);stored[5] = val; printw(" %8i", stored[5]); readReg(&nf2, OQ_QUEUE_6_NUM_PKTS_STORED_REG, &val);stored[6] = val; printw(" %8i", stored[6]); readReg(&nf2, OQ_QUEUE_7_NUM_PKTS_STORED_REG, &val);stored[7] = val; printw(" %8i", stored[7]); move (15,17); readReg(&nf2, OQ_QUEUE_0_NUM_PKTS_REMOVED_REG, &val);removed[0] = val; printw("%8i", removed[0]); readReg(&nf2, OQ_QUEUE_1_NUM_PKTS_REMOVED_REG, &val);removed[1] = val; printw(" %8i", removed[1]); readReg(&nf2, OQ_QUEUE_2_NUM_PKTS_REMOVED_REG, &val);removed[2] = val; printw(" %8i", removed[2]); readReg(&nf2, OQ_QUEUE_3_NUM_PKTS_REMOVED_REG, &val);removed[3] = val; printw(" %8i", removed[3]); readReg(&nf2, OQ_QUEUE_4_NUM_PKTS_REMOVED_REG, &val);removed[4] = val; printw(" %8i", removed[4]); readReg(&nf2, OQ_QUEUE_5_NUM_PKTS_REMOVED_REG, &val);removed[5] = val; printw(" %8i", removed[5]); readReg(&nf2, OQ_QUEUE_6_NUM_PKTS_REMOVED_REG, &val);removed[6] = val; printw(" %8i", removed[6]); readReg(&nf2, OQ_QUEUE_7_NUM_PKTS_REMOVED_REG, &val);removed[7] = val; printw(" %8i", removed[7]); move (16,17); readReg(&nf2, OQ_QUEUE_0_NUM_PKT_BYTES_STORED_REG, &val); printw("%8i", val); readReg(&nf2, OQ_QUEUE_1_NUM_PKT_BYTES_STORED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_2_NUM_PKT_BYTES_STORED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_3_NUM_PKT_BYTES_STORED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_4_NUM_PKT_BYTES_STORED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_5_NUM_PKT_BYTES_STORED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_6_NUM_PKT_BYTES_STORED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_7_NUM_PKT_BYTES_STORED_REG, &val); printw(" %8i", val); move (17,17); readReg(&nf2, OQ_QUEUE_0_NUM_PKT_BYTES_REMOVED_REG, &val); printw("%8i", val); readReg(&nf2, OQ_QUEUE_1_NUM_PKT_BYTES_REMOVED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_2_NUM_PKT_BYTES_REMOVED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_3_NUM_PKT_BYTES_REMOVED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_4_NUM_PKT_BYTES_REMOVED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_5_NUM_PKT_BYTES_REMOVED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_6_NUM_PKT_BYTES_REMOVED_REG, &val); printw(" %8i", val); readReg(&nf2, OQ_QUEUE_7_NUM_PKT_BYTES_REMOVED_REG, &val); printw(" %8i", val); move (18,17); readReg(&nf2, OQ_QUEUE_0_ADDR_LO_REG, &val);lo_addr[0] = val; printw("%8x", lo_addr[0]<<3); readReg(&nf2, OQ_QUEUE_1_ADDR_LO_REG, &val);lo_addr[1] = val; printw(" %8x", lo_addr[1]<<3); readReg(&nf2, OQ_QUEUE_2_ADDR_LO_REG, &val);lo_addr[2] = val; printw(" %8x", lo_addr[2]<<3); readReg(&nf2, OQ_QUEUE_3_ADDR_LO_REG, &val);lo_addr[3] = val; printw(" %8x", lo_addr[3]<<3); readReg(&nf2, OQ_QUEUE_4_ADDR_LO_REG, &val);lo_addr[4] = val; printw(" %8x", lo_addr[4]<<3); readReg(&nf2, OQ_QUEUE_5_ADDR_LO_REG, &val);lo_addr[5] = val; printw(" %8x", lo_addr[5]<<3); readReg(&nf2, OQ_QUEUE_6_ADDR_LO_REG, &val);lo_addr[6] = val; printw(" %8x", lo_addr[6]<<3); readReg(&nf2, OQ_QUEUE_7_ADDR_LO_REG, &val);lo_addr[7] = val; printw(" %8x", lo_addr[7]<<3); move (19,17); readReg(&nf2, OQ_QUEUE_0_ADDR_HI_REG, &val);hi_addr[0] = val; printw("%8x", hi_addr[0]<<3); readReg(&nf2, OQ_QUEUE_1_ADDR_HI_REG, &val);hi_addr[1] = val; printw(" %8x", hi_addr[1]<<3); readReg(&nf2, OQ_QUEUE_2_ADDR_HI_REG, &val);hi_addr[2] = val; printw(" %8x", hi_addr[2]<<3); readReg(&nf2, OQ_QUEUE_3_ADDR_HI_REG, &val);hi_addr[3] = val; printw(" %8x", hi_addr[3]<<3); readReg(&nf2, OQ_QUEUE_4_ADDR_HI_REG, &val);hi_addr[4] = val; printw(" %8x", hi_addr[4]<<3); readReg(&nf2, OQ_QUEUE_5_ADDR_HI_REG, &val);hi_addr[5] = val; printw(" %8x", hi_addr[5]<<3); readReg(&nf2, OQ_QUEUE_6_ADDR_HI_REG, &val);hi_addr[6] = val; printw(" %8x", hi_addr[6]<<3); readReg(&nf2, OQ_QUEUE_7_ADDR_HI_REG, &val);hi_addr[7] = val; printw(" %8x", hi_addr[7]<<3); move (20,17); readReg(&nf2, OQ_QUEUE_0_WR_ADDR_REG, &val); printw("%8x", val<<3); readReg(&nf2, OQ_QUEUE_1_WR_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_2_WR_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_3_WR_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_4_WR_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_5_WR_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_6_WR_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_7_WR_ADDR_REG, &val); printw(" %8x", val<<3); move (21,17); readReg(&nf2, OQ_QUEUE_0_RD_ADDR_REG, &val); printw("%8x", val<<3); readReg(&nf2, OQ_QUEUE_1_RD_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_2_RD_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_3_RD_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_4_RD_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_5_RD_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_6_RD_ADDR_REG, &val); printw(" %8x", val<<3); readReg(&nf2, OQ_QUEUE_7_RD_ADDR_REG, &val); printw(" %8x", val<<3); move (22,0); printw("Size:"); move (22,16); for (i=0;i<8;i++) { printw(" %6iKB", ((hi_addr[i]-lo_addr[i])/128)); } move (24,0); readReg(&nf2, ANTI_SPOOF_AS_NUM_HITS_REG, &val); printw("MAC lut num hits: %u\n", val); readReg(&nf2, ANTI_SPOOF_AS_NUM_MISSES_REG, &val); printw("MAC lut num misses: %u\n\n", val); for(i=0; i<16; i=i+1){ writeReg(&nf2, ANTI_SPOOF_AS_MAC_LUT_RD_ADDR_REG, i); readReg(&nf2, ANTI_SPOOF_AS_PORTS_MAC_HI_REG, &val); printw(" CAM table entry %02u: wr_protect: %u, ports: 0x%04x, mac: 0x%04x", i, val>>31, (val&0x7fff0000)>>16, (val&0xffff)); readReg(&nf2, ANTI_SPOOF_AS_MAC_LO_REG, &val); printw("%08x\n", val); } refresh(); sleep(1); } }