void inventory::restack(player *p)
{
// tasks that the old restack seemed to do:
// 1. reassign inventory letters
// 2. remove items from non-matching stacks
// 3. combine matching stacks
if (!p) {
return;
}
std::list<item> to_restack;
int idx = 0;
for (invstack::iterator iter = items.begin(); iter != items.end(); ++iter, ++idx) {
std::list<item> &stack = *iter;
item &topmost = stack.front();
const int ipos = p->invlet_to_position(topmost.invlet);
if( !inv_chars.valid( topmost.invlet ) || ( ipos != INT_MIN && ipos != idx ) ) {
assign_empty_invlet(topmost);
for( std::list<item>::iterator stack_iter = stack.begin();
stack_iter != stack.end(); ++stack_iter ) {
stack_iter->invlet = topmost.invlet;
}
}
// remove non-matching items, stripping off end of stack so the first item keeps the invlet.
while( stack.size() > 1 && !topmost.stacks_with(stack.back()) ) {
to_restack.splice(to_restack.begin(), *iter, --stack.end());
}
}
// combine matching stacks
// separate loop to ensure that ALL stacks are homogeneous
for (invstack::iterator iter = items.begin(); iter != items.end(); ++iter) {
for (invstack::iterator other = iter; other != items.end(); ++other) {
if (iter != other && iter->front().stacks_with( other->front() ) ) {
if( other->front().count_by_charges() ) {
iter->front().charges += other->front().charges;
} else {
iter->splice(iter->begin(), *other);
}
other = items.erase(other);
--other;
}
}
}
//re-add non-matching items
for( auto &elem : to_restack ) {
add_item( elem );
}
//Ensure that all items in the same stack have the same invlet.
for( std::list< item > &outer : items ) {
for( item &inner : outer ) {
inner.invlet = outer.front().invlet;
}
}
}
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 = NULL;
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 +
( 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, ( 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( "REMOVE" );
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, ( 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( int i = 0; i < num_bp; ++i ) {
const body_part bp = bp_aBodyPart[i];
const int total = get_total_bionics_slots( bp );
const std::string s = string_format( "%s: %d/%d",
body_part_name_as_heading( bp, 1 ).c_str(),
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( g->u.has_trait( trait_id( "DEBUG_CBM_SLOTS" ) ) ) {
for( int i = 0; i < num_bp; ++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 && g->u.has_trait( trait_id( "DEBUG_CBM_SLOTS" ) ) ) {
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 );
}
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 = NULL;
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.c_str() );
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().c_str() );
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 == "REMOVE" ) {
menu_mode = REMOVING;
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 < ( 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 >= ( 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 == REMOVING ) {
recalc = uninstall_bionic( bio_id );
redraw = true;
continue;
}
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 ) {
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.c_str(),
bio_data.name.c_str(), 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, ( 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, ( int )passive.size() - LIST_HEIGHT );
if( static_cast<int>( i ) > max_scroll_check ) {
scroll_position = max_scroll_check;
} else {
scroll_position = i;
}
break;
}
}
}
}
}
}
}
void player::power_mutations()
{
if( !is_player() ) {
// TODO: Implement NPCs activating muts
return;
}
std::vector <std::string> passive;
std::vector <std::string> active;
for( auto &mut : my_mutations ) {
if (!mutation_branch::get( mut.first ).activated) {
passive.push_back(mut.first);
} else {
active.push_back(mut.first);
}
// New mutations are initialized with no key at all, so we have to do this here.
if( mut.second.key == ' ' ) {
for( const auto &letter : mutation_chars ) {
if( trait_by_invlet( letter ).empty() ) {
mut.second.key = letter;
break;
}
}
}
}
// maximal number of rows in both columns
const int mutations_count = std::max(passive.size(), active.size());
int TITLE_HEIGHT = 2;
int DESCRIPTION_HEIGHT = 5;
// Main window
/** Total required height is:
* top frame line: + 1
* height of title window: + TITLE_HEIGHT
* line after the title: + 1
* line with active/passive mutation captions: + 1
* height of the biggest list of active/passive mutations: + mutations_count
* line before mutation description: + 1
* height of description window: + DESCRIPTION_HEIGHT
* bottom frame line: + 1
* TOTAL: TITLE_HEIGHT + mutations_count + DESCRIPTION_HEIGHT + 5
*/
int HEIGHT = std::min(TERMY, std::max(FULL_SCREEN_HEIGHT,
TITLE_HEIGHT + mutations_count + DESCRIPTION_HEIGHT + 5));
int WIDTH = FULL_SCREEN_WIDTH + (TERMX - FULL_SCREEN_WIDTH) / 2;
int START_X = (TERMX - WIDTH) / 2;
int START_Y = (TERMY - HEIGHT) / 2;
WINDOW *wBio = newwin(HEIGHT, WIDTH, START_Y, START_X);
// Description window @ the bottom of the bio window
int DESCRIPTION_START_Y = START_Y + HEIGHT - DESCRIPTION_HEIGHT - 1;
int DESCRIPTION_LINE_Y = DESCRIPTION_START_Y - START_Y - 1;
WINDOW *w_description = newwin(DESCRIPTION_HEIGHT, WIDTH - 2,
DESCRIPTION_START_Y, START_X + 1);
// Title window
int TITLE_START_Y = START_Y + 1;
int HEADER_LINE_Y = TITLE_HEIGHT + 1; // + lines with text in titlebar, local
WINDOW *w_title = newwin(TITLE_HEIGHT, WIDTH - 2, TITLE_START_Y, START_X + 1);
int scroll_position = 0;
int second_column = 32 + (TERMX - FULL_SCREEN_WIDTH) /
4; // X-coordinate of the list of active mutations
input_context ctxt("MUTATIONS");
ctxt.register_updown();
ctxt.register_action("ANY_INPUT");
ctxt.register_action("TOGGLE_EXAMINE");
ctxt.register_action("REASSIGN");
ctxt.register_action("HELP_KEYBINDINGS");
bool redraw = true;
std::string menu_mode = "activating";
while(true) {
// offset for display: mutation with index i is drawn at y=list_start_y+i
// drawing the mutation starts with mutation[scroll_position]
const int list_start_y = HEADER_LINE_Y + 2 - scroll_position;
int max_scroll_position = HEADER_LINE_Y + 2 + mutations_count -
((menu_mode == "examining") ? DESCRIPTION_LINE_Y : (HEIGHT - 1));
if(redraw) {
redraw = false;
werase(wBio);
draw_border(wBio);
// Draw line under title
mvwhline(wBio, HEADER_LINE_Y, 1, LINE_OXOX, WIDTH - 2);
// Draw symbols to connect additional lines to border
mvwputch(wBio, HEADER_LINE_Y, 0, BORDER_COLOR, LINE_XXXO); // |-
mvwputch(wBio, HEADER_LINE_Y, WIDTH - 1, BORDER_COLOR, LINE_XOXX); // -|
// Captions
mvwprintz(wBio, HEADER_LINE_Y + 1, 2, c_ltblue, _("Passive:"));
mvwprintz(wBio, HEADER_LINE_Y + 1, second_column, c_ltblue, _("Active:"));
draw_exam_window(wBio, DESCRIPTION_LINE_Y, menu_mode == "examining");
nc_color type;
if (passive.empty()) {
mvwprintz(wBio, list_start_y, 2, c_ltgray, _("None"));
} else {
for (size_t i = scroll_position; i < passive.size(); i++) {
const auto &md = mutation_branch::get( passive[i] );
const auto &td = my_mutations[passive[i]];
if (list_start_y + static_cast<int>(i) ==
(menu_mode == "examining" ? DESCRIPTION_LINE_Y : HEIGHT - 1)) {
break;
}
type = c_cyan;
mvwprintz(wBio, list_start_y + i, 2, type, "%c %s", td.key, md.name.c_str());
}
}
if (active.empty()) {
mvwprintz(wBio, list_start_y, second_column, c_ltgray, _("None"));
} else {
for (size_t i = scroll_position; i < active.size(); i++) {
const auto &md = mutation_branch::get( active[i] );
const auto &td = my_mutations[active[i]];
if (list_start_y + static_cast<int>(i) ==
(menu_mode == "examining" ? DESCRIPTION_LINE_Y : HEIGHT - 1)) {
break;
}
if (!td.powered) {
type = c_red;
}else if (td.powered) {
type = c_ltgreen;
} else {
type = c_ltred;
}
// TODO: track resource(s) used and specify
mvwputch( wBio, list_start_y + i, second_column, type, td.key );
std::stringstream mut_desc;
mut_desc << md.name;
if ( md.cost > 0 && md.cooldown > 0 ) {
mut_desc << string_format( _(" - %d RU / %d turns"),
md.cost, md.cooldown );
} else if ( md.cost > 0 ) {
mut_desc << string_format( _(" - %d RU"), md.cost );
} else if ( md.cooldown > 0 ) {
mut_desc << string_format( _(" - %d turns"), md.cooldown );
}
if ( td.powered ) {
mut_desc << _(" - Active");
}
mvwprintz( wBio, list_start_y + i, second_column + 2, type,
mut_desc.str().c_str() );
}
}
// Scrollbar
if(scroll_position > 0) {
mvwputch(wBio, HEADER_LINE_Y + 2, 0, c_ltgreen, '^');
}
if(scroll_position < max_scroll_position && max_scroll_position > 0) {
mvwputch(wBio, (menu_mode == "examining" ? DESCRIPTION_LINE_Y : HEIGHT - 1) - 1,
0, c_ltgreen, 'v');
}
}
wrefresh(wBio);
show_mutations_titlebar(w_title, this, menu_mode);
const std::string action = ctxt.handle_input();
const long ch = ctxt.get_raw_input().get_first_input();
if (menu_mode == "reassigning") {
menu_mode = "activating";
const auto mut_id = trait_by_invlet( ch );
if( mut_id.empty() ) {
// Selected an non-existing mutation (or escape, or ...)
continue;
}
redraw = true;
const long newch = popup_getkey(_("%s; enter new letter."),
mutation_branch::get_name( mut_id ).c_str());
wrefresh(wBio);
if(newch == ch || newch == ' ' || newch == KEY_ESCAPE) {
continue;
}
if( !mutation_chars.valid( newch ) ) {
popup( _("Invalid mutation letter. Only those characters are valid:\n\n%s"),
mutation_chars.get_allowed_chars().c_str() );
continue;
}
const auto other_mut_id = trait_by_invlet( newch );
if( !other_mut_id.empty() ) {
std::swap(my_mutations[mut_id].key, my_mutations[other_mut_id].key);
} else {
my_mutations[mut_id].key = newch;
}
// TODO: show a message like when reassigning a key to an item?
} else if (action == "DOWN") {
if(scroll_position < max_scroll_position) {
scroll_position++;
redraw = true;
}
} else if (action == "UP") {
if(scroll_position > 0) {
scroll_position--;
redraw = true;
}
} else if (action == "REASSIGN") {
menu_mode = "reassigning";
} else if (action == "TOGGLE_EXAMINE") { // switches between activation and examination
menu_mode = menu_mode == "activating" ? "examining" : "activating";
werase(w_description);
draw_exam_window(wBio, DESCRIPTION_LINE_Y, false);
redraw = true;
}else if (action == "HELP_KEYBINDINGS") {
redraw = true;
} else {
const auto mut_id = trait_by_invlet( ch );
if( mut_id.empty() ) {
// entered a key that is not mapped to any mutation,
// -> leave screen
break;
}
const auto &mut_data = mutation_branch::get( mut_id );
if (menu_mode == "activating") {
if (mut_data.activated) {
if (my_mutations[mut_id].powered) {
add_msg_if_player(m_neutral, _("You stop using your %s."), mut_data.name.c_str());
deactivate_mutation( mut_id );
delwin(w_title);
delwin(w_description);
delwin(wBio);
// Action done, leave screen
break;
} else if( (!mut_data.hunger || get_hunger() <= 400) &&
(!mut_data.thirst || get_thirst() <= 400) &&
(!mut_data.fatigue || get_fatigue() <= 400) ) {
// this will clear the mutations menu for targeting purposes
werase(wBio);
wrefresh(wBio);
delwin(w_title);
delwin(w_description);
delwin(wBio);
g->draw();
add_msg_if_player( m_neutral, _("You activate your %s."), mut_data.name.c_str() );
activate_mutation( mut_id );
// Action done, leave screen
break;
} else {
popup( _( "You don't have enough in you to activate your %s!" ), mut_data.name.c_str() );
redraw = true;
continue;
}
} else {
popup(_("\
You cannot activate %s! To read a description of \
%s, press '!', then '%c'."), mut_data.name.c_str(), mut_data.name.c_str(),
my_mutations[mut_id].key );
redraw = true;
}
}
if (menu_mode == "examining") { // Describing mutations, not activating them!
draw_exam_window(wBio, DESCRIPTION_LINE_Y, true);
// Clear the lines first
werase(w_description);
fold_and_print(w_description, 0, 0, WIDTH - 2, c_ltblue, mut_data.description);
wrefresh(w_description);
}
}
}
//if we activated a mutation, already killed the windows
if(!(menu_mode == "activating")) {
werase(wBio);
wrefresh(wBio);
delwin(w_title);
delwin(w_description);
delwin(wBio);
}
}