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);
}
