WORLDPTR worldfactory::pick_world( bool show_prompt )
{
std::map<std::string, WORLDPTR> worlds = get_all_worlds();
std::vector<std::string> world_names = all_worldnames;
// Filter out special worlds (TUTORIAL | DEFENSE) from world_names.
for (std::vector<std::string>::iterator it = world_names.begin(); it != world_names.end();) {
if (*it == "TUTORIAL" || *it == "DEFENSE") {
it = world_names.erase(it);
} else {
++it;
}
}
// If there is only one world to pick from, autoreturn it.
if (world_names.size() == 1) {
return worlds[world_names[0]];
}
// If there are no worlds to pick from, immediately try to make one.
else if (world_names.empty()) {
return make_new_world( show_prompt );
}
// If we're skipping prompts, just return the first one.
else if( !show_prompt ) {
return worlds[world_names[0]];
}
const int iTooltipHeight = 3;
const int iContentHeight = FULL_SCREEN_HEIGHT - 3 - iTooltipHeight;
const unsigned int num_pages = world_names.size() / iContentHeight + 1; // at least 1 page
const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0;
const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0;
std::map<int, bool> mapLines;
mapLines[3] = true;
std::map<int, std::vector<std::string> > world_pages;
unsigned int worldnum = 0;
for (size_t i = 0; i < num_pages; ++i) {
for (int j = 0; j < iContentHeight && worldnum < world_names.size(); ++j) {
world_pages[i].push_back(world_names[worldnum++]);
}
}
unsigned int sel = 0, selpage = 0;
WINDOW *w_worlds_border = newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, iOffsetY, iOffsetX);
WINDOW *w_worlds_tooltip = newwin(iTooltipHeight, FULL_SCREEN_WIDTH - 2, 1 + iOffsetY,
1 + iOffsetX);
WINDOW *w_worlds_header = newwin(1, FULL_SCREEN_WIDTH - 2, 1 + iTooltipHeight + iOffsetY,
1 + iOffsetX);
WINDOW *w_worlds = newwin(iContentHeight, FULL_SCREEN_WIDTH - 2,
iTooltipHeight + 2 + iOffsetY, 1 + iOffsetX);
draw_border(w_worlds_border);
mvwputch(w_worlds_border, 4, 0, BORDER_COLOR, LINE_XXXO); // |-
mvwputch(w_worlds_border, 4, FULL_SCREEN_WIDTH - 1, BORDER_COLOR, LINE_XOXX); // -|
for (std::map<int, bool>::iterator iter = mapLines.begin(); iter != mapLines.end(); ++iter) {
mvwputch(w_worlds_border, FULL_SCREEN_HEIGHT - 1, iter->first + 1, BORDER_COLOR, LINE_XXOX); // _|_
}
center_print(w_worlds_border, 0, c_ltred, _(" WORLD SELECTION "));
wrefresh(w_worlds_border);
for (int i = 0; i < 78; i++) {
if (mapLines[i]) {
mvwputch(w_worlds_header, 0, i, BORDER_COLOR, LINE_OXXX);
} else {
mvwputch(w_worlds_header, 0, i, BORDER_COLOR, LINE_OXOX); // Draw header line
}
}
wrefresh(w_worlds_header);
input_context ctxt("PICK_WORLD_DIALOG");
ctxt.register_updown();
ctxt.register_action("HELP_KEYBINDINGS");
ctxt.register_action("QUIT");
ctxt.register_action("NEXT_TAB");
ctxt.register_action("PREV_TAB");
ctxt.register_action("CONFIRM");
std::stringstream sTemp;
while(true) {
//Clear the lines
for (int i = 0; i < iContentHeight; i++) {
for (int j = 0; j < 79; j++) {
if (mapLines[j]) {
mvwputch(w_worlds, i, j, BORDER_COLOR, LINE_XOXO);
} else {
mvwputch(w_worlds, i, j, c_black, ' ');
}
if (i < iTooltipHeight) {
mvwputch(w_worlds_tooltip, i, j, c_black, ' ');
}
}
}
//Draw World Names
for (size_t i = 0; i < world_pages[selpage].size(); ++i) {
sTemp.str("");
sTemp << i + 1;
mvwprintz(w_worlds, i, 0, c_white, "%s", sTemp.str().c_str());
mvwprintz(w_worlds, i, 4, c_white, "");
if (i == sel) {
wprintz(w_worlds, c_yellow, ">> ");
} else {
wprintz(w_worlds, c_yellow, " ");
}
wprintz(w_worlds, c_white, "%s (%i)", (world_pages[selpage])[i].c_str(),
world_generator->all_worlds[((world_pages[selpage])[i])]->world_saves.size());
}
//Draw Tabs
mvwprintz(w_worlds_header, 0, 7, c_white, "");
for (size_t i = 0; i < num_pages; ++i) {
nc_color tabcolor = (selpage == i) ? hilite(c_white) : c_white;
if (!world_pages[i].empty()) { //skip empty pages
wprintz(w_worlds_header, c_white, "[");
wprintz(w_worlds_header, tabcolor, _("Page %d"), i + 1);
wprintz(w_worlds_header, c_white, "]");
wputch(w_worlds_header, BORDER_COLOR, LINE_OXOX);
}
}
wrefresh(w_worlds_header);
fold_and_print(w_worlds_tooltip, 0, 0, 78, c_white, _("Pick a world to enter game"));
wrefresh(w_worlds_tooltip);
wrefresh(w_worlds);
const std::string action = ctxt.handle_input();
if (action == "QUIT") {
break;
} else if (!world_pages[selpage].empty() && action == "DOWN") {
sel++;
if (sel >= world_pages[selpage].size()) {
sel = 0;
}
} else if (!world_pages[selpage].empty() && action == "UP") {
if (sel == 0) {
sel = world_pages[selpage].size() - 1;
} else {
sel--;
}
} else if (action == "NEXT_TAB") {
sel = 0;
do { //skip empty pages
selpage++;
if (selpage >= world_pages.size()) {
selpage = 0;
}
} while(world_pages[selpage].empty());
} else if (action == "PREV_TAB") {
sel = 0;
do { //skip empty pages
if (selpage != 0) {
selpage--;
} else {
selpage = world_pages.size() - 1;
}
} while(world_pages[selpage].empty());
} else if (action == "CONFIRM") {
// we are wanting to get out of this by confirmation, so ask if we want to load the level [y/n prompt] and if yes exit
if (query_yn(_("Do you want to start the game in world [%s]?"),
world_pages[selpage][sel].c_str())) {
werase(w_worlds);
werase(w_worlds_border);
werase(w_worlds_header);
werase(w_worlds_tooltip);
return all_worlds[world_pages[selpage][sel]];//sel + selpage * iContentHeight;
}
}
}
werase(w_worlds);
werase(w_worlds_border);
werase(w_worlds_header);
werase(w_worlds_tooltip);
return NULL;
}
void game::show_options()
{
// Remember what the options were originally so we can restore them if player cancels.
option_table OPTIONS_OLD = OPTIONS;
WINDOW* w_options_border = newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH,
(TERMY > FULL_SCREEN_HEIGHT) ? (TERMY-FULL_SCREEN_HEIGHT)/2 : 0,
(TERMX > FULL_SCREEN_WIDTH) ? (TERMX-FULL_SCREEN_WIDTH)/2 : 0);
WINDOW* w_options = newwin(FULL_SCREEN_HEIGHT-2, FULL_SCREEN_WIDTH-2,
1 + ((TERMY > FULL_SCREEN_HEIGHT) ? (TERMY-FULL_SCREEN_HEIGHT)/2 : 0),
1 + ((TERMX > FULL_SCREEN_WIDTH) ? (TERMX-FULL_SCREEN_WIDTH)/2 : 0));
int offset = 1;
const int MAX_LINE = 22;
int line = 0;
char ch = ' ';
bool changed_options = false;
bool needs_refresh = true;
wborder(w_options_border, LINE_XOXO, LINE_XOXO, LINE_OXOX, LINE_OXOX,
LINE_OXXO, LINE_OOXX, LINE_XXOO, LINE_XOOX);
mvwprintz(w_options_border, 0, 36, c_ltred, " OPTIONS ");
wrefresh(w_options_border);
do {
// TODO: change instructions
if(needs_refresh) {
werase(w_options);
mvwprintz(w_options, 0, 40, c_white, "Use up/down keys to scroll through");
mvwprintz(w_options, 1, 40, c_white, "available options.");
mvwprintz(w_options, 2, 40, c_white, "Use left/right keys to toggle.");
mvwprintz(w_options, 3, 40, c_white, "Press ESC or q to return. ");
// highlight options for option descriptions
std::string tmp = option_desc(option_key(offset + line));
std::string out;
size_t pos;
int displayline = 5;
do {
pos = tmp.find_first_of('\n');
out = tmp.substr(0, pos);
mvwprintz(w_options, displayline, 40, c_white, out.c_str());
tmp = tmp.substr(pos + 1);
displayline++;
} while(pos != std::string::npos && displayline < 12);
needs_refresh = false;
}
// Clear the lines
for(int i = 0; i < 25; i++) {
mvwprintz(w_options, i, 0, c_black, " ");
}
int valid_option_count = 0;
// display options
for(int i = 0; i < 26 && offset + i < NUM_OPTION_KEYS; i++) {
valid_option_count++;
mvwprintz(w_options, i, 0, c_white, "%s: ",
option_name(option_key(offset + i)).c_str());
if(option_is_bool(option_key(offset + i))) {
bool on = OPTIONS[ option_key(offset + i) ];
if(i == line) {
mvwprintz(w_options, i, 30, hilite(c_ltcyan), (on ? "True" : "False"));
} else {
mvwprintz(w_options, i, 30, (on ? c_ltgreen : c_ltred), (on ? "True" : "False"));
}
} else {
char option_val = OPTIONS[ option_key(offset + i) ];
if(i == line) {
mvwprintz(w_options, i, 30, hilite(c_ltcyan), "%d", option_val);
} else {
mvwprintz(w_options, i, 30, c_ltgreen, "%d", option_val);
}
}
}
wrefresh(w_options);
ch = input();
needs_refresh = true;
switch(ch) {
// move up and down
case 'j':
line++;
if(line > MAX_LINE/2 && offset + 1 < NUM_OPTION_KEYS - MAX_LINE) {
++offset;
--line;
}
if(line > MAX_LINE) {
line = 0;
offset = 1;
}
break;
case 'k':
line--;
if(line < MAX_LINE/2 && offset > 1) {
--offset;
++line;
}
if(line < 0) {
line = MAX_LINE;
offset = NUM_OPTION_KEYS - MAX_LINE - 1;
}
break;
// toggle options with left/right keys
case 'h':
if(option_is_bool(option_key(offset + line))) {
OPTIONS[ option_key(offset + line) ] = !(OPTIONS[ option_key(offset + line) ]);
} else {
OPTIONS[ option_key(offset + line) ]--;
if((OPTIONS[ option_key(offset + line) ]) < option_min_options(option_key(offset + line))) {
OPTIONS[ option_key(offset + line) ] = option_max_options(option_key(offset + line)) - 1;
}
}
changed_options = true;
break;
case 'l':
if(option_is_bool(option_key(offset + line))) {
OPTIONS[ option_key(offset + line) ] = !(OPTIONS[ option_key(offset + line) ]);
} else {
OPTIONS[ option_key(offset + line) ]++;
if((OPTIONS[ option_key(offset + line) ]) >= option_max_options(option_key(offset + line))) {
OPTIONS[ option_key(offset + line) ] = option_min_options(option_key(offset + line));
}
}
changed_options = true;
break;
}
if(changed_options && OPTIONS[OPT_SEASON_LENGTH] < 1) { OPTIONS[OPT_SEASON_LENGTH]=option_max_options(OPT_SEASON_LENGTH)-1; }
} while(ch != 'q' && ch != 'Q' && ch != KEY_ESCAPE);
if(changed_options)
{
if(query_yn("Save changes?"))
{
save_options();
trigdist=(OPTIONS[OPT_CIRCLEDIST] ? true : false);
}
else
{
// Player wants to keep the old options. Revert!
OPTIONS = OPTIONS_OLD;
}
}
werase(w_options);
}
void test_pattern(int iCurrentPage, int iCurrentLine)
{
std::vector<std::string> vMatchingItems;
std::string sItemName = "";
if (vAutoPickupRules[iCurrentPage][iCurrentLine].sRule == "") {
return;
}
//Loop through all itemfactory items
//APU now ignores prefixes, bottled items and suffix combinations still not generated
for( auto &p : item_controller->get_all_itypes() ) {
sItemName = p.second->nname(1);
if (vAutoPickupRules[iCurrentPage][iCurrentLine].bActive &&
auto_pickup_match(sItemName, vAutoPickupRules[iCurrentPage][iCurrentLine].sRule)) {
vMatchingItems.push_back(sItemName);
}
}
const int iOffsetX = 15 + ((TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0);
const int iOffsetY = 5 + ((TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0);
int iStartPos = 0;
const int iContentHeight = FULL_SCREEN_HEIGHT - 8;
const int iContentWidth = FULL_SCREEN_WIDTH - 30;
std::stringstream sTemp;
WINDOW *w_test_rule_border = newwin(iContentHeight + 2, iContentWidth, iOffsetY, iOffsetX);
WINDOW_PTR w_test_rule_borderptr( w_test_rule_border );
WINDOW *w_test_rule_content = newwin(iContentHeight, iContentWidth - 2, 1 + iOffsetY, 1 + iOffsetX);
WINDOW_PTR w_test_rule_contentptr( w_test_rule_content );
draw_border(w_test_rule_border);
int nmatch = vMatchingItems.size();
std::string buf = string_format(ngettext("%1$d item matches: %2$s", "%1$d items match: %2$s",
nmatch), nmatch, vAutoPickupRules[iCurrentPage][iCurrentLine].sRule.c_str());
mvwprintz(w_test_rule_border, 0, iContentWidth / 2 - utf8_width(buf.c_str()) / 2, hilite(c_white),
"%s", buf.c_str());
mvwprintz(w_test_rule_border, iContentHeight + 1, 1, red_background(c_white),
_("Won't display bottled and suffixes=(fits)"));
wrefresh(w_test_rule_border);
iCurrentLine = 0;
input_context ctxt("AUTO_PICKUP_TEST");
ctxt.register_updown();
ctxt.register_action("QUIT");
while(true) {
// Clear the lines
for (int i = 0; i < iContentHeight; i++) {
for (int j = 0; j < 79; j++) {
mvwputch(w_test_rule_content, i, j, c_black, ' ');
}
}
calcStartPos(iStartPos, iCurrentLine, iContentHeight, vMatchingItems.size());
// display auto pickup
for (int i = iStartPos; i < (int)vMatchingItems.size(); i++) {
if (i >= iStartPos &&
i < iStartPos + ((iContentHeight > (int)vMatchingItems.size()) ? (int)vMatchingItems.size() :
iContentHeight)) {
nc_color cLineColor = c_white;
sTemp.str("");
sTemp << i + 1;
mvwprintz(w_test_rule_content, i - iStartPos, 0, cLineColor, "%s", sTemp.str().c_str());
mvwprintz(w_test_rule_content, i - iStartPos, 4, cLineColor, "");
if (iCurrentLine == i) {
wprintz(w_test_rule_content, c_yellow, ">> ");
} else {
wprintz(w_test_rule_content, c_yellow, " ");
}
wprintz(w_test_rule_content, (iCurrentLine == i) ? hilite(cLineColor) : cLineColor,
vMatchingItems[i].c_str());
}
}
wrefresh(w_test_rule_content);
const std::string action = ctxt.handle_input();
if (action == "DOWN") {
iCurrentLine++;
if (iCurrentLine >= (int)vMatchingItems.size()) {
iCurrentLine = 0;
}
} else if (action == "UP") {
iCurrentLine--;
if (iCurrentLine < 0) {
iCurrentLine = vMatchingItems.size() - 1;
}
} else {
break;
}
}
}
void draw_tabs(WINDOW *w, int active_tab, ...)
{
int win_width;
win_width = getmaxx(w);
std::vector<std::string> labels;
va_list ap;
va_start(ap, active_tab);
char *tmp;
while ((tmp = va_arg(ap, char *)))
labels.push_back((std::string)(tmp));
va_end(ap);
// Draw the line under the tabs
for (int x = 0; x < win_width; x++)
mvwputch(w, 2, x, c_white, LINE_OXOX);
int total_width = 0;
for (int i = 0; i < labels.size(); i++)
total_width += labels[i].length() + 6; // "< |four| >"
if (total_width > win_width) {
//debugmsg("draw_tabs not given enough space! %s", labels[0]);
return;
}
// Extra "buffer" space per each side of each tab
double buffer_extra = (win_width - total_width) / (labels.size() * 2);
int buffer = int(buffer_extra);
// Set buffer_extra to (0, 1); the "extra" whitespace that builds up
buffer_extra = buffer_extra - buffer;
int xpos = 0;
double savings = 0;
for (int i = 0; i < labels.size(); i++) {
int length = labels[i].length();
xpos += buffer + 2;
savings += buffer_extra;
if (savings > 1) {
savings--;
xpos++;
}
mvwputch(w, 0, xpos, c_white, LINE_OXXO);
mvwputch(w, 1, xpos, c_white, LINE_XOXO);
mvwputch(w, 0, xpos + length + 1, c_white, LINE_OOXX);
mvwputch(w, 1, xpos + length + 1, c_white, LINE_XOXO);
if (i == active_tab) {
mvwputch(w, 1, xpos - 2, h_white, '<');
mvwputch(w, 1, xpos + length + 3, h_white, '>');
mvwputch(w, 2, xpos, c_white, LINE_XOOX);
mvwputch(w, 2, xpos + length + 1, c_white, LINE_XXOO);
mvwprintz(w, 1, xpos + 1, h_white, labels[i].c_str());
for (int x = xpos + 1; x <= xpos + length; x++) {
mvwputch(w, 0, x, c_white, LINE_OXOX);
mvwputch(w, 2, x, c_black, 'x');
}
} else {
mvwputch(w, 2, xpos, c_white, LINE_XXOX);
mvwputch(w, 2, xpos + length + 1, c_white, LINE_XXOX);
mvwprintz(w, 1, xpos + 1, c_white, labels[i].c_str());
for (int x = xpos + 1; x <= xpos + length; x++)
mvwputch(w, 0, x, c_white, LINE_OXOX);
}
xpos += length + 1 + buffer;
}
}
// Why put this in a Big Switch? Why not let bionics have pointers to
// functions, much like monsters and items?
//
// Well, because like diseases, which are also in a Big Switch, bionics don't
// share functions....
void player::activate_bionic(int b, game *g)
{
bionic bio = my_bionics[b];
int power_cost = bionics[bio.id].power_cost;
if (weapon.type->id == itm_bio_claws && bio.id == bio_claws)
power_cost = 0;
if (power_level < power_cost) {
if (my_bionics[b].powered) {
g->add_msg("Your %s powers down.", bionics[bio.id].name.c_str());
my_bionics[b].powered = false;
} else
g->add_msg("You cannot power your %s", bionics[bio.id].name.c_str());
return;
}
if (my_bionics[b].powered && my_bionics[b].charge > 0) {
// Already-on units just lose a bit of charge
my_bionics[b].charge--;
} else {
// Not-on units, or those with zero charge, have to pay the power cost
if (bionics[bio.id].charge_time > 0) {
my_bionics[b].powered = true;
my_bionics[b].charge = bionics[bio.id].charge_time;
}
power_level -= power_cost;
}
std::string junk;
std::vector<point> traj;
std::vector<std::string> good;
std::vector<std::string> bad;
WINDOW* w;
int dirx, diry, t, l, index;
item tmp_item;
switch (bio.id) {
case bio_painkiller:
pkill += 6;
pain -= 2;
if (pkill > pain)
pkill = pain;
break;
case bio_nanobots:
healall(4);
break;
case bio_resonator:
g->sound(posx, posy, 30, "VRRRRMP!");
for (int i = posx - 1; i <= posx + 1; i++) {
for (int j = posy - 1; j <= posy + 1; j++) {
g->m.bash(i, j, 40, junk);
g->m.bash(i, j, 40, junk); // Multibash effect, so that doors &c will fall
g->m.bash(i, j, 40, junk);
if (g->m.is_destructable(i, j) && rng(1, 10) >= 4)
g->m.ter(i, j) = t_rubble;
}
}
break;
case bio_time_freeze:
moves += 100 * power_level;
power_level = 0;
g->add_msg("Your speed suddenly increases!");
if (one_in(3)) {
g->add_msg("Your muscles tear with the strain.");
hurt(g, bp_arms, 0, rng(5, 10));
hurt(g, bp_arms, 1, rng(5, 10));
hurt(g, bp_legs, 0, rng(7, 12));
hurt(g, bp_legs, 1, rng(7, 12));
hurt(g, bp_torso, 0, rng(5, 15));
}
if (one_in(5))
add_disease(DI_TELEGLOW, rng(50, 400), g);
break;
case bio_teleport:
g->teleport();
add_disease(DI_TELEGLOW, 300, g);
break;
// TODO: More stuff here (and bio_blood_filter)
case bio_blood_anal:
w = newwin(20, 40, 3, 10);
wborder(w, LINE_XOXO, LINE_XOXO, LINE_OXOX, LINE_OXOX,
LINE_OXXO, LINE_OOXX, LINE_XXOO, LINE_XOOX );
if (has_disease(DI_FUNGUS))
bad.push_back("Fungal Parasite");
if (has_disease(DI_DERMATIK))
bad.push_back("Insect Parasite");
if (has_disease(DI_POISON))
bad.push_back("Poison");
if (radiation > 0)
bad.push_back("Irradiated");
if (has_disease(DI_PKILL1))
good.push_back("Minor Painkiller");
if (has_disease(DI_PKILL2))
good.push_back("Moderate Painkiller");
if (has_disease(DI_PKILL3))
good.push_back("Heavy Painkiller");
if (has_disease(DI_PKILL_L))
good.push_back("Slow-Release Painkiller");
if (has_disease(DI_DRUNK))
good.push_back("Alcohol");
if (has_disease(DI_CIG))
good.push_back("Nicotine");
if (has_disease(DI_HIGH))
good.push_back("Intoxicant: Other");
if (has_disease(DI_TOOK_PROZAC))
good.push_back("Prozac");
if (has_disease(DI_TOOK_FLUMED))
good.push_back("Antihistamines");
if (has_disease(DI_ADRENALINE))
good.push_back("Adrenaline Spike");
if (good.size() == 0 && bad.size() == 0)
mvwprintz(w, 1, 1, c_white, "No effects.");
else {
for (int line = 1; line < 39 && line <= good.size() + bad.size(); line++) {
if (line < bad.size())
mvwprintz(w, line, 1, c_red, bad[line - 1].c_str());
else
mvwprintz(w, line, 1, c_green, good[line - 1 - bad.size()].c_str());
}
}
wrefresh(w);
refresh();
getch();
delwin(w);
break;
case bio_blood_filter:
rem_disease(DI_FUNGUS);
rem_disease(DI_POISON);
rem_disease(DI_PKILL1);
rem_disease(DI_PKILL2);
rem_disease(DI_PKILL3);
rem_disease(DI_PKILL_L);
rem_disease(DI_DRUNK);
rem_disease(DI_CIG);
rem_disease(DI_HIGH);
rem_disease(DI_TOOK_PROZAC);
rem_disease(DI_TOOK_FLUMED);
rem_disease(DI_ADRENALINE);
break;
case bio_evap:
if (query_yn("Drink directly? Otherwise you will need a container.")) {
tmp_item = item(g->itypes[itm_water], 0);
thirst -= 50;
if (has_trait(PF_GOURMAND) && thirst < -60) {
g->add_msg("You can't finish it all!");
thirst = -60;
} else if (!has_trait(PF_GOURMAND) && thirst < -20) {
g->add_msg("You can't finish it all!");
thirst = -20;
}
} else {
t = g->inv("Choose a container:");
if (i_at(t).type == 0) {
g->add_msg("You don't have that item!");
power_level += bionics[bio_evap].power_cost;
} else if (!i_at(t).is_container()) {
g->add_msg("That %s isn't a container!", i_at(t).tname().c_str());
power_level += bionics[bio_evap].power_cost;
} else {
it_container *cont = dynamic_cast<it_container*>(i_at(t).type);
if (i_at(t).volume_contained() + 1 > cont->contains) {
g->add_msg("There's no space left in your %s.", i_at(t).tname().c_str());
power_level += bionics[bio_evap].power_cost;
} else if (!(cont->flags & con_wtight)) {
g->add_msg("Your %s isn't watertight!", i_at(t).tname().c_str());
power_level += bionics[bio_evap].power_cost;
} else {
g->add_msg("You pour water into your %s.", i_at(t).tname().c_str());
i_at(t).put_in(item(g->itypes[itm_water], 0));
}
}
}
break;
case bio_lighter:
g->draw();
mvprintw(0, 0, "Torch in which direction?");
get_direction(dirx, diry, input());
if (dirx == -2) {
g->add_msg("Invalid direction.");
power_level += bionics[bio_lighter].power_cost;
return;
}
dirx += posx;
diry += posy;
if (!g->m.add_field(g, dirx, diry, fd_fire, 1)) // Unsuccessful.
g->add_msg("You can't light a fire there.");
break;
case bio_claws:
if (weapon.type->id == itm_bio_claws) {
g->add_msg("You withdraw your claws.");
weapon = ret_null;
} else if (weapon.type->id != 0) {
g->add_msg("Your claws extend, forcing you to drop your %s.",
weapon.tname().c_str());
g->m.add_item(posx, posy, weapon);
weapon = item(g->itypes[itm_bio_claws], 0);
weapon.invlet = '#';
} else {
g->add_msg("Your claws extend!");
weapon = item(g->itypes[itm_bio_claws], 0);
weapon.invlet = '#';
}
break;
case bio_blaster:
tmp_item = weapon;
weapon = item(g->itypes[itm_bio_blaster], 0);
weapon.curammo = dynamic_cast<it_ammo*>(g->itypes[itm_bio_fusion]);
weapon.charges = 1;
g->refresh_all();
g->plfire(false);
weapon = tmp_item;
break;
case bio_laser:
tmp_item = weapon;
weapon = item(g->itypes[itm_v29], 0);
weapon.curammo = dynamic_cast<it_ammo*>(g->itypes[itm_laser_pack]);
weapon.charges = 1;
g->refresh_all();
g->plfire(false);
weapon = tmp_item;
break;
case bio_emp:
g->draw();
mvprintw(0, 0, "Fire EMP in which direction?");
get_direction(dirx, diry, input());
if (dirx == -2) {
g->add_msg("Invalid direction.");
power_level += bionics[bio_emp].power_cost;
return;
}
dirx += posx;
diry += posy;
g->emp_blast(dirx, diry);
break;
case bio_hydraulics:
g->add_msg("Your muscles hiss as hydraulic strength fills them!");
break;
case bio_water_extractor:
for (int i = 0; i < g->m.i_at(posx, posy).size(); i++) {
item tmp = g->m.i_at(posx, posy)[i];
if (tmp.type->id == itm_corpse && query_yn("Extract water from the %s",
tmp.tname().c_str())) {
i = g->m.i_at(posx, posy).size() + 1; // Loop is finished
t = g->inv("Choose a container:");
if (i_at(t).type == 0) {
g->add_msg("You don't have that item!");
power_level += bionics[bio_water_extractor].power_cost;
} else if (!i_at(t).is_container()) {
g->add_msg("That %s isn't a container!", i_at(t).tname().c_str());
power_level += bionics[bio_water_extractor].power_cost;
} else {
it_container *cont = dynamic_cast<it_container*>(i_at(t).type);
if (i_at(t).volume_contained() + 1 > cont->contains) {
g->add_msg("There's no space left in your %s.", i_at(t).tname().c_str());
power_level += bionics[bio_water_extractor].power_cost;
} else {
g->add_msg("You pour water into your %s.", i_at(t).tname().c_str());
i_at(t).put_in(item(g->itypes[itm_water], 0));
}
}
}
if (i == g->m.i_at(posx, posy).size() - 1) // We never chose a corpse
power_level += bionics[bio_water_extractor].power_cost;
}
break;
case bio_magnet:
for (int i = posx - 10; i <= posx + 10; i++) {
for (int j = posy - 10; j <= posy + 10; j++) {
if (g->m.i_at(i, j).size() > 0) {
if (g->m.sees(i, j, posx, posy, -1, t))
traj = line_to(i, j, posx, posy, t);
else
traj = line_to(i, j, posx, posy, 0);
}
for (int k = 0; k < g->m.i_at(i, j).size(); k++) {
if (g->m.i_at(i, j)[k].made_of(IRON) || g->m.i_at(i, j)[k].made_of(STEEL)){
tmp_item = g->m.i_at(i, j)[k];
g->m.i_rem(i, j, k);
for (l = 0; l < traj.size(); l++) {
index = g->mon_at(traj[l].x, traj[l].y);
if (index != -1) {
if (g->z[index].hurt(tmp_item.weight() * tmp_item.volume()))
g->kill_mon(index);
g->m.add_item(traj[l].x, traj[l].y, tmp_item);
l = traj.size() + 1;
} else if (l > 0 && g->m.move_cost(traj[l].x, traj[l].y) == 0) {
g->m.bash(traj[l].x, traj[l].y, tmp_item.weight() * tmp_item.volume(),
junk);
g->sound(traj[l].x, traj[l].y, 12, junk);
if (g->m.move_cost(traj[l].x, traj[l].y) == 0) {
g->m.add_item(traj[l - 1].x, traj[l - 1].y, tmp_item);
l = traj.size() + 1;
}
}
}
if (l == traj.size())
g->m.add_item(posx, posy, tmp_item);
k--;
}
}
}
}
break;
case bio_lockpick:
g->draw();
mvprintw(0, 0, "Unlock in which direction?");
get_direction(dirx, diry, input());
if (dirx == -2) {
g->add_msg("Invalid direction.");
power_level += bionics[bio_lockpick].power_cost;
return;
}
dirx += posx;
diry += posy;
if (g->m.ter(dirx, diry) == t_door_locked) {
moves -= 40;
g->add_msg("You unlock the door.");
g->m.ter(dirx, diry) = t_door_c;
} else
g->add_msg("You can't unlock that %s.", g->m.tername(dirx, diry).c_str());
break;
}
}
virtual void select(int entnum, uimenu *menu) {
if ( ! started ) {
started = true;
padding = std::string(menu->pad_right - 1, ' ');
for (std::map<std::string, trait>::iterator iter = traits.begin(); iter != traits.end(); ++iter) {
vTraits.push_back(iter->first);
pTraits[iter->first] = ( p->has_trait( iter->first ) );
}
}
int startx = menu->w_width - menu->pad_right;
for ( int i = 1; i < lastlen; i++ ) {
mvwprintw(menu->window, i, startx, "%s", padding.c_str() );
}
mvwprintw(menu->window, 1, startx, mutation_data[vTraits[ entnum ]].valid ? _("Valid") : _("Nonvalid"));
int line2 = 2;
if ( mutation_data[vTraits[ entnum ]].prereqs.size() > 0 ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Prereqs:"));
for (int j = 0; j < mutation_data[vTraits[ entnum ]].prereqs.size(); j++) {
std::string mstr=mutation_data[vTraits[ entnum ]].prereqs[j];
mvwprintz(menu->window, line2, startx + 11, mcolor(mstr), traits[ mstr ].name.c_str());
line2++;
}
}
if ( mutation_data[vTraits[ entnum ]].cancels.size() > 0 ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Cancels:"));
for (int j = 0; j < mutation_data[vTraits[ entnum ]].cancels.size(); j++) {
std::string mstr=mutation_data[vTraits[ entnum ]].cancels[j];
mvwprintz(menu->window, line2, startx + 11, mcolor(mstr), traits[ mstr ].name.c_str());
line2++;
}
}
if ( mutation_data[vTraits[ entnum ]].replacements.size() > 0 ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Becomes:"));
for (int j = 0; j < mutation_data[vTraits[ entnum ]].replacements.size(); j++) {
std::string mstr=mutation_data[vTraits[ entnum ]].replacements[j];
mvwprintz(menu->window, line2, startx + 11, mcolor(mstr), traits[ mstr ].name.c_str());
line2++;
}
}
if ( mutation_data[vTraits[ entnum ]].additions.size() > 0 ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Add-ons:"));
for (int j = 0; j < mutation_data[vTraits[ entnum ]].additions.size(); j++) {
std::string mstr=mutation_data[vTraits[ entnum ]].additions[j];
mvwprintz(menu->window, line2, startx + 11, mcolor(mstr), traits[ mstr ].name.c_str());
line2++;
}
}
if ( mutation_data[vTraits[ entnum ]].category.size() > 0 ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Category:"));
for (int j = 0; j < mutation_data[vTraits[ entnum ]].category.size(); j++) {
mvwprintw(menu->window, line2, startx + 11, mutation_data[vTraits[ entnum ]].category[j].c_str());
line2++;
}
}
line2 += 2;
mvwprintz(menu->window, line2, startx, c_ltgray, "pts: %d vis: %d ugly: %d",
traits[vTraits[ entnum ]].points,
traits[vTraits[ entnum ]].visibility,
traits[vTraits[ entnum ]].ugliness
);
line2 += 2;
std::vector<std::string> desc = foldstring( traits[vTraits[ entnum ]].description, menu->pad_right - 1 );
for( int j = 0; j < desc.size(); j++ ) {
mvwprintz(menu->window, line2, startx, c_ltgray, "%s", desc[j].c_str() );
line2++;
}
lastlen = line2 + 1;
mvwprintz(menu->window, menu->w_height - 3, startx, c_green, "%s", msg.c_str());
msg = padding;
mvwprintw(menu->window, menu->w_height - 2, startx, "[/] find, [q]uit");
};
int set_traits(WINDOW* w, game* g, player *u, int &points)
{
draw_tabs(w, "TRAITS");
WINDOW* w_description = newwin(3, 78, 21 + getbegy(w), 1 + getbegx(w));
// Track how many good / bad POINTS we have; cap both at MAX_TRAIT_POINTS
int num_good = 0, num_bad = 0;
for (int i = 0; i < PF_SPLIT; i++) {
if (u->has_trait(i))
num_good += traits[i].points;
}
for (int i = PF_SPLIT + 1; i < PF_MAX; i++) {
if (u->has_trait(i))
num_bad += abs(traits[i].points);
}
for (int i = 0; i < 16; i++) {
mvwprintz(w, 5 + i, 40, c_dkgray, "\
");
mvwprintz(w, 5 + i, 40, c_dkgray, traits[PF_SPLIT + 1 + i].name.c_str());
}
mvwprintz(w,11,32, c_ltgray, "h l");
mvwprintz(w,12,32, c_ltgray, "< >");
mvwprintz(w,13,32, c_ltgray, "4 6");
mvwprintz(w,15,32, c_ltgray, "Space");
mvwprintz(w,16,31, c_ltgray,"Toggles");
int cur_adv = 1, cur_dis = PF_SPLIT + 1, cur_trait, traitmin, traitmax, xoff;
nc_color col_on, col_off, hi_on, hi_off;
bool using_adv = true; // True if we're selecting advantages, false if we're
// selecting disadvantages
do {
mvwprintz(w, 3, 2, c_ltgray, "Points left: %d ", points);
mvwprintz(w, 3,20, c_ltgreen, "%s%d/%d", (num_good < 10 ? " " : ""),
num_good, MAX_TRAIT_POINTS);
mvwprintz(w, 3,33, c_ltred, "%s%d/%d", (num_bad < 10 ? " " : ""),
num_bad, MAX_TRAIT_POINTS);
// Clear the bottom of the screen.
mvwprintz(w_description, 0, 0, c_ltgray, " ");
mvwprintz(w_description, 1, 0, c_ltgray, " ");
mvwprintz(w_description, 2, 0, c_ltgray, " ");
if (using_adv) {
col_on = COL_TR_GOOD_ON;
col_off = COL_TR_GOOD_OFF;
hi_on = hilite(col_on);
hi_off = hilite(col_off);
xoff = 2;
cur_trait = cur_adv;
traitmin = 1;
traitmax = PF_SPLIT;
mvwprintz(w, 3, 40, c_ltgray, " ");
mvwprintz(w, 3, 40, COL_TR_GOOD, "%s costs %d points",
traits[cur_adv].name.c_str(), traits[cur_adv].points);
mvwprintz(w_description, 0, 0, COL_TR_GOOD, "%s", traits[cur_adv].description.c_str());
} else {
col_on = COL_TR_BAD_ON;
col_off = COL_TR_BAD_OFF;
hi_on = hilite(col_on);
hi_off = hilite(col_off);
xoff = 40;
cur_trait = cur_dis;
traitmin = PF_SPLIT + 1;
traitmax = PF_MAX;
mvwprintz(w, 3, 40, c_ltgray, " ");
mvwprintz(w, 3, 40, COL_TR_BAD, "%s earns %d points",
traits[cur_dis].name.c_str(), traits[cur_dis].points * -1);
mvwprintz(w_description, 0, 0, COL_TR_BAD, "%s", traits[cur_dis].description.c_str());
}
if (cur_trait <= traitmin + 7) {
for (int i = traitmin; i < traitmin + 16; i++) {
mvwprintz(w, 5 + i - traitmin, xoff, c_ltgray, "\
"); // Clear the line
if (i == cur_trait) {
if (u->has_trait(i))
mvwprintz(w, 5 + i - traitmin, xoff, hi_on, traits[i].name.c_str());
else
mvwprintz(w, 5 + i - traitmin, xoff, hi_off, traits[i].name.c_str());
} else {
if (u->has_trait(i))
mvwprintz(w, 5 + i - traitmin, xoff, col_on, traits[i].name.c_str());
else
mvwprintz(w, 5 + i - traitmin, xoff, col_off, traits[i].name.c_str());
}
}
} else if (cur_trait >= traitmax - 9) {
for (int i = traitmax - 16; i < traitmax; i++) {
mvwprintz(w, 21 + i - traitmax, xoff, c_ltgray, "\
"); // Clear the line
if (i == cur_trait) {
if (u->has_trait(i))
mvwprintz(w, 21 + i - traitmax, xoff, hi_on, traits[i].name.c_str());
else
mvwprintz(w, 21 + i - traitmax, xoff, hi_off, traits[i].name.c_str());
} else {
if (u->has_trait(i))
mvwprintz(w, 21 + i - traitmax, xoff, col_on, traits[i].name.c_str());
else
mvwprintz(w, 21 + i - traitmax, xoff, col_off, traits[i].name.c_str());
}
}
} else {
void player::power_mutations()
{
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 : inv_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 char 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;
}
const auto other_mut_id = trait_by_invlet( newch );
// if there is already a mutation with the new key, the key
// is considered valid.
if( other_mut_id.empty() && inv_chars.find(newch) == std::string::npos ) {
// TODO separate list of letters for mutations
popup(_("%c is not a valid inventory letter."), newch);
continue;
}
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(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 || hunger <= 400) &&
(!mut_data.thirst || thirst <= 400) &&
(!mut_data.fatigue || 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( 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);
}
}
void monster::print_info(game *g, WINDOW* w, int vStart)
{
// First line of w is the border; the next two are terrain info, and after that
// is a blank line. w is 13 characters tall, and we can't use the last one
// because it's a border as well; so we have lines 4 through 11.
// w is also 48 characters wide - 2 characters for border = 46 characters for us
// vStart added because 'help' text in targeting win makes helpful info hard to find
// at a glance.
const int vEnd = vStart + 5; // TODO: parameterize this
mvwprintz(w, vStart, 1, c_white, "%s ", type->name.c_str());
switch (attitude(&(g->u))) {
case MATT_FRIEND:
wprintz(w, h_white, _("Friendly! "));
break;
case MATT_FLEE:
wprintz(w, c_green, _("Fleeing! "));
break;
case MATT_IGNORE:
wprintz(w, c_ltgray, _("Ignoring "));
break;
case MATT_FOLLOW:
wprintz(w, c_yellow, _("Tracking "));
break;
case MATT_ATTACK:
wprintz(w, c_red, _("Hostile! "));
break;
default:
wprintz(w, h_red, "BUG: Behavior unnamed. (monster.cpp:print_info)");
break;
}
if (has_effect(ME_DOWNED))
wprintz(w, h_white, _("On ground"));
else if (has_effect(ME_STUNNED))
wprintz(w, h_white, _("Stunned"));
else if (has_effect(ME_BEARTRAP))
wprintz(w, h_white, _("Trapped"));
std::string damage_info;
nc_color col;
if (hp >= type->hp) {
damage_info = _("It is uninjured");
col = c_green;
} else if (hp >= type->hp * .8) {
damage_info = _("It is lightly injured");
col = c_ltgreen;
} else if (hp >= type->hp * .6) {
damage_info = _("It is moderately injured");
col = c_yellow;
} else if (hp >= type->hp * .3) {
damage_info = _("It is heavily injured");
col = c_yellow;
} else if (hp >= type->hp * .1) {
damage_info = _("It is severly injured");
col = c_ltred;
} else {
damage_info = _("it is nearly dead");
col = c_red;
}
mvwprintz(w, vStart+1, 1, col, damage_info.c_str());
int line = vStart + 2;
std::vector<std::string> lines = foldstring(type->description, getmaxx(w) - 2);
int numlines = lines.size();
for (int i = 0; i < numlines && line <= vEnd; i++, line++)
mvwprintz(w, line, 1, c_white, lines[i].c_str());
}
void defense_game::refresh_setup(WINDOW* w, int selection)
{
werase(w);
mvwprintz(w, 0, 1, c_ltred, _("DEFENSE MODE"));
mvwprintz(w, 0, 28, c_ltred, _("Press +/- or >/< to cycle, spacebar to toggle"));
mvwprintz(w, 1, 28, c_ltred, _("Press S to start, ! to save as a template"));
mvwprintz(w, 2, 2, c_ltgray, _("Scenario:"));
mvwprintz(w, 3, 2, SELCOL(1), defense_style_name(style).c_str());
mvwprintz(w, 3, 28, c_ltgray, defense_style_description(style).c_str());
mvwprintz(w, 4, 2, c_ltgray, _("Location:"));
mvwprintz(w, 5, 2, SELCOL(2), defense_location_name(location).c_str());
mvwprintz(w, 5, 28, c_ltgray, defense_location_description(location).c_str());
mvwprintz(w, 7, 2, c_ltgray, _("Initial Difficulty:"));
mvwprintz(w, 7, NUMALIGN(initial_difficulty), SELCOL(3), "%d",
initial_difficulty);
mvwprintz(w, 7, 28, c_ltgray, _("The difficulty of the first wave."));
mvwprintz(w, 8, 2, c_ltgray, _("Wave Difficulty:"));
mvwprintz(w, 8, NUMALIGN(wave_difficulty), SELCOL(4), "%d", wave_difficulty);
mvwprintz(w, 8, 28, c_ltgray, _("The increase of difficulty with each wave."));
mvwprintz(w, 10, 2, c_ltgray, _("Time b/w Waves:"));
mvwprintz(w, 10, NUMALIGN(time_between_waves), SELCOL(5), "%d",
time_between_waves);
mvwprintz(w, 10, 28, c_ltgray, _("The time, in minutes, between waves."));
mvwprintz(w, 11, 2, c_ltgray, _("Waves b/w Caravans:"));
mvwprintz(w, 11, NUMALIGN(waves_between_caravans), SELCOL(6), "%d",
waves_between_caravans);
mvwprintz(w, 11, 28, c_ltgray, _("The number of waves in between caravans."));
mvwprintz(w, 13, 2, c_ltgray, _("Initial Cash:"));
mvwprintz(w, 13, NUMALIGN(initial_cash), SELCOL(7), "%d", initial_cash);
mvwprintz(w, 13, 28, c_ltgray, _("The amount of money the player starts with."));
mvwprintz(w, 14, 2, c_ltgray, _("Cash for 1st Wave:"));
mvwprintz(w, 14, NUMALIGN(cash_per_wave), SELCOL(8), "%d", cash_per_wave);
mvwprintz(w, 14, 28, c_ltgray, _("The cash awarded for the first wave."));
mvwprintz(w, 15, 2, c_ltgray, _("Cash Increase:"));
mvwprintz(w, 15, NUMALIGN(cash_increase), SELCOL(9), "%d", cash_increase);
mvwprintz(w, 15, 28, c_ltgray, _("The increase in the award each wave."));
mvwprintz(w, 17, 2, c_ltgray, _("Enemy Selection:"));
mvwprintz(w, 18, 2, TOGCOL(10, zombies), _("Zombies"));
mvwprintz(w, 18, 14, TOGCOL(11, specials), _("Special Zombies"));
mvwprintz(w, 18, 34, TOGCOL(12, spiders), _("Spiders"));
mvwprintz(w, 18, 46, TOGCOL(13, triffids), _("Triffids"));
mvwprintz(w, 18, 59, TOGCOL(14, robots), _("Robots"));
mvwprintz(w, 18, 70, TOGCOL(15, subspace), _("Subspace"));
mvwprintz(w, 20, 2, c_ltgray, _("Needs:"));
mvwprintz(w, 21, 2, TOGCOL(16, hunger), _("Food"));
mvwprintz(w, 21, 16, TOGCOL(17, thirst), _("Water"));
mvwprintz(w, 21, 31, TOGCOL(18, sleep), _("Sleep"));
mvwprintz(w, 21, 46, TOGCOL(19, mercenaries), _("Mercenaries"));
wrefresh(w);
}
void uimenu::show() {
if (!started) {
bool w_auto = (w_width == -1 || w_width == -2 );
bool w_autofold = ( w_width == -2);
int realtextwidth = 0;
if ( w_auto ) {
w_width = 4;
}
bool h_auto = (w_height == -1);
if ( h_auto ) {
w_height = 4;
}
std::vector<int> autoassign;
autoassign.clear();
int pad = pad_left + pad_right + 2;
for ( int i = 0; i < entries.size(); i++ ) {
int txtwidth = utf8_width(entries[ i ].txt.c_str());
if(entries[ i ].enabled) {
if( entries[ i ].hotkey > 0 ) {
keymap[ entries[ i ].hotkey ] = i;
} else if ( entries[ i ].hotkey == -1 ) {
autoassign.push_back(i);
}
if ( entries[ i ].retval == -1 ) {
entries[ i ].retval = i;
}
if ( w_auto && w_width < txtwidth + pad + 4 ) {
w_width = txtwidth + pad + 4;
}
} else {
if ( w_auto && w_width < txtwidth + pad + 4 ) {
w_width = txtwidth + pad + 4; // todo: or +5 if header
}
}
}
if ( autoassign.size() > 0 ) {
for ( int a = 0; a < autoassign.size(); a++ ) {
int palloc = autoassign[ a ];
if ( palloc < 9 ) {
entries[ palloc ].hotkey = palloc + 49; // 1-9;
} else if ( palloc == 9 ) {
entries[ palloc ].hotkey = palloc + 39; // 0;
} else if ( palloc < 36 ) {
entries[ palloc ].hotkey = palloc + 87; // a-z
} else if ( palloc < 61 ) {
entries[ palloc ].hotkey = palloc + 29; // A-Z
}
if ( palloc < 61 ) {
keymap[ entries[ palloc ].hotkey ] = palloc;
}
}
}
if (w_auto && w_width > TERMX) {
w_width = TERMX;
}
if(text.size() > 0 ) {
int twidth = utf8_width(text.c_str());
if ( textwidth == -1 ) {
if ( w_autofold || !w_auto ) {
realtextwidth = w_width - 4;
} else {
realtextwidth = twidth;
if ( twidth + 4 > w_width ) {
if ( realtextwidth + 4 > TERMX ) {
realtextwidth = TERMX - 4;
}
w_width = realtextwidth + 4;
}
}
} else if ( textwidth != -1 ) {
realtextwidth = textwidth;
}
textformatted = foldstring(text, realtextwidth);
}
if (h_auto) {
w_height = 2 + textformatted.size() + entries.size();
}
vmax = entries.size();
if ( w_height > TERMY ) {
w_height = TERMY;
}
if ( vmax + 2 + textformatted.size() > w_height ) {
vmax = w_height - 2 - textformatted.size();
if ( vmax < 1 ) {
popup("Can't display menu options, %d %d available screen rows are occupied by\n'%s\n(snip)\n%s'\nThis is probably a bug.\n",
textformatted.size(),TERMY,textformatted[0].c_str(),textformatted[textformatted.size()-1].c_str()
);
}
}
if (w_x == -1) {
w_x = int((TERMX - w_width) / 2);
}
if (w_y == -1) {
w_y = int((TERMY - w_height) / 2);
}
window = newwin(w_height, w_width, w_y, w_x);
werase(window);
wattron(window, border_color);
wborder(window, LINE_XOXO, LINE_XOXO, LINE_OXOX, LINE_OXOX,
LINE_OXXO, LINE_OOXX, LINE_XXOO, LINE_XOOX );
wattroff(window, border_color);
if( title.size() > 0 ) {
mvwprintz(window, 0, 1, border_color, "< ");
wprintz(window, title_color, "%s", title.c_str() );
wprintz(window, border_color, " >");
}
started = true;
}
std::string padspaces = std::string(w_width - 2 - pad_left - pad_right, ' ');
for ( int i = 0; i < textformatted.size(); i++ ) {
mvwprintz(window, 1+i, 2, text_color, "%s", textformatted[i].c_str());
}
int estart = textformatted.size() + 1; // todo fold text + get offset
if ( selected < vshift ) {
vshift=selected;
} else if ( selected >= vshift + vmax ) {
vshift=1+selected-vmax;
}
for ( int ei = vshift, si=0; si < vmax; ei++,si++ ) {
if ( ei < entries.size() ) {
nc_color co = ( ei == selected ? hilight_color : ( entries[ ei ].enabled ? text_color : disabled_color ) );
if ( hilight_full ) {
mvwprintz(window, estart + si, pad_left + 1, co , "%s", padspaces.c_str());
}
if(entries[ ei ].enabled && entries[ ei ].hotkey > 33 && entries[ ei ].hotkey < 126 ) {
mvwprintz(window, estart + si, pad_left + 2, ( ei == selected ? hilight_color : hotkey_color ) , "%c", entries[ ei ].hotkey);
}
mvwprintz(window, estart + si, pad_left + 4, co, "%s", entries[ ei ].txt.c_str() );
} else {
mvwprintz(window, estart + si, pad_left + 1, c_ltgray , "%s", padspaces.c_str());
}
}
wrefresh(window);
}
void defense_game::setup()
{
WINDOW* w = newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, 0, 0);
int selection = 1;
refresh_setup(w, selection);
while (true) {
char ch = input();
if (ch == 'S') {
if (!zombies && !specials && !spiders && !triffids && !robots && !subspace) {
popup(_("You must choose at least one monster group!"));
refresh_setup(w, selection);
} else
return;
} else if (ch == '+' || ch == '>' || ch == 'j') {
if (selection == 19)
selection = 1;
else
selection++;
refresh_setup(w, selection);
} else if (ch == '-' || ch == '<' || ch == 'k') {
if (selection == 1)
selection = 19;
else
selection--;
refresh_setup(w, selection);
} else if (ch == '!') {
std::string name = string_input_popup(_("Template Name:"), 20); //TODO: this is NON FUNCTIONAL!!!
refresh_setup(w, selection);
} else {
switch (selection) {
case 1: // Scenario selection
if (ch == 'l') {
if (style == defense_style(NUM_DEFENSE_STYLES - 1))
style = defense_style(1);
else
style = defense_style(style + 1);
}
if (ch == 'h') {
if (style == defense_style(1))
style = defense_style(NUM_DEFENSE_STYLES - 1);
else
style = defense_style(style - 1);
}
init_to_style(style);
break;
case 2: // Location selection
if (ch == 'l') {
if (location == defense_location(NUM_DEFENSE_LOCATIONS - 1))
location = defense_location(1);
else
location = defense_location(location + 1);
}
if (ch == 'h') {
if (location == defense_location(1))
location = defense_location(NUM_DEFENSE_LOCATIONS - 1);
else
location = defense_location(location - 1);
}
mvwprintz(w, 5, 2, c_black, "\
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
mvwprintz(w, 5, 2, c_yellow, defense_location_name(location).c_str());
mvwprintz(w, 5, 28, c_ltgray,
defense_location_description(location).c_str());
break;
case 3: // Difficulty of the first wave
if (ch == 'h' && initial_difficulty > 10)
initial_difficulty -= 5;
if (ch == 'l' && initial_difficulty < 995)
initial_difficulty += 5;
mvwprintz(w, 7, 22, c_black, "xxx");
mvwprintz(w, 7, NUMALIGN(initial_difficulty), c_yellow, "%d",
initial_difficulty);
break;
case 4: // Wave Difficulty
if (ch == 'h' && wave_difficulty > 10)
wave_difficulty -= 5;
if (ch == 'l' && wave_difficulty < 995)
wave_difficulty += 5;
mvwprintz(w, 8, 22, c_black, "xxx");
mvwprintz(w, 8, NUMALIGN(wave_difficulty), c_yellow, "%d",
wave_difficulty);
break;
case 5:
if (ch == 'h' && time_between_waves > 5)
time_between_waves -= 5;
if (ch == 'l' && time_between_waves < 995)
time_between_waves += 5;
mvwprintz(w, 10, 22, c_black, "xxx");
mvwprintz(w, 10, NUMALIGN(time_between_waves), c_yellow, "%d",
time_between_waves);
break;
case 6:
if (ch == 'h' && waves_between_caravans > 1)
waves_between_caravans -= 1;
if (ch == 'l' && waves_between_caravans < 50)
waves_between_caravans += 1;
mvwprintz(w, 11, 22, c_black, "xxx");
mvwprintz(w, 11, NUMALIGN(waves_between_caravans), c_yellow, "%d",
waves_between_caravans);
break;
case 7:
if (ch == 'h' && initial_cash > 0)
initial_cash -= 100;
if (ch == 'l' && initial_cash < 99900)
initial_cash += 100;
mvwprintz(w, 13, 20, c_black, "xxxxx");
mvwprintz(w, 13, NUMALIGN(initial_cash), c_yellow, "%d", initial_cash);
break;
case 8:
if (ch == 'h' && cash_per_wave > 0)
cash_per_wave -= 100;
if (ch == 'l' && cash_per_wave < 9900)
cash_per_wave += 100;
mvwprintz(w, 14, 21, c_black, "xxxx");
mvwprintz(w, 14, NUMALIGN(cash_per_wave), c_yellow, "%d", cash_per_wave);
break;
case 9:
if (ch == 'h' && cash_increase > 0)
cash_increase -= 50;
if (ch == 'l' && cash_increase < 9950)
cash_increase += 50;
mvwprintz(w, 15, 21, c_black, "xxxx");
mvwprintz(w, 15, NUMALIGN(cash_increase), c_yellow, "%d", cash_increase);
break;
case 10:
if (ch == ' ' || ch == '\n') {
zombies = !zombies;
specials = false;
}
mvwprintz(w, 18, 2, (zombies ? c_ltgreen : c_yellow), "Zombies");
mvwprintz(w, 18, 14, c_yellow, _("Special Zombies"));
break;
case 11:
if (ch == ' ' || ch == '\n') {
specials = !specials;
zombies = false;
}
mvwprintz(w, 18, 2, c_yellow, _("Zombies"));
mvwprintz(w, 18, 14, (specials ? c_ltgreen : c_yellow), _("Special Zombies"));
break;
case 12:
if (ch == ' ' || ch == '\n')
spiders = !spiders;
mvwprintz(w, 18, 34, (spiders ? c_ltgreen : c_yellow), _("Spiders"));
break;
case 13:
if (ch == ' ' || ch == '\n')
triffids = !triffids;
mvwprintz(w, 18, 46, (triffids ? c_ltgreen : c_yellow), _("Triffids"));
break;
case 14:
if (ch == ' ' || ch == '\n')
robots = !robots;
mvwprintz(w, 18, 59, (robots ? c_ltgreen : c_yellow), _("Robots"));
break;
case 15:
if (ch == ' ' || ch == '\n')
subspace = !subspace;
mvwprintz(w, 18, 70, (subspace ? c_ltgreen : c_yellow), _("Subspace"));
break;
case 16:
if (ch == ' ' || ch == '\n')
hunger = !hunger;
mvwprintz(w, 21, 2, (hunger ? c_ltgreen : c_yellow), _("Food"));
break;
case 17:
if (ch == ' ' || ch == '\n')
thirst = !thirst;
mvwprintz(w, 21, 16, (thirst ? c_ltgreen : c_yellow), _("Water"));
break;
case 18:
if (ch == ' ' || ch == '\n')
sleep = !sleep;
mvwprintz(w, 21, 31, (sleep ? c_ltgreen : c_yellow), _("Sleep"));
break;
case 19:
if (ch == ' ' || ch == '\n')
mercenaries = !mercenaries;
mvwprintz(w, 21, 46, (mercenaries ? c_ltgreen : c_yellow), _("Mercenaries"));
break;
}
}
if (ch == 'h' || ch == 'l' || ch == ' ' || ch == '\n')
refresh_setup(w, selection);
}
}
int worldfactory::show_worldgen_tab_modselection(WINDOW *win, WORLDPTR world)
{
// Use active_mod_order of the world,
// saves us from writting 'world->active_mod_order' all the time.
std::vector<std::string> &active_mod_order = world->active_mod_order;
{
std::vector<std::string> tmp_mod_order;
// clear active_mod_order and re-add all the mods, his ensures
// that changes (like changing depencies) get updated
tmp_mod_order.swap(active_mod_order);
for(size_t i = 0; i < tmp_mod_order.size(); i++) {
mman_ui->try_add(tmp_mod_order[i], active_mod_order);
}
}
const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0;
const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0;
// lots of small windows so that each section can be drawn to independently of the others as necessary
WINDOW *w_header1, *w_header2, *w_shift, *w_list, *w_active, *w_description;
w_header1 = newwin(1, FULL_SCREEN_WIDTH / 2 - 5, 3 + iOffsetY, 1 + iOffsetX);
w_header2 = newwin(1, FULL_SCREEN_WIDTH / 2 - 4, 3 + iOffsetY,
FULL_SCREEN_WIDTH / 2 + 3 + iOffsetX);
w_shift = newwin(13, 5, 3 + iOffsetY, FULL_SCREEN_WIDTH / 2 - 3 + iOffsetX);
w_list = newwin(11, FULL_SCREEN_WIDTH / 2 - 4, 5 + iOffsetY, iOffsetX);
w_active = newwin(11, FULL_SCREEN_WIDTH / 2 - 4, 5 + iOffsetY,
FULL_SCREEN_WIDTH / 2 + 2 + iOffsetX);
w_description = newwin(4, FULL_SCREEN_WIDTH - 2, 19 + iOffsetY, 1 + iOffsetX);
draw_modselection_borders(win);
std::vector<std::string> headers;
headers.push_back(_("Mod List"));
headers.push_back(_("Mod Load Order"));
std::vector<WINDOW *> header_windows;
header_windows.push_back(w_header1);
header_windows.push_back(w_header2);
int tab_output = 0;
int last_active_header = 0;
size_t active_header = 0;
size_t useable_mod_count = mman_ui->usable_mods.size();
int startsel[2] = {0, 0};
int cursel[2] = {0, 0};
bool redraw_headers = true;
bool redraw_shift = true;
bool redraw_description = true;
bool redraw_list = true;
bool redraw_active = true;
bool selection_changed = false;
input_context ctxt("MODMANAGER_DIALOG");
ctxt.register_cardinal();
ctxt.register_action("HELP_KEYBINDINGS");
ctxt.register_action("QUIT");
ctxt.register_action("NEXT_TAB");
ctxt.register_action("PREV_TAB");
ctxt.register_action("CONFIRM");
ctxt.register_action("ADD_MOD");
ctxt.register_action("REMOVE_MOD");
ctxt.register_action("SAVE_DEFAULT_MODS");
while (tab_output == 0) {
if (redraw_headers) {
for (size_t i = 0; i < headers.size(); ++i) {
werase(header_windows[i]);
const int header_x = (getmaxx(header_windows[i]) - headers[i].size()) / 2;
mvwprintz(header_windows[i], 0, header_x , c_cyan, "%s", headers[i].c_str());
if (active_header == i) {
mvwputch(header_windows[i], 0, header_x - 3, c_red, '<');
mvwputch(header_windows[i], 0, header_x + headers[i].size() + 2, c_red, '>');
}
wrefresh(header_windows[i]);
}
redraw_list = true;
redraw_active = true;
redraw_shift = true;
redraw_headers = false;
}
if (selection_changed) {
if (active_header == 0) {
redraw_list = true;
}
if (active_header == 1) {
redraw_shift = true;
redraw_active = true;
}
selection_changed = false;
redraw_description = true;
}
if (redraw_description) {
werase(w_description);
MOD_INFORMATION *selmod = NULL;
if (mman_ui->usable_mods.empty()) {
// Do nothing, leave selmod == NULL
} else if (active_header == 0) {
selmod = mman->mod_map[mman_ui->usable_mods[cursel[0]]];
} else if (!active_mod_order.empty()) {
selmod = mman->mod_map[active_mod_order[cursel[1]]];
}
if (selmod != NULL) {
fold_and_print(w_description, 0, 1, getmaxx(w_description) - 1,
c_white, mman_ui->get_information(selmod));
}
redraw_description = false;
wrefresh(w_description);
}
if (redraw_list) {
werase(w_list);
calcStartPos(startsel[0], cursel[0], getmaxy(w_list), useable_mod_count);
if (useable_mod_count == 0) {
center_print(w_list, 0, c_red, _("--NO AVAILABLE MODS--"));
} else {
std::stringstream list_output;
for( size_t i = startsel[0], c = 0;
i < useable_mod_count && c < getmaxy(w_list); ++i, ++c ) {
if ((int)i != cursel[0]) {
list_output << std::string(3, ' ');
} else {
if (active_header == 0) {
list_output << "<color_yellow>";
} else {
list_output << "<color_blue>";
}
list_output << ">></color> ";
}
list_output << mman->mod_map[mman_ui->usable_mods[i]]->name << "\n";
}
fold_and_print(w_list, 0, 1, getmaxx(w_list) - 1, c_white, list_output.str());
}
draw_scrollbar(w_list, cursel[0], getmaxy(w_list), useable_mod_count, 0, 0);
wrefresh(w_list);
}
if (redraw_active) {
werase(w_active);
const int active_count = active_mod_order.size();
calcStartPos(startsel[1], cursel[1], getmaxy(w_active), active_count);
if (active_count == 0) {
center_print(w_active, 0, c_red, _("--NO ACTIVE MODS--"));
} else {
std::stringstream list_output;
for (int i = startsel[1], c = 0; i < active_count && c < getmaxy(w_active); ++i, ++c) {
if (i != cursel[1]) {
list_output << std::string(3, ' ');
} else {
if (active_header == 1) {
list_output << "<color_yellow>";
} else {
list_output << "<color_blue>";
}
list_output << ">></color> ";
}
list_output << mman->mod_map[active_mod_order[i]]->name << "\n";
}
fold_and_print(w_active, 0, 1, getmaxx(w_active) - 1, c_white, list_output.str());
}
draw_scrollbar(w_active, cursel[1], getmaxy(w_active), active_count, 0, 0);
wrefresh(w_active);
}
if (redraw_shift) {
werase(w_shift);
if (active_header == 1) {
std::stringstream shift_display;
// get shift information for whatever is visible in the active list
for (size_t i = startsel[1], c = 0; i < active_mod_order.size() && c < getmaxy(w_active); ++i, ++c) {
if (mman_ui->can_shift_up(i, active_mod_order)) {
shift_display << "<color_blue>+</color> ";
} else {
shift_display << "<color_dkgray>+</color> ";
}
if (mman_ui->can_shift_down(i, active_mod_order)) {
shift_display << "<color_blue>-</color>";
} else {
shift_display << "<color_dkgray>-</color>";
}
shift_display << "\n";
}
fold_and_print(w_shift, 2, 1, getmaxx(w_shift), c_white, shift_display.str());
}
redraw_shift = false;
wrefresh(w_shift);
}
refresh();
last_active_header = active_header;
const int next_header = (active_header == 1) ? 0 : 1;
const int prev_header = (active_header == 0) ? 1 : 0;
int selection = (active_header == 0) ? cursel[0] : cursel[1];
int last_selection = selection;
unsigned int next_selection = selection + 1;
int prev_selection = selection - 1;
if (active_header == 0) {
next_selection = (next_selection >= useable_mod_count) ? 0 : next_selection;
prev_selection = (prev_selection < 0) ? useable_mod_count - 1 : prev_selection;
} else {
next_selection = (next_selection >= active_mod_order.size()) ? 0 : next_selection;
prev_selection = (prev_selection < 0) ? active_mod_order.size() - 1 : prev_selection;
}
const std::string action = ctxt.handle_input();
if (action == "DOWN") {
selection = next_selection;
} else if (action == "UP") {
selection = prev_selection;
} else if (action == "RIGHT") {
active_header = next_header;
} else if (action == "LEFT") {
active_header = prev_header;
} else if (action == "CONFIRM") {
if (active_header == 0 && !mman_ui->usable_mods.empty()) {
// try-add
mman_ui->try_add(mman_ui->usable_mods[cursel[0]], active_mod_order);
redraw_active = true;
redraw_shift = true;
} else if (active_header == 1 && !active_mod_order.empty()) {
// try-rem
mman_ui->try_rem(cursel[1], active_mod_order);
redraw_active = true;
redraw_shift = true;
if (active_mod_order.empty()) {
// switch back to other list, we can't change
// anything in the empty active mods list.
active_header = 0;
}
}
} else if (action == "ADD_MOD") {
if (active_header == 1 && active_mod_order.size() > 1) {
mman_ui->try_shift('+', cursel[1], active_mod_order);
redraw_active = true;
redraw_shift = true;
}
} else if (action == "REMOVE_MOD") {
if (active_header == 1 && active_mod_order.size() > 1) {
mman_ui->try_shift('-', cursel[1], active_mod_order);
redraw_active = true;
redraw_shift = true;
}
} else if (action == "NEXT_TAB") {
tab_output = 1;
} else if (action == "PREV_TAB") {
tab_output = -1;
} else if (action == "SAVE_DEFAULT_MODS") {
if(mman->set_default_mods(active_mod_order)) {
popup(_("Saved list of active mods as default"));
draw_modselection_borders(win);
redraw_headers = true;
}
} else if (action == "QUIT") {
tab_output = -999;
}
// RESOLVE INPUTS
if (last_active_header != (int)active_header) {
redraw_headers = true;
redraw_shift = true;
redraw_description = true;
}
if (last_selection != selection) {
if (active_header == 0) {
redraw_list = true;
cursel[0] = selection;
} else {
redraw_active = true;
redraw_shift = true;
cursel[1] = selection;
}
redraw_description = true;
}
if (active_mod_order.empty()) {
redraw_active = true;
cursel[1] = 0;
}
if (active_header == 1) {
if (active_mod_order.empty()) {
cursel[1] = 0;
} else {
if (cursel[1] < 0) {
cursel[1] = 0;
} else if (cursel[1] >= (int)active_mod_order.size()) {
cursel[1] = active_mod_order.size() - 1;
}
}
}
// end RESOLVE INPUTS
}
werase(w_header1);
werase(w_header2);
werase(w_shift);
werase(w_list);
werase(w_active);
werase(w_description);
delwin(w_header1);
delwin(w_header2);
delwin(w_shift);
delwin(w_list);
delwin(w_active);
delwin(w_description);
return tab_output;
}
int worldfactory::show_worldgen_tab_options(WINDOW *win, WORLDPTR world)
{
const int iTooltipHeight = 1;
const int iContentHeight = FULL_SCREEN_HEIGHT - 3 - iTooltipHeight;
const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0;
const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0;
WINDOW *w_options = newwin(iContentHeight, FULL_SCREEN_WIDTH - 2, iTooltipHeight + 2 + iOffsetY,
1 + iOffsetX);
std::stringstream sTemp;
std::map<int, bool> mapLines;
mapLines[3] = true;
mapLines[60] = true;
// only populate once
if (world->world_options.empty()) {
for (auto it = OPTIONS.begin(); it != OPTIONS.end(); ++it) {
if (it->second.getPage() == "world_default") {
world->world_options[it->first] = it->second;
}
}
}
std::vector<std::string> keys;
for (auto it = world->world_options.begin();
it != world->world_options.end(); ++it) {
keys.push_back(it->first);
}
for (std::map<int, bool>::iterator mLine = mapLines.begin(); mLine != mapLines.end(); ++mLine) {
if (mLine->second) {
mvwputch(win, 2, mLine->first + 1, BORDER_COLOR, LINE_OXXX); // -.-
mvwputch(win, FULL_SCREEN_HEIGHT - 1, mLine->first + 1, BORDER_COLOR, LINE_XXOX); // _|_
}
}
wrefresh(win);
refresh();
input_context ctxt("WORLDGEN_OPTION_DIALOG");
ctxt.register_cardinal();
ctxt.register_action("HELP_KEYBINDINGS");
ctxt.register_action("QUIT");
ctxt.register_action("NEXT_TAB");
ctxt.register_action("PREV_TAB");
unsigned int sel = 0;
unsigned int curoption = 0;
do {
for (int i = 0; i < iContentHeight; i++) {
for (int j = 0; j < 79; j++) {
if (mapLines[j]) {
mvwputch(w_options, i, j, BORDER_COLOR, LINE_XOXO);
} else {
mvwputch(w_options, i, j, c_black, ' ');
}
}
}
curoption = 0;
for (auto it = world->world_options.begin();
it != world->world_options.end(); ++it) {
nc_color cLineColor = c_ltgreen;
sTemp.str("");
sTemp << curoption + 1;
mvwprintz(w_options, curoption , 0, c_white, "%s", sTemp.str().c_str());
mvwprintz(w_options, curoption , 4, c_white, "");
if (sel == curoption) {
wprintz(w_options, c_yellow, ">> ");
} else {
wprintz(w_options, c_yellow, " ");
}
wprintz(w_options, c_white, "%s", (it->second.getMenuText()).c_str());
if (it->second.getValue() == "False") {
cLineColor = c_ltred;
}
mvwprintz(w_options, curoption, 62, (sel == curoption) ? hilite(cLineColor) : cLineColor, "%s",
(it->second.getValueName()).c_str());
++curoption;
}
wrefresh(w_options);
refresh();
const std::string action = ctxt.handle_input();
if (action == "DOWN") {
sel++;
if (sel >= world->world_options.size()) {
sel = 0;
}
} else if (action == "UP") {
if (sel == 0) {
sel = world->world_options.size() - 1;
} else {
sel--;
}
} else if (!world->world_options.empty() && action == "LEFT") {
world->world_options[keys[sel]].setPrev();
} else if (!world->world_options.empty() && action == "RIGHT") {
world->world_options[keys[sel]].setNext();
} else if (action == "PREV_TAB") {
werase(w_options);
delwin(w_options);
return -1;
} else if (action == "NEXT_TAB") {
werase(w_options);
delwin(w_options);
return 1;
} else if (action == "QUIT") {
return -999;
}
} while (true);
return 0;
}
void game::mutation_wish()
{
WINDOW* w_list = newwin(25, 30, 0, 0);
WINDOW* w_info = newwin(25, 50, 0, 30);
int a = 0, shift = 0, result_selected = 0;
int ch = '.';
bool search = false, found = false;
std::string pattern;
std::string info;
std::vector<int> search_results;
do {
werase(w_info);
werase(w_list);
mvwprintw(w_list, 0, 0, "Mutate: ");
if (search) {
found = false;
if (ch == '\n') {
search = false;
found = true;
ch = '.';
} else if (ch == KEY_BACKSPACE || ch == 127) {
if (pattern.length() > 0)
pattern.erase(pattern.end() - 1);
} else if (ch == '>') {
search = false;
if (!search_results.empty()) {
result_selected++;
if (result_selected > search_results.size())
result_selected = 0;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > PF_MAX2) {
a = shift + 23 - PF_MAX2;
shift = PF_MAX2 - 23;
}
}
} else if (ch == '<') {
search = false;
if (!search_results.empty()) {
result_selected--;
if (result_selected < 0)
result_selected = search_results.size() - 1;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > PF_MAX2) {
a = shift + 23 - PF_MAX2;
shift = PF_MAX2 - 23;
}
}
} else {
pattern += ch;
search_results.clear();
}
if (search) {
for (int i = 0; i < PF_MAX2; i++) {
if (traits[i].name.find(pattern) != std::string::npos) {
shift = i;
a = 0;
result_selected = 0;
if (shift + 23 > PF_MAX2) {
a = shift + 23 - PF_MAX2;
shift = PF_MAX2 - 23;
}
found = true;
search_results.push_back(i);
}
}
if (search_results.size() > 0) {
shift = search_results[0];
a = 0;
}
}
} else { // Not searching; scroll by keys
if (ch == 'j') a++;
if (ch == 'k') a--;
if (ch == '/') {
search = true;
pattern = "";
found = false;
search_results.clear();
}
if (ch == '>' && !search_results.empty()) {
result_selected++;
if (result_selected > search_results.size())
result_selected = 0;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > PF_MAX2) {
a = shift + 23 - PF_MAX2;
shift = PF_MAX2 - 23;
}
} else if (ch == '<' && !search_results.empty()) {
result_selected--;
if (result_selected < 0)
result_selected = search_results.size() - 1;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > PF_MAX2) {
a = shift + 23 - PF_MAX2;
shift = PF_MAX2 - 23;
}
}
}
if (!search_results.empty())
mvwprintz(w_list, 0, 11, c_green, "%s ", pattern.c_str());
else if (pattern.length() > 0)
mvwprintz(w_list, 0, 11, c_red, "%s not found! ",pattern.c_str());
if (a < 0) {
a = 0;
shift--;
if (shift < 0) shift = 0;
}
if (a > 22) {
a = 22;
shift++;
if (shift + 23 > PF_MAX2) shift = PF_MAX2 - 23;
}
for (int i = 1; i < 24; i++) {
nc_color col = c_white;
if (i == a + 1)
col = h_white;
mvwprintz(w_list, i, 0, col, traits[i-1+shift].name.c_str());
}
mvwprintw(w_info, 1, 0, mutation_data[a+shift].valid ? "Valid" : "Nonvalid");
int line2 = 2;
mvwprintw(w_info, line2, 0, "Prereqs:");
for (int j = 0; j < mutation_data[a+shift].prereqs.size(); j++) {
mvwprintw(w_info, line2, 9, traits[ mutation_data[a+shift].prereqs[j] ].name.c_str());
line2++;
}
mvwprintw(w_info, line2, 0, "Cancels:");
for (int j = 0; j < mutation_data[a+shift].cancels.size(); j++) {
mvwprintw(w_info, line2, 9, traits[ mutation_data[a+shift].cancels[j] ].name.c_str());
line2++;
}
mvwprintw(w_info, line2, 0, "Becomes:");
for (int j = 0; j < mutation_data[a+shift].replacements.size(); j++) {
mvwprintw(w_info, line2, 9, traits[ mutation_data[a+shift].replacements[j] ].name.c_str());
line2++;
}
mvwprintw(w_info, line2, 0, "Add-ons:");
for (int j = 0; j < mutation_data[a+shift].additions.size(); j++) {
mvwprintw(w_info, line2, 9, traits[ mutation_data[a+shift].additions[j] ].name.c_str());
line2++;
}
wrefresh(w_info);
wrefresh(w_list);
if (search)
ch = getch();
else
ch = input();
} while (ch != '\n');
clear();
if (a+shift == 0)
u.mutate(this);
else
u.mutate_towards(this, pl_flag(a + shift));
delwin(w_info);
delwin(w_list);
}
virtual void select(int entnum, uimenu *menu) override
{
if ( ! started ) {
started = true;
padding = std::string(menu->pad_right - 1, ' ');
for( auto &traits_iter : mutation_branch::get_all() ) {
vTraits.push_back( traits_iter.first );
pTraits[traits_iter.first] = ( p->has_trait( traits_iter.first ) );
}
}
auto &mdata = mutation_branch::get( vTraits[entnum] );
int startx = menu->w_width - menu->pad_right;
for ( int i = 2; i < lastlen; i++ ) {
mvwprintw(menu->window, i, startx, "%s", padding.c_str() );
}
mvwprintw(menu->window, 3, startx,
mdata.valid ? _("Valid") : _("Nonvalid"));
int line2 = 4;
if ( !mdata.prereqs.empty() ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Prereqs:"));
for (auto &j : mdata.prereqs) {
mvwprintz(menu->window, line2, startx + 11, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
line2++;
}
}
if ( !mdata.prereqs2.empty() ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Prereqs, 2d:"));
for (auto &j : mdata.prereqs2) {
mvwprintz(menu->window, line2, startx + 15, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
line2++;
}
}
if ( !mdata.threshreq.empty() ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Thresholds required:"));
for (auto &j : mdata.threshreq) {
mvwprintz(menu->window, line2, startx + 21, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
line2++;
}
}
if ( !mdata.cancels.empty() ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Cancels:"));
for (auto &j : mdata.cancels) {
mvwprintz(menu->window, line2, startx + 11, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
line2++;
}
}
if ( !mdata.replacements.empty() ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Becomes:"));
for (auto &j : mdata.replacements) {
mvwprintz(menu->window, line2, startx + 11, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
line2++;
}
}
if ( !mdata.additions.empty() ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Add-ons:"));
for (auto &j : mdata.additions) {
mvwprintz(menu->window, line2, startx + 11, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
line2++;
}
}
if ( !mdata.category.empty() ) {
line2++;
mvwprintz(menu->window, line2, startx, c_ltgray, _("Category:"));
for (auto &j : mdata.category) {
mvwprintw(menu->window, line2, startx + 11, "%s", j.c_str());
line2++;
}
}
line2 += 2;
mvwprintz(menu->window, line2, startx, c_ltgray, "pts: %d vis: %d ugly: %d",
mdata.points,
mdata.visibility,
mdata.ugliness
);
line2 += 2;
std::vector<std::string> desc = foldstring( mdata.description,
menu->pad_right - 1 );
for( auto &elem : desc ) {
mvwprintz( menu->window, line2, startx, c_ltgray, "%s", elem.c_str() );
line2++;
}
lastlen = line2 + 1;
mvwprintz(menu->window, menu->w_height - 3, startx, c_green, "%s", msg.c_str());
msg = padding;
mvwprintw(menu->window, menu->w_height - 2, startx, _("[/] find, [q]uit"));
};
void game::wish()
{
WINDOW* w_list = newwin(25, 30, 0, 0);
WINDOW* w_info = newwin(25, 50, 0, 30);
int a = 0, shift = 0, result_selected = 0;
int ch = '.';
bool search = false, found = false;
std::string pattern;
std::string info;
std::vector<int> search_results;
item tmp;
tmp.corpse = mtypes[0];
do {
werase(w_info);
werase(w_list);
mvwprintw(w_list, 0, 0, "Wish for a: ");
if (search) {
found = false;
if (ch == '\n') {
search = false;
found = true;
ch = '.';
} else if (ch == KEY_BACKSPACE || ch == 127) {
if (pattern.length() > 0)
pattern.erase(pattern.end() - 1);
} else if (ch == '>') {
search = false;
if (!search_results.empty()) {
result_selected++;
if (result_selected > search_results.size())
result_selected = 0;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > itypes.size()) {
a = shift + 23 - itypes.size();
shift = itypes.size() - 23;
}
}
} else if (ch == '<') {
search = false;
if (!search_results.empty()) {
result_selected--;
if (result_selected < 0)
result_selected = search_results.size() - 1;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > itypes.size()) {
a = shift + 23 - itypes.size();
shift = itypes.size() - 23;
}
}
} else {
pattern += ch;
search_results.clear();
}
if (search) {
for (int i = 0; i < itypes.size(); i++) {
if (itypes[i]->name.find(pattern) != std::string::npos) {
shift = i;
a = 0;
result_selected = 0;
if (shift + 23 > itypes.size()) {
a = shift + 23 - itypes.size();
shift = itypes.size() - 23;
}
found = true;
search_results.push_back(i);
}
}
if (search_results.size() > 0) {
shift = search_results[0];
a = 0;
}
}
} else { // Not searching; scroll by keys
if (ch == 'j') a++;
if (ch == 'k') a--;
if (ch == '/') {
search = true;
pattern = "";
found = false;
search_results.clear();
}
if (ch == '>' && !search_results.empty()) {
result_selected++;
if (result_selected > search_results.size())
result_selected = 0;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > itypes.size()) {
a = shift + 23 - itypes.size();
shift = itypes.size() - 23;
}
} else if (ch == '<' && !search_results.empty()) {
result_selected--;
if (result_selected < 0)
result_selected = search_results.size() - 1;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > itypes.size()) {
a = shift + 23 - itypes.size();
shift = itypes.size() - 23;
}
}
}
if (!search_results.empty())
mvwprintz(w_list, 0, 11, c_green, "%s ", pattern.c_str());
else if (pattern.length() > 0)
mvwprintz(w_list, 0, 11, c_red, "%s not found! ",pattern.c_str());
if (a < 0) {
a = 0;
shift--;
if (shift < 0) shift = 0;
}
if (a > 22) {
a = 22;
shift++;
if (shift + 23 > itypes.size()) shift = itypes.size() - 23;
}
for (int i = 1; i < 24 && i-1+shift < itypes.size(); i++) {
nc_color col = c_white;
if (i == a + 1)
col = h_white;
mvwprintz(w_list, i, 0, col, itypes[i-1+shift]->name.c_str());
wprintz(w_list, itypes[i-1+shift]->color, "%c%", itypes[i-1+shift]->sym);
}
tmp.make(itypes[a + shift]);
tmp.bday = turn;
if (tmp.is_tool())
tmp.charges = dynamic_cast<it_tool*>(tmp.type)->max_charges;
else if (tmp.is_ammo())
tmp.charges = 100;
else if (tmp.is_gun())
tmp.charges = 0;
else if (tmp.is_gunmod() && (tmp.has_flag(IF_MODE_AUX) ||
tmp.typeId() == itm_spare_mag))
tmp.charges = 0;
else
tmp.charges = -1;
info = tmp.info(true);
mvwprintw(w_info, 1, 0, info.c_str());
wrefresh(w_info);
wrefresh(w_list);
if (search)
ch = getch();
else
ch = input();
} while (ch != '\n');
clear();
mvprintw(0, 0, "\nWish granted - %d (%d).", tmp.type->id, itm_antibiotics);
tmp.invlet = nextinv;
u.i_add(tmp);
advance_nextinv();
getch();
delwin(w_info);
delwin(w_list);
}
void veh_interact::do_install(int reason)
{
werase (w_msg);
if (g->u.morale_level() < MIN_MORALE_CRAFT)
{ // See morale.h
mvwprintz(w_msg, 0, 1, c_ltred, "Your morale is too low to construct...");
wrefresh (w_msg);
return;
}
switch (reason)
{
case 1:
mvwprintz(w_msg, 0, 1, c_ltred, "Cannot install any part here.");
wrefresh (w_msg);
return;
case 2:
mvwprintz(w_msg, 0, 1, c_ltgray, "You need a ");
wprintz(w_msg, has_wrench? c_ltgreen : c_red, "wrench");
wprintz(w_msg, c_ltgray, " and a ");
wprintz(w_msg, has_welder? c_ltgreen : c_red, "powered welder");
wprintz(w_msg, c_ltgray, " to install parts.");
mvwprintz(w_msg, 1, 1, c_ltgray, "To change a wheel you need a ");
wprintz(w_msg, has_wrench? c_ltgreen : c_red, "wrench");
wprintz(w_msg, c_ltgray, " and a ");
wprintz(w_msg, has_jack? c_ltgreen : c_red, "jack");
wrefresh (w_msg);
return;
default:;
}
mvwprintz(w_mode, 0, 1, c_ltgray, "Choose new part to install here: ");
wrefresh (w_mode);
int pos = 0;
int engines = 0;
int dif_eng = 0;
for (int p = 0; p < veh->parts.size(); p++)
{
if (veh->part_flag (p, vpf_engine))
{
engines++;
dif_eng = dif_eng / 2 + 12;
}
}
while (true)
{
sel_part = can_mount[pos];
display_list (pos);
itype_id itm = vpart_list[sel_part].item;
bool has_comps = crafting_inv.has_amount(itm, 1);
bool has_skill = g->u.skillLevel("mechanics") >= vpart_list[sel_part].difficulty;
bool wheel = vpart_list[sel_part].flags & mfb (vpf_wheel);
bool has_tools = has_welder && has_wrench;
werase (w_msg);
mvwprintz(w_msg, 0, 1, c_ltgray, "Needs ");
wprintz(w_msg, has_comps? c_ltgreen : c_red, g->itypes[itm]->name.c_str());
wprintz(w_msg, c_ltgray, ", a ");
wprintz(w_msg, has_wrench? c_ltgreen : c_red, "wrench");
wprintz(w_msg, c_ltgray, ", a ");
wprintz(w_msg, has_welder? c_ltgreen : c_red, "powered welder");
wprintz(w_msg, c_ltgray, ", and level ");
wprintz(w_msg, has_skill? c_ltgreen : c_red, "%d", vpart_list[sel_part].difficulty);
wprintz(w_msg, c_ltgray, " skill in mechanics.");
if(wheel)
{
wprintz(w_msg, c_ltgray, " -OR- ");
wprintz(w_msg, has_comps? c_ltgreen : c_red, g->itypes[itm]->name.c_str());
wprintz(w_msg, c_ltgray, ", a ");
wprintz(w_msg, has_wrench? c_ltgreen : c_red, "wrench");
wprintz(w_msg, c_ltgray, ", and a ");
wprintz(w_msg, has_jack? c_ltgreen : c_red, "jack");
has_skill=(has_jack||has_skill); // my mother can change her car's tires
has_tools = has_tools || (has_wrench && has_jack);
sel_type=SEL_JACK;
}
bool eng = vpart_list[sel_part].flags & mfb (vpf_engine);
bool has_skill2 = !eng || (g->u.skillLevel("mechanics") >= dif_eng);
if (engines && eng) // already has engine
{
wprintz(w_msg, c_ltgray, " You also need level ");
wprintz(w_msg, has_skill2? c_ltgreen : c_red, "%d", dif_eng);
wprintz(w_msg, c_ltgray, " skill in mechanics to install additional engine.");
}
wrefresh (w_msg);
char ch = input(); // See keypress.h
int dx, dy;
get_direction (g, dx, dy, ch);
if ((ch == '\n' || ch == ' ') && has_comps && has_tools && has_skill && has_skill2)
{
//if(itm.is_var_veh_part() && crafting_inv.has_amount(itm, 2);
sel_cmd = 'i';
return;
}
else
{
if (ch == KEY_ESCAPE || ch == 'q' )
{
werase (w_list);
wrefresh (w_list);
werase (w_msg);
break;
}
}
if (dy == -1 || dy == 1)
{
pos += dy;
if (pos < 0)
{
pos = can_mount.size()-1;
}
else if (pos >= can_mount.size())
{
pos = 0;
}
}
}
}
int set_stats(WINDOW* w, game* g, player *u, int &points)
{
unsigned char sel = 1;
char ch;
draw_tabs(w, "STATS");
mvwprintz(w, 11, 2, c_ltgray, "j/k, 8/2, or arrows select");
mvwprintz(w, 12, 2, c_ltgray, " a statistic.");
mvwprintz(w, 13, 2, c_ltgray, "l, 6, or right arrow");
mvwprintz(w, 14, 2, c_ltgray, " increases the statistic.");
mvwprintz(w, 15, 2, c_ltgray, "h, 4, or left arrow");
mvwprintz(w, 16, 2, c_ltgray, " decreases the statistic.");
mvwprintz(w, 18, 2, c_ltgray, "> Takes you to the next tab.");
mvwprintz(w, 19, 2, c_ltgray, "< Returns you to the main menu.");
do {
mvwprintz(w, 3, 2, c_ltgray, "Points left: %d ", points);
switch (sel) {
case 1:
if (u->str_max >= HIGH_STAT)
mvwprintz(w, 3, 33, c_ltred, "Increasing Str further costs 2 points.");
else
mvwprintz(w, 3, 33, c_black, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
mvwprintz(w, 6, 2, COL_STAT_ACT, "Strength: %d ", u->str_max);
mvwprintz(w, 7, 2, c_ltgray, "Dexterity: %d ", u->dex_max);
mvwprintz(w, 8, 2, c_ltgray, "Intelligence: %d ", u->int_max);
mvwprintz(w, 9, 2, c_ltgray, "Perception: %d ", u->per_max);
mvwprintz(w, 6, 33, COL_STAT_ACT, "Base HP: %d ",
calc_HP(u->str_max, u->has_trait(PF_TOUGH)));
mvwprintz(w, 7, 33, COL_STAT_ACT, "Carry weight: %d lbs ",
u->weight_capacity(false) / 4);
mvwprintz(w, 8, 33, COL_STAT_ACT, "Melee damage: %d ",
u->base_damage(false));
mvwprintz(w,10, 33, COL_STAT_ACT, "Strength also makes you more resistant to ");
mvwprintz(w,11, 33, COL_STAT_ACT, "many diseases and poisons, and makes actions");
mvwprintz(w,12, 33, COL_STAT_ACT, "which require brute force more effective. ");
break;
case 2:
if (u->dex_max >= HIGH_STAT)
mvwprintz(w, 3, 33, c_ltred, "Increasing Dex further costs 2 points.");
else
mvwprintz(w, 3, 33, c_black, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
mvwprintz(w, 6, 2, c_ltgray, "Strength: %d ", u->str_max);
mvwprintz(w, 7, 2, COL_STAT_ACT, "Dexterity: %d ", u->dex_max);
mvwprintz(w, 8, 2, c_ltgray, "Intelligence: %d ", u->int_max);
mvwprintz(w, 9, 2, c_ltgray, "Perception: %d ", u->per_max);
mvwprintz(w, 6, 33, COL_STAT_ACT, "Melee to-hit bonus: +%d ",
u->base_to_hit(false));
mvwprintz(w, 7, 33, COL_STAT_ACT, " ");
mvwprintz(w, 7, 33, COL_STAT_ACT, "Ranged %s: %s%d",
(u->ranged_dex_mod(false) <= 0 ? "bonus" : "penalty"),
(u->ranged_dex_mod(false) <= 0 ? "+" : "-"),
abs(u->ranged_dex_mod(false)));
mvwprintz(w, 8, 33, COL_STAT_ACT, " ");
mvwprintz(w, 8, 33, COL_STAT_ACT, "Throwing %s: %s%d",
(u->throw_dex_mod(false) <= 0 ? "bonus" : "penalty"),
(u->throw_dex_mod(false) <= 0 ? "+" : "-"),
abs(u->throw_dex_mod(false)));
mvwprintz(w, 9, 33, COL_STAT_ACT, " ");
mvwprintz(w,10, 33, COL_STAT_ACT, "Dexterity also enhances many actions which ");
mvwprintz(w,11, 33, COL_STAT_ACT, "require finesse. ");
mvwprintz(w,12, 33, COL_STAT_ACT, " ");
break;
case 3:
if (u->int_max >= HIGH_STAT)
mvwprintz(w, 3, 33, c_ltred, "Increasing Int further costs 2 points.");
else
mvwprintz(w, 3, 33, c_black, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
mvwprintz(w, 6, 2, c_ltgray, "Strength: %d ", u->str_max);
mvwprintz(w, 7, 2, c_ltgray, "Dexterity: %d ", u->dex_max);
mvwprintz(w, 8, 2, COL_STAT_ACT, "Intelligence: %d ", u->int_max);
mvwprintz(w, 9, 2, c_ltgray, "Perception: %d ", u->per_max);
mvwprintz(w, 6, 33, COL_STAT_ACT, "Skill comprehension: %d%%%% ",
u->skillLevel("melee").comprehension(u->int_max));
mvwprintz(w, 7, 33, COL_STAT_ACT, "Read times: %d%%%% ",
u->read_speed(false));
mvwprintz(w, 8, 33, COL_STAT_ACT, " ");
mvwprintz(w, 9, 33, COL_STAT_ACT, "Intelligence is also used when crafting, ");
mvwprintz(w,10, 33, COL_STAT_ACT, "installing bionics, and interacting with ");
mvwprintz(w,11, 33, COL_STAT_ACT, "NPCs. ");
mvwprintz(w,12, 33, COL_STAT_ACT, " ");
break;
case 4:
if (u->per_max >= HIGH_STAT)
mvwprintz(w, 3, 33, c_ltred, "Increasing Per further costs 2 points.");
else
mvwprintz(w, 3, 33, c_black, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
mvwprintz(w, 6, 2, c_ltgray, "Strength: %d ", u->str_max);
mvwprintz(w, 7, 2, c_ltgray, "Dexterity: %d ", u->dex_max);
mvwprintz(w, 8, 2, c_ltgray, "Intelligence: %d ", u->int_max);
mvwprintz(w, 9, 2, COL_STAT_ACT, "Perception: %d ", u->per_max);
mvwprintz(w, 6, 33, COL_STAT_ACT, " ");
mvwprintz(w, 6, 33, COL_STAT_ACT, "Ranged %s: %s%d",
(u->ranged_per_mod(false) <= 0 ? "bonus" : "penalty"),
(u->ranged_per_mod(false) <= 0 ? "+" : "-"),
abs(u->ranged_per_mod(false)));
mvwprintz(w, 7, 33, COL_STAT_ACT, " ");
mvwprintz(w, 8, 33, COL_STAT_ACT, "Perception is also used for detecting ");
mvwprintz(w, 9, 33, COL_STAT_ACT, "traps and other things of interest. ");
mvwprintz(w,10, 33, COL_STAT_ACT, " ");
mvwprintz(w,11, 33, COL_STAT_ACT, " ");
mvwprintz(w,12, 33, COL_STAT_ACT, " ");
break;
}
wrefresh(w);
ch = input();
if (ch == 'j' && sel < 4)
sel++;
if (ch == 'k' && sel > 1)
sel--;
if (ch == 'h') {
if (sel == 1 && u->str_max > 4) {
if (u->str_max > HIGH_STAT)
points++;
u->str_max--;
points++;
} else if (sel == 2 && u->dex_max > 4) {
if (u->dex_max > HIGH_STAT)
points++;
u->dex_max--;
points++;
} else if (sel == 3 && u->int_max > 4) {
if (u->int_max > HIGH_STAT)
points++;
u->int_max--;
points++;
} else if (sel == 4 && u->per_max > 4) {
if (u->per_max > HIGH_STAT)
points++;
u->per_max--;
points++;
}
}
if (ch == 'l' && points > 0) {
if (sel == 1 && u->str_max < 20 && (u->str_max < HIGH_STAT || points > 1)) {
points--;
if (u->str_max >= HIGH_STAT)
points--;
u->str_max++;
} else if (sel == 2 && u->dex_max < 20 &&
(u->dex_max < HIGH_STAT || points > 1)) {
points--;
if (u->dex_max >= HIGH_STAT)
points--;
u->dex_max++;
} else if (sel == 3 && u->int_max < 20 &&
(u->int_max < HIGH_STAT || points > 1)) {
points--;
if (u->int_max >= HIGH_STAT)
points--;
u->int_max++;
} else if (sel == 4 && u->per_max < 20 &&
(u->per_max < HIGH_STAT || points > 1)) {
points--;
if (u->per_max >= HIGH_STAT)
points--;
u->per_max++;
}
}
if (ch == '<' && query_yn(g->VIEWX, g->VIEWY, "Return to main menu?"))
return -1;
if (ch == '>')
return 1;
} while (true);
}
void veh_interact::do_repair(int reason)
{
werase (w_msg);
if (g->u.morale_level() < MIN_MORALE_CRAFT)
{ // See morale.h
mvwprintz(w_msg, 0, 1, c_ltred, "Your morale is too low to construct...");
wrefresh (w_msg);
return;
}
switch (reason)
{
case 1:
mvwprintz(w_msg, 0, 1, c_ltred, "There are no damaged parts here.");
wrefresh (w_msg);
return;
case 2:
mvwprintz(w_msg, 0, 1, c_ltgray, "You need a powered welder to repair.");
mvwprintz(w_msg, 0, 12, has_welder? c_ltgreen : c_red, "powered welder");
wrefresh (w_msg);
return;
default:;
}
mvwprintz(w_mode, 0, 1, c_ltgray, "Choose a part here to repair:");
wrefresh (w_mode);
int pos = 0;
while (true)
{
sel_part = parts_here[need_repair[pos]];
werase (w_parts);
veh->print_part_desc (w_parts, 0, winw2, cpart, need_repair[pos]);
wrefresh (w_parts);
werase (w_msg);
bool has_comps = true;
int dif = veh->part_info(sel_part).difficulty + (veh->parts[sel_part].hp <= 0? 0 : 2);
bool has_skill = g->u.skillLevel("mechanics") >= dif;
mvwprintz(w_msg, 0, 1, c_ltgray, "You need level %d skill in mechanics.", dif);
mvwprintz(w_msg, 0, 16, has_skill? c_ltgreen : c_red, "%d", dif);
if (veh->parts[sel_part].hp <= 0)
{
itype_id itm = veh->part_info(sel_part).item;
has_comps = crafting_inv.has_amount(itm, 1);
mvwprintz(w_msg, 1, 1, c_ltgray, "You also need a wrench and %s to replace broken one.",
g->itypes[itm]->name.c_str());
mvwprintz(w_msg, 1, 17, has_wrench? c_ltgreen : c_red, "wrench");
mvwprintz(w_msg, 1, 28, has_comps? c_ltgreen : c_red, g->itypes[itm]->name.c_str());
}
wrefresh (w_msg);
char ch = input(); // See keypress.h
int dx, dy;
get_direction (g, dx, dy, ch);
if ((ch == '\n' || ch == ' ') && has_comps && (veh->parts[sel_part].hp > 0 ||
has_wrench) && has_skill)
{
sel_cmd = 'r';
return;
}
else
if (ch == KEY_ESCAPE || ch == 'q' )
{
werase (w_parts);
veh->print_part_desc (w_parts, 0, winw2, cpart, -1);
wrefresh (w_parts);
werase (w_msg);
break;
}
if (dy == -1 || dy == 1)
{
pos += dy;
if(pos >= need_repair.size())
pos = 0;
else if(pos < 0)
pos = need_repair.size() - 1;
}
}
}
void monster::print_info(game *g, WINDOW* w)
{
// First line of w is the border; the next two are terrain info, and after that
// is a blank line. w is 13 characters tall, and we can't use the last one
// because it's a border as well; so we have lines 4 through 11.
// w is also 48 characters wide - 2 characters for border = 46 characters for us
mvwprintz(w, 6, 1, c_white, "%s ", type->name.c_str());
switch (attitude(&(g->u))) {
case MATT_FRIEND:
wprintz(w, h_white, "Friendly! ");
break;
case MATT_FLEE:
wprintz(w, c_green, "Fleeing! ");
break;
case MATT_IGNORE:
wprintz(w, c_ltgray, "Ignoring ");
break;
case MATT_FOLLOW:
wprintz(w, c_yellow, "Tracking ");
break;
case MATT_ATTACK:
wprintz(w, c_red, "Hostile! ");
break;
default:
wprintz(w, h_red, "BUG: Behavior unnamed ");
break;
}
if (has_effect(ME_DOWNED))
wprintz(w, h_white, "On ground");
else if (has_effect(ME_STUNNED))
wprintz(w, h_white, "Stunned");
else if (has_effect(ME_BEARTRAP))
wprintz(w, h_white, "Trapped");
std::string damage_info;
nc_color col;
if (hp == type->hp) {
damage_info = "It is uninjured";
col = c_green;
} else if (hp >= type->hp * .8) {
damage_info = "It is lightly injured";
col = c_ltgreen;
} else if (hp >= type->hp * .6) {
damage_info = "It is moderately injured";
col = c_yellow;
} else if (hp >= type->hp * .3) {
damage_info = "It is heavily injured";
col = c_yellow;
} else if (hp >= type->hp * .1) {
damage_info = "It is severly injured";
col = c_ltred;
} else {
damage_info = "it is nearly dead";
col = c_red;
}
mvwprintz(w, 7, 1, col, damage_info.c_str());
std::string tmp = type->description;
std::string out;
size_t pos;
int line = 8;
do {
pos = tmp.find_first_of('\n');
out = tmp.substr(0, pos);
mvwprintz(w, line, 1, c_white, out.c_str());
tmp = tmp.substr(pos + 1);
line++;
} while (pos != std::string::npos && line < 12);
}
void veh_interact::do_remove(int reason)
{
werase (w_msg);
if (g->u.morale_level() < MIN_MORALE_CRAFT)
{ // See morale.h
mvwprintz(w_msg, 0, 1, c_ltred, "Your morale is too low to construct...");
wrefresh (w_msg);
return;
}
switch (reason)
{
case 1:
mvwprintz(w_msg, 0, 1, c_ltred, "No parts here.");
wrefresh (w_msg);
return;
case 2:
mvwprintz(w_msg, 0, 1, c_ltred,
"You cannot remove mount point while something is attached to it.");
wrefresh (w_msg);
return;
case 3:
mvwprintz(w_msg, 0, 1, c_ltgray, "You need a ");
wprintz(w_msg, has_wrench? c_ltgreen : c_red, "wrench");
wprintz(w_msg, c_ltgray, " and a ");
wprintz(w_msg, has_hacksaw? c_ltgreen : c_red, "hacksaw");
wprintz(w_msg, c_ltgray, " to remove parts.");
if(wheel) {
mvwprintz(w_msg, 1, 1, c_ltgray, "To change a wheel you need a ");
wprintz(w_msg, has_wrench? c_ltgreen : c_red, "wrench");
wprintz(w_msg, c_ltgray, " and a ");
wprintz(w_msg, has_jack? c_ltgreen : c_red, "jack");
}
wrefresh (w_msg);
return;
case 4:
mvwprintz(w_msg, 0, 1, c_ltred, "You need level 2 mechanics skill to remove parts.");
wrefresh (w_msg);
return;
default:;
}
mvwprintz(w_mode, 0, 1, c_ltgray, "Choose a part here to remove:");
wrefresh (w_mode);
int first = parts_here.size() > 1? 1 : 0;
int pos = first;
while (true)
{
sel_part = parts_here[pos];
werase (w_parts);
veh->print_part_desc (w_parts, 0, winw2, cpart, pos);
wrefresh (w_parts);
char ch = input(); // See keypress.h
int dx, dy;
get_direction (g, dx, dy, ch);
if (ch == '\n' || ch == ' ')
{
sel_cmd = 'o';
return;
}
else
if (ch == KEY_ESCAPE || ch == 'q' )
{
werase (w_parts);
veh->print_part_desc (w_parts, 0, winw2, cpart, -1);
wrefresh (w_parts);
werase (w_msg);
break;
}
if (dy == -1 || dy == 1)
{
pos += dy;
if (pos < first)
pos = parts_here.size()-1;
else
if (pos >= parts_here.size())
pos = first;
}
}
}
char compare_split_screen_popup(int iLeft, int iWidth, int iHeight, std::string sItemName, std::vector<iteminfo> vItemDisplay, std::vector<iteminfo> vItemCompare)
{
WINDOW* w = newwin(iHeight, iWidth, 0, iLeft);
mvwprintz(w, 1, 2, c_white, sItemName.c_str());
int line_num = 3;
int iStartX = 0;
std::string sPlus;
bool bStartNewLine = true;
for (int i = 0; i < vItemDisplay.size(); i++) {
if (vItemDisplay[i].sType == "MENU") {
if (vItemDisplay[i].sPre == "iOffsetY") {
line_num += vItemDisplay[i].iValue;
} else if (vItemDisplay[i].sPre == "iOffsetX") {
iStartX = vItemDisplay[i].iValue;
} else {
mvwprintz(w, line_num, iStartX, c_ltgreen, "%s", (vItemDisplay[i].sName).c_str());
wprintz(w, c_white, "%s", (vItemDisplay[i].sPre).c_str());
line_num++;
}
} else if (vItemDisplay[i].sType == "DESCRIPTION") {
std::string sText = vItemDisplay[i].sName;
std::replace(sText.begin(), sText.end(), '\n', ' ');
int iPos;
while (1) {
line_num++;
if (sText.size() > iWidth-4) {
int iPos = sText.find_last_of(' ', iWidth-4);
mvwprintz(w, line_num, 2, c_white, (sText.substr(0, iPos)).c_str());
sText = sText.substr(iPos+1, sText.size());
} else {
mvwprintz(w, line_num, 2, c_white, (sText).c_str());
break;
}
}
} else {
if (bStartNewLine) {
mvwprintz(w, line_num, 2, c_white, "%s", (vItemDisplay[i].sName).c_str());
bStartNewLine = false;
} else {
wprintz(w, c_white, "%s", (vItemDisplay[i].sName).c_str());
}
sPlus = "";
std::string sPre = vItemDisplay[i].sPre;
if (sPre.size() > 1 && sPre.substr(sPre.size()-1, 1) == "+") {
wprintz(w, c_white, "%s", (sPre.substr(0, sPre.size()-1)).c_str());
sPlus = "+";
} else if (sPre != "+")
wprintz(w, c_white, "%s", sPre.c_str());
else if (sPre == "+")
sPlus = "+";
if (vItemDisplay[i].iValue != -999) {
nc_color thisColor = c_white;
for (int k = 0; k < vItemCompare.size(); k++) {
if (vItemCompare[k].iValue != -999) {
if (vItemDisplay[i].sName == vItemCompare[k].sName) {
if (vItemDisplay[i].iValue == vItemCompare[k].iValue) {
thisColor = c_white;
} else if (vItemDisplay[i].iValue > vItemCompare[k].iValue) {
if (vItemDisplay[i].bLowerIsBetter) {
thisColor = c_ltred;
} else {
thisColor = c_ltgreen;
}
} else if (vItemDisplay[i].iValue < vItemCompare[k].iValue) {
if (vItemDisplay[i].bLowerIsBetter) {
thisColor = c_ltgreen;
} else {
thisColor = c_ltred;
}
}
break;
}
}
}
if (sPlus == "+" )
wprintz(w, thisColor, "%s", (sPlus).c_str());
wprintz(w, thisColor, "%d", vItemDisplay[i].iValue);
}
wprintz(w, c_white, (vItemDisplay[i].sPost).c_str());
if (vItemDisplay[i].bNewLine) {
line_num++;
bStartNewLine = true;
}
}
}
wborder(w, LINE_XOXO, LINE_XOXO, LINE_OXOX, LINE_OXOX,
LINE_OXXO, LINE_OOXX, LINE_XXOO, LINE_XOOX );
char ch = ' ';
wrefresh(w);
if (iLeft > 0) {
ch = getch();
werase(w);
wrefresh(w);
delwin(w);
refresh();
}
return ch;
}
void veh_interact::display_stats ()
{
bool conf = veh->valid_wheel_config();
mvwprintz(w_stats, 0, 1, c_ltgray, "Name: ");
mvwprintz(w_stats, 0, 7, c_ltgreen, veh->name.c_str());
if(OPTIONS[OPT_USE_METRIC_SYS]) {
mvwprintz(w_stats, 1, 1, c_ltgray, "Safe speed: Km/h");
mvwprintz(w_stats, 1, 14, c_ltgreen,"%3d", int(veh->safe_velocity(false) * 0.0161f));
mvwprintz(w_stats, 2, 1, c_ltgray, "Top speed: Km/h");
mvwprintz(w_stats, 2, 14, c_ltred, "%3d", int(veh->max_velocity(false) * 0.0161f));
mvwprintz(w_stats, 3, 1, c_ltgray, "Accel.: Kmh/t");
mvwprintz(w_stats, 3, 14, c_ltblue,"%3d", int(veh->acceleration(false) * 0.0161f));
}
else {
mvwprintz(w_stats, 1, 1, c_ltgray, "Safe speed: mph");
mvwprintz(w_stats, 1, 14, c_ltgreen,"%3d", veh->safe_velocity(false) / 100);
mvwprintz(w_stats, 2, 1, c_ltgray, "Top speed: mph");
mvwprintz(w_stats, 2, 14, c_ltred, "%3d", veh->max_velocity(false) / 100);
mvwprintz(w_stats, 3, 1, c_ltgray, "Accel.: mph/t");
mvwprintz(w_stats, 3, 14, c_ltblue,"%3d", veh->acceleration(false) / 100);
}
mvwprintz(w_stats, 4, 1, c_ltgray, "Mass: kg");
mvwprintz(w_stats, 4, 12, c_ltblue,"%5d", (int) (veh->total_mass() / 4 * 0.45));
mvwprintz(w_stats, 5, 26, c_ltgray, "K dynamics: ");
mvwprintz(w_stats, 5, 37, c_ltblue, "%3d", (int) (veh->k_dynamics() * 100));
mvwputch (w_stats, 5, 41, c_ltgray, '%');
mvwprintz(w_stats, 6, 26, c_ltgray, "K mass: ");
mvwprintz(w_stats, 6, 37, c_ltblue, "%3d", (int) (veh->k_mass() * 100));
mvwputch (w_stats, 6, 41, c_ltgray, '%');
mvwprintz(w_stats, 5, 1, c_ltgray, "Wheels: ");
mvwprintz(w_stats, 5, 11, conf? c_ltgreen : c_ltred, conf? "enough" : " lack");
mvwprintz(w_stats, 6, 1, c_ltgray, "Fuel usage (safe): ");
int xfu = 20;
int ftypes[3] = { AT_GAS, AT_BATT, AT_PLASMA };
nc_color fcs[3] = { c_ltred, c_yellow, c_ltblue };
bool first = true;
for (int i = 0; i < 3; i++)
{
int fu = veh->basic_consumption (ftypes[i]);
if (fu > 0)
{
fu = fu / 100;
if (fu < 1)
fu = 1;
if (!first)
mvwprintz(w_stats, 6, xfu++, c_ltgray, "/");
mvwprintz(w_stats, 6, xfu++, fcs[i], "%d", fu);
if (fu > 9) xfu++;
if (fu > 99) xfu++;
first = false;
}
}
veh->print_fuel_indicator (w_stats, 0, 26, true, true);
wrefresh (w_stats);
}
bool player::install_bionics(game *g, it_bionic* type)
{
if (type == NULL) {
debugmsg("Tried to install NULL bionic");
return false;
}
std::string bio_name = type->name.substr(5); // Strip off "CBM: "
WINDOW* w = newwin(25, 80, 0, 0);
int pl_skill = int_cur + sklevel[sk_electronics] * 4 +
sklevel[sk_firstaid] * 3 +
sklevel[sk_mechanics] * 2;
int skint = int(pl_skill / 4);
int skdec = int((pl_skill * 10) / 4) % 10;
// Header text
mvwprintz(w, 0, 0, c_white, "Installing bionics:");
mvwprintz(w, 0, 20, type->color, bio_name.c_str());
// Dividing bars
for (int i = 0; i < 80; i++) {
mvwputch(w, 1, i, c_ltgray, LINE_OXOX);
mvwputch(w, 21, i, c_ltgray, LINE_OXOX);
}
// Init the list of bionics
for (int i = 1; i < type->options.size(); i++) {
bionic_id id = type->options[i];
mvwprintz(w, i + 2, 0, (has_bionic(id) ? c_ltred : c_ltblue),
bionics[id].name.c_str());
}
// Helper text
mvwprintz(w, 2, 40, c_white, "Difficulty of this module: %d",
type->difficulty);
mvwprintz(w, 3, 40, c_white, "Your installation skill: %d.%d",
skint, skdec);
mvwprintz(w, 4, 40, c_white, "Installation requires high intelligence,");
mvwprintz(w, 5, 40, c_white, "and skill in electronics, first aid, and");
mvwprintz(w, 6, 40, c_white, "mechanics (in that order of importance).");
int chance_of_success = int((100 * pl_skill) /
(pl_skill + 4 * type->difficulty));
mvwprintz(w, 8, 40, c_white, "Chance of success:");
nc_color col_suc;
if (chance_of_success >= 95)
col_suc = c_green;
else if (chance_of_success >= 80)
col_suc = c_ltgreen;
else if (chance_of_success >= 60)
col_suc = c_yellow;
else if (chance_of_success >= 35)
col_suc = c_ltred;
else
col_suc = c_red;
mvwprintz(w, 8, 59, col_suc, "%d%%%%", chance_of_success);
mvwprintz(w, 10, 40, c_white, "Failure may result in crippling damage,");
mvwprintz(w, 11, 40, c_white, "loss of existing bionics, genetic damage");
mvwprintz(w, 12, 40, c_white, "or faulty installation.");
wrefresh(w);
if (type->id == itm_bionics_battery) { // No selection list; just confirm
mvwprintz(w, 2, 0, h_ltblue, "Battery Level +10");
mvwprintz(w, 22, 0, c_ltblue, "\
Installing this bionic will increase your total battery capacity by 10.\n\
Batteries are necessary for most bionics to function. They also require a\n\
charge mechanism, which must be installed from another CBM.");
char ch;
wrefresh(w);
do
ch = getch();
while (ch != 'q' && ch != '\n' && ch != KEY_ESCAPE);
if (ch == '\n') {
int success = chance_of_success - rng(1, 100);
if (success > 0) {
g->add_msg("Successfully installed batteries.");
max_power_level += 10;
} else
bionics_install_failure(g, this, success);
werase(w);
delwin(w);
g->refresh_all();
return true;
}
werase(w);
delwin(w);
g->refresh_all();
return false;
}
void input_context::display_help()
{
inp_mngr.set_timeout(-1);
// Shamelessly stolen from help.cpp
WINDOW *w_help = newwin(FULL_SCREEN_HEIGHT - 2, FULL_SCREEN_WIDTH - 2,
1 + (int)((TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0),
1 + (int)((TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0));
// has the user changed something?
bool changed = false;
// keybindings before the user changed anything.
input_manager::t_action_contexts old_action_contexts(inp_mngr.action_contexts);
// current status: adding/removing/showing keybindings
enum { s_remove, s_add, s_add_global, s_show } status = s_show;
// copy of registered_actions, but without the ANY_INPUT and COORDINATE, which should not be shown
std::vector<std::string> org_registered_actions(registered_actions);
std::vector<std::string>::iterator any_input = std::find(org_registered_actions.begin(), org_registered_actions.end(), ANY_INPUT);
if (any_input != org_registered_actions.end()) {
org_registered_actions.erase(any_input);
}
std::vector<std::string>::iterator coordinate = std::find(org_registered_actions.begin(), org_registered_actions.end(), COORDINATE);
if (coordinate != org_registered_actions.end()) {
org_registered_actions.erase(coordinate);
}
// colors of the keybindings
static const nc_color global_key = c_ltgray;
static const nc_color local_key = c_ltgreen;
static const nc_color unbound_key = c_ltred;
// (vertical) scroll offset
size_t scroll_offset = 0;
// height of the area usable for display of keybindings, excludes headers & borders
const size_t display_height = FULL_SCREEN_HEIGHT - 2 - 2; // -2 for the border
// width of the legend
const size_t legwidth = FULL_SCREEN_WIDTH - 51 - 2;
// keybindings help
std::ostringstream legend;
legend << "<color_" << string_from_color(unbound_key) << ">" << _("Unbound keys") << "</color>\n";
legend << "<color_" << string_from_color(local_key) << ">" << _("Keybinding active only on this screen") << "</color>\n";
legend << "<color_" << string_from_color(global_key) << ">" << _("Keybinding active globally") << "</color>\n";
legend << _("Press - to remove keybinding\nPress + to add local keybinding\nPress = to add global keybinding\n");
input_context ctxt("HELP_KEYBINDINGS");
ctxt.register_action("UP", _("Scroll up"));
ctxt.register_action("DOWN", _("Scroll down"));
ctxt.register_action("REMOVE");
ctxt.register_action("ADD_LOCAL");
ctxt.register_action("ADD_GLOBAL");
ctxt.register_action("QUIT");
ctxt.register_action("ANY_INPUT");
if (category != "HELP_KEYBINDINGS") {
// avoiding inception!
ctxt.register_action("HELP_KEYBINDINGS");
}
std::string hotkeys = ctxt.get_available_single_char_hotkeys(display_help_hotkeys);
while(true) {
werase(w_help);
draw_border(w_help);
draw_scrollbar(w_help, scroll_offset, display_height, org_registered_actions.size(), 1);
mvwprintz(w_help, 0, (FULL_SCREEN_WIDTH - utf8_width(_("Keybindings"))) / 2 - 1,
c_ltred, " %s ", _("Keybindings"));
fold_and_print(w_help, 1, 51, legwidth, c_white, legend.str());
for (size_t i = 0; i + scroll_offset < org_registered_actions.size() && i < display_height; i++) {
const std::string &action_id = org_registered_actions[i + scroll_offset];
bool overwrite_default;
const action_attributes &attributes = inp_mngr.get_action_attributes(action_id, category, &overwrite_default);
char invlet;
if (i < hotkeys.size()) {
invlet = hotkeys[i];
} else {
invlet = ' ';
}
if (status == s_add_global && overwrite_default) {
// We're trying to add a global, but this action has a local
// defined, so gray out the invlet.
mvwprintz(w_help, i + 1, 2, c_dkgray, "%c ", invlet);
} else if (status == s_add || status == s_add_global) {
mvwprintz(w_help, i + 1, 2, c_blue, "%c ", invlet);
} else if (status == s_remove) {
mvwprintz(w_help, i + 1, 2, c_blue, "%c ", invlet);
} else {
mvwprintz(w_help, i + 1, 2, c_blue, " ");
}
nc_color col;
if (attributes.input_events.empty()) {
col = unbound_key;
} else if (overwrite_default) {
col = local_key;
} else {
col = global_key;
}
mvwprintz(w_help, i + 1, 4, col, "%s: ", get_action_name(action_id).c_str());
mvwprintz(w_help, i + 1, 30, col, "%s", get_desc(action_id).c_str());
}
wrefresh(w_help);
refresh();
// In addition to the modifiable hotkeys, we also check for hardcoded
// keys, e.g. '+', '-', '=', in order to prevent the user from
// entering an unrecoverable state.
const std::string action = ctxt.handle_input();
const long raw_input_char = ctxt.get_raw_input().get_first_input();
if (action == "ADD_LOCAL" || raw_input_char == '+') {
status = s_add;
} else if (action == "ADD_GLOBAL" || raw_input_char == '=') {
status = s_add_global;
} else if (action == "REMOVE" || raw_input_char == '-') {
status = s_remove;
} else if (action == "ANY_INPUT") {
const size_t hotkey_index = hotkeys.find_first_of(raw_input_char);
if (status == s_show || hotkey_index == std::string::npos || hotkey_index >= org_registered_actions.size()) {
continue;
}
const int action_index = hotkey_index + scroll_offset;
const std::string &action_id = org_registered_actions[action_index];
// Check if this entry is local or global.
bool is_local = false;
inp_mngr.get_action_attributes(action_id, category, &is_local);
const std::string name = get_action_name(action_id);
if (status == s_remove && (!OPTIONS["QUERY_KEYBIND_REMOVAL"] || query_yn(_("Clear keys for %s?"), name.c_str()))) {
// If it's global, reset the global actions.
std::string category_to_access = category;
if (!is_local) {
category_to_access = default_context_id;
}
inp_mngr.remove_input_for_action(action_id, category_to_access);
changed = true;
} else if (status == s_add_global && is_local) {
// Disallow adding global actions to an action that already has a local defined.
popup(_("There are already local keybindings defined for this action, please remove them first."));
} else if (status == s_add || status == s_add_global) {
const long newbind = popup_getkey(_("New key for %s:"), name.c_str());
const input_event new_event(newbind, CATA_INPUT_KEYBOARD);
const std::string conflicts = get_conflicts(new_event);
const bool has_conflicts = !conflicts.empty();
bool resolve_conflicts = false;
if (has_conflicts) {
resolve_conflicts = query_yn(_("This key conflicts with %s. Remove this key from the conflicting command(s), and continue?"), conflicts.c_str());
}
if (!has_conflicts || resolve_conflicts) {
if (resolve_conflicts) {
clear_conflicting_keybindings(new_event);
}
// We might be adding a local or global action.
std::string category_to_access = category;
if (status == s_add_global) {
category_to_access = default_context_id;
}
inp_mngr.add_input_for_action(action_id, category_to_access, new_event);
changed = true;
}
}
status = s_show;
} else if (action == "DOWN") {
if (scroll_offset + 1 < org_registered_actions.size()) {
scroll_offset++;
}
} else if (action == "UP") {
if (scroll_offset > 0) {
scroll_offset--;
}
} else if (action == "QUIT") {
if (status != s_show) {
status = s_show;
} else {
break;
}
} else if (action == "HELP_KEYBINDINGS") {
// update available hotkeys in case they've changed
hotkeys = ctxt.get_available_single_char_hotkeys(display_help_hotkeys);
}
}
if (changed && query_yn(_("Save changes?"))) {
try {
inp_mngr.save();
} catch(std::exception &err) {
popup(_("saving keybindings failed: %s"), err.what());
} catch(std::string &err) {
popup(_("saving keybindings failed: %s"), err.c_str());
}
} else if(changed) {
inp_mngr.action_contexts.swap(old_action_contexts);
}
werase(w_help);
wrefresh(w_help);
delwin(w_help);
}
void show_auto_pickup()
{
save_reset_changes(false);
const int iHeaderHeight = 4;
const int iContentHeight = FULL_SCREEN_HEIGHT - 2 - iHeaderHeight;
const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0;
const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0;
std::map<int, bool> mapLines;
mapLines[4] = true;
mapLines[50] = true;
mapLines[54] = true;
const int iTotalCols = mapLines.size() - 1;
WINDOW *w_auto_pickup_help = newwin((FULL_SCREEN_HEIGHT / 2) - 2, FULL_SCREEN_WIDTH * 3 / 4,
7 + iOffsetY + (FULL_SCREEN_HEIGHT / 2) / 2, iOffsetX + 19 / 2);
WINDOW_PTR w_auto_pickup_helpptr( w_auto_pickup_help );
WINDOW *w_auto_pickup_border = newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, iOffsetY, iOffsetX);
WINDOW_PTR w_auto_pickup_borderptr( w_auto_pickup_border );
WINDOW *w_auto_pickup_header = newwin(iHeaderHeight, FULL_SCREEN_WIDTH - 2, 1 + iOffsetY,
1 + iOffsetX);
WINDOW_PTR w_auto_pickup_headerptr( w_auto_pickup_header );
WINDOW *w_auto_pickup = newwin(iContentHeight, FULL_SCREEN_WIDTH - 2, iHeaderHeight + 1 + iOffsetY,
1 + iOffsetX);
WINDOW_PTR w_auto_pickupptr( w_auto_pickup );
draw_border(w_auto_pickup_border);
mvwputch(w_auto_pickup_border, 3, 0, c_ltgray, LINE_XXXO); // |-
mvwputch(w_auto_pickup_border, 3, 79, c_ltgray, LINE_XOXX); // -|
for( auto &mapLine : mapLines ) {
mvwputch( w_auto_pickup_border, FULL_SCREEN_HEIGHT - 1, mapLine.first + 1, c_ltgray,
LINE_XXOX ); // _|_
}
mvwprintz(w_auto_pickup_border, 0, 29, c_ltred, _(" AUTO PICKUP MANAGER "));
wrefresh(w_auto_pickup_border);
int tmpx = 0;
tmpx += shortcut_print(w_auto_pickup_header, 0, tmpx, c_white, c_ltgreen, _("<A>dd")) + 2;
tmpx += shortcut_print(w_auto_pickup_header, 0, tmpx, c_white, c_ltgreen, _("<R>emove")) + 2;
tmpx += shortcut_print(w_auto_pickup_header, 0, tmpx, c_white, c_ltgreen, _("<C>opy")) + 2;
tmpx += shortcut_print(w_auto_pickup_header, 0, tmpx, c_white, c_ltgreen, _("<M>ove")) + 2;
tmpx += shortcut_print(w_auto_pickup_header, 0, tmpx, c_white, c_ltgreen, _("<E>nable")) + 2;
tmpx += shortcut_print(w_auto_pickup_header, 0, tmpx, c_white, c_ltgreen, _("<D>isable")) + 2;
shortcut_print(w_auto_pickup_header, 0, tmpx, c_white, c_ltgreen, _("<T>est"));
tmpx = 0;
tmpx += shortcut_print(w_auto_pickup_header, 1, tmpx, c_white, c_ltgreen,
_("<+-> Move up/down")) + 2;
tmpx += shortcut_print(w_auto_pickup_header, 1, tmpx, c_white, c_ltgreen, _("<Enter>-Edit")) + 2;
shortcut_print(w_auto_pickup_header, 1, tmpx, c_white, c_ltgreen, _("<Tab>-Switch Page"));
for (int i = 0; i < 78; i++) {
if (mapLines[i]) {
mvwputch(w_auto_pickup_header, 2, i, c_ltgray, LINE_OXXX);
mvwputch(w_auto_pickup_header, 3, i, c_ltgray, LINE_XOXO);
} else {
mvwputch(w_auto_pickup_header, 2, i, c_ltgray, LINE_OXOX); // Draw line under header
}
}
mvwprintz(w_auto_pickup_header, 3, 1, c_white, "#");
mvwprintz(w_auto_pickup_header, 3, 8, c_white, _("Rules"));
mvwprintz(w_auto_pickup_header, 3, 51, c_white, _("I/E"));
wrefresh(w_auto_pickup_header);
int iCurrentPage = 1;
int iCurrentLine = 0;
int iCurrentCol = 1;
int iStartPos = 0;
bool bStuffChanged = false;
input_context ctxt("AUTO_PICKUP");
ctxt.register_cardinal();
ctxt.register_action("CONFIRM");
ctxt.register_action("QUIT");
ctxt.register_action("NEXT_TAB");
ctxt.register_action("PREV_TAB");
ctxt.register_action("ADD_RULE");
ctxt.register_action("REMOVE_RULE");
ctxt.register_action("COPY_RULE");
ctxt.register_action("SWAP_RULE_GLOBAL_CHAR");
ctxt.register_action("ENABLE_RULE");
ctxt.register_action("DISABLE_RULE");
ctxt.register_action("MOVE_RULE_UP");
ctxt.register_action("MOVE_RULE_DOWN");
ctxt.register_action("TEST_RULE");
ctxt.register_action("SWITCH_AUTO_PICKUP_OPTION");
ctxt.register_action("HELP_KEYBINDINGS");
std::stringstream sTemp;
while(true) {
int locx = 17;
locx += shortcut_print(w_auto_pickup_header, 2, locx, c_white,
(iCurrentPage == 1) ? hilite(c_white) : c_white, _("[<Global>]")) + 1;
shortcut_print(w_auto_pickup_header, 2, locx, c_white,
(iCurrentPage == 2) ? hilite(c_white) : c_white, _("[<Character>]"));
locx = 55;
mvwprintz(w_auto_pickup_header, 0, locx, c_white, _("Auto pickup enabled:"));
locx += shortcut_print(w_auto_pickup_header, 1, locx,
((OPTIONS["AUTO_PICKUP"]) ? c_ltgreen : c_ltred), c_white,
((OPTIONS["AUTO_PICKUP"]) ? _("True") : _("False")));
locx += shortcut_print(w_auto_pickup_header, 1, locx, c_white, c_ltgreen, " ");
locx += shortcut_print(w_auto_pickup_header, 1, locx, c_white, c_ltgreen, _("<S>witch"));
shortcut_print(w_auto_pickup_header, 1, locx, c_white, c_ltgreen, " ");
wrefresh(w_auto_pickup_header);
// Clear the lines
for (int i = 0; i < iContentHeight; i++) {
for (int j = 0; j < 79; j++) {
if (mapLines[j]) {
mvwputch(w_auto_pickup, i, j, c_ltgray, LINE_XOXO);
} else {
mvwputch(w_auto_pickup, i, j, c_black, ' ');
}
}
}
const bool currentPageNonEmpty = !vAutoPickupRules[iCurrentPage].empty();
if (iCurrentPage == 2 && g->u.name == "") {
vAutoPickupRules[2].clear();
mvwprintz(w_auto_pickup, 8, 15, c_white,
_("Please load a character first to use this page!"));
}
//Draw Scrollbar
draw_scrollbar(w_auto_pickup_border, iCurrentLine, iContentHeight,
vAutoPickupRules[iCurrentPage].size(), 5);
calcStartPos(iStartPos, iCurrentLine, iContentHeight,
vAutoPickupRules[iCurrentPage].size());
// display auto pickup
for (int i = iStartPos; i < (int)vAutoPickupRules[iCurrentPage].size(); i++) {
if (i >= iStartPos &&
i < iStartPos + ((iContentHeight > (int)vAutoPickupRules[iCurrentPage].size()) ?
(int)vAutoPickupRules[iCurrentPage].size() : iContentHeight)) {
nc_color cLineColor = (vAutoPickupRules[iCurrentPage][i].bActive) ?
c_white : c_ltgray;
sTemp.str("");
sTemp << i + 1;
mvwprintz(w_auto_pickup, i - iStartPos, 1, cLineColor, "%s", sTemp.str().c_str());
mvwprintz(w_auto_pickup, i - iStartPos, 5, cLineColor, "");
if (iCurrentLine == i) {
wprintz(w_auto_pickup, c_yellow, ">> ");
} else {
wprintz(w_auto_pickup, c_yellow, " ");
}
wprintz(w_auto_pickup, (iCurrentLine == i &&
iCurrentCol == 1) ? hilite(cLineColor) : cLineColor, "%s",
((vAutoPickupRules[iCurrentPage][i].sRule == "") ? _("<empty rule>") :
vAutoPickupRules[iCurrentPage][i].sRule).c_str());
mvwprintz(w_auto_pickup, i - iStartPos, 52, (iCurrentLine == i &&
iCurrentCol == 2) ? hilite(cLineColor) : cLineColor, "%s",
((vAutoPickupRules[iCurrentPage][i].bExclude) ? rm_prefix(_("<Exclude>E")).c_str() : rm_prefix(
_("<Include>I")).c_str()));
}
}
wrefresh(w_auto_pickup);
const std::string action = ctxt.handle_input();
if (action == "NEXT_TAB") {
iCurrentPage++;
if (iCurrentPage > 2) {
iCurrentPage = 1;
iCurrentLine = 0;
}
} else if (action == "PREV_TAB") {
iCurrentPage--;
if (iCurrentPage < 1) {
iCurrentPage = 2;
iCurrentLine = 0;
}
} else if (action == "QUIT") {
break;
} else if (iCurrentPage == 2 && g->u.name.empty()) {
//Only allow loaded games to use the char sheet
} else if (action == "DOWN") {
iCurrentLine++;
iCurrentCol = 1;
if (iCurrentLine >= (int)vAutoPickupRules[iCurrentPage].size()) {
iCurrentLine = 0;
}
} else if (action == "UP") {
iCurrentLine--;
iCurrentCol = 1;
if (iCurrentLine < 0) {
iCurrentLine = vAutoPickupRules[iCurrentPage].size() - 1;
}
} else if (action == "ADD_RULE") {
bStuffChanged = true;
vAutoPickupRules[iCurrentPage].push_back(cPickupRules("", true, false));
iCurrentLine = vAutoPickupRules[iCurrentPage].size() - 1;
} else if (action == "REMOVE_RULE" && currentPageNonEmpty) {
bStuffChanged = true;
vAutoPickupRules[iCurrentPage].erase(vAutoPickupRules[iCurrentPage].begin() + iCurrentLine);
if (iCurrentLine > (int)vAutoPickupRules[iCurrentPage].size() - 1) {
iCurrentLine--;
}
if(iCurrentLine < 0){
iCurrentLine = 0;
}
} else if (action == "COPY_RULE" && currentPageNonEmpty) {
bStuffChanged = true;
vAutoPickupRules[iCurrentPage].push_back(cPickupRules(
vAutoPickupRules[iCurrentPage][iCurrentLine].sRule,
vAutoPickupRules[iCurrentPage][iCurrentLine].bActive,
vAutoPickupRules[iCurrentPage][iCurrentLine].bExclude));
iCurrentLine = vAutoPickupRules[iCurrentPage].size() - 1;
} else if (action == "SWAP_RULE_GLOBAL_CHAR" && currentPageNonEmpty) {
if ((iCurrentPage == 1 && g->u.name != "") || iCurrentPage == 2) {
bStuffChanged = true;
//copy over
vAutoPickupRules[(iCurrentPage == 1) ? 2 : 1].push_back(cPickupRules(
vAutoPickupRules[iCurrentPage][iCurrentLine].sRule,
vAutoPickupRules[iCurrentPage][iCurrentLine].bActive,
vAutoPickupRules[iCurrentPage][iCurrentLine].bExclude));
//remove old
vAutoPickupRules[iCurrentPage].erase(vAutoPickupRules[iCurrentPage].begin() + iCurrentLine);
iCurrentLine = vAutoPickupRules[(iCurrentPage == 1) ? 2 : 1].size() - 1;
iCurrentPage = (iCurrentPage == 1) ? 2 : 1;
}
} else if (action == "CONFIRM" && currentPageNonEmpty) {
bStuffChanged = true;
if (iCurrentCol == 1) {
fold_and_print(w_auto_pickup_help, 1, 1, 999, c_white,
_(
"* is used as a Wildcard. A few Examples:\n"
"\n"
"wooden arrow matches the itemname exactly\n"
"wooden ar* matches items beginning with wood ar\n"
"*rrow matches items ending with rrow\n"
"*avy fle*fi*arrow multiple * are allowed\n"
"heAVY*woOD*arrOW case insensitive search\n"
"")
);
draw_border(w_auto_pickup_help);
wrefresh(w_auto_pickup_help);
vAutoPickupRules[iCurrentPage][iCurrentLine].sRule = trim_rule(string_input_popup(_("Pickup Rule:"),
30, vAutoPickupRules[iCurrentPage][iCurrentLine].sRule));
} else if (iCurrentCol == 2) {
vAutoPickupRules[iCurrentPage][iCurrentLine].bExclude =
!vAutoPickupRules[iCurrentPage][iCurrentLine].bExclude;
}
} else if (action == "ENABLE_RULE" && currentPageNonEmpty) {
bStuffChanged = true;
vAutoPickupRules[iCurrentPage][iCurrentLine].bActive = true;
} else if (action == "DISABLE_RULE" && currentPageNonEmpty) {
bStuffChanged = true;
vAutoPickupRules[iCurrentPage][iCurrentLine].bActive = false;
} else if (action == "LEFT") {
iCurrentCol--;
if (iCurrentCol < 1) {
iCurrentCol = iTotalCols;
}
} else if (action == "RIGHT") {
iCurrentCol++;
if (iCurrentCol > iTotalCols) {
iCurrentCol = 1;
}
} else if (action == "MOVE_RULE_UP" && currentPageNonEmpty) {
bStuffChanged = true;
if (iCurrentLine < (int)vAutoPickupRules[iCurrentPage].size() - 1) {
std::swap(vAutoPickupRules[iCurrentPage][iCurrentLine],
vAutoPickupRules[iCurrentPage][iCurrentLine + 1]);
iCurrentLine++;
iCurrentCol = 1;
}
} else if (action == "MOVE_RULE_DOWN" && currentPageNonEmpty) {
bStuffChanged = true;
if (iCurrentLine > 0) {
std::swap(vAutoPickupRules[iCurrentPage][iCurrentLine],
vAutoPickupRules[iCurrentPage][iCurrentLine - 1]);
iCurrentLine--;
iCurrentCol = 1;
}
} else if (action == "TEST_RULE" && currentPageNonEmpty) {
test_pattern(iCurrentPage, iCurrentLine);
} else if (action == "SWITCH_AUTO_PICKUP_OPTION") {
OPTIONS["AUTO_PICKUP"].setNext();
save_options((g->u.name != ""));
}
}
if (bStuffChanged) {
if(query_yn(_("Save changes?"))) {
save_auto_pickup(false);
if (g->u.name != "") {
save_auto_pickup(true);
}
} else {
save_reset_changes(true);
}
}
}
void game::monster_wish()
{
WINDOW* w_list = newwin(25, 30, 0, 0);
WINDOW* w_info = newwin(25, 50, 0, 30);
int a = 0, shift = 1, result_selected = 0;
int ch = '.';
bool search = false, found = false, friendly = false;
std::string pattern;
std::string info;
std::vector<int> search_results;
monster tmp;
do {
werase(w_info);
werase(w_list);
mvwprintw(w_list, 0, 0, "Spawn a: ");
if (search) {
found = false;
if (ch == '\n') {
search = false;
found = true;
ch = '.';
} else if (ch == KEY_BACKSPACE || ch == 127) {
if (pattern.length() > 0)
pattern.erase(pattern.end() - 1);
} else if (ch == '>') {
search = false;
if (!search_results.empty()) {
result_selected++;
if (result_selected > search_results.size())
result_selected = 0;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > mtypes.size()) {
a = shift + 23 - mtypes.size();
shift = mtypes.size() - 23;
}
}
} else if (ch == '<') {
search = false;
if (!search_results.empty()) {
result_selected--;
if (result_selected < 0)
result_selected = search_results.size() - 1;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > mtypes.size()) {
a = shift + 23 - mtypes.size();
shift = mtypes.size() - 23;
}
}
} else {
pattern += ch;
search_results.clear();
}
if (search) {
for (int i = 1; i < mtypes.size(); i++) {
if (mtypes[i]->name.find(pattern) != std::string::npos) {
shift = i;
a = 0;
result_selected = 0;
if (shift + 23 > mtypes.size()) {
a = shift + 23 - mtypes.size();
shift = mtypes.size() - 23;
}
found = true;
search_results.push_back(i);
}
}
}
} else { // Not searching; scroll by keys
if (ch == 'j') a++;
if (ch == 'k') a--;
if (ch == 'f') friendly = !friendly;
if (ch == '/') {
search = true;
pattern = "";
found = false;
search_results.clear();
}
if (ch == '>' && !search_results.empty()) {
result_selected++;
if (result_selected > search_results.size())
result_selected = 0;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > mtypes.size()) {
a = shift + 23 - mtypes.size();
shift = mtypes.size() - 23;
}
} else if (ch == '<' && !search_results.empty()) {
result_selected--;
if (result_selected < 0)
result_selected = search_results.size() - 1;
shift = search_results[result_selected];
a = 0;
if (shift + 23 > mtypes.size()) {
a = shift + 23 - mtypes.size();
shift = mtypes.size() - 23;
}
}
}
if (!search_results.empty())
mvwprintz(w_list, 0, 11, c_green, "%s ", pattern.c_str());
else if (pattern.length() > 0)
mvwprintz(w_list, 0, 11, c_red, "%s not found! ",pattern.c_str());
if (a < 0) {
a = 0;
shift--;
if (shift < 1) shift = 1;
}
if (a > 22) {
a = 22;
shift++;
if (shift + 23 > mtypes.size()) shift = mtypes.size() - 23;
}
for (int i = 1; i < 24; i++) {
nc_color col = c_white;
if (i == a + 1)
col = h_white;
mvwprintz(w_list, i, 0, col, mtypes[i-1+shift]->name.c_str());
wprintz(w_list, mtypes[i-1+shift]->color, " %c%", mtypes[i-1+shift]->sym);
}
tmp = monster(mtypes[a + shift]);
if (friendly)
tmp.friendly = -1;
tmp.print_info(this, w_info);
wrefresh(w_info);
wrefresh(w_list);
if (search)
ch = getch();
else
ch = input();
} while (ch != '\n');
clear();
delwin(w_info);
delwin(w_list);
refresh_all();
wrefresh(w_terrain);
point spawn = look_around();
if (spawn.x == -1)
return;
tmp.spawn(spawn.x, spawn.y);
z.push_back(tmp);
}
robot_finds_kitten::robot_finds_kitten(WINDOW *w)
{
ret = false;
char ktile[83] =
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#&()*+./:;=?![]{|}y";
int used_messages[MAXMESSAGES];
rfkLINES = 20;
rfkCOLS = 60;
const int numbogus = 20;
nummessages = 201;
empty.x = -1;
empty.y = -1;
empty.color = (nc_color)0;
empty.character = ' ';
for (int c = 0; c < rfkCOLS; c++) {
for (int c2 = 0; c2 < rfkLINES; c2++) {
rfkscreen[c][c2] = EMPTY;
}
}
/* Create an array to ensure we don't get duplicate messages. */
for (int c = 0; c < nummessages; c++) {
used_messages[c] = 0;
bogus_messages[c] = 0;
bogus[c] = empty;
}
/* Now we initialize the various game OBJECTs.
* Assign a position to the player. */
robot.x = rand() % rfkCOLS;
robot.y = rand() % (rfkLINES - 3) + 3;
robot.character = '#';
robot.color = c_white;
rfkscreen[robot.x][robot.y] = ROBOT;
/* Assign the kitten a unique position. */
do {
kitten.x = rand() % rfkCOLS;
kitten.y = rand() % (rfkLINES - 3) + 3;
} while (rfkscreen[kitten.x][kitten.y] != EMPTY);
/* Assign the kitten a character and a color. */
do {
kitten.character = ktile[rand() % 82];
} while (kitten.character == '#' || kitten.character == ' ');
do {
kitten.color = all_colors.get_random();
} while ( kitten.color == c_black );
rfkscreen[kitten.x][kitten.y] = KITTEN;
/* Now, initialize non-kitten OBJECTs. */
for (int c = 0; c < numbogus; c++) {
/* Assign a unique position. */
do {
bogus[c].x = rand() % rfkCOLS;
bogus[c].y = (rand() % (rfkLINES - 3)) + 3;
} while (rfkscreen[bogus[c].x][bogus[c].y] != EMPTY);
rfkscreen[bogus[c].x][bogus[c].y] = c + 2;
/* Assign a character. */
do {
bogus[c].character = ktile[rand() % 82];
} while (bogus[c].character == '#' || bogus[c].character == ' ');
do {
bogus[c].color = all_colors.get_random();
} while ( bogus[c].color == c_black );
/* Assign a unique message. */
int index = 0;
do {
index = rand() % nummessages;
} while (used_messages[index] != 0);
bogus_messages[c] = index;
used_messages[index] = 1;
}
instructions(w);
werase(w);
mvwprintz (w, 0, 0, c_white, _("robotfindskitten v22July2008 - press q to quit."));
for (int c = 0; c < rfkCOLS; c++) {
mvwputch (w, 2, c, BORDER_COLOR, '_');
}
wmove(w, kitten.y, kitten.x);
draw_kitten(w);
for (int c = 0; c < numbogus; c++) {
mvwputch(w, bogus[c].y, bogus[c].x, bogus[c].color, bogus[c].character);
}
wmove(w, robot.y, robot.x);
draw_robot(w);
int old_x = robot.x;
int old_y = robot.y;
wrefresh(w);
/* Now the fun begins. */
int input = '.';
input = getch();
while (input != 'q' && input != 'Q' && input != 27 /*escape*/) {
process_input(input, w);
if(ret == true) {
break;
}
/* Redraw robot, where avaliable */
if (!(old_x == robot.x && old_y == robot.y)) {
wmove(w, old_y, old_x);
wputch(w, c_white, ' ');
wmove(w, robot.y, robot.x);
draw_robot(w);
rfkscreen[old_x][old_y] = EMPTY;
rfkscreen[robot.x][robot.y] = ROBOT;
old_x = robot.x;
old_y = robot.y;
}
wrefresh(w);
input = getch();
}
}
int worldfactory::show_worldgen_tab_confirm(WINDOW *win, WORLDPTR world)
{
const int iTooltipHeight = 1;
const int iContentHeight = FULL_SCREEN_HEIGHT - 3 - iTooltipHeight;
const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0;
const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0;
WINDOW *w_confirmation = newwin(iContentHeight, FULL_SCREEN_WIDTH - 2,
iTooltipHeight + 2 + iOffsetY, 1 + iOffsetX);
unsigned namebar_y = 1;
unsigned namebar_x = 3 + utf8_width(_("World Name:"));
int line = 1;
bool noname = false;
input_context ctxt("WORLDGEN_CONFIRM_DIALOG");
// Disabled because it conflicts with the "pick random world name" option,
// feel free to enable it and change its keybinding in keybindings.json
// ctxt.register_action("HELP_KEYBINDINGS");
ctxt.register_action("QUIT");
ctxt.register_action("ANY_INPUT");
ctxt.register_action("NEXT_TAB");
ctxt.register_action("PREV_TAB");
ctxt.register_action("PICK_RANDOM_WORLDNAME");
std::string worldname = world->world_name;
do {
mvwprintz(w_confirmation, namebar_y, 2, c_white, _("World Name:"));
mvwprintz(w_confirmation, namebar_y, namebar_x, c_ltgray, "______________________________");
fold_and_print(w_confirmation, 3, 2, 76, c_ltgray,
_("Press <color_yellow>?</color> to pick a random name for your world."));
fold_and_print(w_confirmation, FULL_SCREEN_HEIGHT / 2 - 2, 2, 76, c_ltgray, _("\
Press <color_yellow>></color> when you are satisfied with the world as it is and are ready \
to continue, or <color_yellow><</color> to go back and review your world."));
if (!noname) {
mvwprintz(w_confirmation, namebar_y, namebar_x, c_ltgray, "%s", worldname.c_str());
if (line == 1) {
wprintz(w_confirmation, h_ltgray, "_");
}
}
if (noname) {
mvwprintz(w_confirmation, namebar_y, namebar_x, c_ltgray, "______________________________");
noname = false;
}
wrefresh(win);
wrefresh(w_confirmation);
refresh();
const std::string action = ctxt.handle_input();
if (action == "NEXT_TAB") {
if (worldname.empty()) {
mvwprintz(w_confirmation, namebar_y, namebar_x, h_ltgray, _("______NO NAME ENTERED!!!!_____"));
noname = true;
wrefresh(w_confirmation);
if (!query_yn(_("Are you SURE you're finished? World name will be randomly generated."))) {
continue;
} else {
world->world_name = pick_random_name();
if (!valid_worldname(world->world_name)) {
continue;
}
return 1;
}
} else if (query_yn(_("Are you SURE you're finished?")) && valid_worldname(worldname)) {
world->world_name = worldname;
werase(w_confirmation);
delwin(w_confirmation);
return 1;
} else {
continue;
}
} else if (action == "PREV_TAB") {
world->world_name = worldname;
werase(w_confirmation);
delwin(w_confirmation);
return -1;
} else if (action == "PICK_RANDOM_WORLDNAME") {
mvwprintz(w_confirmation, namebar_y, namebar_x, c_ltgray, "______________________________");
world->world_name = worldname = pick_random_name();
} else if (action == "QUIT") {
world->world_name =
worldname; // cache the current worldname just in case they say No to the exit query
return -999;
} else if (action == "ANY_INPUT") {
const input_event ev = ctxt.get_raw_input();
const long ch = ev.get_first_input();
switch (line) {
case 1: {
utf8_wrapper wrap(worldname);
utf8_wrapper newtext( ev.text );
if( ch == KEY_BACKSPACE ) {
if (!wrap.empty()) {
wrap.erase(wrap.length() - 1, 1);
worldname = wrap.str();
}
} else if(ch == KEY_F(2)) {
std::string tmp = get_input_string_from_file();
int tmplen = utf8_width(tmp.c_str());
if(tmplen > 0 && tmplen + utf8_width(worldname.c_str()) < 30) {
worldname.append(tmp);
}
} else if( !newtext.empty() && is_char_allowed( newtext.at( 0 ) ) ) {
// no emty string, no slash, no backslash, no control sequence
wrap.append( newtext );
worldname = wrap.str();
}
mvwprintz(w_confirmation, namebar_y, namebar_x, c_ltgray,
"______________________________ ");
mvwprintz(w_confirmation, namebar_y, namebar_x, c_ltgray,
"%s", worldname.c_str());
wprintz(w_confirmation, h_ltgray, "_");
}
break;
}
}
} while (true);
return 0;
}