NCURSES_EXPORT(int) (refresh) (void) { T((T_CALLED("refresh()"))); returnCode(wrefresh(stdscr)); }
int wscrl(WINDOW *win, int n) { int physical = FALSE; int i; T(("wscrl(%x,%d) called", win, n)); if (! win->_scroll) return ERR; if (n == 0) return OK; /* as an optimization, if the scrolling region is the entire screen scroll the physical screen */ if ( win->_begx == 0 && win->_maxx == columns - 1 && !memory_above && !memory_below && ((((win->_begy+win->_regtop == 0 && win->_begy+win->_regbottom == lines - 1) || change_scroll_region) && ( (n < 0 && (parm_rindex || scroll_reverse)) || (n > 0 && (parm_index || scroll_forward)) ) ) || (win->_idlok && (parm_insert_line || insert_line) && (parm_delete_line || delete_line) ) ) ) physical = TRUE; if (physical == TRUE) { wrefresh(win); scroll_window(curscr, n, win->_begy+win->_regtop, win->_begy+win->_regbottom); scroll_window(newscr, n, win->_begy+win->_regtop, win->_begy+win->_regbottom); } scroll_window(win, n, win->_regtop, win->_regbottom); if (physical == TRUE) { if (n < 0) { if ( (( win->_begy+win->_regtop == 0 && win->_begy+win->_regbottom == lines - 1) || change_scroll_region) && (parm_rindex || scroll_reverse) ) { if (change_scroll_region && (win->_begy+win->_regtop != 0 || win->_begy+win->_regbottom != lines - 1) ) putp(tparm(change_scroll_region, win->_begy+win->_regtop, win->_begy+win->_regbottom)); i = abs(n); mvcur(-1, -1, win->_begy+win->_regtop, 0); if (parm_rindex) { putp(tparm(parm_rindex, i)); } else if (scroll_reverse) { while (i--) putp(scroll_reverse); } if (change_scroll_region && (win->_begy+win->_regtop != 0 || win->_begy+win->_regbottom != lines - 1) ) putp(tparm(change_scroll_region, 0, lines-1)); } else { i = abs(n); if (win->_begy+win->_regbottom < lines - 1) { mvcur(-1, -1, win->_begy+win->_regbottom, 0); if (parm_delete_line) { putp(tparm(parm_delete_line, i)); } else if (delete_line) { while (i--) putp(delete_line); i = abs(n); } } mvcur(-1, -1, win->_begy+win->_regtop, 0); if (parm_insert_line) { putp(tparm(parm_insert_line, i)); } else if (insert_line) { while (i--) putp(insert_line); } } } else { if ( (( win->_begy+win->_regtop == 0 && win->_begy+win->_regbottom == lines - 1) || change_scroll_region) && (parm_index || scroll_forward) ) { if (change_scroll_region && (win->_begy+win->_regtop != 0 || win->_begy+win->_regbottom != lines - 1) ) putp(tparm(change_scroll_region, win->_begy+win->_regtop, win->_begy+win->_regbottom)); mvcur(-1, -1, win->_begy+win->_regbottom, 0); if (parm_index) { putp(tparm(parm_index, n)); } else if (scroll_forward) { i = n; while (i--) putp(scroll_forward); } if (change_scroll_region && (win->_begy+win->_regtop != 0 || win->_begy+win->_regbottom != lines - 1) ) putp(tparm(change_scroll_region, 0, lines-1)); } else { mvcur(-1, -1, win->_begy+win->_regtop, 0); if (parm_delete_line) { putp(tparm(parm_delete_line, n)); } else if (delete_line) { i = n; while (i--) putp(delete_line); } if (win->_begy+win->_regbottom < lines - 1) { mvcur(win->_begy+win->_regtop, 0, win->_begy+win->_regbottom, 0); if (parm_insert_line) { putp(tparm(parm_insert_line, n)); } else if (insert_line) { i = n; while (i--) putp(insert_line); } } } } mvcur(-1, -1, win->_begy+win->_cury, win->_begx+win->_curx); } else touchline(win, win->_regtop, win->_regbottom - win->_regtop + 1); return OK; }
~wish_monster_callback() override { werase( w_info ); wrefresh( w_info ); }
unsigned int vl_draw_list(WINDOW *win, vl_list *list, void **current_entry_user_ptr) { dl_list *node; unsigned int max_y,max_x; int key, i; char update; update = TRUE; getmaxyx(win, max_y, max_x); if( list->first_visible_entry == NULL ){ char found_selected; node = list->entries; while( node && node->prev ) node = node->prev; list->first_visible_entry = node; i = 1; found_selected = 0; while( node && node->next && i < max_y ){ if( node == list->selected_entry ) found_selected = 1; node = node->next; i++; } list->last_visible_entry = node; if( list->selected_entry != NULL && found_selected == 0 ){ /* Scroll down until we find our entry */ while( list->last_visible_entry && list->last_visible_entry->next ){ if( list->last_visible_entry == list->selected_entry ) break; list->first_visible_entry = list->first_visible_entry->next; list->last_visible_entry = list->last_visible_entry->next; } /* If possible, scroll down so that our entry is in the middle */ i = 0; while( list->last_visible_entry && list->last_visible_entry->next && i < (max_y / 2)){ list->first_visible_entry = list->first_visible_entry->next; list->last_visible_entry = list->last_visible_entry->next; i ++; } } } if( list->selected_entry == NULL ) list->selected_entry = list->first_visible_entry; #if 0 if( current_user_entry ){ selected_entry = current_user_entry; selected_entry_pos = 0; while( node ){ if( node == current_user_entry ) break; selected_entry_pos ++; node = node->next; } if( node == NULL ) selected_entry = NULL; } #endif while(1){ if(update){ vl_int_draw_list(win, max_x, list->selected_entry, list->first_visible_entry, list->last_visible_entry); update = FALSE; wrefresh(win); } key = wgetch(win); switch(key){ case KEY_UP: if(list->selected_entry->prev != NULL){ update = TRUE; if( list->selected_entry == list->first_visible_entry ){ /* Time to scroll (UPWARDS) */ list->first_visible_entry = list->first_visible_entry->prev; list->last_visible_entry = list->last_visible_entry->prev; list->selected_entry = list->selected_entry->prev; }else{ /* No Scrolling needed */ list->selected_entry = list->selected_entry->prev; } } break; case KEY_DOWN: if(list->selected_entry->next != NULL){ update = TRUE; if( list->selected_entry == list->last_visible_entry ){ /* Time to scroll (DOWNWARDS) */ list->first_visible_entry = list->first_visible_entry->next; list->last_visible_entry = list->last_visible_entry->next; list->selected_entry = list->selected_entry->next; }else{ /* No scrolling needed */ list->selected_entry = list->selected_entry->next; } } break; case KEY_NPAGE: /* Scroll down by height/2 entries */ case CTRL('d'): if( list->selected_entry->next != NULL){ update = TRUE; for(i=0;i<(max_y/2);i++){ if( list->selected_entry == list->last_visible_entry ){ list->first_visible_entry = list->first_visible_entry->next; list->last_visible_entry = list->last_visible_entry->next; list->selected_entry = list->selected_entry->next; }else{ list->selected_entry = list->selected_entry->next; } if( list->selected_entry->next == NULL ) break; } } break; case KEY_PPAGE: /* Scroll up by height/2 entries */ case CTRL('u'): if( list->selected_entry->prev != NULL ){ update = TRUE; for(i=0;i<(max_y/2);i++){ if( list->selected_entry == list->first_visible_entry ){ list->first_visible_entry = list->first_visible_entry->prev; list->last_visible_entry = list->last_visible_entry->prev; list->selected_entry = list->selected_entry->prev; }else{ list->selected_entry = list->selected_entry->prev; } if( list->selected_entry->prev == NULL ) break; } } break; case KEY_HOME: /* Goto first entry */ if( list->selected_entry->prev == NULL ) break; update = TRUE; while( list->selected_entry->prev != NULL ) list->selected_entry = list->selected_entry->prev; list->first_visible_entry = list->selected_entry; list->last_visible_entry = list->first_visible_entry; i = 1; while( list->last_visible_entry && list->last_visible_entry->next && i < max_y ){ list->last_visible_entry = list->last_visible_entry->next; i++; } break; case KEY_END: /* Goto last entry */ if( list->selected_entry->next == NULL ) break; update = TRUE; while( list->selected_entry->next != NULL ) list->selected_entry = list->selected_entry->next; while( list->last_visible_entry && list->last_visible_entry->next ){ list->last_visible_entry = list->last_visible_entry->next; list->first_visible_entry = list->first_visible_entry->next; } break; /*case KEY_HOME:*/ #if 0 case 'H': case 'h': if(selected_pos != 0){ update = TRUE; if( min_y != 0 ){ min_y = 0; start_entry = 0; stop_entry = (LINES-3); max_y = stop_entry; }else{ y_pos = selected_pos; vl_int_draw_list(win,list,&y_pos,0,selected_pos,selected_pos); start_entry = 0; stop_entry = 0; } y_pos = 0; selected_pos = 0; } break; /*case KEY_END:*/ case 'E': case 'e': if(selected_pos != last_entry){ update = TRUE; if( max_y < last_entry ){ /* Need to update the whole list */ y_pos = 0; start_entry = last_entry - (LINES-3); stop_entry = last_entry; min_y = start_entry; max_y = last_entry; }else{ /* Only update the current and last pos */ y_pos = selected_pos - min_y; vl_int_draw_list(win,list,&y_pos,last_entry,selected_pos,selected_pos); start_entry = last_entry; stop_entry = last_entry; if(last_entry < (LINES - 3)){ y_pos = last_entry; }else{ y_pos = (LINES - 3); } } selected_pos = last_entry; } break; #endif case KEY_ENTER: case 13: case 10: key = KEY_ENTER; default: *current_entry_user_ptr = ((vl_entry*)list->selected_entry->data)->user_ptr; return key; break; } } return 0; }
/* * This redraws the scrolling list. */ static void drawCDKScrollList (CDKSCROLL *scrollp, boolean Box) { int screenPos; int xpos, ypos; int j, k; /* If the list is empty, don't draw anything. */ if (scrollp->listSize > 0) { /* Redraw the list */ for (j = 0; j < scrollp->viewSize; j++) { xpos = SCREEN_YPOS (scrollp, 0); ypos = SCREEN_YPOS (scrollp, j); writeBlanks (scrollp->listWin, xpos, ypos, HORIZONTAL, 0, scrollp->boxWidth - 2 * BorderOf (scrollp)); k = j + scrollp->currentTop; /* Draw the elements in the scroll list. */ if (k < scrollp->listSize) { screenPos = SCREENPOS (scrollp, k); /* Write in the correct line. */ writeChtype (scrollp->listWin, (screenPos >= 0) ? screenPos : 1, ypos, scrollp->item[k], HORIZONTAL, (screenPos >= 0) ? 0 : (1 - screenPos), scrollp->itemLen[k]); } } drawCDKScrollCurrent (scrollp); /* Determine where the toggle is supposed to be. */ if (scrollp->scrollbarWin != 0) { scrollp->togglePos = floorCDK (scrollp->currentItem * (double)scrollp->step); /* Make sure the toggle button doesn't go out of bounds. */ if (scrollp->togglePos >= getmaxy (scrollp->scrollbarWin)) scrollp->togglePos = getmaxy (scrollp->scrollbarWin) - 1; /* Draw the scrollbar. */ (void)mvwvline (scrollp->scrollbarWin, 0, 0, ACS_CKBOARD, getmaxy (scrollp->scrollbarWin)); (void)mvwvline (scrollp->scrollbarWin, scrollp->togglePos, 0, ' ' | A_REVERSE, scrollp->toggleSize); } } /* Box it if needed. */ if (Box) { drawObjBox (scrollp->win, ObjOf (scrollp)); } else { touchwin (scrollp->win); } wrefresh (scrollp->win); }
void curses_message_win_puts(const char *message, boolean recursed) { int height, width, linespace, count; char *tmpstr; WINDOW *win = curses_get_nhwin(MESSAGE_WIN); boolean border = curses_window_has_border(MESSAGE_WIN); int message_length = strlen(message); int border_space = 0; if (!recursed) { strcpy(toplines, message); mesg_add_line((char *) message); } curses_get_window_size(MESSAGE_WIN, &height, &width); if (border) { border_space = 1; if (mx < 1) { mx = 1; } if (my < 1) { my = 1; } } linespace = ((width + border_space) - 3) - mx; if (linespace < message_length) { if (my >= (height - 1 + border_space)) /* bottom of message win */ { if (turn_lines == height) { curses_more(); } else { scroll_window(MESSAGE_WIN); turn_lines++; } } else { if (mx != border_space) { my++; mx = border_space; } } } if (height > 1) { curses_toggle_color_attr(win, NONE, ATR_BOLD, ON); } if ((mx == border_space) && ((message_length + 2) > width)) { tmpstr = curses_break_str(message, (width - 2), 1); mvwprintw(win, my, mx, tmpstr); mx += strlen(tmpstr); free(tmpstr); if (height > 1) { curses_toggle_color_attr(win, NONE, ATR_BOLD, OFF); } wrefresh(win); curses_message_win_puts(curses_str_remainder(message, (width - 2), 1), TRUE); } else { mvwprintw(win, my, mx, message); curses_toggle_color_attr(win, NONE, ATR_BOLD, OFF); } wrefresh(win); mx += message_length + 1; }
int main(int argc, char *argv[]) { char dir[PATH_MAX]; char config_dir[PATH_MAX]; char *console = NULL; int x; int rwin_args = 0; int lwin_args = 0; struct stat stat_buf; setlocale(LC_ALL, ""); getcwd(dir, sizeof(dir)); SetConsoleTitle("Vifm"); /* Window initializations */ rwin.curr_line = 0; rwin.top_line = 0; rwin.list_rows = 0; rwin.list_pos = 0; rwin.selected_filelist = NULL; rwin.history_num = 0; rwin.invert = 0; rwin.color_scheme = 0; lwin.curr_line = 0; lwin.top_line = 0; lwin.list_rows = 0; lwin.list_pos = 0; lwin.selected_filelist = NULL; lwin.history_num = 0; lwin.invert = 0; lwin.color_scheme = 0; /* These need to be initialized before reading the configuration file */ cfg.command_num = 0; cfg.filetypes_num = 0; cfg.nmapped_num = 0; cfg.vim_filter = 0; cfg.show_one_window = 0; command_list = NULL; filetypes = NULL; cfg.search_history_len = 15; cfg.search_history_num = -1; cfg.search_history = (char **)calloc(cfg.search_history_len, sizeof(char*)); cfg.cmd_history_len = 15; cfg.cmd_history_num = -1; cfg.cmd_history = (char **)calloc(cfg.cmd_history_len, sizeof(char *)); cfg.auto_execute = 0; cfg.color_scheme_num = 0; //col_schemes = (Col_scheme *)calloc(1, sizeof(Col_scheme*)); cfg.shell_cmd = strdup("cmd"); /* Maximum argument length to pass to the shell */ cfg.max_args = 4096; /* POSIX MINIMUM */ init_config(); set_config_dir(); read_config_file(); /* Misc configuration */ lwin.prev_invert = lwin.invert; lwin.hide_dot = 1; strncpy(lwin.regexp, "\\..~$", sizeof(lwin.regexp)); rwin.prev_invert = rwin.invert; rwin.hide_dot = 1; strncpy(rwin.regexp, "\\..~$", sizeof(rwin.regexp)); cfg.timer = 10; curr_stats.yanked_files = NULL; curr_stats.num_yanked_files = 0; curr_stats.need_redraw = 0; curr_stats.getting_input = 0; curr_stats.menu = 0; curr_stats.redraw_menu = 0; curr_stats.is_updir = 0; curr_stats.last_char = 0; curr_stats.is_console = 0; curr_stats.search = 0; curr_stats.save_msg = 0; curr_stats.use_register = 0; curr_stats.curr_register = -1; curr_stats.register_saved = 0; curr_stats.show_full = 0; curr_stats.view = 0; if (cfg.show_one_window) curr_stats.number_of_windows = 1; else curr_stats.number_of_windows = 2; if(stat(config_dir, &stat_buf) == 0) curr_stats.config_file_mtime = stat_buf.st_mtime; else curr_stats.config_file_mtime = 0; /* Check if running in X */ console = getenv("DISPLAY"); if(!console || !*console) curr_stats.is_console = 1; /* Setup the ncurses interface. */ if(!setup_ncurses_interface()) return -1; /* Load the initial directory */ snprintf(rwin.curr_dir, sizeof(rwin.curr_dir), "%s", dir); snprintf(lwin.curr_dir, sizeof(lwin.curr_dir), "%s", dir); rwin.dir_entry = (dir_entry_t *)malloc(sizeof(dir_entry_t)); lwin.dir_entry = (dir_entry_t *)malloc(sizeof(dir_entry_t)); rwin.dir_entry[0].name = malloc(sizeof("../") +1); lwin.dir_entry[0].name = malloc(sizeof("../") +1); strcpy(rwin.dir_entry[0].name, "../"); strcpy(lwin.dir_entry[0].name, "../"); change_directory(&rwin, dir); change_directory(&lwin, dir); other_view = &lwin; curr_view = &rwin; /* Get Command Line Arguments */ for(x = 1; x < argc; x++) { if(argv[x] != NULL) { if(!strcmp(argv[x], "-f")) { cfg.vim_filter = 1; } else if(!strcmp(argv[x], "--version")) { endwin(); system("clear"); printf("vifm %.1f\n\n", VERSION); exit(0); } else if(!strcmp(argv[x], "--help")) { endwin(); show_help_msg(); exit(0); } else if(is_dir(argv[x])) { if(lwin_args) { snprintf(rwin.curr_dir, sizeof(rwin.curr_dir), "%s", argv[x]); rwin_args++; } else { snprintf(lwin.curr_dir, sizeof(lwin.curr_dir), "%s", argv[x]); lwin_args++; } } else { endwin(); show_help_msg(); exit(0); } } } load_dir_list(&rwin, 0); if (rwin_args) { change_directory(&rwin, rwin.curr_dir); load_dir_list(&rwin, 0); } mvwaddstr(rwin.win, rwin.curr_line, 0, "*"); wrefresh(rwin.win); /* This is needed for the sort_dir_list() which uses curr_view */ switch_views(); load_dir_list(&lwin, 0); if (lwin_args) { change_directory(&lwin, lwin.curr_dir); load_dir_list(&lwin, 0); } moveto_list_pos(&lwin, 0); update_all_windows(); werase(status_bar); wnoutrefresh(status_bar); if(cfg.vim_filter) curr_stats.number_of_windows = 1; /* Enter the main loop. */ main_key_press_cb(curr_view); return 0; }
//clears a window int wclear(WINDOW *win) { werase(win); wrefresh(win); return 1; };
int maprefresh(void) { return wrefresh(mapwindow); }
void game::place_construction(constructable *con) { refresh_all(); inventory total_inv = crafting_inventory(); std::vector<point> valid; for (int x = u.posx - 1; x <= u.posx + 1; x++) { for (int y = u.posy - 1; y <= u.posy + 1; y++) { if (x == u.posx && y == u.posy) y++; construct test; bool place_okay = (test.*(con->able))(this, point(x, y)); for (int i = 0; i < con->stages.size() && !place_okay; i++) { if (m.ter(x, y) == con->stages[i].terrain) place_okay = true; } if (place_okay) { // Make sure we're not trying to continue a construction that we can't finish int starting_stage = 0, max_stage = -1; for (int i = 0; i < con->stages.size(); i++) { if (m.ter(x, y) == con->stages[i].terrain) starting_stage = i + 1; } for(int i = starting_stage; i < con->stages.size(); i++) { if (player_can_build(u, total_inv, con, i, true, true)) max_stage = i; else break; } if (max_stage >= starting_stage) { valid.push_back(point(x, y)); m.drawsq(w_terrain, u, x, y, true, false); wrefresh(w_terrain); } } } } mvprintz(0, 0, c_red, "Pick a direction in which to construct:"); int dirx, diry; get_direction(this, dirx, diry, input()); if (dirx == -2) { add_msg("Invalid direction."); return; } dirx += u.posx; diry += u.posy; bool point_is_okay = false; for (int i = 0; i < valid.size() && !point_is_okay; i++) { if (valid[i].x == dirx && valid[i].y == diry) point_is_okay = true; } if (!point_is_okay) { add_msg("You cannot build there!"); return; } // Figure out what stage to start at, and what stage is the maximum int starting_stage = 0, max_stage = 0; for (int i = 0; i < con->stages.size(); i++) { if (m.ter(dirx, diry) == con->stages[i].terrain) starting_stage = i + 1; if (player_can_build(u, total_inv, con, i, true)) max_stage = i; } u.assign_activity(ACT_BUILD, con->stages[starting_stage].time * 1000, con->id); u.moves = 0; std::vector<int> stages; for (int i = starting_stage; i <= max_stage; i++) stages.push_back(i); u.activity.values = stages; u.activity.placement = point(dirx, diry); }
//Refreshes window 0 (stdscr), causing it to redraw on top. int refresh(void) { return wrefresh(mainwin); };
void game::construction_menu() { WINDOW *w_con = newwin(25, 80, 0, 0); wborder(w_con, LINE_XOXO, LINE_XOXO, LINE_OXOX, LINE_OXOX, LINE_OXXO, LINE_OOXX, LINE_XXOO, LINE_XOOX ); mvwprintz(w_con, 0, 1, c_red, "Construction"); mvwputch(w_con, 0, 30, c_white, LINE_OXXX); mvwputch(w_con, 24, 30, c_white, LINE_XXOX); for (int i = 1; i < 24; i++) mvwputch(w_con, i, 30, c_white, LINE_XOXO); mvwprintz(w_con, 1, 31, c_white, "Difficulty:"); wrefresh(w_con); bool update_info = true; int select = 0; char ch; inventory total_inv = crafting_inventory(); do { // Erase existing list of constructions for (int i = 1; i < 24; i++) { for (int j = 1; j < 29; j++) mvwputch(w_con, i, j, c_black, 'x'); } // Determine where in the master list to start printing //int offset = select - 11; int offset = 0; if (select >= 22) offset = select - 22; // Print the constructions between offset and max (or how many will fit) for (int i = 0; i <= 22 && (i + offset) < constructions.size(); i++) { int current = i + offset; nc_color col = (player_can_build(u, total_inv, constructions[current]) ? c_white : c_dkgray); // Map menu items to hotkey letters, skipping j, k, l, and q. char hotkey = current + ((current < 9) ? 97 : ((current < 13) ? 100 : 101)); if (current == select) col = hilite(col); mvwprintz(w_con, 1 + i, 1, col, "%c %s", hotkey, constructions[current]->name.c_str()); } if (update_info) { update_info = false; constructable* current_con = constructions[select]; // Print difficulty int pskill = u.skillLevel("carpentry").level(); int diff = current_con->difficulty > 0 ? current_con->difficulty : 0; mvwprintz(w_con, 1, 43, (pskill >= diff ? c_white : c_red), "%d ", diff); // Clear out lines for tools & materials for (int i = 2; i < 24; i++) { for (int j = 31; j < 79; j++) mvwputch(w_con, i, j, c_black, 'x'); } // Print stages and their requirements int posx = 33, posy = 2; for (int n = 0; n < current_con->stages.size(); n++) { nc_color color_stage = (player_can_build(u, total_inv, current_con, n, false, true) ? c_white : c_dkgray); mvwprintz(w_con, posy, 31, color_stage, "Stage %d: %s", n + 1, current_con->stages[n].terrain == t_null? "" : terlist[current_con->stages[n].terrain].name.c_str()); posy++; // Print tools construction_stage stage = current_con->stages[n]; bool has_tool[3] = {stage.tools[0].empty(), stage.tools[1].empty(), stage.tools[2].empty()}; for (int i = 0; i < 3 && !has_tool[i]; i++) { posy++; posx = 33; for (int j = 0; j < stage.tools[i].size(); j++) { itype_id tool = stage.tools[i][j]; nc_color col = c_red; if (total_inv.has_amount(tool, 1)) { has_tool[i] = true; col = c_green; } int length = itypes[tool]->name.length(); if (posx + length > 79) { posy++; posx = 33; } mvwprintz(w_con, posy, posx, col, itypes[tool]->name.c_str()); posx += length + 1; // + 1 for an empty space if (j < stage.tools[i].size() - 1) { // "OR" if there's more if (posx > 77) { posy++; posx = 33; } mvwprintz(w_con, posy, posx, c_white, "OR"); posx += 3; } } } // Print components posy++; posx = 33; bool has_component[3] = {stage.components[0].empty(), stage.components[1].empty(), stage.components[2].empty()}; for (int i = 0; i < 3; i++) { posx = 33; while (has_component[i]) i++; for (int j = 0; j < stage.components[i].size() && i < 3; j++) { nc_color col = c_red; component comp = stage.components[i][j]; if (( itypes[comp.type]->is_ammo() && total_inv.has_charges(comp.type, comp.count)) || (!itypes[comp.type]->is_ammo() && total_inv.has_amount(comp.type, comp.count))) { has_component[i] = true; col = c_green; } int length = itypes[comp.type]->name.length(); if (posx + length > 79) { posy++; posx = 33; } mvwprintz(w_con, posy, posx, col, "%s x%d", itypes[comp.type]->name.c_str(), comp.count); posx += length + 3; // + 2 for " x", + 1 for an empty space // Add more space for the length of the count if (comp.count < 10) posx++; else if (comp.count < 100) posx += 2; else posx += 3; if (j < stage.components[i].size() - 1) { // "OR" if there's more if (posx > 77) { posy++; posx = 33; } mvwprintz(w_con, posy, posx, c_white, "OR"); posx += 3; } } posy++; } } wrefresh(w_con); } // Finished updating ch = input(); switch (ch) { case 'j': update_info = true; if (select < constructions.size() - 1) select++; else select = 0; break; case 'k': update_info = true; if (select > 0) select--; else select = constructions.size() - 1; break; case '\n': case 'l': if (player_can_build(u, total_inv, constructions[select])) { place_construction(constructions[select]); ch = 'q'; } else { popup("You can't build that!"); for (int i = 1; i < 24; i++) mvwputch(w_con, i, 30, c_white, LINE_XOXO); update_info = true; } break; case 'q': case 'Q': case KEY_ESCAPE: break; default: if (ch < 96 || ch > constructions.size() + 101) break; // Map menu items to hotkey letters, skipping j, k, l, and q. char hotkey = ch - ((ch < 106) ? 97 : ((ch < 112) ? 100 : 101)); if (player_can_build(u, total_inv, constructions[hotkey])) { place_construction(constructions[hotkey]); ch = 'q'; } else { popup("You can't build that!"); for (int i = 1; i < 24; i++) mvwputch(w_con, i, 30, c_white, LINE_XOXO); update_info = true; } break; } } while (ch != 'q' && ch != 'Q' && ch != KEY_ESCAPE); refresh_all(); }
list_selection *do_selection(list_selection * sel, const char *title, void(*perform) (list_selection *, void *), void *data) { WINDOW *wn; bool update = true; list_selection *s; list_selection *top = sel; list_selection *current = top; int i; int height = 0, width = (int)strlen(title) + 8; for (s = sel; s; s = s->next) { if ((int)strlen(s->str) > width) { width = (int)strlen(s->str); } ++height; log_debug("s %s w %d h %d\n", s->str, width, height); } if (height == 0 || width == 0) return 0; if (width + 3 > SX) width = SX - 4; if (height + 2 > SY) height = SY - 2; log_debug("w %d h %d\n", width, height); wn = newwin(height + 2, width + 4, (SY - height - 2) / 2, (SX - width - 4) / 2); for (;;) { int input; if (update) { for (s = top; s != NULL && top->index + height != s->index; s = s->next) { i = s->index - top->index; wmove(wn, i + 1, 4); waddnstr(wn, s->str, -1); wclrtoeol(wn); } wclrtobot(wn); wxborder(wn); mvwprintw(wn, 0, 2, "[ %s ]", title); update = false; } i = current->index - top->index; wattron(wn, A_BOLD | COLOR_PAIR(COLOR_YELLOW)); wmove(wn, i + 1, 2); waddstr(wn, "->"); wmove(wn, i + 1, 4); waddnstr(wn, current->str, width - 2); wattroff(wn, A_BOLD | COLOR_PAIR(COLOR_YELLOW)); wrefresh(wn); input = getch(); wmove(wn, i + 1, 2); waddstr(wn, " "); wmove(wn, i + 1, 4); waddnstr(wn, current->str, width); switch (input) { case KEY_NPAGE: for (i = 0; i != height / 2; ++i) { if (current->next) { current = current->next; if (current->index - height >= top->index) { top = current; update = true; } } } break; case KEY_PPAGE: for (i = 0; i != height / 2; ++i) { if (current->prev) { if (current == top) { top = sel; while (top->index + height < current->index) top = top->next; update = true; } current = current->prev; } } break; case KEY_DOWN: if (current->next) { current = current->next; if (current->index - height >= top->index) { top = current; update = true; } } break; case KEY_UP: if (current->prev) { if (current == top) { top = sel; while (top->index + height < current->index) top = top->next; update = true; } current = current->prev; } break; case 27: case 'q': delwin(wn); return NULL; case 10: case 13: if (perform) perform(current, data); else { delwin(wn); return current; } break; default: s = current->next; if (s == NULL) s = top; while (s != current) { if (tolower(s->str[0]) == tolower(input)) { current = s; update = true; } else { s = s->next; if (s == NULL) s = top; } } if (current->index - height >= top->index) { top = current; update = true; } } } }
const std::string &string_input_popup::query_string( const bool loop, const bool draw_only ) { if( !w ) { create_window(); } if( !ctxt ) { create_context(); } utf8_wrapper ret( _text ); utf8_wrapper edit( ctxt->get_edittext() ); if( _position == -1 ) { _position = ret.length(); } const int scrmax = _endx - _startx; // in output (console) cells, not characters of the string! int shift = 0; bool redraw = true; int ch = 0; do { if( _position < 0 ) { _position = 0; } const size_t left_shift = ret.substr( 0, _position ).display_width(); if( ( int )left_shift < shift ) { shift = 0; } else if( _position < ( int )ret.length() && ( int )left_shift + 1 >= shift + scrmax ) { // if the cursor is inside the input string, keep one cell right of // the cursor visible, because the cursor might be on a multi-cell // character. shift = left_shift - scrmax + 2; } else if( _position == ( int )ret.length() && ( int )left_shift >= shift + scrmax ) { // cursor is behind the end of the input string, keep the // trailing '_' visible (always a single cell character) shift = left_shift - scrmax + 1; } else if( shift < 0 ) { shift = 0; } const size_t xleft_shift = ret.substr_display( 0, shift ).display_width(); if( ( int )xleft_shift != shift ) { // This prevents a multi-cell character from been split, which is not possible // instead scroll a cell further to make that character disappear completely shift++; } if( redraw ) { redraw = false; draw( ret, edit, shift ); wrefresh( w ); } wrefresh( w ); if( draw_only ) { return _text; } const std::string action = ctxt->handle_input(); const input_event ev = ctxt->get_raw_input(); ch = ev.type == CATA_INPUT_KEYBOARD ? ev.get_first_input() : 0; if( callbacks[ch] ) { callbacks[ch](); } // This class only registers the ANY_INPUT action by default. If the // client provides their own input_context with registered actions // besides ANY_INPUT, ignore those so that the client may handle them. if( action != "ANY_INPUT" ) { continue; } if( ch == KEY_ESCAPE ) { _text = std::string(); _canceled = true; return _text; } else if( ch == '\n' ) { add_to_history( ret.str() ); _text = ret.str(); return _text; } else if( ch == KEY_UP ) { show_history( ret ); redraw = true; } else if( ch == KEY_DOWN || ch == KEY_NPAGE || ch == KEY_PPAGE || ch == KEY_BTAB || ch == 9 ) { /* absolutely nothing */ } else if( ch == KEY_RIGHT ) { if( _position + 1 <= ( int )ret.size() ) { _position++; } redraw = true; } else if( ch == KEY_LEFT ) { if( _position > 0 ) { _position--; } redraw = true; } else if( ch == 0x15 ) { // ctrl-u: delete all the things _position = 0; ret.erase( 0 ); redraw = true; // Move the cursor back and re-draw it } else if( ch == KEY_BACKSPACE ) { // but silently drop input if we're at 0, instead of adding '^' if( _position > 0 && _position <= ( int )ret.size() ) { //TODO: it is safe now since you only input ascii chars _position--; ret.erase( _position, 1 ); redraw = true; } } else if( ch == KEY_HOME ) { _position = 0; redraw = true; } else if( ch == KEY_END ) { _position = ret.size(); redraw = true; } else if( ch == KEY_DC ) { if( _position < ( int )ret.size() ) { ret.erase( _position, 1 ); redraw = true; } } else if( ch == KEY_F( 2 ) ) { std::string tmp = get_input_string_from_file(); int tmplen = utf8_width( tmp ); if( tmplen > 0 && ( tmplen + utf8_width( ret.c_str() ) <= _max_length || _max_length == 0 ) ) { ret.append( tmp ); } } else if( ch == ERR ) { // Ignore the error } else if( !ev.text.empty() && _only_digits && !( isdigit( ev.text[0] ) || ev.text[0] == '-' ) ) { // ignore non-digit (and '-' is a digit as well) } else if( _max_length > 0 && ( int )ret.length() >= _max_length ) { // no further input possible, ignore key } else if( !ev.text.empty() ) { const utf8_wrapper t( ev.text ); ret.insert( _position, t ); _position += t.length(); edit.erase( 0 ); ctxt->set_edittext( edit.c_str() ); redraw = true; } else if( ev.edit_refresh ) { const utf8_wrapper t( ev.edit ); edit.erase( 0 ); edit.insert( 0, t ); ctxt->set_edittext( edit.c_str() ); redraw = true; } else if( ev.edit.empty() ) { edit.erase( 0 ); ctxt->set_edittext( edit.c_str() ); redraw = true; } } while( loop == true ); _text = ret.str(); return _text; }
hp_part Character::body_window( const std::string &menu_header, bool show_all, bool precise, int normal_bonus, int head_bonus, int torso_bonus, int bleed, int bite, int infect ) const { WINDOW *hp_window = newwin(10, 31, (TERMY - 10) / 2, (TERMX - 31) / 2); draw_border(hp_window); trim_and_print( hp_window, 1, 1, getmaxx(hp_window) - 2, c_ltred, menu_header.c_str() ); nc_color color = c_ltgray; bool allowed_result[num_hp_parts] = { false }; const auto check_part = [&]( hp_part part, std::string part_name, int heal_val, int line_num ) { body_part bp = player::hp_to_bp( part ); if( show_all || hp_cur[part] < hp_max[part] || has_effect("infected", bp) || has_effect("bite", bp) || has_effect("bleed", bp) ) { nc_color color = show_all ? c_green : limb_color( bp, bleed, bite, infect ); if( color != c_ltgray || heal_val != 0 ) { mvwprintz( hp_window, line_num, 1, color, part_name.c_str() ); allowed_result[part] = true; } } }; check_part( hp_head, _("1: Head"), head_bonus, 2 ); check_part( hp_torso, _("2: Torso"), torso_bonus, 3 ); check_part( hp_arm_l, _("3: Left Arm"), normal_bonus, 4 ); check_part( hp_arm_r, _("4: Right Arm"), normal_bonus, 5 ); check_part( hp_leg_l, _("5: Left Leg"), normal_bonus, 6 ); check_part( hp_leg_r, _("6: Right Leg"), normal_bonus, 7 ); mvwprintz( hp_window, 8, 1, c_ltgray, _("7: Exit") ); std::string health_bar; for( int i = 0; i < num_hp_parts; i++ ) { if( !allowed_result[i] ) { continue; } body_part bp = body_part( i ); // Have printed the name of the body part, can select it int current_hp = hp_cur[i]; if( current_hp != 0 ) { std::tie( health_bar, color ) = get_hp_bar(current_hp, hp_max[i], false); // Drop the bar color, use the state color instead const nc_color state_col = limb_color( bp, true, true, true ); color = state_col != c_ltgray ? state_col : c_green; if( precise ) { mvwprintz(hp_window, i + 2, 15, color, "%5d", current_hp); } else { mvwprintz(hp_window, i + 2, 15, color, health_bar.c_str()); } } else { // curhp is 0; requires surgical attention // But still could be infected or bleeding const nc_color state_col = limb_color( bp, true, true, true ); color = state_col != c_ltgray ? state_col : c_dkgray; mvwprintz(hp_window, i + 2, 15, color, "-----"); } if( current_hp != 0 ) { switch( hp_part( i ) ) { case hp_head: current_hp += head_bonus; break; case hp_torso: current_hp += torso_bonus; break; default: current_hp += normal_bonus; break; } if( current_hp > hp_max[i] ) { current_hp = hp_max[i]; } else if (current_hp < 0) { current_hp = 0; } if( current_hp == hp_cur[i] && ( infect <= 0 || !has_effect( "infected", bp ) ) && ( bite <= 0 || !has_effect( "bite", bp ) ) && ( bleed <= 0 || !has_effect( "bleed", bp ) ) ) { // Nothing would change continue; } mvwprintz( hp_window, i + 2, 20, c_dkgray, " -> " ); std::tie( health_bar, color ) = get_hp_bar( current_hp, hp_max[i], false ); const nc_color state_col = limb_color( bp, bleed > 0, bite > 0, infect > 0 ); color = state_col != c_ltgray ? state_col : c_green; if( precise ) { mvwprintz( hp_window, i + 2, 24, color, "%5d", current_hp ); } else { mvwprintz( hp_window, i + 2, 24, color, health_bar.c_str() ); } } else { // curhp is 0; requires surgical attention const nc_color state_col = limb_color( bp, bleed > 0, bite > 0, infect > 0 ); color = state_col != c_ltgray ? state_col : c_dkgray; mvwprintz(hp_window, i + 2, 24, color, "-----"); } } wrefresh(hp_window); char ch; hp_part healed_part = num_hp_parts; do { ch = getch(); if (ch == '1') { healed_part = hp_head; } else if (ch == '2') { healed_part = hp_torso; } else if (ch == '3') { healed_part = hp_arm_l; } else if (ch == '4') { healed_part = hp_arm_r; } else if (ch == '5') { healed_part = hp_leg_l; } else if (ch == '6') { healed_part = hp_leg_r; } else if (ch == '7' || ch == KEY_ESCAPE) { healed_part = num_hp_parts; break; } } while (ch < '1' || ch > '7'); werase(hp_window); wrefresh(hp_window); delwin(hp_window); refresh(); return healed_part; }
void player::power_bionics() { std::vector <bionic *> passive = filtered_bionics( *my_bionics, TAB_PASSIVE ); std::vector <bionic *> active = filtered_bionics( *my_bionics, TAB_ACTIVE ); bionic *bio_last = nullptr; bionic_tab_mode tab_mode = TAB_ACTIVE; //added title_tab_height for the tabbed bionic display int TITLE_HEIGHT = 2; int TITLE_TAB_HEIGHT = 3; // Main window /** Total required height is: * top frame line: + 1 * height of title window: + TITLE_HEIGHT * height of tabs: + TITLE_TAB_HEIGHT * height of the biggest list of active/passive bionics: + bionic_count * bottom frame line: + 1 * TOTAL: TITLE_HEIGHT + TITLE_TAB_HEIGHT + bionic_count + 2 */ const int HEIGHT = std::min( TERMY, std::max( FULL_SCREEN_HEIGHT, TITLE_HEIGHT + TITLE_TAB_HEIGHT + static_cast<int>( my_bionics->size() ) + 2 ) ); const int WIDTH = FULL_SCREEN_WIDTH + ( TERMX - FULL_SCREEN_WIDTH ) / 2; const int START_X = ( TERMX - WIDTH ) / 2; const int START_Y = ( TERMY - HEIGHT ) / 2; //wBio is the entire bionic window catacurses::window wBio = catacurses::newwin( HEIGHT, WIDTH, START_Y, START_X ); const int LIST_HEIGHT = HEIGHT - TITLE_HEIGHT - TITLE_TAB_HEIGHT - 2; const int DESCRIPTION_WIDTH = WIDTH - 2 - 40; const int DESCRIPTION_START_Y = START_Y + TITLE_HEIGHT + TITLE_TAB_HEIGHT + 1; const int DESCRIPTION_START_X = START_X + 1 + 40; //w_description is the description panel that is controlled with ! key catacurses::window w_description = catacurses::newwin( LIST_HEIGHT, DESCRIPTION_WIDTH, DESCRIPTION_START_Y, DESCRIPTION_START_X ); // Title window const int TITLE_START_Y = START_Y + 1; const int HEADER_LINE_Y = TITLE_HEIGHT + TITLE_TAB_HEIGHT + 1; catacurses::window w_title = catacurses::newwin( TITLE_HEIGHT, WIDTH - 2, TITLE_START_Y, START_X + 1 ); const int TAB_START_Y = TITLE_START_Y + 2; //w_tabs is the tab bar for passive and active bionic groups catacurses::window w_tabs = catacurses::newwin( TITLE_TAB_HEIGHT, WIDTH - 2, TAB_START_Y, START_X + 1 ); int scroll_position = 0; int cursor = 0; //generate the tab title string and a count of the bionics owned bionic_menu_mode menu_mode = ACTIVATING; // offset for display: bionic with index i is drawn at y=list_start_y+i // drawing the bionics starts with bionic[scroll_position] const int list_start_y = HEADER_LINE_Y;// - scroll_position; int half_list_view_location = LIST_HEIGHT / 2; int max_scroll_position = std::max( 0, static_cast<int>( active.size() ) ); input_context ctxt( "BIONICS" ); ctxt.register_updown(); ctxt.register_action( "ANY_INPUT" ); ctxt.register_action( "TOGGLE_EXAMINE" ); ctxt.register_action( "REASSIGN" ); ctxt.register_action( "NEXT_TAB" ); ctxt.register_action( "PREV_TAB" ); ctxt.register_action( "CONFIRM" ); ctxt.register_action( "HELP_KEYBINDINGS" ); bool recalc = false; bool redraw = true; for( ;; ) { if( recalc ) { passive = filtered_bionics( *my_bionics, TAB_PASSIVE ); active = filtered_bionics( *my_bionics, TAB_ACTIVE ); if( active.empty() && !passive.empty() ) { tab_mode = TAB_PASSIVE; } if( --cursor < 0 ) { cursor = 0; } if( scroll_position > max_scroll_position && cursor - scroll_position < LIST_HEIGHT - half_list_view_location ) { scroll_position--; } recalc = false; // bionics were modified, so it's necessary to redraw the screen redraw = true; } //track which list we are looking at std::vector<bionic *> *current_bionic_list = ( tab_mode == TAB_ACTIVE ? &active : &passive ); max_scroll_position = std::max( 0, static_cast<int>( current_bionic_list->size() ) - LIST_HEIGHT ); if( redraw ) { redraw = false; werase( wBio ); draw_border( wBio, BORDER_COLOR, _( " BIONICS " ) ); // Draw symbols to connect additional lines to border mvwputch( wBio, HEADER_LINE_Y - 1, 0, BORDER_COLOR, LINE_XXXO ); // |- mvwputch( wBio, HEADER_LINE_Y - 1, WIDTH - 1, BORDER_COLOR, LINE_XOXX ); // -| int max_width = 0; std::vector<std::string>bps; for( const body_part bp : all_body_parts ) { const int total = get_total_bionics_slots( bp ); const std::string s = string_format( "%s: %d/%d", body_part_name_as_heading( bp, 1 ), total - get_free_bionics_slots( bp ), total ); bps.push_back( s ); max_width = std::max( max_width, utf8_width( s ) ); } const int pos_x = WIDTH - 2 - max_width; if( get_option < bool >( "CBM_SLOTS_ENABLED" ) ) { for( size_t i = 0; i < bps.size(); ++i ) { mvwprintz( wBio, i + list_start_y, pos_x, c_light_gray, bps[i] ); } } if( current_bionic_list->empty() ) { std::string msg; switch( tab_mode ) { case TAB_ACTIVE: msg = _( "No activatable bionics installed." ); break; case TAB_PASSIVE: msg = _( "No passive bionics installed." ); break; } fold_and_print( wBio, list_start_y, 2, pos_x - 1, c_light_gray, msg ); } else { for( size_t i = scroll_position; i < current_bionic_list->size(); i++ ) { if( list_start_y + static_cast<int>( i ) - scroll_position == HEIGHT - 1 ) { break; } const bool is_highlighted = cursor == static_cast<int>( i ); const nc_color col = get_bionic_text_color( *( *current_bionic_list )[i], is_highlighted ); const std::string desc = string_format( "%c %s", ( *current_bionic_list )[i]->invlet, build_bionic_powerdesc_string( *( *current_bionic_list )[i] ).c_str() ); trim_and_print( wBio, list_start_y + i - scroll_position, 2, WIDTH - 3, col, desc ); if( is_highlighted && menu_mode != EXAMINING && get_option < bool >( "CBM_SLOTS_ENABLED" ) ) { const bionic_id bio_id = ( *current_bionic_list )[i]->id; draw_connectors( wBio, list_start_y + i - scroll_position, utf8_width( desc ) + 3, pos_x - 2, bio_id ); // redraw highlighted (occupied) body parts for( auto &elem : bio_id->occupied_bodyparts ) { const int i = static_cast<int>( elem.first ); mvwprintz( wBio, i + list_start_y, pos_x, c_yellow, bps[i] ); } } } } draw_scrollbar( wBio, cursor, LIST_HEIGHT, current_bionic_list->size(), list_start_y ); #if defined(__ANDROID__) ctxt.get_registered_manual_keys().clear(); for( size_t i = 0; i < current_bionic_list->size(); i++ ) { ctxt.register_manual_key( ( *current_bionic_list )[i]->invlet, build_bionic_powerdesc_string( *( *current_bionic_list )[i] ).c_str() ); } #endif } wrefresh( wBio ); draw_bionics_tabs( w_tabs, active.size(), passive.size(), tab_mode ); draw_bionics_titlebar( w_title, this, menu_mode ); if( menu_mode == EXAMINING && !current_bionic_list->empty() ) { draw_description( w_description, *( *current_bionic_list )[cursor] ); } const std::string action = ctxt.handle_input(); const long ch = ctxt.get_raw_input().get_first_input(); bionic *tmp = nullptr; bool confirmCheck = false; if( action == "DOWN" ) { redraw = true; if( static_cast<size_t>( cursor ) < current_bionic_list->size() - 1 ) { cursor++; } else { cursor = 0; } if( scroll_position < max_scroll_position && cursor - scroll_position > LIST_HEIGHT - half_list_view_location ) { scroll_position++; } if( scroll_position > 0 && cursor - scroll_position < half_list_view_location ) { scroll_position = std::max( cursor - half_list_view_location, 0 ); } } else if( action == "UP" ) { redraw = true; if( cursor > 0 ) { cursor--; } else { cursor = current_bionic_list->size() - 1; } if( scroll_position > 0 && cursor - scroll_position < half_list_view_location ) { scroll_position--; } if( scroll_position < max_scroll_position && cursor - scroll_position > LIST_HEIGHT - half_list_view_location ) { scroll_position = std::max( std::min<int>( current_bionic_list->size() - LIST_HEIGHT, cursor - half_list_view_location ), 0 ); } } else if( menu_mode == REASSIGNING ) { menu_mode = ACTIVATING; if( action == "CONFIRM" && !current_bionic_list->empty() ) { auto &bio_list = tab_mode == TAB_ACTIVE ? active : passive; tmp = bio_list[cursor]; } else { tmp = bionic_by_invlet( ch ); } if( tmp == nullptr ) { // Selected an non-existing bionic (or Escape, or ...) continue; } redraw = true; const long newch = popup_getkey( _( "%s; enter new letter. Space to clear. Esc to cancel." ), tmp->id->name ); wrefresh( wBio ); if( newch == ch || newch == KEY_ESCAPE ) { continue; } if( newch == ' ' ) { tmp->invlet = ' '; continue; } if( !bionic_chars.valid( newch ) ) { popup( _( "Invalid bionic letter. Only those characters are valid:\n\n%s" ), bionic_chars.get_allowed_chars() ); continue; } bionic *otmp = bionic_by_invlet( newch ); if( otmp != nullptr ) { std::swap( tmp->invlet, otmp->invlet ); } else { tmp->invlet = newch; } // TODO: show a message like when reassigning a key to an item? } else if( action == "NEXT_TAB" ) { redraw = true; scroll_position = 0; cursor = 0; if( tab_mode == TAB_ACTIVE ) { tab_mode = TAB_PASSIVE; } else { tab_mode = TAB_ACTIVE; } } else if( action == "PREV_TAB" ) { redraw = true; scroll_position = 0; cursor = 0; if( tab_mode == TAB_PASSIVE ) { tab_mode = TAB_ACTIVE; } else { tab_mode = TAB_PASSIVE; } } else if( action == "REASSIGN" ) { menu_mode = REASSIGNING; } else if( action == "TOGGLE_EXAMINE" ) { // switches between activation and examination menu_mode = menu_mode == ACTIVATING ? EXAMINING : ACTIVATING; redraw = true; } else if( action == "HELP_KEYBINDINGS" ) { redraw = true; } else if( action == "CONFIRM" ) { confirmCheck = true; } else { confirmCheck = true; } //confirmation either occurred by pressing enter where the bionic cursor is, or the hotkey was selected if( confirmCheck ) { auto &bio_list = tab_mode == TAB_ACTIVE ? active : passive; if( action == "CONFIRM" && !current_bionic_list->empty() ) { tmp = bio_list[cursor]; } else { tmp = bionic_by_invlet( ch ); if( tmp && tmp != bio_last ) { // new bionic selected, update cursor and scroll position int temp_cursor = 0; for( temp_cursor = 0; temp_cursor < static_cast<int>( bio_list.size() ); temp_cursor++ ) { if( bio_list[temp_cursor] == tmp ) { break; } } // if bionic is not found in current list, ignore the attempt to view/activate if( temp_cursor >= static_cast<int>( bio_list.size() ) ) { continue; } //relocate cursor to the bionic that was found cursor = temp_cursor; scroll_position = 0; while( scroll_position < max_scroll_position && cursor - scroll_position > LIST_HEIGHT - half_list_view_location ) { scroll_position++; } } } if( !tmp ) { // entered a key that is not mapped to any bionic, // -> leave screen break; } bio_last = tmp; const bionic_id &bio_id = tmp->id; const bionic_data &bio_data = bio_id.obj(); if( menu_mode == ACTIVATING ) { if( bio_data.activated ) { int b = tmp - &( *my_bionics )[0]; if( tmp->powered ) { deactivate_bionic( b ); } else { activate_bionic( b ); // Clear the menu if we are firing a bionic gun if( tmp->info().gun_bionic || tmp->ammo_count > 0 ) { break; } } // update message log and the menu g->refresh_all(); redraw = true; if( moves < 0 ) { return; } continue; } else { popup( _( "You can not activate %s!\n" "To read a description of %s, press '!', then '%c'." ), bio_data.name, bio_data.name, tmp->invlet ); redraw = true; } } else if( menu_mode == EXAMINING ) { // Describing bionics, allow user to jump to description key redraw = true; if( action != "CONFIRM" ) { for( size_t i = 0; i < active.size(); i++ ) { if( active[i] == tmp ) { tab_mode = TAB_ACTIVE; cursor = static_cast<int>( i ); int max_scroll_check = std::max( 0, static_cast<int>( active.size() ) - LIST_HEIGHT ); if( static_cast<int>( i ) > max_scroll_check ) { scroll_position = max_scroll_check; } else { scroll_position = i; } break; } } for( size_t i = 0; i < passive.size(); i++ ) { if( passive[i] == tmp ) { tab_mode = TAB_PASSIVE; cursor = static_cast<int>( i ); int max_scroll_check = std::max( 0, static_cast<int>( passive.size() ) - LIST_HEIGHT ); if( static_cast<int>( i ) > max_scroll_check ) { scroll_position = max_scroll_check; } else { scroll_position = i; } break; } } } } } } }
/* layman's scrollable window... */ void show_scroll_win(WINDOW *main_window, const char *title, const char *text) { int res; int total_lines = get_line_no(text); int x, y; int start_x = 0, start_y = 0; int text_lines = 0, text_cols = 0; int total_cols = 0; int win_cols = 0; int win_lines = 0; int i = 0; WINDOW *win; WINDOW *pad; PANEL *panel; /* find the widest line of msg: */ total_lines = get_line_no(text); for (i = 0; i < total_lines; i++) { const char *line = get_line(text, i); int len = get_line_length(line); total_cols = max(total_cols, len+2); } /* create the pad */ pad = newpad(total_lines+10, total_cols+10); (void) wattrset(pad, attributes[SCROLLWIN_TEXT]); fill_window(pad, text); win_lines = min(total_lines+4, LINES-2); win_cols = min(total_cols+2, COLS-2); text_lines = max(win_lines-4, 0); text_cols = max(win_cols-2, 0); /* place window in middle of screen */ y = (LINES-win_lines)/2; x = (COLS-win_cols)/2; win = newwin(win_lines, win_cols, y, x); keypad(win, TRUE); /* show the help in the help window, and show the help panel */ (void) wattrset(win, attributes[SCROLLWIN_BOX]); box(win, 0, 0); (void) wattrset(win, attributes[SCROLLWIN_HEADING]); mvwprintw(win, 0, 3, " %s ", title); panel = new_panel(win); /* handle scrolling */ do { copywin(pad, win, start_y, start_x, 2, 2, text_lines, text_cols, 0); print_in_middle(win, text_lines+2, 0, text_cols, "<OK>", attributes[DIALOG_MENU_FORE]); wrefresh(win); res = wgetch(win); switch (res) { case KEY_NPAGE: case ' ': case 'd': start_y += text_lines-2; break; case KEY_PPAGE: case 'u': start_y -= text_lines+2; break; case KEY_HOME: start_y = 0; break; case KEY_END: start_y = total_lines-text_lines; break; case KEY_DOWN: case 'j': start_y++; break; case KEY_UP: case 'k': start_y--; break; case KEY_LEFT: case 'h': start_x--; break; case KEY_RIGHT: case 'l': start_x++; break; } if (res == 10 || res == 27 || res == 'q' || res == KEY_F(F_HELP) || res == KEY_F(F_BACK) || res == KEY_F(F_EXIT)) break; if (start_y < 0) start_y = 0; if (start_y >= total_lines-text_lines) start_y = total_lines-text_lines; if (start_x < 0) start_x = 0; if (start_x >= total_cols-text_cols) start_x = total_cols-text_cols; } while (res); del_panel(panel); delwin(win); refresh_all_windows(main_window); }
void write_status_bar(int x, char *line) { mvwprintw(status_bar_window, 0, x, "%s", line); wrefresh(status_bar_window); }
void game::draw_custom_explosion( const tripoint &, const std::map<tripoint, nc_color> &all_area ) { constexpr explosion_neighbors all_neighbors = N_NORTH | N_SOUTH | N_WEST | N_EAST; // We will "shell" the explosion area // Each phase will strip a single layer of points // A layer contains all points that have less than 4 neighbors in cardinal directions // Layers will first be generated, then drawn in inverse order // Start by getting rid of everything except current z-level std::map<point, explosion_tile> neighbors; #if defined(TILES) if( !use_tiles ) { for( const auto &pr : all_area ) { const tripoint relative_point = relative_view_pos( u, pr.first ); if( relative_point.z == 0 ) { point flat_point{ relative_point.x, relative_point.y }; neighbors[flat_point] = explosion_tile{ N_NO_NEIGHBORS, pr.second }; } } } else { // In tiles mode, the coordinates have to be absolute const tripoint view_center = relative_view_pos( u, u.pos() ); for( const auto &pr : all_area ) { const tripoint &pt = pr.first; // Relative point is only used for z level check const tripoint relative_point = relative_view_pos( u, pr.first ); if( relative_point.z == view_center.z ) { point flat_point{ pt.x, pt.y }; neighbors[flat_point] = explosion_tile{ N_NO_NEIGHBORS, pr.second }; } } } #else for( const auto &pr : all_area ) { const tripoint relative_point = relative_view_pos( u, pr.first ); if( relative_point.z == 0 ) { point flat_point{ relative_point.x, relative_point.y }; neighbors[flat_point] = explosion_tile{ N_NO_NEIGHBORS, pr.second }; } } #endif // Searches for a neighbor, sets the neighborhood flag on current point and on the neighbor const auto set_neighbors = [&]( const point &pos, explosion_neighbors &ngh, explosion_neighbors here, explosion_neighbors there ) { if( ( ngh & here ) == N_NO_NEIGHBORS ) { auto other = neighbors.find( pos ); if( other != neighbors.end() ) { ngh = ngh | here; other->second.neighborhood = other->second.neighborhood | there; } } }; // If the point we are about to remove has a neighbor in a given direction // unset that neighbor's flag that our current point is its neighbor const auto unset_neighbor = [&]( const point &pos, const explosion_neighbors ngh, explosion_neighbors here, explosion_neighbors there ) { if( ( ngh & here ) != N_NO_NEIGHBORS ) { auto other = neighbors.find( pos ); if( other != neighbors.end() ) { other->second.neighborhood = ( other->second.neighborhood | there ) ^ there; } } }; // Find all neighborhoods for( auto &pr : neighbors ) { const point &pt = pr.first; explosion_neighbors &ngh = pr.second.neighborhood; set_neighbors( point( pt.x - 1, pt.y ), ngh, N_WEST, N_EAST ); set_neighbors( point( pt.x + 1, pt.y ), ngh, N_EAST, N_WEST ); set_neighbors( point( pt.x, pt.y - 1 ), ngh, N_NORTH, N_SOUTH ); set_neighbors( point( pt.x, pt.y + 1 ), ngh, N_SOUTH, N_NORTH ); } // We need to save the layers because we will draw them in reverse order std::list< std::map<point, explosion_tile> > layers; bool changed; while( !neighbors.empty() ) { std::map<point, explosion_tile> layer; changed = false; // Find a layer that can be drawn for( const auto &pr : neighbors ) { if( pr.second.neighborhood != all_neighbors ) { changed = true; layer.insert( pr ); } } if( !changed ) { // An error, but a minor one - let it slide return; } // Remove the layer from the area to process for( const auto &pr : layer ) { const point &pt = pr.first; const explosion_neighbors ngh = pr.second.neighborhood; unset_neighbor( point( pt.x - 1, pt.y ), ngh, N_WEST, N_EAST ); unset_neighbor( point( pt.x + 1, pt.y ), ngh, N_EAST, N_WEST ); unset_neighbor( point( pt.x, pt.y - 1 ), ngh, N_NORTH, N_SOUTH ); unset_neighbor( point( pt.x, pt.y + 1 ), ngh, N_SOUTH, N_NORTH ); neighbors.erase( pr.first ); } layers.push_front( std::move( layer ) ); } #if defined(TILES) if( !use_tiles ) { draw_custom_explosion_curses( *this, layers ); return; } // We need to draw all explosions up to now std::map<point, explosion_tile> combined_layer; for( const auto &layer : layers ) { combined_layer.insert( layer.begin(), layer.end() ); tilecontext->init_custom_explosion_layer( combined_layer ); wrefresh(w_terrain); draw_animation_delay(EXPLOSION_MULTIPLIER); } tilecontext->void_custom_explosion(); #else draw_custom_explosion_curses( *this, layers ); #endif }
int main(int argc, string argv[]){ int c; int portnum; char* game_address; int verbose=0, server=0; while ( (c = getopt(argc, argv, "sp:g:hv")) != -1){ switch(c){ case 's': server = 1; break; case 'p': portnum = atoi(optarg); break; case 'g': game_address = optarg; break; case 'h': print_startup_options_help(); exit(1); case 'v': verbose = 1; break; } } if(server){ //launch server code } else{ clock_t timeNowMs = (1000* clock())/(CLOCKS_PER_SEC); init_ncurses(); int done = 0; gameMode_t game_mode = playerCreationMode; gameMode_t prev_mode; do{ //add timing code while loop //add updating and drawing code int c = getch(); if(c == 27 && !gameModeCmp(game_mode,escape_screen)){ //EscapeKey mvprintw(0,0,"GOING TO ESCAPE SCREEN"); prev_mode = game_mode; game_mode = escape_screen; } int update = game_mode.update(c); int draw = game_mode.draw(stdscr); wrefresh(stdscr); if(update == EXIT_GAME){ done = 1; }else if(update == RETURN){ game_mode = prev_mode; prev_mode = null_mode; } //timing code /*clock_t now = (1000* clock())/(CLOCKS_PER_SEC); int k = 0; while((now = now = (1000* clock())/(CLOCKS_PER_SEC)) - timeNowMs < 16){ k += 1; } timeNowMs = now;*/ }while(!done); endwin(); } return 0; }
static void show_current_field(WINDOW *win, FORM * form) { FIELD *field; FIELDTYPE *type; char *buffer; int nbuf; int field_rows, field_cols, field_max; if (has_colors()) { wbkgd(win, COLOR_PAIR(1)); } werase(win); wprintw(win, "Cursor: %d,%d", form->currow, form->curcol); if (data_ahead(form)) waddstr(win, " ahead"); if (data_behind(form)) waddstr(win, " behind"); waddch(win, '\n'); if ((field = current_field(form)) != 0) { wprintw(win, "Page %d%s, Field %d/%d%s:", form_page(form), new_page(field) ? "*" : "", field_index(field), field_count(form), field_arg(field) ? "(arg)" : ""); if ((type = field_type(field)) != 0) { if (type == TYPE_ALNUM) waddstr(win, "ALNUM"); else if (type == TYPE_ALPHA) waddstr(win, "ALPHA"); else if (type == TYPE_ENUM) waddstr(win, "ENUM"); else if (type == TYPE_INTEGER) waddstr(win, "INTEGER"); #ifdef NCURSES_VERSION else if (type == TYPE_IPV4) waddstr(win, "IPV4"); #endif else if (type == TYPE_NUMERIC) waddstr(win, "NUMERIC"); else if (type == TYPE_REGEXP) waddstr(win, "REGEXP"); else waddstr(win, "other"); } if (field_opts(field) & O_EDIT) waddstr(win, " editable"); else waddstr(win, " readonly"); if (field_status(field)) waddstr(win, " modified"); if (dynamic_field_info(field, &field_rows, &field_cols, &field_max) != ERR) { wprintw(win, " size %dx%d (max %d)", field_rows, field_cols, field_max); } waddch(win, ' '); wattrset(win, field_fore(field)); waddstr(win, "fore"); wattroff(win, field_fore(field)); waddch(win, '/'); wattrset(win, field_back(field)); waddstr(win, "back"); wattroff(win, field_back(field)); wprintw(win, ", pad '%c'", field_pad(field)); waddstr(win, "\n"); for (nbuf = 0; nbuf <= 2; ++nbuf) { if ((buffer = field_buffer(field, nbuf)) != 0) { wprintw(win, "buffer %d:", nbuf); wattrset(win, A_REVERSE); waddstr(win, buffer); wattroff(win, A_REVERSE); waddstr(win, "\n"); } } } wrefresh(win); }
void curses_update_stats() { char buf[BUFSZ]; int count, enc, orient, sx_start; WINDOW *win = curses_get_nhwin(STATUS_WIN); static boolean first = TRUE; boolean horiz; int sx = 0; int sy = 0; boolean border = curses_window_has_border(STATUS_WIN); if (border) { sx++; sy++; } sx_start = sx; if (first) { init_stats(); first = FALSE; } orient = curses_get_window_orientation(STATUS_WIN); if ((orient == ALIGN_RIGHT) || (orient == ALIGN_LEFT)) { horiz = FALSE; } else { horiz = TRUE; } curses_clear_nhwin(STATUS_WIN); /* Line 1 */ /* Player name and title */ strcpy(buf, plname); if ('a' <= buf[0] && buf[0] <= 'z') buf[0] += 'A'-'a'; strcat(buf, " the "); if (u.mtimedone) { char mname[BUFSZ]; int k = 0; strcpy(mname, mons[u.umonnum].mname); while(mname[k] != 0) { if ((k == 0 || (k > 0 && mname[k-1] == ' ')) && 'a' <= mname[k] && mname[k] <= 'z') { mname[k] += 'A' - 'a'; } k++; } strcat(buf, mname); } else { strcat(buf, rank_of(u.ulevel, pl_character[0], flags.female)); } if (strcmp(buf, prevname.txt) != 0) /* Title changed */ { prevname.highlight_turns = 5; prevname.highlight_color = HIGHLIGHT_COLOR; free(prevname.txt); prevname.txt = curses_copy_of(buf); } if (prevname.label != NULL) { mvwaddstr(win, sy, sx, prevname.label); sx += strlen(prevname.label); } if (prevname.highlight_turns > 0) { curses_toggle_color_attr(win, prevname.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevname.txt); curses_toggle_color_attr(win, prevname.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevname.txt); } if (horiz) { sx += strlen(prevname.txt) + 1; } else { sx = sx_start; sy++; } /* Strength */ if (ACURR(A_STR) != prevstr.value) /* Strength changed */ { if (ACURR(A_STR) > prevstr.value) { prevstr.highlight_color = STAT_UP_COLOR; } else { prevstr.highlight_color = STAT_DOWN_COLOR; } prevstr.value = ACURR(A_STR); if (ACURR(A_STR) > 118) { sprintf(buf, "%d", ACURR(A_STR) - 100); } else if (ACURR(A_STR)==118) { sprintf(buf, "18/**"); } else if(ACURR(A_STR) > 18) { sprintf(buf, "18/%02d", ACURR(A_STR) - 18); } else { sprintf(buf, "%d", ACURR(A_STR)); } free(prevstr.txt); prevstr.txt = curses_copy_of(buf); prevstr.highlight_turns = 5; } if (prevstr.label != NULL) { mvwaddstr(win, sy, sx, prevstr.label); sx += strlen(prevstr.label); } if (prevstr.highlight_turns > 0) { curses_toggle_color_attr(win, prevstr.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevstr.txt); curses_toggle_color_attr(win, prevstr.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevstr.txt); } if (horiz) { sx += strlen(prevstr.txt) + 1; } else { sx = sx_start; sy++; } /* Intelligence */ if (ACURR(A_INT) != prevint.value) /* Intelligence changed */ { if (ACURR(A_INT) > prevint.value) { prevint.highlight_color = STAT_UP_COLOR; } else { prevint.highlight_color = STAT_DOWN_COLOR; } prevint.value = ACURR(A_INT); sprintf(buf, "%d", ACURR(A_INT)); free(prevint.txt); prevint.txt = curses_copy_of(buf); prevint.highlight_turns = 5; } if (prevint.label != NULL) { mvwaddstr(win, sy, sx, prevint.label); sx += strlen(prevint.label); } if (prevint.highlight_turns > 0) { curses_toggle_color_attr(win, prevint.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevint.txt); curses_toggle_color_attr(win, prevint.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevint.txt); } if (horiz) { sx += strlen(prevint.txt) + 1; } else { sx = sx_start; sy++; } /* Wisdom */ if (ACURR(A_WIS) != prevwis.value) /* Wisdom changed */ { if (ACURR(A_WIS) > prevwis.value) { prevwis.highlight_color = STAT_UP_COLOR; } else { prevwis.highlight_color = STAT_DOWN_COLOR; } prevwis.value = ACURR(A_WIS); sprintf(buf, "%d", ACURR(A_WIS)); free(prevwis.txt); prevwis.txt = curses_copy_of(buf); prevwis.highlight_turns = 5; } if (prevwis.label != NULL) { mvwaddstr(win, sy, sx, prevwis.label); sx += strlen(prevwis.label); } if (prevwis.highlight_turns > 0) { curses_toggle_color_attr(win, prevwis.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevwis.txt); curses_toggle_color_attr(win, prevwis.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevwis.txt); } if (horiz) { sx += strlen(prevwis.txt) + 1; } else { sx = sx_start; sy++; } /* Dexterity */ if (ACURR(A_DEX) != prevdex.value) /* Dexterity changed */ { if (ACURR(A_DEX) > prevdex.value) { prevdex.highlight_color = STAT_UP_COLOR; } else { prevdex.highlight_color = STAT_DOWN_COLOR; } prevdex.value = ACURR(A_DEX); sprintf(buf, "%d", ACURR(A_DEX)); free(prevdex.txt); prevdex.txt = curses_copy_of(buf); prevdex.highlight_turns = 5; } if (prevdex.label != NULL) { mvwaddstr(win, sy, sx, prevdex.label); sx += strlen(prevdex.label); } if (prevdex.highlight_turns > 0) { curses_toggle_color_attr(win, prevdex.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevdex.txt); curses_toggle_color_attr(win, prevdex.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevdex.txt); } if (horiz) { sx += strlen(prevdex.txt) + 1; } else { sx = sx_start; sy++; } /* Constitution */ if (ACURR(A_CON) != prevcon.value) /* Constitution changed */ { if (ACURR(A_CON) > prevcon.value) { prevcon.highlight_color = STAT_UP_COLOR; } else { prevcon.highlight_color = STAT_DOWN_COLOR; } prevcon.value = ACURR(A_CON); sprintf(buf, "%d", ACURR(A_CON)); free(prevcon.txt); prevcon.txt = curses_copy_of(buf); prevcon.highlight_turns = 5; } if (prevcon.label != NULL) { mvwaddstr(win, sy, sx, prevcon.label); sx += strlen(prevcon.label); } if (prevcon.highlight_turns > 0) { curses_toggle_color_attr(win, prevcon.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevcon.txt); curses_toggle_color_attr(win, prevcon.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevcon.txt); } if (horiz) { sx += strlen(prevcon.txt) + 1; } else { sx = sx_start; sy++; } /* Charisma */ if (ACURR(A_CHA) != prevcha.value) /* Charisma changed */ { if (ACURR(A_CHA) > prevcha.value) { prevcha.highlight_color = STAT_UP_COLOR; } else { prevcha.highlight_color = STAT_DOWN_COLOR; } prevcha.value = ACURR(A_CHA); sprintf(buf, "%d", ACURR(A_CHA)); free(prevcha.txt); prevcha.txt = curses_copy_of(buf); prevcha.highlight_turns = 5; } if (prevcha.label != NULL) { mvwaddstr(win, sy, sx, prevcha.label); sx += strlen(prevcha.label); } if (prevcha.highlight_turns > 0) { curses_toggle_color_attr(win, prevcha.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevcha.txt); curses_toggle_color_attr(win, prevcha.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevcha.txt); } if (horiz) { sx += strlen(prevcha.txt) + 1; } else { sx = sx_start; sy++; } /* Alignment */ if (prevalign.alignment != u.ualign.type) /* Alignment changed */ { prevalign.highlight_color = HIGHLIGHT_COLOR; prevalign.highlight_turns = 10; /* This is a major change! */ prevalign.alignment = u.ualign.type; free(prevalign.txt); switch (u.ualign.type) { case A_LAWFUL: { prevalign.txt = curses_copy_of("Lawful"); break; } case A_NEUTRAL: { prevalign.txt = curses_copy_of("Neutral"); break; } case A_CHAOTIC: { prevalign.txt = curses_copy_of("Chaotic"); break; } } } if (prevalign.label != NULL) { mvwaddstr(win, sy, sx, prevalign.label); sx += strlen(prevalign.label); } if (prevalign.highlight_turns > 0) { curses_toggle_color_attr(win, prevalign.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevalign.txt); curses_toggle_color_attr(win, prevalign.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevalign.txt); } /* Line 2 */ sx = sx_start; sy++; /* Dungeon Level */ if (depth(&u.uz) != prevdepth.value) /* Dungeon level changed */ { prevdepth.highlight_color = HIGHLIGHT_COLOR; prevdepth.highlight_turns = 5; prevdepth.value = depth(&u.uz); free(prevdepth.txt); if (In_endgame(&u.uz)) { strcpy(buf, (Is_astralevel(&u.uz) ? "Astral Plane":"End Game")); } else { sprintf(buf, "%d", depth(&u.uz)); } prevdepth.txt = curses_copy_of(buf); } if (prevdepth.label != NULL) { mvwaddstr(win, sy, sx, prevdepth.label); sx += strlen(prevdepth.label); } if (prevdepth.highlight_turns > 0) { curses_toggle_color_attr(win, prevdepth.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevdepth.txt); curses_toggle_color_attr(win, prevdepth.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevdepth.txt); } if (horiz) { sx += strlen(prevdepth.txt) + 1; } else { sx = sx_start; sy++; } /* Gold */ #ifndef GOLDOBJ if (prevau.value != u.ugold) /* Gold changed */ { if (u.ugold > prevau.value) { #else if (prevau.value != money_cnt(invent)) /* Gold changed */ { if (money_cnt(invent) > prevau.value) { #endif prevau.highlight_color = HI_GOLD; } else { prevau.highlight_color = STAT_DOWN_COLOR; } #ifndef GOLDOBJ prevau.value = u.ugold; sprintf(buf,"%ld", u.ugold); #else prevau.value = money_cnt(invent); sprintf(buf,"%ld", money_cnt(invent)); #endif free(prevau.txt); prevau.txt = curses_copy_of(buf); prevau.highlight_turns = 5; } if (prevau.label != NULL) { mvwaddstr(win, sy, sx, prevau.label); sx += strlen(prevau.label); } if (prevau.highlight_turns > 0) { curses_toggle_color_attr(win, prevau.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevau.txt); curses_toggle_color_attr(win, prevau.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevau.txt); } if (horiz) { sx += strlen(prevau.txt) + 1; } else { sx = sx_start; sy++; } /* Hit Points */ if (u.mtimedone) /* Currently polymorphed - show monster HP */ { if (u.mh != prevhp.value) { if (u.mh > prevhp.value) { prevhp.highlight_color = STAT_UP_COLOR; } else { prevhp.highlight_color = STAT_DOWN_COLOR; } prevhp.highlight_turns = 3; prevhp.value = u.mh; sprintf(buf, "%d", u.mh); free(prevhp.txt); prevhp.txt = curses_copy_of(buf); } } else if (u.uhp != prevhp.value) /* Not polymorphed */ { if (u.uhp > prevhp.value) { prevhp.highlight_color = STAT_UP_COLOR; } else { prevhp.highlight_color = STAT_DOWN_COLOR; } prevhp.value = u.uhp; sprintf(buf, "%d", u.uhp); free(prevhp.txt); prevhp.txt = curses_copy_of(buf); prevhp.highlight_turns = 3; } if (prevhp.label != NULL) { mvwaddstr(win, sy, sx, prevhp.label); sx += strlen(prevhp.label); } if (prevhp.highlight_turns > 0) { curses_toggle_color_attr(win, prevhp.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevhp.txt); curses_toggle_color_attr(win, prevhp.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevhp.txt); } sx += strlen(prevhp.txt); /* Max Hit Points */ if (u.mtimedone) /* Currently polymorphed - show monster HP */ { if (u.mhmax != prevmhp.value) { if (u.mhmax > prevmhp.value) { prevmhp.highlight_color = STAT_UP_COLOR; } else { prevmhp.highlight_color = STAT_DOWN_COLOR; } prevmhp.value = u.mhmax; sprintf(buf, "%d", u.mhmax); free(prevmhp.txt); prevmhp.txt = curses_copy_of(buf); prevmhp.highlight_turns = 3; } } else if (u.uhpmax != prevmhp.value) /* Not polymorphed */ { if (u.uhpmax > prevmhp.value) { prevmhp.highlight_color = STAT_UP_COLOR; } else { prevmhp.highlight_color = STAT_DOWN_COLOR; } prevmhp.value = u.uhpmax; sprintf(buf, "%d", u.uhpmax); free(prevmhp.txt); prevmhp.txt = curses_copy_of(buf); prevmhp.highlight_turns = 3; } if (prevmhp.label != NULL) { mvwaddstr(win, sy, sx, prevmhp.label); sx += strlen(prevmhp.label); } if (prevmhp.highlight_turns > 0) { curses_toggle_color_attr(win, prevmhp.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevmhp.txt); curses_toggle_color_attr(win, prevmhp.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevmhp.txt); } if (horiz) { sx += strlen(prevmhp.txt) + 1; } else { sx = sx_start; sy++; } /* Power */ if (u.uen != prevpow.value) { if (u.uen > prevpow.value) { prevpow.highlight_color = STAT_UP_COLOR; } else { prevpow.highlight_color = STAT_DOWN_COLOR; } prevpow.value = u.uen; sprintf(buf, "%d", u.uen); free(prevpow.txt); prevpow.txt = curses_copy_of(buf); prevpow.highlight_turns = 3; } if (prevpow.label != NULL) { mvwaddstr(win, sy, sx, prevpow.label); sx += strlen(prevpow.label); } if (prevpow.highlight_turns > 0) { curses_toggle_color_attr(win, prevpow.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevpow.txt); curses_toggle_color_attr(win, prevpow.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevpow.txt); } sx += strlen(prevpow.txt); /* Max Power */ if (u.uenmax != prevmpow.value) { if (u.uenmax > prevmpow.value) { prevmpow.highlight_color = STAT_UP_COLOR; } else { prevmpow.highlight_color = STAT_DOWN_COLOR; } prevmpow.value = u.uenmax; sprintf(buf, "%d", u.uenmax); free(prevmpow.txt); prevmpow.txt = curses_copy_of(buf); prevmpow.highlight_turns = 3; } if (prevmpow.label != NULL) { mvwaddstr(win, sy, sx, prevmpow.label); sx += strlen(prevmpow.label); } if (prevmpow.highlight_turns > 0) { curses_toggle_color_attr(win, prevmpow.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevmpow.txt); curses_toggle_color_attr(win, prevmpow.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevmpow.txt); } if (horiz) { sx += strlen(prevmpow.txt) + 1; } else { sx = sx_start; sy++; } /* Armor Class */ if (u.uac != prevac.value) { if (u.uac > prevac.value) /* Lower is better for AC */ { prevac.highlight_color = STAT_DOWN_COLOR; } else { prevac.highlight_color = STAT_UP_COLOR; } prevac.value = u.uac; sprintf(buf, "%d", u.uac); free(prevac.txt); prevac.txt = curses_copy_of(buf); prevac.highlight_turns = 5; } if (prevac.label != NULL) { mvwaddstr(win, sy, sx, prevac.label); sx += strlen(prevac.label); } if (prevac.highlight_turns > 0) { curses_toggle_color_attr(win, prevac.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevac.txt); curses_toggle_color_attr(win, prevac.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevac.txt); } if (horiz) { sx += strlen(prevac.txt) + 1; } else { sx = sx_start; sy++; } /* Experience */ #ifdef EXP_ON_BOTL if (prevexp.display != flags.showexp) /* Setting has changed */ { prevexp.display = flags.showexp; free(prevlevel.label); if (prevexp.display) { prevlevel.label = curses_copy_of("/"); } else { prevlevel.label = curses_copy_of("Lvl:"); } } if (prevexp.display && !u.mtimedone) { if (u.uexp != prevexp.value) { if (u.uexp > prevexp.value) { prevexp.highlight_color = STAT_UP_COLOR; } else { prevexp.highlight_color = STAT_DOWN_COLOR; } sprintf(buf, "%d", u.uexp); free(prevexp.txt); prevexp.txt = curses_copy_of(buf); prevexp.highlight_turns = 3; } if (prevexp.label != NULL) { mvwaddstr(win, sy, sx, prevexp.label); sx += strlen(prevexp.label); } if (prevexp.highlight_turns > 0) { curses_toggle_color_attr(win, prevexp.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevexp.txt); curses_toggle_color_attr(win, prevexp.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevexp.txt); } sx += strlen(prevexp.txt); } prevexp.value = u.uexp; /* Track it even when it's not displayed */ #endif /* EXP_ON_BOTL */ /* Level */ if (u.mtimedone) /* Currently polymorphed - show monster HD */ { if (strncmp(prevlevel.label, "HD:", 3) != 0) { free(prevlevel.label); prevlevel.label = curses_copy_of("HD:"); } if (mons[u.umonnum].mlevel != prevlevel.value) { if (mons[u.umonnum].mlevel > prevlevel.value) { prevlevel.highlight_color = STAT_UP_COLOR; } else { prevlevel.highlight_color = STAT_DOWN_COLOR; } prevlevel.highlight_turns = 5; } prevlevel.value = mons[u.umonnum].mlevel; sprintf(buf, "%d", mons[u.umonnum].mlevel); free(prevlevel.txt); prevlevel.txt = curses_copy_of(buf); } else /* Not polymorphed */ { if (strncmp(prevlevel.label, "HD:", 3) == 0) { free(prevlevel.label); if (prevexp.display) { prevlevel.label = curses_copy_of("/"); } else { prevlevel.label = curses_copy_of("Lvl:"); } } if (u.ulevel > prevlevel.value) { prevlevel.highlight_color = STAT_UP_COLOR; prevlevel.highlight_turns = 5; } else if (u.ulevel < prevlevel.value) { prevlevel.highlight_color = STAT_DOWN_COLOR; prevlevel.highlight_turns = 5; } prevlevel.value = u.ulevel; sprintf(buf, "%d", u.ulevel); free(prevlevel.txt); prevlevel.txt = curses_copy_of(buf); } if (prevlevel.label != NULL) { mvwaddstr(win, sy, sx, prevlevel.label); sx += strlen(prevlevel.label); } if (prevlevel.highlight_turns > 0) { curses_toggle_color_attr(win, prevlevel.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevlevel.txt); curses_toggle_color_attr(win, prevlevel.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevlevel.txt); } if (horiz) { sx += strlen(prevlevel.txt) + 1; } else { sx = sx_start; sy++; } /* Time */ if (prevtime.display != flags.time) /* Setting has changed */ { prevtime.display = flags.time; } if (prevtime.display) { if (moves != prevtime.value) { sprintf(buf, "%ld", moves); free(prevtime.txt); prevtime.txt = curses_copy_of(buf); } if (prevtime.label != NULL) { mvwaddstr(win, sy, sx, prevtime.label); sx += strlen(prevtime.label); } mvwaddstr(win, sy, sx, prevtime.txt); if (horiz) { sx += strlen(prevtime.txt) + 1; } else { sx = sx_start; sy++; } } /* Score */ #ifdef SCORE_ON_BOTL if (prevscore.display != flags.showscore) /* Setting has changed */ { prevscore.display = flags.showscore; } if (prevscore.display) { if (botl_score() != prevscore.value) { if (botl_score() > prevscore.value) { prevscore.highlight_color = STAT_UP_COLOR; } else /* Not sure this is possible */ { prevscore.highlight_color = STAT_DOWN_COLOR; } sprintf(buf, "%ld", botl_score()); free(prevscore.txt); prevscore.txt = curses_copy_of(buf); prevscore.highlight_turns = 3; } if (prevscore.label != NULL) { mvwaddstr(win, sy, sx, prevscore.label); sx += strlen(prevscore.label); } if (prevscore.highlight_turns > 0) { curses_toggle_color_attr(win, prevscore.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevscore.txt); curses_toggle_color_attr(win, prevscore.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevscore.txt); } if (horiz) { sx += strlen(prevscore.txt) + 1; } else { sx = sx_start; sy++; } } prevscore.value = botl_score(); /* Track it even when it's not displayed */ #endif /* SCORE_ON_BOTL */ /* Hunger */ if (u.uhs != prevhunger.value) { if ((u.uhs > prevhunger.value) || (u.uhs > 3)) { prevhunger.highlight_color = STAT_DOWN_COLOR; } else { prevhunger.highlight_color = STAT_UP_COLOR; } prevhunger.value = u.uhs; for (count = 0; count < strlen(hu_stat[u.uhs]); count++) { if ((hu_stat[u.uhs][count]) == ' ') { break; } buf[count] = hu_stat[u.uhs][count]; } buf[count] = '\0'; free(prevhunger.txt); prevhunger.txt = curses_copy_of(buf); prevhunger.highlight_turns = 5; } if (prevhunger.label != NULL) { mvwaddstr(win, sy, sx, prevhunger.label); sx += strlen(prevhunger.label); } if (prevhunger.highlight_turns > 0) { curses_toggle_color_attr(win, prevhunger.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevhunger.txt); curses_toggle_color_attr(win, prevhunger.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevhunger.txt); } if (strlen(prevhunger.txt) > 0) { if (horiz) { sx += strlen(prevhunger.txt) + 1; } else { sx = sx_start; sy++; } } /* Confusion */ if (Confusion != prevconf.value) { prevconf.highlight_color = STAT_DOWN_COLOR; if (prevconf.txt != NULL) { free(prevconf.txt); } if (Confusion) { prevconf.txt = curses_copy_of("Conf"); } else { prevconf.txt = NULL; } if (prevconf.value == 0) { prevconf.highlight_turns = 5; } prevconf.value = Confusion; } if (prevconf.label != NULL) { mvwaddstr(win, sy, sx, prevconf.label); sx += strlen(prevconf.label); } if (prevconf.txt != NULL) { if (prevconf.highlight_turns > 0) { curses_toggle_color_attr(win, prevconf.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevconf.txt); curses_toggle_color_attr(win, prevconf.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevconf.txt); } } if (prevconf.txt != NULL) { if (horiz) { sx += strlen(prevconf.txt) + 1; } else { sx = sx_start; sy++; } } /* Blindness */ if (Blind != prevblind.value) { prevblind.highlight_color = STAT_DOWN_COLOR; if (prevblind.txt != NULL) { free(prevblind.txt); } if (Blind) { prevblind.txt = curses_copy_of("Blind"); } else { prevblind.txt = NULL; } if (prevblind.value == 0) { prevblind.highlight_turns = 5; } prevblind.value = Blind; } if (prevblind.label != NULL) { mvwaddstr(win, sy, sx, prevblind.label); sx += strlen(prevblind.label); } if (prevblind.txt != NULL) { if (prevblind.highlight_turns > 0) { curses_toggle_color_attr(win, prevblind.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevblind.txt); curses_toggle_color_attr(win, prevblind.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevblind.txt); } } if (prevblind.txt != NULL) { if (horiz) { sx += strlen(prevblind.txt) + 1; } else { sx = sx_start; sy++; } } /* Stun */ if (Stunned != prevstun.value) { prevstun.highlight_color = STAT_DOWN_COLOR; if (prevstun.txt != NULL) { free(prevstun.txt); } if (Stunned) { prevstun.txt = curses_copy_of("Stun"); } else { prevstun.txt = NULL; } if (prevstun.value == 0) { prevstun.highlight_turns = 5; } prevstun.value = Stunned; } if (prevstun.label != NULL) { mvwaddstr(win, sy, sx, prevstun.label); sx += strlen(prevstun.label); } if (prevstun.txt != NULL) { if (prevstun.highlight_turns > 0) { curses_toggle_color_attr(win, prevstun.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevstun.txt); curses_toggle_color_attr(win, prevstun.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevstun.txt); } } if (prevstun.txt != NULL) { if (horiz) { sx += strlen(prevstun.txt) + 1; } else { sx = sx_start; sy++; } } /* Hallucination */ if (Hallucination != prevhallu.value) { prevhallu.highlight_color = STAT_DOWN_COLOR; if (prevhallu.txt != NULL) { free(prevhallu.txt); } if (Hallucination) { prevhallu.txt = curses_copy_of("Hallu"); } else { prevhallu.txt = NULL; } if (prevhallu.value == 0) { prevhallu.highlight_turns = 5; } prevhallu.value = Hallucination; } if (prevhallu.label != NULL) { mvwaddstr(win, sy, sx, prevhallu.label); sx += strlen(prevhallu.label); } if (prevhallu.txt != NULL) { if (prevhallu.highlight_turns > 0) { curses_toggle_color_attr(win, prevhallu.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevhallu.txt); curses_toggle_color_attr(win, prevhallu.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevhallu.txt); } } if (prevhallu.txt != NULL) { if (horiz) { sx += strlen(prevhallu.txt) + 1; } else { sx = sx_start; sy++; } } /* Sick */ if (Sick != prevsick.value) { prevsick.highlight_color = STAT_DOWN_COLOR; if (prevsick.txt != NULL) { free(prevsick.txt); } if (Sick) { if (u.usick_type & SICK_VOMITABLE) { prevsick.txt = curses_copy_of("FoodPois"); } else { prevsick.txt = curses_copy_of("Ill"); } } else { prevsick.txt = NULL; } if (prevsick.value == 0) { prevsick.highlight_turns = 5; } prevsick.value = Sick; } if (prevsick.label != NULL) { mvwaddstr(win, sy, sx, prevsick.label); sx += strlen(prevsick.label); } if (prevsick.txt != NULL) { if (prevsick.highlight_turns > 0) { curses_toggle_color_attr(win, prevsick.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevsick.txt); curses_toggle_color_attr(win, prevsick.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevsick.txt); } } if (prevsick.txt != NULL) { if (horiz) { sx += strlen(prevsick.txt) + 1; } else { sx = sx_start; sy++; } } /* Slime */ if (Slimed != prevslime.value) { prevslime.highlight_color = STAT_DOWN_COLOR; if (prevslime.txt != NULL) { free(prevslime.txt); } if (Slimed) { prevslime.txt = curses_copy_of("Slime"); } else { prevslime.txt = NULL; } if (prevslime.value == 0) { prevslime.highlight_turns = 5; } prevslime.value = Slimed; } if (prevslime.label != NULL) { mvwaddstr(win, sy, sx, prevslime.label); sx += strlen(prevslime.label); } if (prevslime.txt != NULL) { if (prevslime.highlight_turns > 0) { curses_toggle_color_attr(win, prevslime.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevslime.txt); curses_toggle_color_attr(win, prevslime.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevslime.txt); } } if (prevslime.txt != NULL) { if (horiz) { sx += strlen(prevslime.txt) + 1; } else { sx = sx_start; sy++; } } /* Encumberance */ enc = near_capacity(); if (enc != prevencumb.value) { if (enc < prevencumb.value) { prevencumb.highlight_color = STAT_UP_COLOR; } else { prevencumb.highlight_color = STAT_DOWN_COLOR; } if (prevencumb.txt != NULL) { free(prevencumb.txt); } if (enc > UNENCUMBERED) { sprintf(buf, "%s", enc_stat[enc]); prevencumb.txt = curses_copy_of(buf); prevencumb.highlight_turns = 5; } else { prevencumb.txt = NULL; } prevencumb.value = enc; } if (prevencumb.label != NULL) { mvwaddstr(win, sy, sx, prevencumb.label); sx += strlen(prevencumb.label); } if (prevencumb.txt != NULL) { if (prevencumb.highlight_turns > 0) { curses_toggle_color_attr(win, prevencumb.highlight_color, NONE, ON); mvwaddstr(win, sy, sx, prevencumb.txt); curses_toggle_color_attr(win, prevencumb.highlight_color, NONE, OFF); } else { mvwaddstr(win, sy, sx, prevencumb.txt); } } if (prevencumb.txt != NULL) { if (horiz) { sx += strlen(prevencumb.txt) + 1; } else { sx = sx_start; sy++; } } wrefresh(win); } /* Decrement the highlight_turns for all stats. Call curses_update_stats if needed to unhighlight a stat */ void curses_decrement_highlight() { boolean unhighlight = FALSE; if (prevname.highlight_turns > 0) { prevname.highlight_turns--; if (prevname.highlight_turns == 0) { unhighlight = TRUE; } } if (prevdepth.highlight_turns > 0) { prevdepth.highlight_turns--; if (prevdepth.highlight_turns == 0) { unhighlight = TRUE; } } if (prevstr.highlight_turns > 0) { prevstr.highlight_turns--; if (prevstr.highlight_turns == 0) { unhighlight = TRUE; } } if (prevint.highlight_turns > 0) { prevint.highlight_turns--; if (prevint.highlight_turns == 0) { unhighlight = TRUE; } } if (prevwis.highlight_turns > 0) { prevwis.highlight_turns--; if (prevwis.highlight_turns == 0) { unhighlight = TRUE; } } if (prevdex.highlight_turns > 0) { prevdex.highlight_turns--; if (prevdex.highlight_turns == 0) { unhighlight = TRUE; } } if (prevcon.highlight_turns > 0) { prevcon.highlight_turns--; if (prevcon.highlight_turns == 0) { unhighlight = TRUE; } } if (prevcha.highlight_turns > 0) { prevcha.highlight_turns--; if (prevcha.highlight_turns == 0) { unhighlight = TRUE; } } if (prevalign.highlight_turns > 0) { prevalign.highlight_turns--; if (prevalign.highlight_turns == 0) { unhighlight = TRUE; } } if (prevau.highlight_turns > 0) { prevau.highlight_turns--; if (prevau.highlight_turns == 0) { unhighlight = TRUE; } } if (prevhp.highlight_turns > 0) { prevhp.highlight_turns--; if (prevhp.highlight_turns == 0) { unhighlight = TRUE; } } if (prevmhp.highlight_turns > 0) { prevmhp.highlight_turns--; if (prevmhp.highlight_turns == 0) { unhighlight = TRUE; } } if (prevlevel.highlight_turns > 0) { prevlevel.highlight_turns--; if (prevlevel.highlight_turns == 0) { unhighlight = TRUE; } } if (prevpow.highlight_turns > 0) { prevpow.highlight_turns--; if (prevpow.highlight_turns == 0) { unhighlight = TRUE; } } if (prevmpow.highlight_turns > 0) { prevmpow.highlight_turns--; if (prevmpow.highlight_turns == 0) { unhighlight = TRUE; } } if (prevac.highlight_turns > 0) { prevac.highlight_turns--; if (prevac.highlight_turns == 0) { unhighlight = TRUE; } } #ifdef EXP_ON_BOTL if (prevexp.highlight_turns > 0) { prevexp.highlight_turns--; if (prevexp.highlight_turns == 0) { unhighlight = TRUE; } } #endif if (prevtime.highlight_turns > 0) { prevtime.highlight_turns--; if (prevtime.highlight_turns == 0) { unhighlight = TRUE; } } #ifdef SCORE_ON_BOTL if (prevscore.highlight_turns > 0) { prevscore.highlight_turns--; if (prevscore.highlight_turns == 0) { unhighlight = TRUE; } } #endif if (prevhunger.highlight_turns > 0) { prevhunger.highlight_turns--; if (prevhunger.highlight_turns == 0) { unhighlight = TRUE; } } if (prevconf.highlight_turns > 0) { prevconf.highlight_turns--; if (prevconf.highlight_turns == 0) { unhighlight = TRUE; } } if (prevblind.highlight_turns > 0) { prevblind.highlight_turns--; if (prevblind.highlight_turns == 0) { unhighlight = TRUE; } } if (prevstun.highlight_turns > 0) { prevstun.highlight_turns--; if (prevstun.highlight_turns == 0) { unhighlight = TRUE; } } if (prevhallu.highlight_turns > 0) { prevhallu.highlight_turns--; if (prevhallu.highlight_turns == 0) { unhighlight = TRUE; } } if (prevsick.highlight_turns > 0) { prevsick.highlight_turns--; if (prevsick.highlight_turns == 0) { unhighlight = TRUE; } } if (prevslime.highlight_turns > 0) { prevslime.highlight_turns--; if (prevslime.highlight_turns == 0) { unhighlight = TRUE; } } if (prevencumb.highlight_turns > 0) { prevencumb.highlight_turns--; if (prevencumb.highlight_turns == 0) { unhighlight = TRUE; } } if (unhighlight) { curses_update_stats(); } } /* Initialize the stats with beginning values. */ static void init_stats() { char buf[BUFSZ]; int count; /* Player name and title */ strcpy(buf, plname); if ('a' <= buf[0] && buf[0] <= 'z') buf[0] += 'A'-'a'; strcat(buf, " the "); if (u.mtimedone) { char mname[BUFSZ]; int k = 0; strcpy(mname, mons[u.umonnum].mname); while(mname[k] != 0) { if ((k == 0 || (k > 0 && mname[k-1] == ' ')) && 'a' <= mname[k] && mname[k] <= 'z') { mname[k] += 'A' - 'a'; } k++; } strcat(buf, mname); } else { strcat(buf, rank_of(u.ulevel, pl_character[0], flags.female)); } prevname.txt = curses_copy_of(buf); prevname.display = TRUE; prevname.highlight_turns = 0; prevname.label = NULL; /* Strength */ if (ACURR(A_STR) > 118) { sprintf(buf, "%d", ACURR(A_STR) - 100); } else if (ACURR(A_STR)==118) { sprintf(buf, "18/**"); } else if(ACURR(A_STR) > 18) { sprintf(buf, "18/%02d", ACURR(A_STR) - 18); } else { sprintf(buf, "%d", ACURR(A_STR)); } prevstr.value = ACURR(A_STR); prevstr.txt = curses_copy_of(buf); prevstr.display = TRUE; prevstr.highlight_turns = 0; prevstr.label = curses_copy_of("Str:"); /* Intelligence */ sprintf(buf, "%d", ACURR(A_INT)); prevint.value = ACURR(A_INT); prevint.txt = curses_copy_of(buf); prevint.display = TRUE; prevint.highlight_turns = 0; prevint.label = curses_copy_of("Int:"); /* Wisdom */ sprintf(buf, "%d", ACURR(A_WIS)); prevwis.value = ACURR(A_WIS); prevwis.txt = curses_copy_of(buf); prevwis.display = TRUE; prevwis.highlight_turns = 0; prevwis.label = curses_copy_of("Wis:"); /* Dexterity */ sprintf(buf, "%d", ACURR(A_DEX)); prevdex.value = ACURR(A_DEX); prevdex.txt = curses_copy_of(buf); prevdex.display = TRUE; prevdex.highlight_turns = 0; prevdex.label = curses_copy_of("Dex:"); /* Constitution */ sprintf(buf, "%d", ACURR(A_CON)); prevcon.value = ACURR(A_CON); prevcon.txt = curses_copy_of(buf); prevcon.display = TRUE; prevcon.highlight_turns = 0; prevcon.label = curses_copy_of("Con:"); /* Charisma */ sprintf(buf, "%d", ACURR(A_CHA)); prevcha.value = ACURR(A_CHA); prevcha.txt = curses_copy_of(buf); prevcha.display = TRUE; prevcha.highlight_turns = 0; prevcha.label = curses_copy_of("Cha:"); /* Alignment */ switch (u.ualign.type) { case A_LAWFUL: { prevalign.txt = curses_copy_of("Lawful"); break; } case A_NEUTRAL: { prevalign.txt = curses_copy_of("Neutral"); break; } case A_CHAOTIC: { prevalign.txt = curses_copy_of("Chaotic"); break; } } prevalign.alignment = u.ualign.type; prevalign.display = TRUE; prevalign.highlight_turns = 0; prevalign.label = NULL; /* Dungeon level */ if (In_endgame(&u.uz)) { strcpy(buf, (Is_astralevel(&u.uz) ? "Astral Plane":"End Game")); } else { sprintf(buf, "%d", depth(&u.uz)); } prevdepth.value = depth(&u.uz); prevdepth.txt = curses_copy_of(buf); prevdepth.display = TRUE; prevdepth.highlight_turns = 0; prevdepth.label = curses_copy_of("Dlvl:"); /* Gold */ #ifndef GOLDOBJ sprintf(buf,"%ld", u.ugold); prevau.value = u.ugold; #else sprintf(buf,"%ld", money_cnt(invent)); prevau.value = money_cnt(invent); #endif prevau.txt = curses_copy_of(buf); prevau.display = TRUE; prevau.highlight_turns = 0; sprintf(buf, "%c:", GOLD_SYM); prevau.label = curses_copy_of(buf); /* Hit Points */ if (u.mtimedone) /* Currently polymorphed - show monster HP */ { prevhp.value = u.mh; sprintf(buf, "%d", u.mh); prevhp.txt = curses_copy_of(buf); } else if (u.uhp != prevhp.value) /* Not polymorphed */ { prevhp.value = u.uhp; sprintf(buf, "%d", u.uhp); prevhp.txt = curses_copy_of(buf); } prevhp.display = TRUE; prevhp.highlight_turns = 0; prevhp.label = curses_copy_of("HP:"); /* Max Hit Points */ if (u.mtimedone) /* Currently polymorphed - show monster HP */ { prevmhp.value = u.mhmax; sprintf(buf, "%d", u.mhmax); prevmhp.txt = curses_copy_of(buf); } else /* Not polymorphed */ { prevmhp.value = u.uhpmax; sprintf(buf, "%d", u.uhpmax); prevmhp.txt = curses_copy_of(buf); } prevmhp.display = TRUE; prevmhp.highlight_turns = 0; prevmhp.label = curses_copy_of("/"); /* Power */ prevpow.value = u.uen; sprintf(buf, "%d", u.uen); prevpow.txt = curses_copy_of(buf); prevpow.display = TRUE; prevpow.highlight_turns = 0; prevpow.label = curses_copy_of("Pw:"); /* Max Power */ prevmpow.value = u.uenmax; sprintf(buf, "%d", u.uenmax); prevmpow.txt = curses_copy_of(buf); prevmpow.display = TRUE; prevmpow.highlight_turns = 0; prevmpow.label = curses_copy_of("/"); /* Armor Class */ prevac.value = u.uac; sprintf(buf, "%d", u.uac); prevac.txt = curses_copy_of(buf); prevac.display = TRUE; prevac.highlight_turns = 0; prevac.label = curses_copy_of("AC:"); /* Experience */ #ifdef EXP_ON_BOTL prevexp.value = u.uexp; sprintf(buf, "%ld", u.uexp); prevexp.txt = curses_copy_of(buf); prevexp.display = flags.showexp; prevexp.highlight_turns = 0; prevexp.label = curses_copy_of("Xp:"); #endif /* Level */ if (u.mtimedone) /* Currently polymorphed - show monster HP */ { prevlevel.value = mons[u.umonnum].mlevel; sprintf(buf, "%d", mons[u.umonnum].mlevel); prevlevel.txt = curses_copy_of(buf); prevlevel.label = curses_copy_of("HD:"); } else if (u.ulevel != prevlevel.value) /* Not polymorphed */ { prevlevel.value = u.ulevel; sprintf(buf, "%d", u.ulevel); prevlevel.txt = curses_copy_of(buf); if (prevexp.display) { prevlevel.label = curses_copy_of("/"); } else { prevlevel.label = curses_copy_of("Lvl:"); } } prevlevel.display = TRUE; prevlevel.highlight_turns = 0; /* Time */ prevtime.value = moves; sprintf(buf, "%ld", moves); prevtime.txt = curses_copy_of(buf); prevtime.display = flags.time; prevtime.highlight_turns = 0; prevtime.label = curses_copy_of("T:"); /* Score */ #ifdef SCORE_ON_BOTL prevscore.value = botl_score(); sprintf(buf, "%ld", botl_score()); prevscore.txt = curses_copy_of(buf); prevscore.display = flags.showscore; prevscore.highlight_turns = 0; prevscore.label = curses_copy_of("S:"); #endif /* Hunger */ prevhunger.value = u.uhs; for (count = 0; count < strlen(hu_stat[u.uhs]); count++) { if ((hu_stat[u.uhs][count]) == ' ') { break; } buf[count] = hu_stat[u.uhs][count]; } buf[count] = '\0'; prevhunger.txt = curses_copy_of(buf); prevhunger.display = TRUE; prevhunger.highlight_turns = 0; prevhunger.label = NULL; /* Confusion */ prevconf.value = Confusion; if (Confusion) { prevconf.txt = curses_copy_of("Conf"); } else { prevconf.txt = NULL; } prevconf.display = TRUE; prevconf.highlight_turns = 0; prevconf.label = NULL; /* Blindness */ prevblind.value = Blind; if (Blind) { prevblind.txt = curses_copy_of("Blind"); } else { prevblind.txt = NULL; } prevblind.display = TRUE; prevblind.highlight_turns = 0; prevblind.label = NULL; /* Stun */ prevstun.value = Stunned; if (Stunned) { prevstun.txt = curses_copy_of("Stun"); } else { prevstun.txt = NULL; } prevstun.display = TRUE; prevstun.highlight_turns = 0; prevstun.label = NULL; /* Hallucination */ prevhallu.value = Hallucination; if (Hallucination) { prevhallu.txt = curses_copy_of("Hallu"); } else { prevhallu.txt = NULL; } prevhallu.display = TRUE; prevhallu.highlight_turns = 0; prevhallu.label = NULL; /* Sick */ prevsick.value = Sick; if (Sick) { if (u.usick_type & SICK_VOMITABLE) { prevsick.txt = curses_copy_of("Sick"); } else { prevsick.txt = curses_copy_of("Ill"); } } else { prevsick.txt = NULL; } prevsick.display = TRUE; prevsick.highlight_turns = 0; prevsick.label = NULL; /* Slimed */ prevslime.value = Slimed; if (Slimed) { prevslime.txt = curses_copy_of("Slime"); } else { prevslime.txt = NULL; } prevslime.display = TRUE; prevslime.highlight_turns = 0; prevslime.label = NULL; /* Encumberance */ prevencumb.value = near_capacity(); if (prevencumb.value > UNENCUMBERED) { sprintf(buf, "%s", enc_stat[prevencumb.value]); prevencumb.txt = curses_copy_of(buf); } else { prevencumb.txt = NULL; } prevencumb.display = TRUE; prevencumb.highlight_turns = 0; prevencumb.label = NULL; }
/* * Handle a "special request" */ static errr Term_xtra_gcu(int n, int v) { term_data *td = (term_data *)(Term->data); /* Analyze the request */ switch (n) { /* Clear screen */ case TERM_XTRA_CLEAR: touchwin(td->win); (void)wclear(td->win); return (0); /* Make a noise */ case TERM_XTRA_NOISE: (void)write(1, "\007", 1); return (0); /* Flush the Curses buffer */ case TERM_XTRA_FRESH: (void)wrefresh(td->win); return (0); #ifdef USE_CURS_SET /* Change the cursor visibility */ case TERM_XTRA_SHAPE: curs_set(v); return (0); #endif /* Suspend/Resume curses */ case TERM_XTRA_ALIVE: return (Term_xtra_gcu_alive(v)); /* Process events */ case TERM_XTRA_EVENT: return (Term_xtra_gcu_event(v)); /* Flush events */ case TERM_XTRA_FLUSH: while (!Term_xtra_gcu_event(FALSE)); return (0); /* Delay */ case TERM_XTRA_DELAY: usleep(1000 * v); return (0); /* Get Delay of some milliseconds */ case TERM_XTRA_GET_DELAY: { int ret; struct timeval tv; ret = gettimeofday(&tv, NULL); Term_xtra_long = (tv.tv_sec * 1000) + (tv.tv_usec / 1000); return ret; } /* Subdirectory scan */ case TERM_XTRA_SCANSUBDIR: { DIR *directory; struct dirent *entry; scansubdir_max = 0; directory = opendir(scansubdir_dir); if (!directory) return 1; while ((entry = readdir(directory))) { char file[PATH_MAX + NAME_MAX + 2]; struct stat filedata; file[PATH_MAX + NAME_MAX] = 0; strncpy(file, scansubdir_dir, PATH_MAX); strncat(file, "/", 2); strncat(file, entry->d_name, NAME_MAX); if (!stat(file, &filedata) && S_ISDIR((filedata.st_mode))) { string_free(scansubdir_result[scansubdir_max]); scansubdir_result[scansubdir_max] = string_make(entry->d_name); ++scansubdir_max; } } } /* React to events */ case TERM_XTRA_REACT: Term_xtra_gcu_react(); return (0); } /* Unknown */ return (1); }
/* * Display a dialog box with a list of options that can be turned on or off * The `flag' parameter is used to select between radiolist and checklist. */ int dialog_checklist (const char *title, const char *prompt, int height, int width, int list_height, int item_no, const char * const * items, int flag) { int i, x, y, box_x, box_y; int key = 0, button = 0, choice = 0, ascroll = 0, max_choice, *status; WINDOW *dialog, *list; checkflag = flag; /* Allocate space for storing item on/off status */ if ((status = malloc (sizeof (int) * item_no)) == NULL) { endwin (); fprintf (stderr, "\nCan't allocate memory in dialog_checklist().\n"); exit (-1); } /* Initializes status */ for (i = 0; i < item_no; i++) { status[i] = !strcasecmp (items[i * 3 + 2], "on"); if (!choice && status[i]) choice = i; } max_choice = MIN (list_height, item_no); /* center dialog box on screen */ x = (COLS - width) / 2; y = (LINES - height) / 2; draw_shadow (stdscr, y, x, height, width); dialog = newwin (height, width, y, x); keypad (dialog, TRUE); draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); wattrset (dialog, border_attr); mvwaddch (dialog, height-3, 0, ACS_LTEE); for (i = 0; i < width - 2; i++) waddch (dialog, ACS_HLINE); wattrset (dialog, dialog_attr); waddch (dialog, ACS_RTEE); if (title != NULL && strlen(title) >= width-2 ) { /* truncate long title -- mec */ char * title2 = malloc(width-2+1); memcpy( title2, title, width-2 ); title2[width-2] = '\0'; title = title2; } if (title != NULL) { wattrset (dialog, title_attr); mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); waddstr (dialog, (char *)title); waddch (dialog, ' '); } wattrset (dialog, dialog_attr); print_autowrap (dialog, prompt, width - 2, 1, 3); list_width = width - 6; box_y = height - list_height - 5; box_x = (width - list_width) / 2 - 1; /* create new window for the list */ list = subwin (dialog, list_height, list_width, y+box_y+1, x+box_x+1); keypad (list, TRUE); /* draw a box around the list items */ draw_box (dialog, box_y, box_x, list_height + 2, list_width + 2, menubox_border_attr, menubox_attr); /* Find length of longest item in order to center checklist */ check_x = 0; for (i = 0; i < item_no; i++) check_x = MAX (check_x, + strlen (items[i * 3 + 1]) + 4); check_x = (list_width - check_x) / 2; item_x = check_x + 4; if (choice >= list_height) { ascroll = choice - list_height + 1; choice -= ascroll; } /* Print the list */ for (i = 0; i < max_choice; i++) { print_item (list, items[(ascroll+i) * 3 + 1], status[i+ascroll], i, i == choice); } wnoutrefresh (list); print_arrows(dialog, choice, item_no, ascroll, box_y, box_x + check_x + 5, list_height); print_buttons(dialog, height, width, 0); while (key != ESC) { key = wgetch (dialog); for (i = 0; i < max_choice; i++) if (toupper(key) == toupper(items[(ascroll+i)*3+1][0])) break; if ( i < max_choice || key == KEY_UP || key == KEY_DOWN || key == '+' || key == '-' ) { if (key == KEY_UP || key == '-') { if (!choice) { if (!ascroll) continue; /* Scroll list down */ if (list_height > 1) { /* De-highlight current first item */ print_item (list, items[ascroll * 3 + 1], status[ascroll], 0, FALSE); scrollok (list, TRUE); wscrl (list, -1); scrollok (list, FALSE); } ascroll--; print_item (list, items[ascroll * 3 + 1], status[ascroll], 0, TRUE); wnoutrefresh (list); print_arrows(dialog, choice, item_no, ascroll, box_y, box_x + check_x + 5, list_height); wrefresh (dialog); continue; /* wait for another key press */ } else i = choice - 1; } else if (key == KEY_DOWN || key == '+') { if (choice == max_choice - 1) { if (ascroll + choice >= item_no - 1) continue; /* Scroll list up */ if (list_height > 1) { /* De-highlight current last item before scrolling up */ print_item (list, items[(ascroll + max_choice - 1) * 3 + 1], status[ascroll + max_choice - 1], max_choice - 1, FALSE); scrollok (list, TRUE); scroll (list); scrollok (list, FALSE); } ascroll++; print_item (list, items[(ascroll + max_choice - 1) * 3 + 1], status[ascroll + max_choice - 1], max_choice - 1, TRUE); wnoutrefresh (list); print_arrows(dialog, choice, item_no, ascroll, box_y, box_x + check_x + 5, list_height); wrefresh (dialog); continue; /* wait for another key press */ } else i = choice + 1; } if (i != choice) { /* De-highlight current item */ print_item (list, items[(ascroll + choice) * 3 + 1], status[ascroll + choice], choice, FALSE); /* Highlight new item */ choice = i; print_item (list, items[(ascroll + choice) * 3 + 1], status[ascroll + choice], choice, TRUE); wnoutrefresh (list); wrefresh (dialog); } continue; /* wait for another key press */ } switch (key) { case 'H': case 'h': case '?': delwin (dialog); free (status); return 1; case TAB: case KEY_LEFT: case KEY_RIGHT: button = ((key == KEY_LEFT ? --button : ++button) < 0) ? 1 : (button > 1 ? 0 : button); print_buttons(dialog, height, width, button); wrefresh (dialog); break; case 'S': case 's': case ' ': case '\n': if (!button) { if (flag == FLAG_CHECK) { status[ascroll + choice] = !status[ascroll + choice]; wmove (list, choice, check_x); wattrset (list, check_selected_attr); wprintw (list, "[%c]", status[ascroll + choice] ? 'X' : ' '); } else { if (!status[ascroll + choice]) { for (i = 0; i < item_no; i++) status[i] = 0; status[ascroll + choice] = 1; for (i = 0; i < max_choice; i++) print_item (list, items[(ascroll + i) * 3 + 1], status[ascroll + i], i, i == choice); } } wnoutrefresh (list); wrefresh (dialog); for (i = 0; i < item_no; i++) { if (status[i]) { if (flag == FLAG_CHECK) { strcpy(selection,"* "); strcat(selection,items[i*3]); } else { strcpy(selection," "); strcat(selection,items[i*3]); } } } } delwin (dialog); free (status); return button; case 'X': case 'x': key = ESC; case ESC: break; } } delwin (dialog); free (status); return -1; /* ESC pressed */ }
static void *Display_Thread(void *arg) { pthread_t spindown_thread; int parent_x, parent_y, new_x, new_y; int power_speed_height = 5; int status_height = 3; char DisplayLine[DISPLAY_MAX_MSG_SIZE]; char DisplayBuffer[DISPLAY_MAX_MSG_LINES][DISPLAY_MAX_MSG_SIZE]; char StatusLine[DISPLAY_MAX_MSG_SIZE]; // zero out the display buffer; memset(DisplayBuffer, 0, sizeof(DisplayBuffer)); // Setup ncurses display initscr(); noecho(); nodelay(stdscr, TRUE); cbreak(); curs_set(FALSE); // set up initial windows getmaxyx(stdscr, parent_y, parent_x); WINDOW *pwr_window = newwin(power_speed_height, parent_x/2, 0, 0); WINDOW *spd_window = newwin(power_speed_height, parent_x/2, 0, parent_x - parent_x/2); WINDOW *msg_window = newwin(parent_y - power_speed_height - status_height, parent_x, power_speed_height, 0); WINDOW *sta_window = newwin(status_height, parent_x, parent_y - status_height, 0); box(pwr_window, 0, 0); box(spd_window, 0, 0); box(msg_window, 0, 0); box(sta_window, 0, 0); // refresh each window wrefresh(pwr_window); wrefresh(spd_window); wrefresh(msg_window); wrefresh(sta_window); while (runDisplayThread) { // use non-blocking ncurses input for control characters char ch = getch(); // 'm' for manual resistance control if (ch == 'm') { currentMode = MODE_MANUAL; } // 'e' for ergo if (ch == 'e') { currentMode = MODE_ERGO; } // 's' for slope if (ch == 's') { currentMode = MODE_SLOPE; } // 'c' for spindown/calibrate - as 's' was already taken ;) if (ch == 'c') { lastMode = currentMode; currentMode = MODE_CALIBRATE; // todo: make sure we don't try and start more than one spindown thread pthread_create (&spindown_thread, NULL, Spindown_Thread, NULL); } // handle window resize events getmaxyx(stdscr, new_y, new_x); if (new_y != parent_y || new_x != parent_x) { parent_x = new_x; parent_y = new_y; wresize(pwr_window, power_speed_height, new_x/2); wresize(spd_window, power_speed_height, parent_x - new_x/2); mvwin(spd_window, 0, new_x/2); wresize(msg_window, parent_y - power_speed_height - status_height, parent_x); mvwin(msg_window, power_speed_height, 0); wresize(sta_window, status_height, parent_x); mvwin(sta_window, parent_y - status_height, 0); // clear the windows if resized wclear(stdscr); wclear(msg_window); } // clear the status window regardless wclear(sta_window); wclear(spd_window); wclear(pwr_window); // for some reason getch() seems to nuke the borders? // easy fix is just to redraw everything regardless.. box(pwr_window, 0, 0); box(spd_window, 0, 0); box(msg_window, 0, 0); box(sta_window, 0, 0); DrawTitle(spd_window, "Speed"); DrawTitle(pwr_window, "Power"); DrawTitle(msg_window, "Messages"); DrawTitle(sta_window, "Status"); mvwprintw(pwr_window, power_speed_height/2, parent_x/4, "%.0lf", currentPower); mvwprintw(spd_window, power_speed_height/2, parent_x/4, "%.1lf", currentSpeed); strcpy(DisplayLine, DisplayMessage); if (strcmp(DisplayBuffer[0], DisplayLine)) { // clear the previous message window content if we have new messages, // so we're not left with artifacts from previous (longer) lines.. wclear(msg_window); box(msg_window, 0, 0); DrawTitle(msg_window, "Messages"); for (int i = DISPLAY_MAX_MSG_LINES-1; i > 0; i--) { strcpy(DisplayBuffer[i], DisplayBuffer[i-1]); } strcpy(DisplayBuffer[0], DisplayLine); for (int i = 0; i < DISPLAY_MAX_MSG_LINES; i++) { mvwprintw(msg_window, i+1, 1, "%s",DisplayBuffer[i]); } } switch (currentMode) { case MODE_MANUAL: sprintf(StatusLine, "Freq: %04u - MANUAL MODE", currentFrequency); break; case MODE_SLOPE: sprintf(StatusLine, "Freq: %04u - SLOPE MODE", currentFrequency); break; case MODE_ERGO: sprintf(StatusLine, "Freq: %04u - ERGO MODE", currentFrequency); break; case MODE_CALIBRATE: sprintf(StatusLine, "Freq: %04u - SPINDOWN MODE", currentFrequency); break; } //strcpy(StatusLine, DisplayStatus); mvwprintw(sta_window, 1, 1, "%s",StatusLine); // refresh each window wrefresh(pwr_window); wrefresh(spd_window); wrefresh(msg_window); wrefresh(sta_window); milliSleep(100); } // clean up ncurses display endwin(); return NULL; }
void refresh_interface(t_interface *in) { wrefresh(WIN(w_root)); }
void refresh( uilist *menu ) override { ( void )menu; // unused wrefresh( w_info ); }
int main( int argc, char **argv ) { int i; int use_sudo=0; int help=0, version=0; int create_log=TD_LOG_NONE; int run_setlocale=1; int testdisk_mode=TESTDISK_O_RDONLY|TESTDISK_O_READAHEAD_32K; list_disk_t *list_disk=NULL; list_disk_t *element_disk; const char *logfile="photorec.log"; FILE *log_handle=NULL; struct ph_options options={ .paranoid=1, .keep_corrupted_file=0, .mode_ext2=0, .expert=0, .lowmem=0, .verbose=0, .list_file_format=list_file_enable }; struct ph_param params; params.recup_dir=NULL; params.cmd_device=NULL; params.cmd_run=NULL; /* random (weak is ok) is need fot GPT */ srand(time(NULL)); #ifdef HAVE_SIGACTION /* set up the signal handler for SIGINT & SIGHUP */ sigemptyset(&action.sa_mask); sigaddset(&action.sa_mask, SIGINT); sigaddset(&action.sa_mask, SIGHUP); action.sa_handler = sighup_hdlr; action.sa_flags = 0; if(sigaction(SIGINT, &action, NULL)==-1) { printf("Error on SIGACTION call\n"); return -1; } if(sigaction(SIGHUP, &action, NULL)==-1) { printf("Error on SIGACTION call\n"); return -1; } #endif printf("PhotoRec %s, Data Recovery Utility, %s\nChristophe GRENIER <*****@*****.**>\nhttp://www.cgsecurity.org\n",VERSION,TESTDISKDATE); for(i=1;i<argc;i++) { if((strcmp(argv[i],"/logname")==0) ||(strcmp(argv[i],"-logname")==0)) { if(i+2>=argc) help=1; else logfile=argv[++i]; } else if((strcmp(argv[i],"/log")==0) ||(strcmp(argv[i],"-log")==0)) { if(create_log==TD_LOG_NONE) create_log=TD_LOG_APPEND; } else if((strcmp(argv[i],"/debug")==0) || (strcmp(argv[i],"-debug")==0)) { options.verbose++; if(create_log==TD_LOG_NONE) create_log=TD_LOG_APPEND; } else if(((strcmp(argv[i],"/d")==0)||(strcmp(argv[i],"-d")==0)) &&(i+1<argc)) { int len=strlen(argv[i+1]); if(argv[i+1][len-1]=='\\' || argv[i+1][len-1]=='/') { params.recup_dir=(char *)MALLOC(len + strlen(DEFAULT_RECUP_DIR) + 1); strcpy(params.recup_dir,argv[i+1]); strcat(params.recup_dir,DEFAULT_RECUP_DIR); } else params.recup_dir=strdup(argv[i+1]); i++; } else if((strcmp(argv[i],"/all")==0) || (strcmp(argv[i],"-all")==0)) testdisk_mode|=TESTDISK_O_ALL; else if((strcmp(argv[i],"/direct")==0) || (strcmp(argv[i],"-direct")==0)) testdisk_mode|=TESTDISK_O_DIRECT; else if((strcmp(argv[i],"/help")==0) || (strcmp(argv[i],"-help")==0) || (strcmp(argv[i],"--help")==0) || (strcmp(argv[i],"/h")==0) || (strcmp(argv[i],"-h")==0) || (strcmp(argv[i],"/?")==0) || (strcmp(argv[i],"-?")==0)) help=1; else if((strcmp(argv[i],"/version")==0) || (strcmp(argv[i],"-version")==0) || (strcmp(argv[i],"--version")==0) || (strcmp(argv[i],"/v")==0) || (strcmp(argv[i],"-v")==0)) version=1; else if((strcmp(argv[i],"/nosetlocale")==0) || (strcmp(argv[i],"-nosetlocale")==0)) run_setlocale=0; else if(strcmp(argv[i],"/cmd")==0) { if(i+2>=argc) help=1; else { disk_t *disk_car; params.cmd_device=argv[++i]; params.cmd_run=argv[++i]; /* There is no log currently */ disk_car=file_test_availability(params.cmd_device, options.verbose, testdisk_mode); if(disk_car==NULL) { printf("\nUnable to open file or device %s\n", params.cmd_device); help=1; } else list_disk=insert_new_disk(list_disk,disk_car); } } else { disk_t *disk_car=file_test_availability(argv[i], options.verbose, testdisk_mode); if(disk_car==NULL) { printf("\nUnable to open file or device %s\n",argv[i]); help=1; } else list_disk=insert_new_disk(list_disk,disk_car); } } if(version!=0) { printf("\n"); printf("Version: %s\n", VERSION); printf("Compiler: %s\n", get_compiler()); printf("Compilation date: %s\n", get_compilation_date()); printf("ext2fs lib: %s, ntfs lib: %s, ewf lib: %s, libjpeg: %s\n", td_ext2fs_version(), td_ntfs_version(), td_ewf_version(), td_jpeg_version()); printf("OS: %s\n" , get_os()); free(params.recup_dir); return 0; } if(help!=0) { printf("\nUsage: photorec [/log] [/debug] [/d recup_dir] [file.dd|file.e01|device]\n"\ " photorec /version\n" \ "\n" \ "/log : create a photorec.log file\n" \ "/debug : add debug information\n" \ "\n" \ "PhotoRec searches various file formats (JPEG, Office...), it stores them\n" \ "in recup_dir directory.\n" \ "\n" \ "If you have problems with PhotoRec or bug reports, please contact me.\n"); free(params.recup_dir); return 0; } #ifdef ENABLE_DFXML xml_set_command_line(argc, argv); #endif if(create_log!=TD_LOG_NONE) log_handle=log_open(logfile, create_log); #ifdef HAVE_SETLOCALE if(run_setlocale>0) { const char *locale; locale = setlocale (LC_ALL, ""); if (locale==NULL) { locale = setlocale (LC_ALL, NULL); log_error("Failed to set locale, using default '%s'.\n", locale); } else { log_info("Using locale '%s'.\n", locale); } } #endif if(create_log!=TD_LOG_NONE && log_handle==NULL) log_handle=log_open_default(logfile, create_log); #ifdef HAVE_NCURSES /* ncurses need locale for correct unicode support */ if(start_ncurses("PhotoRec", argv[0])) { free(params.recup_dir); return 1; } { const char*filename=logfile; while(create_log!=TD_LOG_NONE && log_handle==NULL) { filename=ask_log_location(filename); if(filename!=NULL) log_handle=log_open(filename, create_log); else create_log=TD_LOG_NONE; } } aff_copy(stdscr); wmove(stdscr,5,0); wprintw(stdscr, "Disk identification, please wait...\n"); wrefresh(stdscr); #endif if(log_handle!=NULL) { time_t my_time; #ifdef HAVE_DUP2 dup2(fileno(log_handle),2); #endif my_time=time(NULL); log_info("\n\n%s",ctime(&my_time)); log_info("Command line: PhotoRec"); for(i=1;i<argc;i++) log_info(" %s", argv[i]); log_info("\n\n"); log_flush(); } log_info("PhotoRec %s, Data Recovery Utility, %s\nChristophe GRENIER <*****@*****.**>\nhttp://www.cgsecurity.org\n", VERSION, TESTDISKDATE); log_info("OS: %s\n" , get_os()); log_info("Compiler: %s\n", get_compiler()); log_info("Compilation date: %s\n", get_compilation_date()); log_info("ext2fs lib: %s, ntfs lib: %s, ewf lib: %s, libjpeg: %s\n", td_ext2fs_version(), td_ntfs_version(), td_ewf_version(), td_jpeg_version()); #if defined(__CYGWIN__) || defined(__MINGW32__) || defined(DJGPP) #else #ifdef HAVE_GETEUID if(geteuid()!=0) { log_warning("User is not root!\n"); } #endif #endif screen_buffer_reset(); /* Scan for available device only if no device or image has been supplied in parameter */ if(list_disk==NULL) list_disk=hd_parse(list_disk, options.verbose, testdisk_mode); hd_update_all_geometry(list_disk, options.verbose); /* Activate the cache, even if photorec has its own */ for(element_disk=list_disk;element_disk!=NULL;element_disk=element_disk->next) { element_disk->disk=new_diskcache(element_disk->disk, testdisk_mode); } /* save disk parameters to rapport */ log_info("Hard disk list\n"); for(element_disk=list_disk;element_disk!=NULL;element_disk=element_disk->next) { disk_t *disk=element_disk->disk; log_info("%s, sector size=%u", disk->description(disk), disk->sector_size); if(disk->model!=NULL) log_info(" - %s", disk->model); if(disk->serial_no!=NULL) log_info(", S/N:%s", disk->serial_no); if(disk->fw_rev!=NULL) log_info(", FW:%s", disk->fw_rev); log_info("\n"); } log_info("\n"); reset_list_file_enable(options.list_file_format); file_options_load(options.list_file_format); use_sudo=do_curses_photorec(¶ms, &options, list_disk); #ifdef HAVE_NCURSES end_ncurses(); #endif delete_list_disk(list_disk); log_info("PhotoRec exited normally.\n"); if(log_close()!=0) { printf("PhotoRec: Log file corrupted!\n"); } else if(params.cmd_run!=NULL && params.cmd_run[0]!='\0') { printf("PhotoRec syntax error: %s\n", params.cmd_run); } else { printf("PhotoRec exited normally.\n"); } #ifdef SUDO_BIN if(use_sudo>0) run_sudo(argc, argv); #endif free(params.recup_dir); #ifdef ENABLE_DFXML xml_clear_command_line(); #endif return 0; }
/* * Set skill on any player object; player character or NPC */ void debug_menu::wishskill( player *p ) { const int skoffset = 1; uilist skmenu; skmenu.text = _( "Select a skill to modify" ); skmenu.allow_anykey = true; skmenu.addentry( 0, true, '1', _( "Modify all skills..." ) ); std::vector<int> origskills; origskills.reserve( Skill::skills.size() ); for( const auto &s : Skill::skills ) { const int level = p->get_skill_level( s.ident() ); skmenu.addentry( origskills.size() + skoffset, true, -2, _( "@ %d: %s " ), level, s.name() ); origskills.push_back( level ); } do { skmenu.query(); int skill_id = -1; int skset = -1; const int sksel = skmenu.selected - skoffset; if( skmenu.ret == UILIST_UNBOUND && ( skmenu.keypress == KEY_LEFT || skmenu.keypress == KEY_RIGHT ) ) { if( sksel >= 0 && sksel < static_cast<int>( Skill::skills.size() ) ) { skill_id = sksel; skset = p->get_skill_level( Skill::skills[skill_id].ident() ) + ( skmenu.keypress == KEY_LEFT ? -1 : 1 ); } } else if( skmenu.ret >= 0 && sksel >= 0 && sksel < static_cast<int>( Skill::skills.size() ) ) { skill_id = sksel; const Skill &skill = Skill::skills[skill_id]; const int NUM_SKILL_LVL = 21; uilist sksetmenu; sksetmenu.w_height = NUM_SKILL_LVL + 4; sksetmenu.w_x = skmenu.w_x + skmenu.w_width + 1; sksetmenu.w_y = std::max( 0, skmenu.w_y + ( skmenu.w_height - sksetmenu.w_height ) / 2 ); sksetmenu.settext( string_format( _( "Set '%s' to.." ), skill.name() ) ); const int skcur = p->get_skill_level( skill.ident() ); sksetmenu.selected = skcur; for( int i = 0; i < NUM_SKILL_LVL; i++ ) { sksetmenu.addentry( i, true, i + 48, "%d%s", i, ( skcur == i ? _( " (current)" ) : "" ) ); } sksetmenu.query(); g->draw_ter(); wrefresh( g->w_terrain ); g->draw_panels(); skset = sksetmenu.ret; } if( skill_id >= 0 && skset >= 0 ) { const Skill &skill = Skill::skills[skill_id]; p->set_skill_level( skill.ident(), skset ); skmenu.textformatted[0] = string_format( _( "%s set to %d " ), skill.name(), p->get_skill_level( skill.ident() ) ).substr( 0, skmenu.w_width - 4 ); skmenu.entries[skill_id + skoffset].txt = string_format( _( "@ %d: %s " ), p->get_skill_level( skill.ident() ), skill.name() ); skmenu.entries[skill_id + skoffset].text_color = ( p->get_skill_level( skill.ident() ) == origskills[skill_id] ? skmenu.text_color : c_yellow ); } else if( skmenu.ret == 0 && sksel == -1 ) { const int ret = uilist( _( "Alter all skill values" ), { _( "Add 3" ), _( "Add 1" ), _( "Subtract 1" ), _( "Subtract 3" ), _( "Set to 0" ), _( "Set to 5" ), _( "Set to 10" ), _( "(Reset changes)" ) } ); if( ret >= 0 ) { int skmod = 0; int skset = -1; if( ret < 4 ) { skmod = 3 - ret * 2; } else if( ret < 7 ) { skset = ( ret - 4 ) * 5; } for( size_t skill_id = 0; skill_id < Skill::skills.size(); skill_id++ ) { const Skill &skill = Skill::skills[skill_id]; int changeto = ( skmod != 0 ? p->get_skill_level( skill.ident() ) + skmod : ( skset != -1 ? skset : origskills[skill_id] ) ); p->set_skill_level( skill.ident(), std::max( 0, changeto ) ); skmenu.entries[skill_id + skoffset].txt = string_format( _( "@ %d: %s " ), p->get_skill_level( skill.ident() ), skill.name() ); skmenu.entries[skill_id + skoffset].text_color = ( p->get_skill_level( skill.ident() ) == origskills[skill_id] ? skmenu.text_color : c_yellow ); } } } } while( skmenu.ret != UILIST_CANCEL ); }
// Completely redraw the screen, for instance after a corruption (see wrefresh // man pageL: "If the argument to wrefresh is curscr, the screen is immediately // cleared and repainted from scratch." static void redraw_screen_locked(void){ wrefresh(curscr); }