std::vector<std::string> command_executor::get_menu_images(display& disp, const std::vector<std::string>& items) {
std::vector<std::string> result;
bool has_image = false;
for (size_t i = 0; i < items.size(); ++i) {
std::string const& item = items[i];
const hotkey::HOTKEY_COMMAND hk = hotkey::get_id(item);
std::stringstream str;
//see if this menu item has an associated image
std::string img(get_menu_image(disp, item, i));
if (img.empty() == false) {
has_image = true;
str << IMAGE_PREFIX << img << COLUMN_SEPARATOR;
}
if (hk == hotkey::HOTKEY_NULL) {
const theme::menu* menu = disp.get_theme().get_menu_item(item);
if (menu)
str << menu->title();
else
str << item.substr(0, item.find_last_not_of(' ') + 1) << COLUMN_SEPARATOR;
} else {
std::string desc = hotkey::get_description(item);
if (hk == HOTKEY_ENDTURN) {
const theme::action *b = disp.get_theme().get_action_item("button-endturn");
if (b) {
desc = b->title();
}
}
str << desc << COLUMN_SEPARATOR << hotkey::get_names(item);
}
result.push_back(str.str());
}
//If any of the menu items have an image, create an image column
if (has_image) {
for (std::vector<std::string>::iterator i = result.begin(); i != result.end(); ++i) {
if (*(i->begin()) != IMAGE_PREFIX) {
i->insert(i->begin(), COLUMN_SEPARATOR);
}
}
}
return result;
}
inline bool context::init(config cfg /* = config{} */)
{
cfg_ = cfg;
if (!outp_.init(cfg_))
return false;
if (!disp_.init(cfg_))
return false;
return true;
}
bool show_theme_dialog(display& disp)
{
int action = 0;
std::vector<std::string> options = disp.get_theme().get_known_themes();
if(!options.empty()){
std::string current_theme=_("Saved Theme Preference: ")+preferences::theme();
action = gui::show_dialog(disp,NULL,"",current_theme,gui::OK_CANCEL,&options);
if(action >= 0){
preferences::set_theme(options[action]);
//it would be preferable for the new theme to take effect
//immediately, however, this will have to do for now.
gui2::show_transient_message(disp.video(),"",_("New theme will take effect on next new or loaded game."));
return(1);
}
}else{
gui2::show_transient_message(disp.video(),"",_("No known themes. Try changing from within an existing game."));
}
return(0);
}
void positional_source::update_positions(unsigned int time, const display &disp)
{
int distance_volume = DISTANCE_SILENT;
for(std::vector<map_location>::iterator i = locations_.begin(); i != locations_.end(); ++i) {
if(disp.shrouded(*i) || (check_fogged_ && disp.fogged(*i)))
continue;
int v = calculate_volume(*i, disp);
if(v < distance_volume) {
distance_volume = v;
}
}
if(sound::is_sound_playing(id_)) {
sound::reposition_sound(id_, distance_volume);
} else {
update(time, disp);
}
}
display::scoped_state::scoped_state(display & parent, const gsgl::flags_t & flags)
: parent(parent)
{
parent.bind();
glPushAttrib(GL_ALL_ATTRIB_BITS); CHECK_GL_ERRORS();
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS); CHECK_GL_ERRORS();
enable(flags);
} // display::scoped_state::scoped_state()
int positional_source::calculate_volume(const map_location &loc, const display &disp)
{
assert(range_ > 0);
assert(faderange_ > 0);
if((check_shrouded_ && disp.shrouded(loc)) || (check_fogged_ && disp.fogged(loc)))
return DISTANCE_SILENT;
SDL_Rect area = disp.map_area();
map_location center = disp.hex_clicked_on(area.x + area.w / 2, area.y + area.h / 2);
int distance = distance_between(loc, center);
if(distance <= range_) {
return 0;
}
return static_cast<int>((((distance - range_)
/ static_cast<double>(faderange_)) * DISTANCE_SILENT));
}
display::scoped_perspective::scoped_perspective(display & parent, const gsgl::real_t & field_of_view, const gsgl::real_t & aspect_ratio, const gsgl::real_t & near_distance, const gsgl::real_t & far_distance)
: parent(parent)
{
parent.bind();
glMatrixMode(GL_PROJECTION); CHECK_GL_ERRORS();
glPushMatrix(); CHECK_GL_ERRORS();
glLoadIdentity(); CHECK_GL_ERRORS();
gluPerspective(field_of_view, aspect_ratio, near_distance, far_distance); CHECK_GL_ERRORS();
} // display::scoped_perspective::scoped_perspective()
help_browser::help_browser(display &disp, const section &toplevel) :
gui::widget(disp.video()),
disp_(disp),
menu_(disp.video(),
toplevel),
text_area_(disp.video(), toplevel), toplevel_(toplevel),
ref_cursor_(false),
back_topics_(),
forward_topics_(),
back_button_(disp.video(), "", gui::button::TYPE_PRESS, "button_normal/button_small_H22", gui::button::DEFAULT_SPACE, true, "icons/arrows/long_arrow_ornate_left"),
forward_button_(disp.video(), "", gui::button::TYPE_PRESS, "button_normal/button_small_H22", gui::button::DEFAULT_SPACE, true, "icons/arrows/long_arrow_ornate_right"),
shown_topic_(NULL)
{
// Hide the buttons at first since we do not have any forward or
// back topics at this point. They will be unhidden when history
// appears.
back_button_.hide(true);
forward_button_.hide(true);
// Set sizes to some default values.
set_measurements(font::relative_size(400), font::relative_size(500));
}
void lua_map_generator::user_config(display & disp)
{
lk_.set_video(&disp.video());
try {
lk_.user_config(user_config_.c_str(), generator_data_);
} catch (game::lua_error & e) {
std::string msg = "Error when running lua_map_generator user_config.\n";
msg += "The generator was: " + config_name_ + "\n";
msg += e.what();
throw mapgen_exception(msg);
}
}
void show_fail_tip(display& disp, const std::string& item)
{
std::stringstream err;
utils::string_map symbols;
symbols["mail"] = tintegrate::generate_format(game_config::service_email, "green");
symbols["date"] = tintegrate::generate_format(format_time_local2(time(NULL)), "yellow");
symbols["item"] = tintegrate::generate_format(item, "yellow");
symbols["username"] = tintegrate::generate_format(preferences::login(), "yellow");
err << vgettext2("Update database fail when execute In-App Purchase! In order to compensate data you should get, please send In-App Purchase information to $mail. In-App Purchase information include: date($date), item($item), username($username).", symbols);
gui2::show_message(disp.video(), "", err.str());
}
void renderScene(void) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
disp.setOrthographicProjection();
glLoadIdentity();
//Functions to draw objects
interface.drawBoarder(boarderTexture);
glutSwapBuffers();
}
help_browser::help_browser(display &disp, const section &toplevel) :
gui::widget(disp.video()),
disp_(disp),
menu_(disp.video(),
toplevel),
text_area_(disp.video(), toplevel), toplevel_(toplevel),
ref_cursor_(false),
back_topics_(),
forward_topics_(),
back_button_(disp.video(), _(" < Back"), gui::button::TYPE_PRESS),
forward_button_(disp.video(), _("Forward >"), gui::button::TYPE_PRESS),
shown_topic_(NULL)
{
// Hide the buttons at first since we do not have any forward or
// back topics at this point. They will be unhidden when history
// appears.
back_button_.hide(true);
forward_button_.hide(true);
// Set sizes to some default values.
set_measurements(font::relative_size(400), font::relative_size(500));
}
static void run_lobby_loop(display& disp, mp::ui& ui)
{
disp.video().modeChanged();
bool first = true;
font::cache_mode(font::CACHE_LOBBY);
while (ui.get_result() == mp::ui::CONTINUE) {
if (disp.video().modeChanged() || first) {
SDL_Rect lobby_pos = { 0, 0, disp.video().getx(), disp.video().gety() };
ui.set_location(lobby_pos);
first = false;
}
// process network data first so user actions can override the result
// or uptodate data can prevent invalid actions
// i.e. press cancel while you receive [start_game] or press start game while someone leaves
ui.process_network();
events::pump();
events::raise_process_event();
events::raise_draw_event();
disp.flip();
disp.delay(20);
}
font::cache_mode(font::CACHE_GAME);
}
std::set<map_location> editor_map::set_starting_position_labels(display& disp)
{
std::set<map_location> label_locs;
std::string label = _("Player");
label += " ";
for (int i = 1; i <= gamemap::MAX_PLAYERS; i++) {
if (startingPositions_[i].valid()) {
disp.labels().set_label(startingPositions_[i], label + lexical_cast<std::string>(i));
label_locs.insert(startingPositions_[i]);
}
}
return label_locs;
}
display::scoped_modelview::scoped_modelview(display & parent, const transform *mv)
: parent(parent), mv(mv)
{
parent.bind();
glMatrixMode(GL_MODELVIEW); CHECK_GL_ERRORS();
glPushMatrix(); CHECK_GL_ERRORS();
if (mv)
{
glLoadMatrixf(mv->ptr()); CHECK_GL_ERRORS();
}
} // display::scoped_modelview::scoped_modelview()
std::set<map_location> editor_map::set_starting_position_labels(display& disp)
{
std::set<map_location> label_locs;
std::string label = _("Player");
label += " ";
for (int i = 0, size = starting_positions_.size(); i < size; ++i) {
if (starting_positions_[i].valid()) {
disp.labels().set_label(starting_positions_[i], label + lexical_cast<std::string>(i + 1));
label_locs.insert(starting_positions_[i]);
}
}
return label_locs;
}
void twml_exception::show(display &disp)
{
std::ostringstream sstr;
// The extra spaces between the \n are needed, otherwise the dialog doesn't show
// an empty line.
sstr << _("An error due to possibly invalid WML occurred\nThe error message is :")
<< "\n" << user_message << "\n \n"
<< _("When reporting the bug please include the following error message :")
<< "\n" << dev_message;
gui2::show_error_message(disp.video(), sstr.str());
}
bool iso9660::fclose(file_table *temp2) //change
{
file_table *temp,*temp1;
int count,t;
/////////////change
temp=ft_head;
if(temp->next!=0 && temp!=0)
{
//disp1.printf("\nhead address %x",ft_head->next);
while(temp->next!=temp2 && temp->next!=0)
{
temp=temp->next;
}
if(temp!=0)
{
temp->next=temp2->next;
klm.kdfree(&temp2,sizeof(file_table));
disp1.printf("\nSuccessfully closed the file");
return 1;
}
else
{
disp1.printf("\nFile not found in the file table");
return 0;
}
}
else
{
disp1.printf("\nNo file table is created");
return 0;
}
}
void key_event(display& disp, const SDL_KeyboardEvent& event, command_executor* executor)
{
if(event.keysym.sym == SDLK_ESCAPE && disp.in_game()) {
LOG_G << "escape pressed..showing quit\n";
const int res = gui::dialog(disp,_("Quit"),_("Do you really want to quit?"),gui::YES_NO).show();
if(res == 0) {
throw end_level_exception(QUIT);
} else {
return;
}
}
key_event_execute(disp,event,executor);
}
void command_executor::get_menu_images(display& disp, std::vector<config>& items)
{
for(size_t i = 0; i < items.size(); ++i) {
config& item = items[i];
const std::string& item_id = item["id"];
const hotkey::HOTKEY_COMMAND hk = hotkey::get_id(item_id);
//see if this menu item has an associated image
std::string img(get_menu_image(disp, item_id, i));
if (img.empty() == false) {
item["icon"] = img;
}
const theme::menu* menu = disp.get_theme().get_menu_item(item_id);
if(menu) {
item["label"] = menu->title();
} else if(hk != hotkey::HOTKEY_NULL) {
std::string desc = hotkey::get_description(item_id);
if(hk == HOTKEY_ENDTURN) {
const theme::action *b = disp.get_theme().get_action_item("button-endturn");
if (b) {
desc = b->title();
}
}
item["label"] = desc;
item["details"] = hotkey::get_names(item_id);
} else if(item["label"].empty()) {
// If no matching hotkey was found and a custom label wasn't already set, treat
// the id as a plaintext description. This is because either type of value can
// be written to the id field by the WMI manager. The plaintext description is
// used in the case the menu item specifies the relevant entry is *not* a hotkey.
item["label"] = item_id;
}
}
}
void set_fullscreen(display& disp, const bool ison)
{
_set_fullscreen(ison);
CVideo& video = disp.video();
const std::pair<int,int>& res = resolution();
if (video.isFullScreen() != ison) {
const int flags = ison ? SDL_WINDOW_FULLSCREEN: 0;
int bpp = video.modePossible(res.first, res.second, 32, flags);
VALIDATE(bpp > 0, "bpp must be large than 0!");
video.setMode(res.first, res.second,bpp, flags);
require_change_resolution = true;
}
}
void the_end(display &disp, std::string text, unsigned int duration)
{
//
// Some sane defaults.
//
if(text.empty())
text = _("The End");
if(!duration)
duration = 3500;
SDL_Rect area = screen_area();
CVideo &video = disp.video();
sdl_fill_rect(video.getSurface(),&area,0);
update_whole_screen();
disp.flip();
const size_t font_size = font::SIZE_XLARGE;
area = font::text_area(text,font_size);
area.x = screen_area().w/2 - area.w/2;
area.y = screen_area().h/2 - area.h/2;
for(size_t n = 0; n < 255; n += 5) {
if(n)
sdl_fill_rect(video.getSurface(),&area,0);
const SDL_Color col = create_color(n, n, n, n);
font::draw_text(&video,area,font_size,col,text,area.x,area.y);
update_rect(area);
events::pump();
events::raise_process_event();
events::raise_draw_event();
disp.flip();
disp.delay(10);
}
//
// Delay after the end of fading.
// Rounded to multiples of 10.
//
unsigned int count = duration/10;
while(count) {
events::pump();
events::raise_process_event();
events::raise_draw_event();
disp.flip();
disp.delay(10);
--count;
}
}
unit_drawer::unit_drawer(display & thedisp, std::map<surface,SDL_Rect> & bar_rects) :
disp(thedisp),
dc(disp.get_disp_context()),
map(dc.map()),
teams(dc.teams()),
halo_man(thedisp.get_halo_manager()),
energy_bar_rects_(bar_rects),
viewing_team(disp.viewing_team()),
playing_team(disp.playing_team()),
viewing_team_ref(teams[viewing_team]),
playing_team_ref(teams[playing_team]),
is_blindfolded(disp.is_blindfolded()),
show_everything(disp.show_everything()),
sel_hex(disp.selected_hex()),
mouse_hex(disp.mouseover_hex()),
zoom_factor(disp.get_zoom_factor()),
hex_size(disp.hex_size()),
hex_size_by_2(disp.hex_size()/2)
{}
std::string command_executor::get_menu_image(display& disp, const std::string& command, int index) const {
// TODO: Find a way to do away with the fugly special markup
if(command[0] == '&') {
size_t n = command.find_first_of('=');
if(n != std::string::npos)
return command.substr(1, n - 1);
}
const std::string base_image_name = "icons/action/" + command + "_25.png";
const std::string pressed_image_name = "icons/action/" + command + "_25-pressed.png";
const hotkey::HOTKEY_COMMAND hk = hotkey::get_id(command);
const hotkey::ACTION_STATE state = get_action_state(hk, index);
const theme::menu* menu = disp.get_theme().get_menu_item(command);
if (menu) {
return "icons/arrows/short_arrow_right_25.png~CROP(3,3,18,18)"; // TODO should not be hardcoded
}
if (filesystem::file_exists(game_config::path + "/images/" + base_image_name)) {
switch (state) {
case ACTION_ON:
case ACTION_SELECTED:
return pressed_image_name + "~CROP(3,3,18,18)";
default:
return base_image_name + "~CROP(3,3,18,18)";
}
}
switch (get_action_state(hk, index)) {
case ACTION_ON:
return game_config::images::checked_menu;
case ACTION_OFF:
return game_config::images::unchecked_menu;
case ACTION_SELECTED:
return game_config::images::selected_menu;
case ACTION_DESELECTED:
return game_config::images::deselected_menu;
default: return get_action_image(hk, index);
}
}
static LEVEL_RESULT playsingle_scenario(const config& game_config,
const config* level, display& disp, game_state& state_of_game, hero_map& heros, hero_map& heros_start,
card_map& cards,
const config::const_child_itors &story,
bool skip_replay, end_level_data &end_level)
{
const int ticks = SDL_GetTicks();
int num_turns = (*level)["turns"].to_int();
playsingle_controller playcontroller(*level, state_of_game, heros, heros_start, cards, ticks, num_turns, game_config, disp.video(), skip_replay);
LEVEL_RESULT res = playcontroller.play_scenario(story, skip_replay);
playcontroller.get_end_level_data().result = res;
end_level = playcontroller.get_end_level_data();
if (res == DEFEAT) {
if (resources::persist != NULL) {
resources::persist->end_transaction();
}
gui2::show_transient_message(disp.video(),
_("Defeat"),
_("You have been defeated!")
);
}
if (res != QUIT && end_level.linger_mode)
{
try {
playcontroller.linger();
} catch(end_level_exception& e) {
if (e.result == QUIT) {
return QUIT;
}
}
}
return res;
}
part_ui::part_ui(part &p, display &disp, gui::button &next_button,
gui::button &back_button, gui::button&play_button)
: p_(p)
, disp_(disp)
, video_(disp.video())
, keys_()
, next_button_(next_button)
, back_button_(back_button)
, play_button_(play_button)
, ret_(NEXT), skip_(false), last_key_(false)
, scale_factor_(1.0)
, base_rect_()
, background_(NULL)
, imgs_()
, has_background_(false)
, text_x_(200)
, text_y_(400)
, buttons_x_(0)
, buttons_y_(0)
{
this->prepare_background();
this->prepare_geometry();
this->prepare_floating_images();
}
display::scoped_text::scoped_text(display & parent)
: parent(parent)
{
parent.bind();
// record 3d info
glGetIntegerv(GL_VIEWPORT, text_draw_viewport); CHECK_GL_ERRORS();
glGetFloatv(GL_MODELVIEW_MATRIX, text_draw_modelview.ptr()); CHECK_GL_ERRORS();
glGetFloatv(GL_PROJECTION_MATRIX, text_draw_projection.ptr()); CHECK_GL_ERRORS();
text_draw_pm = text_draw_projection * text_draw_modelview; CHECK_GL_ERRORS();
// set up projection and modelview for drawing text
glPushAttrib(GL_ALL_ATTRIB_BITS); CHECK_GL_ERRORS();
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS); CHECK_GL_ERRORS();
glMatrixMode(GL_PROJECTION); CHECK_GL_ERRORS();
glPushMatrix(); CHECK_GL_ERRORS();
glLoadIdentity(); CHECK_GL_ERRORS();
glOrtho(0.0, parent.surface->w, 0.0, parent.surface->h, -1, 1); CHECK_GL_ERRORS();
glMatrixMode(GL_MODELVIEW); CHECK_GL_ERRORS();
glPushMatrix(); CHECK_GL_ERRORS();
glLoadIdentity(); CHECK_GL_ERRORS();
} // display::scoped_text::scoped_text()
void status_table(display& gui, int selected)
{
std::stringstream heading;
heading << HEADING_PREFIX << _("Leader") << COLUMN_SEPARATOR << ' ' << COLUMN_SEPARATOR
<< _("Team") << COLUMN_SEPARATOR
<< _("Gold") << COLUMN_SEPARATOR
<< _("Villages") << COLUMN_SEPARATOR
<< _("status^Units") << COLUMN_SEPARATOR
<< _("Upkeep") << COLUMN_SEPARATOR
<< _("Income");
gui::menu::basic_sorter sorter;
sorter.set_redirect_sort(0,1).set_alpha_sort(1).set_alpha_sort(2).set_numeric_sort(3)
.set_numeric_sort(4).set_numeric_sort(5).set_numeric_sort(6).set_numeric_sort(7);
std::vector<std::string> items;
std::vector<bool> leader_bools;
items.push_back(heading.str());
const gamemap& map = gui.get_map();
const unit_map& units = gui.get_units();
assert(&gui.get_teams() == resources::teams);
const std::vector<team>& teams = gui.get_teams();
const team& viewing_team = teams[gui.viewing_team()];
unsigned total_villages = 0;
// a variable to check if there are any teams to show in the table
bool status_table_empty = true;
//if the player is under shroud or fog, they don't get
//to see details about the other sides, only their own
//side, allied sides and a ??? is shown to demonstrate
//lack of information about the other sides But he see
//all names with in colors
for(size_t n = 0; n != teams.size(); ++n) {
if(teams[n].hidden()) {
continue;
}
status_table_empty=false;
const bool known = viewing_team.knows_about_team(n, network::nconnections() > 0);
const bool enemy = viewing_team.is_enemy(n+1);
std::stringstream str;
const team_data data = gui.get_disp_context().calculate_team_data(teams[n],n+1);
unit_map::const_iterator leader = units.find_leader(n + 1);
std::string leader_name;
//output the number of the side first, and this will
//cause it to be displayed in the correct color
if(leader != units.end()) {
const bool fogged = viewing_team.fogged(leader->get_location());
// Add leader image. If it's fogged
// show only a random leader image.
if (!fogged || known || game_config::debug) {
str << IMAGE_PREFIX << leader->absolute_image();
leader_bools.push_back(true);
leader_name = leader->name();
} else {
str << IMAGE_PREFIX << std::string("units/unknown-unit.png");
leader_bools.push_back(false);
leader_name = "Unknown";
}
// if (gamestate_.classification().campaign_type == game_classification::MULTIPLAYER)
// leader_name = teams[n].current_player();
#ifndef LOW_MEM
str << leader->image_mods();
#endif
} else {
leader_bools.push_back(false);
}
str << COLUMN_SEPARATOR << team::get_side_highlight(n)
<< leader_name << COLUMN_SEPARATOR
<< (data.teamname.empty() ? teams[n].team_name() : data.teamname)
<< COLUMN_SEPARATOR;
if(!known && !game_config::debug) {
// We don't spare more info (only name)
// so let's go on next side ...
items.push_back(str.str());
continue;
}
if(game_config::debug) {
str << utils::half_signed_value(data.gold) << COLUMN_SEPARATOR;
} else if(enemy && viewing_team.uses_fog()) {
str << ' ' << COLUMN_SEPARATOR;
} else {
str << utils::half_signed_value(data.gold) << COLUMN_SEPARATOR;
}
str << data.villages;
if(!(viewing_team.uses_fog() || viewing_team.uses_shroud())) {
str << "/" << map.villages().size();
}
str << COLUMN_SEPARATOR
<< data.units << COLUMN_SEPARATOR << data.upkeep << COLUMN_SEPARATOR
<< (data.net_income < 0 ? font::BAD_TEXT : font::NULL_MARKUP) << utils::signed_value(data.net_income);
total_villages += data.villages;
items.push_back(str.str());
}
if (total_villages > map.villages().size()) {
//TODO
// ERR_NG << "Logic error: map has " << map.villages().size()
// << " villages but status table shows " << total_villages << " owned in total\n";
}
if (status_table_empty)
{
// no sides to show - display empty table
std::stringstream str;
str << " ";
for (int i=0;i<7;++i)
str << COLUMN_SEPARATOR << " ";
leader_bools.push_back(false);
items.push_back(str.str());
}
int result = 0;
{
leader_scroll_dialog slist(gui, _("Current Status"), leader_bools, selected, gui::DIALOG_FORWARD);
slist.add_button(new gui::dialog_button(gui.video(), _("More >"),
gui::button::TYPE_PRESS, gui::DIALOG_FORWARD),
gui::dialog::BUTTON_EXTRA_LEFT);
slist.set_menu(items, &sorter);
slist.get_menu().move_selection(selected);
result = slist.show();
selected = slist.get_menu().selection();
} // this will kill the dialog before scrolling
if (result >= 0) {
//TODO
// gui.scroll_to_leader(units_, selected+1);
}
else if (result == gui::DIALOG_FORWARD)
scenario_settings_table(gui, selected);
}
terrain_group::terrain_group(const config& cfg, display& gui):
id(cfg["id"]), name(cfg["name"].t_str()),
button(gui.video(), "", gui::button::TYPE_CHECK, cfg["icon"]),
core(cfg["core"].to_bool())
{
}
void scenario_settings_table(display& gui, int selected)
{
std::stringstream heading;
heading << HEADING_PREFIX << _("scenario settings^Leader") << COLUMN_SEPARATOR
<< COLUMN_SEPARATOR
<< _("scenario settings^Side") << COLUMN_SEPARATOR
<< _("scenario settings^Start\nGold") << COLUMN_SEPARATOR
<< _("scenario settings^Base\nIncome") << COLUMN_SEPARATOR
<< _("scenario settings^Gold Per\nVillage") << COLUMN_SEPARATOR
<< _("scenario settings^Support Per\nVillage") << COLUMN_SEPARATOR
<< _("scenario settings^Fog") << COLUMN_SEPARATOR
<< _("scenario settings^Shroud");
gui::menu::basic_sorter sorter;
sorter.set_redirect_sort(0,1).set_alpha_sort(1).set_numeric_sort(2)
.set_numeric_sort(3).set_numeric_sort(4).set_numeric_sort(5)
.set_numeric_sort(6).set_alpha_sort(7).set_alpha_sort(8);
std::vector<std::string> items;
std::vector<bool> leader_bools;
items.push_back(heading.str());
//const gamemap& map = gui.get_map();
const unit_map& units = gui.get_units();
const std::vector<team>& teams = gui.get_teams();
const team& viewing_team = teams[gui.viewing_team()];
bool settings_table_empty = true;
bool fogged;
for(size_t n = 0; n != teams.size(); ++n) {
if(teams[n].hidden()) {
continue;
}
settings_table_empty = false;
std::stringstream str;
unit_map::const_iterator leader = units.find_leader(n + 1);
if(leader != units.end()) {
// Add leader image. If it's fogged
// show only a random leader image.
fogged=viewing_team.fogged(leader->get_location());
if (!fogged || viewing_team.knows_about_team(n, network::nconnections() > 0) || game_config::debug) {
str << IMAGE_PREFIX << leader->absolute_image();
leader_bools.push_back(true);
} else {
str << IMAGE_PREFIX << std::string("units/unknown-unit.png");
leader_bools.push_back(false);
}
#ifndef LOW_MEM
str << "~RC(" << leader->team_color() << '>'
<< team::get_side_color_index(n+1) << ")";
#endif
} else {
leader_bools.push_back(false);
}
str << COLUMN_SEPARATOR << team::get_side_highlight(n)
<< teams[n].current_player() << COLUMN_SEPARATOR
<< n + 1 << COLUMN_SEPARATOR
<< teams[n].start_gold() << COLUMN_SEPARATOR
<< teams[n].base_income() << COLUMN_SEPARATOR
<< teams[n].village_gold() << COLUMN_SEPARATOR
<< teams[n].village_support() << COLUMN_SEPARATOR
<< (teams[n].uses_fog() ? _("yes") : _("no")) << COLUMN_SEPARATOR
<< (teams[n].uses_shroud() ? _("yes") : _("no")) << COLUMN_SEPARATOR;
items.push_back(str.str());
}
if (settings_table_empty)
{
// no sides to show - display empty table
std::stringstream str;
for (int i=0;i<8;++i)
str << " " << COLUMN_SEPARATOR;
leader_bools.push_back(false);
items.push_back(str.str());
}
int result = 0;
{
leader_scroll_dialog slist(gui, _("Scenario Settings"), leader_bools, selected, gui::DIALOG_BACK);
slist.set_menu(items, &sorter);
slist.get_menu().move_selection(selected);
slist.add_button(new gui::dialog_button(gui.video(), _(" < Back"),
gui::button::TYPE_PRESS, gui::DIALOG_BACK),
gui::dialog::BUTTON_EXTRA_LEFT);
result = slist.show();
selected = slist.get_menu().selection();
} // this will kill the dialog before scrolling
if (result >= 0) {
//TODO
//gui_->scroll_to_leader(units_, selected+1);
}
else if (result == gui::DIALOG_BACK)
status_table(gui, selected);
}
