KeyboardMenu::KeyboardMenu(InputManager& input_manager) :
  m_input_manager(input_manager)
{
  add_label(_("Setup Keyboard"));
  add_hl();
  add_controlfield(Controller::UP,         _("Up"));
  add_controlfield(Controller::DOWN,       _("Down"));
  add_controlfield(Controller::LEFT,       _("Left"));
  add_controlfield(Controller::RIGHT,      _("Right"));
  add_controlfield(Controller::JUMP,       _("Jump"));
  add_controlfield(Controller::ACTION,     _("Action"));
  add_controlfield(Controller::PEEK_LEFT,  _("Peek Left"));
  add_controlfield(Controller::PEEK_RIGHT, _("Peek Right"));
  add_controlfield(Controller::PEEK_UP,    _("Peek Up"));
  add_controlfield(Controller::PEEK_DOWN,  _("Peek Down"));
  if (g_config->developer_mode) {
    add_controlfield(Controller::CONSOLE, _("Console"));
  }
  if (g_config->developer_mode) {
    add_controlfield(Controller::CHEAT_MENU, _("Cheat Menu"));
  }
  add_hl();
  add_inactive(_("The following feature is deprecated."));
  // l10n: Continuation of string "The following feature is deprecated."
  add_inactive(_("It will be removed from the next release"));
  // l10n: Continuation of string "It will be removed from the next release"
  add_inactive(_("of SuperTux."));
  add_toggle(Controller::CONTROLCOUNT, _("Jump with Up"), &g_config->keyboard_config.jump_with_up_kbd);
  add_hl();
  add_back(_("Back"));
  refresh();
}
示例#2
0
EditorSectorMenu::EditorSectorMenu() :
  sector(Editor::current()->currentsector),
  sector_name_ptr(sector->get_name_ptr()),
  original_name(*sector_name_ptr),
  size(sector->get_editor_size()),
  new_size(size)
{
  add_label(_("Sector") + " " + sector->get_name());
  add_hl();
  add_textfield(_("Name"), sector_name_ptr);
  add_script(_("Initialization script"), sector->get_init_script_ptr());
  add_color(_("Ambient light"), sector->get_ambient_light_ptr());
  add_numfield(_("Gravity"), &sector->gravity);

  std::vector<std::string> music_formats;
  music_formats.push_back(".ogg");
  music_formats.push_back(".music");
  add_file(_("Music"), &sector->music, music_formats);

  add_hl();
  add_intfield(_("Width"), &(new_size.width));
  add_intfield(_("Height"), &(new_size.height));
  add_entry(MNID_RESIZESECTOR, _("Resize"));

  add_hl();
  add_back(_("OK"));
}
示例#3
0
KeyboardMenu::KeyboardMenu(InputManager& input_manager) :
  m_input_manager(input_manager)
{
  add_label(_("Setup Keyboard"));
  add_hl();
  add_controlfield(Controller::UP,         _("Up"));
  add_controlfield(Controller::DOWN,       _("Down"));
  add_controlfield(Controller::LEFT,       _("Left"));
  add_controlfield(Controller::RIGHT,      _("Right"));
  add_controlfield(Controller::JUMP,       _("Jump"));
  add_controlfield(Controller::ACTION,     _("Action"));
  add_controlfield(Controller::PEEK_LEFT,  _("Peek Left"));
  add_controlfield(Controller::PEEK_RIGHT, _("Peek Right"));
  add_controlfield(Controller::PEEK_UP,    _("Peek Up"));
  add_controlfield(Controller::PEEK_DOWN,  _("Peek Down"));
  if (g_config->developer_mode || g_config->console_enabled) {
    add_controlfield(Controller::CONSOLE, _("Console"));
  }
  if (g_config->developer_mode) {
    add_controlfield(Controller::CHEAT_MENU, _("Cheat Menu"));
  }
  add_toggle(Controller::CONTROLCOUNT, _("Jump with Up"), &g_config->keyboard_config.jump_with_up_kbd);
  add_hl();
  add_back(_("Back"));
  refresh();
}
示例#4
0
WorldmapMenu::WorldmapMenu()
{
  add_label(_("Pause"));
  add_hl();
  add_entry(MNID_RETURNWORLDMAP, _("Continue"));
  add_submenu(_("Options"), MenuStorage::INGAME_OPTIONS_MENU);
  add_hl();
  add_entry(MNID_QUITWORLDMAP, _("Leave World"));
}
示例#5
0
EditorMenu::EditorMenu()
{
  add_label(_("Level Editor"));
  add_hl();
  add_entry(MNID_RETURNTOEDITOR, _("Return to editor"));
  add_entry(MNID_SAVELEVEL, _("Save current level"));
  add_entry(MNID_LEVELSEL, _("Edit another level"));
  add_entry(MNID_LEVELSETSEL, _("Choose another level subset"));
  add_hl();
  add_entry(MNID_QUITEDITOR, _("Exit level editor"));
}
示例#6
0
void
JoystickMenu::recreate_menu()
{
  clear();
  add_label(_("Setup Joystick"));
  add_hl();

  add_toggle(MNID_AUTO_JOYSTICK_CFG, _("Manual Configuration"),
             &m_auto_joystick_cfg)
    .set_help(_("Use manual configuration instead of SDL2's automatic GameController support"));

  if (m_input_manager.use_game_controller())
  {
    m_joysticks_available = false;
  }
  else
  {
    if (m_input_manager.joystick_manager->get_num_joysticks() > 0)
    {
      m_joysticks_available = true;

      add_controlfield(static_cast<int>(Control::UP),          _("Up"));
      add_controlfield(static_cast<int>(Control::DOWN),        _("Down"));
      add_controlfield(static_cast<int>(Control::LEFT),        _("Left"));
      add_controlfield(static_cast<int>(Control::RIGHT),       _("Right"));
      add_controlfield(static_cast<int>(Control::JUMP),        _("Jump"));
      add_controlfield(static_cast<int>(Control::ACTION),      _("Action"));
      add_controlfield(static_cast<int>(Control::START),       _("Pause/Menu"));
      add_controlfield(static_cast<int>(Control::PEEK_LEFT),   _("Peek Left"));
      add_controlfield(static_cast<int>(Control::PEEK_RIGHT),  _("Peek Right"));
      add_controlfield(static_cast<int>(Control::PEEK_UP),     _("Peek Up"));
      add_controlfield(static_cast<int>(Control::PEEK_DOWN),   _("Peek Down"));
      if (g_config->developer_mode) {
        add_controlfield(static_cast<int>(Control::CONSOLE), _("Console"));
      }
      if (g_config->developer_mode) {
        add_controlfield(static_cast<int>(Control::CHEAT_MENU), _("Cheat Menu"));
        add_controlfield(static_cast<int>(Control::DEBUG_MENU), _("Debug Menu"));
      }
      add_toggle(MNID_JUMP_WITH_UP, _("Jump with Up"), &g_config->joystick_config.m_jump_with_up_joy);
    }
    else
    {
      m_joysticks_available = false;

      add_inactive(_("No Joysticks found"));
      add_entry(MNID_SCAN_JOYSTICKS, _("Scan for Joysticks"));
    }
  }

  add_hl();
  add_back(_("Back"));
  refresh();
}
示例#7
0
GameMenu::GameMenu()
{
  Level* level = GameSession::current()->get_current_level();

  add_label(level->name);
  add_hl();
  add_entry(MNID_CONTINUE, _("Continue"));
  add_entry(MNID_RESETLEVEL, _("Restart Level"));
  add_submenu(_("Options"), MenuStorage::INGAME_OPTIONS_MENU);
  add_hl();
  add_entry(MNID_ABORTLEVEL, _("Abort Level"));
}
OptionsMenu::OptionsMenu()
{
  add_label(_("Options"));
  add_hl();
  add_toggle(MNID_FULLSCREEN,_("Fullscreen"), config->use_fullscreen);
  add_toggle(MNID_SOUND, _("Sound"), config->sound_enabled);
  add_toggle(MNID_MUSIC, _("Music"), config->music_enabled);
  add_submenu(_("Setup Keys"), main_controller->get_key_options_menu());
  add_submenu(_("Setup Joystick"),main_controller->get_joystick_options_menu());
  add_hl();
  add_back(_("Back"));
}
void
EditorLevelsetMenu::initialize() {

  levelset_type = world->m_is_levelset ? 1 : 0;

  add_label(_("Level subset properties"));
  add_hl();
  add_textfield(_("Name"), &(world->m_title));
  add_textfield(_("Description"), &(world->m_description));
  add_string_select(1, _("Type"), &levelset_type, {_("Worldmap"), _("Levelset")});
  add_hl();
  add_back(_("OK"));
}
EditorTilegroupMenu::EditorTilegroupMenu()
{
  add_label(_("Tilegroups"));
  add_hl();

  int id = 0;
  for(auto& tg : Editor::current()->tileset->tilegroups) {
    add_entry(id, tg.name);
    id++;
  }

  add_hl();
  add_entry(-1,_("Cancel"));
}
示例#11
0
ColorMenu::ColorMenu(Color* color_) :
  color(color_)
{
  add_label(_("Mix the colour"));
  add_hl();

  add_colorchannel( &(color->red), Color(1.0f, 0.0f, 0.0f));
  add_colorchannel( &(color->green), Color(0.0f, 1.0f, 0.0f));
  add_colorchannel( &(color->blue), Color(0.0f, 0.0f, 1.0f));
  add_colorchannel( &(color->alpha), Color(0.0f, 0.0f, 0.0f));
  add_colordisplay(color);

  add_hl();
  add_back(_("OK"));
}
示例#12
0
EditorTilegroupMenu::EditorTilegroupMenu()
{
  add_label(_("Tilegroups"));
  add_hl();

  int id = 0;
  for(auto i = Editor::current()->level->tileset->tilegroups.begin(); i != Editor::current()->level->tileset->tilegroups.end(); ++i) {
    Tilegroup* tg = &(*i);
    add_entry(id, tg->name);
    id++;
  }

  add_hl();
  add_entry(-1,_("Abort"));
}
示例#13
0
文件: output.c 项目: k6s/yaod
void						update_var(WINDOW *win, char *var, size_t off,
									   size_t var_len, unsigned *hl, int color)
{
	size_t					li;
	size_t					co;
	size_t					start;
	size_t					l_line;

	li = off / 16;
	co = off % 16;
	start = off;
	if (hl)
		add_hl(hl, off, var_len);
	off = 0;
	while (off < var_len)
	{
		/*l_line = (var_len - off + start) / 16 ? 16 : (var_len - off + start % 16); */
		l_line = 1;
		co = (off + start) % 16;
		li = (off + start) / 16;
		axdump_dword(win, var + off, li, co, l_line, color);
		off += l_line;
	}
	prefresh(win, 0, 0, WIN_BORDER_LEN, WIN_BORDER_LEN,
			 WIN_STACK_LI, WIN_STACK_CO);
}
void
EditorLevelsetMenu::initialize() {
  add_label(_("Level subset properties"));
  add_hl();
  add_textfield(_("Name"), &(world->m_title));
  add_textfield(_("Description"), &(world->m_description));

  std::string worldmap_file = FileSystem::join(world->get_basedir(), "worldmap.stwm");
  if (PHYSFS_exists(worldmap_file.c_str())) {
    add_toggle(-1, _("Do not use worldmap"), &(world->m_is_levelset));
    add_entry(MNID_EDITWORLDMAP, _("Edit worldmap"));
  } else {
    add_entry(MNID_NEWWORLDMAP, _("Create worldmap"));
  }
  add_hl();
  add_back(_("OK"));
}
示例#15
0
LanguageMenu::LanguageMenu() 
{
  add_label(_("Language"));
  add_hl();
  add_entry(MNID_LANGUAGE_AUTO_DETECT, _("<auto-detect>"));
  add_entry(MNID_LANGUAGE_ENGLISH, "English");

  int mnid = MNID_LANGUAGE_NEXT;
  std::set<tinygettext::Language> languages = dictionary_manager->get_languages();
  for (std::set<tinygettext::Language>::iterator i = languages.begin(); i != languages.end(); i++) 
  {
    add_entry(mnid++, i->get_name());
  }

  add_hl();
  add_back(_("Back"));
}
示例#16
0
EditorSectorsMenu::EditorSectorsMenu()
{
  add_label(_("Choose sector to edit:"));
  add_hl();

  int id = 0;
  for (const auto& sector : Editor::current()->get_level()->m_sectors) {
    add_entry(id, sector->get_name());
    id++;
  }

  add_hl();
  add_submenu(_("Sector settings..."), MenuStorage::EDITOR_SECTOR_MENU);
  add_entry(-2,_("Create new sector"));
  add_entry(-3,_("Delete this sector"));
  add_entry(-4,_("Cancel"));
}
示例#17
0
EditorMenu::EditorMenu()
{
  bool worldmap = Editor::current()->get_worldmap_mode();
  bool is_world = Editor::current()->get_world();
  std::vector<std::string> snap_grid_sizes;
  snap_grid_sizes.push_back(_("1/8 tile (4px)"));
  snap_grid_sizes.push_back(_("1/4 tile (8px)"));
  snap_grid_sizes.push_back(_("1/2 tile (16px)"));
  snap_grid_sizes.push_back(_("1 tile (32px)"));

  add_label(_("Level Editor"));
  add_hl();
  add_entry(MNID_RETURNTOEDITOR, _("Return to editor"));
  add_entry(MNID_SAVELEVEL, worldmap ? _("Save current worldmap") : _("Save current level"));

  if (!worldmap) {
    add_entry(MNID_TESTLEVEL, _("Test the level"));
  }
  else
  {
    add_entry(MNID_TESTLEVEL, _("Test the worldmap"));
  }

  if (is_world) {
    add_entry(MNID_LEVELSEL, _("Edit another level"));
  }

  add_entry(MNID_LEVELSETSEL, _("Choose another level subset"));

  add_string_select(-1, _("Grid size"), &EditorInputCenter::selected_snap_grid_size, snap_grid_sizes);

  add_toggle(-1, _("Render lighting (F6)"), &DrawingContext::render_lighting);
  add_toggle(-1, _("Snap objects to grid (F7)"), &EditorInputCenter::snap_to_grid);
  add_toggle(-1, _("Show grid (F8)"), &EditorInputCenter::render_grid);
  add_toggle(-1, _("Render background"), &EditorInputCenter::render_background);
  add_toggle(-1, _("Show scroller (F9)"), &EditorScroller::rendered);

  add_submenu(worldmap ? _("Worldmap properties") : _("Level properties"),
              MenuStorage::EDITOR_LEVEL_MENU);

  add_hl();
  add_entry(MNID_QUITEDITOR, _("Exit level editor"));
}
示例#18
0
void
BadguySelectMenu::refresh_menu()
{
  items.clear();

  add_label(_("List of enemies"));
  add_hl();
  add_string_select(-2, _("Enemy"), &selected, all_badguys);
  add_entry(-3, _("Add"));
  add_hl();

  int i = 0;
  for (auto& badguy : *badguys) {
    add_entry(i, badguy);
    i++;
  }

  add_hl();
  add_back(_("OK"));
}
示例#19
0
EditorLevelMenu::EditorLevelMenu() :
  old_tileset(Editor::current()->get_level()->m_tileset)
{
  bool worldmap = Editor::current()->get_worldmap_mode();
  auto level = Editor::current()->get_level();

  add_label(worldmap ? _("Worldmap properties") :_("Level properties"));
  add_hl();
  add_textfield(_("Name"), &(level->m_name));
  add_textfield(_("Author"), &(level->m_author));
  add_textfield(_("Contact"), &(level->m_contact));
  add_textfield(_("License"), &(level->m_license));
  add_file(_("Tileset"), &(level->m_tileset), std::vector<std::string>(1, ".strf"));

  if (!worldmap) {
    add_numfield(_("Target time"), &(level->m_target_time));
  }

  add_hl();
  add_back(_("OK"));
}
示例#20
0
CheatMenu::CheatMenu()
{
  std::vector<Player*> players = Sector::get().get_players();
  auto player = players.empty() ? nullptr : players[0];

  add_label(_("Cheats"));
  add_hl();
  add_entry(MNID_GROW, _("Bonus: Grow"));
  add_entry(MNID_FIRE, _("Bonus: Fire"));
  add_entry(MNID_ICE, _("Bonus: Ice"));
  add_entry(MNID_AIR, _("Bonus: Air"));
  add_entry(MNID_EARTH, _("Bonus: Earth"));
  add_entry(MNID_STAR, _("Bonus: Star"));
  add_entry(MNID_SHRINK, _("Shrink Tux"));
  add_entry(MNID_KILL, _("Kill Tux"));
  add_entry(MNID_FINISH, _("Finish Level"));
  add_entry(MNID_GHOST, (player != nullptr && player->get_ghost_mode()) ?
                        _("Leave Ghost Mode") : _("Activate Ghost Mode"));
  add_hl();
  add_back(_("Back"));
}
void EditorLevelSelectMenu::initialize() {
  auto editor = Editor::current();
  auto basedir = m_world->get_basedir();

  editor->deactivate_request = true;
  m_levelset = std::unique_ptr<Levelset>(new Levelset(basedir));

  add_label(m_world->get_title());
  add_hl();

  for (int i = 0; i < m_levelset->get_num_levels(); ++i)
  {
    std::string filename = m_levelset->get_level_filename(i);
    std::string full_filename = FileSystem::join(basedir, filename);
    std::string title = GameManager::current()->get_level_name(full_filename);
    add_entry(i, title);
  }

  add_hl();
  add_entry(-1, _("Create Level"));
  add_entry(-3, _("Level subset properties"));
  add_back(_("Back"),-2);
}
ContribLevelsetMenu::ContribLevelsetMenu(std::unique_ptr<World> world) :
  m_world(std::move(world)),
  m_levelset()
{
  assert(m_world->is_levelset());

  m_levelset = std::unique_ptr<Levelset>(new Levelset(m_world->get_basedir()));

  auto savegame = Savegame::from_file(m_world->get_savegame_filename());
  LevelsetState state = savegame->get_levelset_state(m_world->get_basedir());

  add_label(m_world->get_title());
  add_hl();

  for (int i = 0; i < m_levelset->get_num_levels(); ++i)
  {
    std::string filename = m_levelset->get_level_filename(i);
    std::string full_filename = FileSystem::join(m_world->get_basedir(), filename);
    std::string title = LevelParser::get_level_name(full_filename);
    LevelState level_state = state.get_level_state(filename);

    std::ostringstream out;
    if (level_state.solved)
    {
      out << title << " [*]";
    }
    else
    {
      out << title << " [ ]";
    }
    add_entry(i, out.str());
  }

  add_hl();
  add_back(_("Back"));
}
示例#23
0
OptionsMenu::OptionsMenu(bool complete) :
  next_magnification(0),
  next_aspect_ratio(0),
  next_resolution(0),
  magnifications(),
  aspect_ratios(),
  resolutions()
{
  add_label(_("Options"));
  add_hl();

  magnifications.clear();
  // These values go from screen:640/projection:1600 to
  // screen:1600/projection:640 (i.e. 640, 800, 1024, 1280, 1600)
  magnifications.push_back(_("auto"));
  magnifications.push_back("40%");
  magnifications.push_back("50%");
  magnifications.push_back("62.5%");
  magnifications.push_back("80%");
  magnifications.push_back("100%");
  magnifications.push_back("125%");
  magnifications.push_back("160%");
  magnifications.push_back("200%");
  magnifications.push_back("250%");
  // Gets the actual magnification:
  if (g_config->magnification != 0.0f) //auto
  {
    std::ostringstream out;
    out << (g_config->magnification*100) << "%";
    std::string magn = out.str();
    size_t count = 0;
    for (std::vector<std::string>::iterator i = magnifications.begin(); i != magnifications.end(); ++i)
    {
      if (*i == magn)
      {
        next_magnification = count;
        magn.clear();
        break;
      }

      ++count;
    }
    if (!magn.empty()) //magnification not in our list but accept anyway
    {
      next_magnification = magnifications.size();
      magnifications.push_back(magn);
    }
  }

  aspect_ratios.clear();
  aspect_ratios.push_back(_("auto"));
  aspect_ratios.push_back("5:4");
  aspect_ratios.push_back("4:3");
  aspect_ratios.push_back("16:10");
  aspect_ratios.push_back("16:9");
  aspect_ratios.push_back("1368:768");
  // Gets the actual aspect ratio:
  if (g_config->aspect_size != Size(0, 0)) //auto
  {
    std::ostringstream out;
    out << g_config->aspect_size.width << ":" << g_config->aspect_size.height;
    std::string aspect_ratio = out.str();
    size_t cnt_ = 0;
    for(std::vector<std::string>::iterator i = aspect_ratios.begin(); i != aspect_ratios.end(); ++i)
    {
      if(*i == aspect_ratio)
      {
        aspect_ratio.clear();
        next_aspect_ratio = cnt_;
        break;
      }
      ++cnt_;
    }

    if (!aspect_ratio.empty())
    {
      next_aspect_ratio = aspect_ratios.size();
      aspect_ratios.push_back(aspect_ratio);
    }
  }

  resolutions.clear();
  int display_mode_count = SDL_GetNumDisplayModes(0);
  std::string last_display_mode;
  for(int i = 0; i < display_mode_count; ++i)
  {
    SDL_DisplayMode mode;
    int ret = SDL_GetDisplayMode(0, i, &mode);
    if (ret != 0)
    {
      log_warning << "failed to get display mode: " << SDL_GetError() << std::endl;
    }
    else
    {
      std::ostringstream out;
      out << mode.w << "x" << mode.h;
      if(mode.refresh_rate)
        out << "@" << mode.refresh_rate;
      if(last_display_mode == out.str())
        continue;
      last_display_mode = out.str();
      resolutions.insert(resolutions.begin(), out.str());
    }
  }
  resolutions.push_back("Desktop");

  std::string fullscreen_size_str = "Desktop";
  {
    std::ostringstream out;
    if (g_config->fullscreen_size != Size(0, 0))
    {
      out << g_config->fullscreen_size.width << "x" << g_config->fullscreen_size.height;
      if (g_config->fullscreen_refresh_rate)
         out << "@" << g_config->fullscreen_refresh_rate;
      fullscreen_size_str = out.str();
    }
  }

  size_t cnt = 0;
  for (std::vector<std::string>::iterator i = resolutions.begin(); i != resolutions.end(); ++i)
  {
    if (*i == fullscreen_size_str)
    {
      fullscreen_size_str.clear();
      next_resolution = cnt;
      break;
    }
    ++cnt;
  }
  if (!fullscreen_size_str.empty())
  {
    next_resolution = resolutions.size();
    resolutions.push_back(fullscreen_size_str);
  }

  if (complete)
  {
    // Language and profile changes are only be possible in the
    // main menu, since elsewhere it might not always work fully
    add_submenu(_("Select Language"), MenuStorage::LANGUAGE_MENU)
      ->set_help(_("Select a different language to display text in"));

    add_submenu(_("Select Profile"), MenuStorage::PROFILE_MENU)
      ->set_help(_("Select a profile to play with"));
  }

  add_toggle(MNID_FULLSCREEN,_("Fullscreen"), &g_config->use_fullscreen)
    ->set_help(_("Fill the entire screen"));

  MenuItem* fullscreen_res = add_string_select(MNID_FULLSCREEN_RESOLUTION, _("Resolution"), &next_resolution, resolutions);
  fullscreen_res->set_help(_("Determine the resolution used in fullscreen mode (you must toggle fullscreen to complete the change)"));

  MenuItem* magnification = add_string_select(MNID_MAGNIFICATION, _("Magnification"), &next_magnification, magnifications);
  magnification->set_help(_("Change the magnification of the game area"));

  MenuItem* aspect = add_string_select(MNID_ASPECTRATIO, _("Aspect Ratio"), &next_aspect_ratio, aspect_ratios);
  aspect->set_help(_("Adjust the aspect ratio"));

  if (SoundManager::current()->is_audio_enabled()) {
    add_toggle(MNID_SOUND, _("Sound"), &g_config->sound_enabled)
      ->set_help(_("Disable all sound effects"));
    add_toggle(MNID_MUSIC, _("Music"), &g_config->music_enabled)
      ->set_help(_("Disable all music"));
  } else {
    add_inactive( _("Sound (disabled)"));
    add_inactive( _("Music (disabled)"));
  }

  add_submenu(_("Setup Keyboard"), MenuStorage::KEYBOARD_MENU)
    ->set_help(_("Configure key-action mappings"));

  add_submenu(_("Setup Joystick"), MenuStorage::JOYSTICK_MENU)
    ->set_help(_("Configure joystick control-action mappings"));

  MenuItem* enable_transitions = add_toggle(MNID_TRANSITIONS, _("Enable transitions"), &g_config->transitions_enabled);
  enable_transitions->set_help(_("Enable screen transitions and smooth menu animation"));

  if (g_config->developer_mode)
  {
    add_toggle(MNID_DEVELOPER_MODE, _("Developer Mode"), &g_config->developer_mode);
  }

  if (g_config->is_christmas() || g_config->christmas_mode)
  {
    add_toggle(MNID_CHRISTMAS_MODE, _("Christmas Mode"), &g_config->christmas_mode);
  }

  add_hl();
  add_back(_("Back"));
}
示例#24
0
void
AddonMenu::refresh()
{
  clear();

  AddonManager& adm = AddonManager::get_instance();

  // refresh list of addons
  m_addons = adm.get_addons();
  
  // sort list
  std::sort(m_addons.begin(), m_addons.end(), generate_addons_menu_sorter);


  add_label(_("Add-ons"));
  add_hl();

  // FIXME: don't use macro, use AddonManager::online_available() or so
#ifdef HAVE_LIBCURL
  add_entry(0, std::string(_("Check Online")));
#else
  add_inactive(0, std::string(_("Check Online (disabled)")));
#endif

  //add_hl();

  for (unsigned int i = 0; i < m_addons.size(); i++) 
  {
    const Addon& addon = *m_addons[i];
    std::string text = "";
    
    if (!addon.kind.empty())
    {
      std::string kind = addon.kind;
      if(addon.kind == "Levelset") {
        kind = _("Levelset");
      }
      else if(addon.kind == "Worldmap") {
        kind = _("Worldmap");
      }
      else if(addon.kind == "World") {
        kind = _("World");
      }
      else if(addon.kind == "Level") {
        kind = _("Level");
      }


      if(!addon.author.empty())
      {
        text = str(boost::format(_("%s \"%s\" by \"%s\""))
                   % kind % addon.title % addon.author);
      }
      else
      {
        // Only addon type and name, no need for translation.
        text = str(boost::format("%s \"%s\"")
                   % kind % addon.title);
      }
    }
    else
    {
      if (!addon.author.empty())
      {
        text = str(boost::format(_("\"%s\" by \"%s\""))
                   % addon.title % addon.author);
      }
      else {
        // Only addon name, no need for translation.
        text = str(boost::format("\"%s\"")
                   % addon.title);
      }
    }
    add_toggle(ADDON_LIST_START_ID + i, text, addon.loaded);
  }

  add_hl();
  add_back(_("Back"));
}
EditorLevelsetSelectMenu::EditorLevelsetSelectMenu() :
  m_contrib_worlds()
{
  Editor::current()->deactivate_request = true;
  // Generating contrib levels list by making use of Level Subset
  std::vector<std::string> level_worlds;

  std::unique_ptr<char*, decltype(&PHYSFS_freeList)>
    files(PHYSFS_enumerateFiles("levels"),
          PHYSFS_freeList);
  for(const char* const* filename = files.get(); *filename != 0; ++filename)
  {
    std::string filepath = FileSystem::join("levels", *filename);
    PHYSFS_Stat statbuf;
    PHYSFS_stat(filepath.c_str(), &statbuf);
    if(statbuf.filetype == PHYSFS_FILETYPE_DIRECTORY)
    {
      level_worlds.push_back(filepath);
    }
  }

  add_label(_("Choose level subset"));
  add_hl();

  int i = 0;
  for (std::vector<std::string>::const_iterator it = level_worlds.begin(); it != level_worlds.end(); ++it)
  {
    try
    {
      std::unique_ptr<World> world = World::load(*it);

      if (!world->hide_from_contribs())
      {
        Savegame savegame(world->get_savegame_filename());
        savegame.load();

        if (world->is_levelset())
        {
          int level_count = 0;

          const auto& state = savegame.get_levelset_state(world->get_basedir());
          for(const auto& level_state : state.level_states)
          {
            if(level_state.filename == "")
              continue;
            level_count += 1;
          }

          std::ostringstream title;
          title << "[" << world->get_title() << "]";
          if (level_count == 0)
          {
            title << " " << _("*NEW*");
          }
          else
          {
            title << " (" << level_count << " " << _("levels") << ")";
          }
          add_entry(i++, title.str());
          m_contrib_worlds.push_back(std::move(world));
        }
        else if (world->is_worldmap())
        {
          int level_count = 0;

          const auto& state = savegame.get_worldmap_state(world->get_worldmap_filename());
          for(const auto& level_state : state.level_states)
          {
            if(level_state.filename == "")
              continue;
            level_count += 1;
          }

          std::ostringstream title;
          title << world->get_title();
          if (level_count == 0)
          {
            title << " " << _("*NEW*");
          }
          else
          {
            title << " (" << level_count << " " << _("levels") << ")";
          }
          add_entry(i++, title.str());
          m_contrib_worlds.push_back(std::move(world));
        }
        else
        {
          log_warning << "unknown World type" << std::endl;
        }
      }
    }
    catch(std::exception& e)
    {
      log_info << "Couldn't parse levelset info for '" << *it << "': " << e.what() << std::endl;
    }
  }

  add_hl();
  add_submenu(_("New level subset"), MenuStorage::EDITOR_NEW_LEVELSET_MENU);
  add_back(_("Back"),-2);
}
示例#26
0
void
FileSystemMenu::refresh_items()
{
  items.clear();
  directories.clear();
  files.clear();
  directory = FileSystem::normalize(directory);

  add_label(directory);
  add_hl();

  int item_id = 0;

  // Do not allow leaving the data directory
  if (directory != "/") {
    directories.push_back("..");
  }

  char** dir_files = PHYSFS_enumerateFiles(directory.c_str());
  if (dir_files)
  {
    for(const char* const* file = dir_files; *file != nullptr; ++file)
    {
      std::string filepath = FileSystem::join(directory, *file);
      if(PhysFSFileSystem::is_directory(filepath))
      {
        directories.push_back(*file);
      }
      else
      {
        if (AddonManager::current()->is_from_old_addon(filepath)) {
          continue;
        }

        if(has_right_suffix(*file))
        {
          files.push_back(*file);
        }
      }
    }
    PHYSFS_freeList(dir_files);
  }

  for(const auto& item : directories)
  {
    add_entry(item_id, "[" + std::string(item) + "]");
    item_id++;
  }

  for(const auto& item : files)
  {
    add_entry(item_id, item);
    item_id++;
  }

  add_hl();
  add_back(_("Cancel"));

  active_item = 2;

  // Re-center menu
  on_window_resize();
}
示例#27
0
void
AddonMenu::rebuild_menu()
{
  clear();
  add_label(_("Add-ons"));
  add_hl();


  if (m_installed_addons.empty())
  {
    if (!m_repository_addons.empty())
    {
      add_inactive(MNID_NOTHING_NEW, _("No Addons installed"));
    }
    else
    {
      add_inactive(MNID_NOTHING_NEW, _("No Addons found"));
    }
  }
  else
  {
    int idx = 0;
    for (const auto& addon_id : m_installed_addons)
    {
      const Addon& addon = m_addon_manager.get_installed_addon(addon_id);
      std::string text = generate_menu_item_text(addon);
      add_toggle(MAKE_INSTALLED_MENU_ID(idx), text, addon.is_enabled());
      idx += 1;
    }
  }

  add_hl();

  {
    bool have_new_stuff = false;
    int idx = 0;
    for (const auto& addon_id : m_repository_addons)
    {
      const Addon& addon = m_addon_manager.get_repository_addon(addon_id);
      try
      {
        // addon is already installed, so check if they are the same
        Addon& installed_addon = m_addon_manager.get_installed_addon(addon_id);
        if (installed_addon.get_md5() == addon.get_md5() ||
            installed_addon.get_version() > addon.get_version())
        {
          log_debug << "ignoring already installed addon " << installed_addon.get_id() << std::endl;
        }
        else
        {
          log_debug << installed_addon.get_id() << " is installed, but updated: '"
                    << installed_addon.get_md5() << "' vs '" << addon.get_md5() << "'  '"
                    << installed_addon.get_version() << "' vs '" << addon.get_version() << "'"
                    << std::endl;
          std::string text = generate_menu_item_text(addon);
          add_entry(MAKE_REPOSITORY_MENU_ID(idx), str(boost::format( _("Install %s *NEW*") ) % text));
          have_new_stuff = true;
        }
      }
      catch(const std::exception& err)
      {
        // addon is not installed
        std::string text = generate_menu_item_text(addon);
        add_entry(MAKE_REPOSITORY_MENU_ID(idx), str(boost::format( _("Install %s") ) % text));
        have_new_stuff = true;
      }
      idx += 1;
    }

    if (!have_new_stuff && m_addon_manager.has_been_updated())
    {
      add_inactive(MNID_NOTHING_NEW, _("No new Addons found"));
    }
  }

  if (!m_addon_manager.has_online_support())
  {
    add_inactive(MNID_CHECK_ONLINE, std::string(_("Check Online (disabled)")));
  }
  else
  {
    add_entry(MNID_CHECK_ONLINE, std::string(_("Check Online")));
  }

  add_hl();
  add_back(_("Back"));
}