void load_json_dir(std::string const &dirname)
{
// get a list of all files in the directory
std::vector<std::string> dir =
get_files_from_path(".json", dirname, true, true);
// iterate over each file
std::vector<std::string>::iterator it;
for (it = dir.begin(); it != dir.end(); it++) {
// open the file as a stream
std::ifstream infile(it->c_str(), std::ifstream::in | std::ifstream::binary);
// and stuff it into ram
std::istringstream iss(
std::string(
(std::istreambuf_iterator<char>(infile)),
std::istreambuf_iterator<char>()
)
);
infile.close();
// parse it
try {
JsonIn jsin(iss);
load_all_from_json(jsin);
} catch( const JsonError &err ) {
throw std::runtime_error( *(it) + ": " + err.what() );
}
}
}
WORLDPTR worldfactory::convert_to_world(std::string origin_path)
{
// prompt for worldname? Nah, just make a worldname... the user can fix it later if they really don't want this as a name...
std::string worldname = get_next_valid_worldname();
// check and loop on validity
// create world informations
WORLDPTR newworld = new WORLD();
newworld->world_name = worldname;
std::stringstream path;
path << FILENAMES["savedir"] << worldname;
newworld->world_path = path.str();
// save world as conversion world
if (save_world(newworld, true)) {
// move files from origin_path into new world path
for( auto &origin_file : get_files_from_path(".", origin_path, false) ) {
std::string filename = origin_file.substr( origin_file.find_last_of( "/\\" ) );
rename( origin_file.c_str(), std::string( newworld->world_path + filename ).c_str() );
}
DebugLog( D_INFO, DC_ALL ) << "worldfactory::convert_to_world -- World Converted Successfully!";
return newworld;
} else {
// something horribly wrong happened
DebugLog( D_ERROR, DC_ALL ) << "worldfactory::convert_to_world -- World Conversion Failed!";
return NULL;
}
}
void mod_manager::load_mods_from(std::string path)
{
for( auto &mod_file : get_files_from_path(MOD_SEARCH_FILE, path, true) ) {
load_mod_info( mod_file );
}
if (file_exist(FILENAMES["mods-dev-default"])) {
load_mod_info(FILENAMES["mods-dev-default"]);
}
if (file_exist(FILENAMES["mods-user-default"])) {
load_mod_info(FILENAMES["mods-user-default"]);
}
}
void DynamicDataLoader::load_data_from_path( const std::string &path, const std::string &src,
loading_ui &ui )
{
assert( !finalized && "Can't load additional data after finalization. Must be unloaded first." );
// We assume that each folder is consistent in itself,
// and all the previously loaded folders.
// E.g. the core might provide a vpart "frame-x"
// the first loaded mode might provide a vehicle that uses that frame
// But not the other way round.
// get a list of all files in the directory
str_vec files = get_files_from_path( ".json", path, true, true );
if( files.empty() ) {
std::ifstream tmp( path.c_str(), std::ios::in );
if( tmp ) {
// path is actually a file, don't checking the extension,
// assume we want to load this file anyway
files.push_back( path );
}
}
// iterate over each file
for( auto &files_i : files ) {
const std::string &file = files_i;
// open the file as a stream
std::ifstream infile( file.c_str(), std::ifstream::in | std::ifstream::binary );
// and stuff it into ram
std::istringstream iss(
std::string(
( std::istreambuf_iterator<char>( infile ) ),
std::istreambuf_iterator<char>()
)
);
try {
// parse it
JsonIn jsin( iss );
load_all_from_json( jsin, src, ui, path, file );
} catch( const JsonError &err ) {
throw std::runtime_error( file + ": " + err.what() );
}
}
}
std::map<std::string, WORLDPTR> worldfactory::get_all_worlds()
{
std::map<std::string, WORLDPTR> retworlds;
std::vector<std::string> qualifiers;
qualifiers.push_back(WORLD_OPTION_FILE);
qualifiers.push_back(SAVE_MASTER);
if (!all_worlds.empty()) {
for( auto &elem : all_worlds ) {
delete elem.second;
}
all_worlds.clear();
all_worldnames.clear();
}
// get the master files. These determine the validity of a world
// worlds exist by having an option file
// create worlds
for( const auto &world_dir : get_directories_with(qualifiers, FILENAMES["savedir"], true) ) {
// get the option file again
// we can assume that there is only one master.gsav, so just collect the first path
bool no_options = true;
auto const detected_world_op = get_files_from_path( WORLD_OPTION_FILE, world_dir, false );
if ( ! detected_world_op.empty() ) {
no_options = false;
}
// get the save files
auto world_sav_files = get_files_from_path( SAVE_EXTENSION, world_dir, false );
// split the save file names between the directory and the extension
for( auto &world_sav_file : world_sav_files ) {
size_t save_index = world_sav_file.find( SAVE_EXTENSION );
world_sav_file = world_sav_file.substr( world_dir.size() + 1,
save_index - ( world_dir.size() + 1 ) );
}
// the directory name is the name of the world
std::string worldname;
unsigned name_index = world_dir.find_last_of( "/\\" );
worldname = world_dir.substr( name_index + 1 );
// create and store the world
retworlds[worldname] = new WORLD();
// give the world a name
retworlds[worldname]->world_name = worldname;
all_worldnames.push_back(worldname);
// add sav files
for( auto &world_sav_file : world_sav_files ) {
retworlds[worldname]->world_saves.push_back( world_sav_file );
}
// set world path
retworlds[worldname]->world_path = world_dir;
mman->load_mods_list(retworlds[worldname]);
// load options into the world
if ( no_options ) {
for( auto &elem : OPTIONS ) {
if( elem.second.getPage() == "world_default" ) {
retworlds[worldname]->world_options[elem.first] = elem.second;
}
}
retworlds[worldname]->world_options["DELETE_WORLD"].setValue("yes");
save_world(retworlds[worldname]);
} else {
retworlds[worldname]->world_options = get_world_options(detected_world_op[0]);
}
}
// check to see if there exists a worldname "save" which denotes that a world exists in the save
// directory and not in a sub-world directory
if (retworlds.find("save") != retworlds.end()) {
WORLDPTR converted_world = convert_to_world(retworlds["save"]->world_path);
if (converted_world) {
converted_world->world_saves = retworlds["save"]->world_saves;
converted_world->world_options = retworlds["save"]->world_options;
std::vector<std::string>::iterator oldindex = std::find(all_worldnames.begin(),
all_worldnames.end(), "save");
delete retworlds["save"];
retworlds.erase("save");
all_worldnames.erase(oldindex);
retworlds[converted_world->world_name] = converted_world;
all_worldnames.push_back(converted_world->world_name);
}
}
all_worlds = retworlds;
return retworlds;
}
bool main_menu::opening_screen()
{
// Play title music, whoo!
play_music( "title" );
world_generator->set_active_world( NULL );
world_generator->init();
init_windows();
init_strings();
print_menu( w_open, 0, iMenuOffsetX, iMenuOffsetY );
if( !assure_dir_exist( FILENAMES["config_dir"] ) ) {
popup( _( "Unable to make config directory. Check permissions." ) );
return false;
}
if( !assure_dir_exist( FILENAMES["savedir"] ) ) {
popup( _( "Unable to make save directory. Check permissions." ) );
return false;
}
if( !assure_dir_exist( FILENAMES["templatedir"] ) ) {
popup( _( "Unable to make templates directory. Check permissions." ) );
return false;
}
for( std::string path : get_files_from_path( ".template", FILENAMES["templatedir"], false,
true ) ) {
path = native_to_utf8( path );
path.erase( path.find( ".template" ), std::string::npos );
path.erase( 0, path.find_last_of( "\\//" ) + 1 );
templates.push_back( path );
}
std::sort( templates.begin(), templates.end(), std::greater<std::string>() );
ctxt.register_cardinal();
ctxt.register_action( "QUIT" );
ctxt.register_action( "CONFIRM" );
ctxt.register_action( "DELETE_TEMPLATE" );
// for the menu shortcuts
ctxt.register_action( "ANY_INPUT" );
bool start = false;
g->u = player();
// Make [Load Game] the default cursor position if there's game save available
if( !world_generator->all_worldnames().empty() ) {
sel1 = 2;
}
while( !start ) {
print_menu( w_open, sel1, iMenuOffsetX, iMenuOffsetY, ( sel1 != 0 ) );
if( layer == 1 ) {
if( sel1 == 0 ) { // Print the MOTD.
const int motdy = ( iMenuOffsetY - mmenu_motd.size() ) * 2 / 3;
const int motdx = 8 + extra_w / 2;
for( size_t i = 0; i < mmenu_motd.size(); i++ ) {
mvwprintz( w_open, motdy + i, motdx, c_light_red, mmenu_motd[i].c_str() );
}
wrefresh( w_open );
catacurses::refresh();
}
std::string action = handle_input_timeout( ctxt );
std::string sInput = ctxt.get_raw_input().text;
// check automatic menu shortcuts
for( size_t i = 0; i < vMenuHotkeys.size(); ++i ) {
for( auto hotkey : vMenuHotkeys[i] ) {
if( sInput == hotkey ) {
sel1 = i;
action = "CONFIRM";
}
}
}
// also check special keys
if( action == "QUIT" ) {
if( query_yn( _( "Really quit?" ) ) ) {
sel1 = 8;
action = "CONFIRM";
}
} else if( action == "LEFT" ) {
if( sel1 > 0 ) {
sel1--;
} else {
sel1 = 8;
}
on_move();
} else if( action == "RIGHT" ) {
if( sel1 < 8 ) {
sel1++;
} else {
sel1 = 0;
}
on_move();
}
if( ( action == "UP" || action == "CONFIRM" ) && sel1 > 0 ) {
if( sel1 == 6 ) {
display_help();
} else if( sel1 == 7 ) {
display_credits();
} else if( sel1 == 8 ) {
return false;
} else {
sel2 = 0;
layer = 2;
print_menu( w_open, sel1, iMenuOffsetX, iMenuOffsetY, ( sel1 != 0 ) );
switch( sel1 ) {
case 1:
start = new_character_tab();
break;
case 2:
start = load_character_tab();
break;
case 3:
world_tab();
break;
default:
break;
}
}
}
} else if( layer == 2 ) {
if( sel1 == 4 ) { // Special game
if( MAP_SHARING::isSharing() ) { // Thee can't save special games, therefore thee can't share them
layer = 1;
popup( _( "Special games don't work with shared maps." ) );
continue;
}
std::vector<std::string> special_names;
int xoffset = 32 + iMenuOffsetX + extra_w / 2;
int yoffset = iMenuOffsetY - 2;
int xlen = 0;
for( int i = 1; i < NUM_SPECIAL_GAMES; i++ ) {
std::string spec_name = special_game_name( special_game_id( i ) );
special_names.push_back( spec_name );
xlen += spec_name.size() + 2;
}
xlen += special_names.size() - 1;
print_menu_items( w_open, special_names, sel2, yoffset, xoffset - ( xlen / 4 ) );
wrefresh( w_open );
catacurses::refresh();
std::string action = handle_input_timeout( ctxt );
if( action == "LEFT" ) {
if( sel2 > 0 ) {
sel2--;
} else {
sel2 = NUM_SPECIAL_GAMES - 2;
}
on_move();
} else if( action == "RIGHT" ) {
if( sel2 < NUM_SPECIAL_GAMES - 2 ) {
sel2++;
} else {
sel2 = 0;
}
on_move();
} else if( action == "DOWN" || action == "QUIT" ) {
layer = 1;
}
if( action == "UP" || action == "CONFIRM" ) {
if( sel2 >= 0 && sel2 < NUM_SPECIAL_GAMES - 1 ) {
g->gamemode = get_special_game( special_game_id( sel2 + 1 ) );
// check world
WORLDPTR world = world_generator->make_new_world( special_game_id( sel2 + 1 ) );
if( world == NULL ) {
continue;
}
world_generator->set_active_world( world );
try {
g->setup();
} catch( const std::exception &err ) {
debugmsg( "Error: %s", err.what() );
g->gamemode.reset();
g->u = player();
continue;
}
if( !g->gamemode->init() ) {
g->gamemode.reset();
g->u = player();
continue;
}
start = true;
}
}
} else if( sel1 == 5 ) { // Settings Menu
int settings_subs_to_display = vSettingsSubItems.size();
std::vector<std::string> settings_subs;
int xoffset = 46 + iMenuOffsetX + extra_w / 2;
int yoffset = iMenuOffsetY - 2;
int xlen = 0;
for( int i = 0; i < settings_subs_to_display; ++i ) {
settings_subs.push_back( vSettingsSubItems[i] );
xlen += vSettingsSubItems[i].size() + 2; // Open and close brackets added
}
xlen += settings_subs.size() - 1;
if( settings_subs.size() > 1 ) {
xoffset -= 6;
}
print_menu_items( w_open, settings_subs, sel2, yoffset, xoffset - ( xlen / 4 ) );
wrefresh( w_open );
catacurses::refresh();
std::string action = handle_input_timeout( ctxt );
std::string sInput = ctxt.get_raw_input().text;
for( int i = 0; i < settings_subs_to_display; ++i ) {
for( auto hotkey : vSettingsHotkeys[i] ) {
if( sInput == hotkey ) {
sel2 = i;
action = "CONFIRM";
}
}
}
if( action == "LEFT" ) {
if( sel2 > 0 ) {
--sel2;
} else {
sel2 = settings_subs_to_display - 1;
}
on_move();
} else if( action == "RIGHT" ) {
if( sel2 < settings_subs_to_display - 1 ) {
++sel2;
} else {
sel2 = 0;
}
on_move();
} else if( action == "DOWN" || action == "QUIT" ) {
layer = 1;
}
if( action == "UP" || action == "CONFIRM" ) {
if( sel2 == 0 ) {
get_options().show( true );
// The language may have changed- gracefully handle this.
init_strings();
print_menu( w_open, sel1, iMenuOffsetX, iMenuOffsetY, ( sel1 != 0 ) );
} else if( sel2 == 1 ) {
input_context ctxt_default = get_default_mode_input_context();
ctxt_default.display_menu();
} else if( sel2 == 2 ) {
get_auto_pickup().show();
} else if( sel2 == 3 ) {
get_safemode().show();
} else if( sel2 == 4 ) {
all_colors.show_gui();
}
}
}
}
}
if( start ) {
g->refresh_all();
g->draw();
}
return start;
}
void color_manager::show_gui()
{
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::vector<int> vLines;
vLines.push_back(-1);
vLines.push_back(48);
const int iTotalCols = vLines.size();
WINDOW *w_colors_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_colors_helpptr( w_colors_help );
WINDOW *w_colors_border = newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, iOffsetY, iOffsetX);
WINDOW_PTR w_colors_borderptr( w_colors_border );
WINDOW *w_colors_header = newwin(iHeaderHeight, FULL_SCREEN_WIDTH - 2, 1 + iOffsetY,
1 + iOffsetX);
WINDOW_PTR w_colors_headerptr( w_colors_header );
WINDOW *w_colors = newwin(iContentHeight, FULL_SCREEN_WIDTH - 2, iHeaderHeight + 1 + iOffsetY,
1 + iOffsetX);
WINDOW_PTR w_colorsptr( w_colors );
draw_border( w_colors_border, BORDER_COLOR, _( " COLOR MANAGER " ) );
mvwputch(w_colors_border, 3, 0, c_ltgray, LINE_XXXO); // |-
mvwputch(w_colors_border, 3, 79, c_ltgray, LINE_XOXX); // -|
for (int i = 0; i < 78; i++) {
mvwputch(w_colors_header, 2, i, c_ltgray, LINE_OXOX); // Draw line under header
}
for( auto &iCol : vLines ) {
if ( iCol > -1 ) {
mvwputch(w_colors_border, FULL_SCREEN_HEIGHT - 1, iCol + 1, c_ltgray, LINE_XXOX); // _|_
mvwputch(w_colors_header, 2, iCol, c_ltgray, LINE_OXXX);
mvwputch(w_colors_header, 3, iCol, c_ltgray, LINE_XOXO);
}
}
wrefresh(w_colors_border);
int tmpx = 0;
tmpx += shortcut_print(w_colors_header, 0, tmpx, c_white, c_ltgreen, _("<R>emove custom color")) + 2;
tmpx += shortcut_print(w_colors_header, 0, tmpx, c_white, c_ltgreen, _("<Arrow Keys> To navigate")) + 2;
tmpx += shortcut_print(w_colors_header, 0, tmpx, c_white, c_ltgreen, _("<Enter>-Edit")) + 2;
shortcut_print(w_colors_header, 0, tmpx, c_white, c_ltgreen, _("Load <T>emplate"));
mvwprintz(w_colors_header, 1, 0, c_white, _("Some color changes may require a restart."));
mvwprintz(w_colors_header, 3, 3, c_white, _("Colorname"));
mvwprintz(w_colors_header, 3, 21, c_white, _("Normal"));
mvwprintz(w_colors_header, 3, 52, c_white, _("Invert"));
wrefresh(w_colors_header);
int iCurrentLine = 0;
int iCurrentCol = 1;
int iStartPos = 0;
const int iMaxColors = color_array.size();
bool bStuffChanged = false;
input_context ctxt("COLORS");
ctxt.register_cardinal();
ctxt.register_action("CONFIRM");
ctxt.register_action("QUIT");
ctxt.register_action("REMOVE_CUSTOM");
ctxt.register_action("LOAD_TEMPLATE");
ctxt.register_action("HELP_KEYBINDINGS");
std::map<std::string, color_struct> name_color_map;
for( const auto &pr : name_map ) {
name_color_map[pr.first] = color_array[pr.second];
}
while(true) {
// Clear all lines
for (int i = 0; i < iContentHeight; i++) {
for (int j = 0; j < 79; j++) {
mvwputch(w_colors, i, j, c_black, ' ');
for( auto &iCol : vLines ) {
if ( iCol == j ) {
mvwputch(w_colors, i, j, c_ltgray, LINE_XOXO);
}
}
}
}
calcStartPos(iStartPos, iCurrentLine, iContentHeight, iMaxColors);
draw_scrollbar(w_colors_border, iCurrentLine, iContentHeight, iMaxColors, 5);
wrefresh(w_colors_border);
auto iter = name_color_map.begin();
std::advance( iter, iStartPos );
std::string sActive = "";
// display colormanager
for (int i=iStartPos; iter != name_color_map.end(); ++iter, ++i) {
if (i >= iStartPos && i < iStartPos + ((iContentHeight > iMaxColors) ? iMaxColors : iContentHeight)) {
auto &entry = iter->second;
if (iCurrentLine == i) {
sActive = iter->first;
mvwprintz(w_colors, i - iStartPos, vLines[iCurrentCol-1] + 2, c_yellow, ">");
}
mvwprintz(w_colors, i - iStartPos, 3, c_white, iter->first.c_str()); //colorname
mvwprintz(w_colors, i - iStartPos, 21, entry.color, _("default")); //default color
if ( !entry.name_custom.empty() ) {
mvwprintz(w_colors, i - iStartPos, 30, name_color_map[entry.name_custom].color, entry.name_custom.c_str()); //custom color
}
mvwprintz(w_colors, i - iStartPos, 52, entry.invert, _("default")); //invert default color
if ( !entry.name_invert_custom.empty() ) {
mvwprintz(w_colors, i - iStartPos, 61, name_color_map[entry.name_invert_custom].color, entry.name_invert_custom.c_str()); //invert custom color
}
}
}
wrefresh(w_colors);
const std::string action = ctxt.handle_input();
if (action == "QUIT") {
break;
} else if (action == "UP") {
iCurrentLine--;
if (iCurrentLine < 0) {
iCurrentLine = iMaxColors - 1;
}
} else if (action == "DOWN") {
iCurrentLine++;
if (iCurrentLine >= (int)iMaxColors) {
iCurrentLine = 0;
}
} else if (action == "LEFT") {
iCurrentCol--;
if (iCurrentCol < 1) {
iCurrentCol = iTotalCols;
}
} else if (action == "RIGHT") {
iCurrentCol++;
if (iCurrentCol > iTotalCols) {
iCurrentCol = 1;
}
} else if (action == "REMOVE_CUSTOM") {
auto &entry = name_color_map[sActive];
if ( iCurrentCol == 1 && !entry.name_custom.empty() ) {
bStuffChanged = true;
entry.name_custom = "";
} else if ( iCurrentCol == 2 && !entry.name_invert_custom.empty() ) {
bStuffChanged = true;
entry.name_invert_custom = "";
}
finalize(); // Need to recalculate caches
} else if (action == "LOAD_TEMPLATE") {
auto vFiles = get_files_from_path(".json", FILENAMES["color_templates"], false, true);
if ( vFiles.size() > 0 ) {
uimenu ui_templates;
ui_templates.w_y = iHeaderHeight + 1 + iOffsetY;
ui_templates.w_height = 18;
ui_templates.return_invalid = true;
ui_templates.text = _("Color templates:");
for ( const auto& filename : vFiles ) {
ui_templates.addentry( filename.substr(filename.find_last_of("/") + 1) );
}
ui_templates.addentry(std::string(_("Cancel")));
ui_templates.query();
if ( (size_t)ui_templates.ret < vFiles.size() ) {
bStuffChanged = true;
clear();
load_default();
load_custom(vFiles[ui_templates.ret]);
name_color_map.clear();
for( const auto &pr : name_map ) {
name_color_map[pr.first] = color_array[pr.second];
}
}
}
finalize(); // Need to recalculate caches
} else if (action == "CONFIRM") {
uimenu ui_colors;
ui_colors.w_y = iHeaderHeight + 1 + iOffsetY;
ui_colors.w_height = 18;
ui_colors.return_invalid = true;
std::string sColorType = _("Normal");
std::string sSelected = name_color_map[sActive].name_custom;
if ( iCurrentCol == 2 ) {
sColorType = _("Invert");
sSelected = name_color_map[sActive].name_invert_custom;
}
ui_colors.text = string_format( _("Custom %s color:"), sColorType.c_str() );
int i = 0;
for ( auto &iter : name_color_map ) {
std::string sColor = iter.first;
std::string sType = _("default");
std::string name_custom = "";
if ( sSelected == sColor ) {
ui_colors.selected = i;
}
if ( !iter.second.name_custom.empty() ) {
name_custom = " <color_" + iter.second.name_custom + ">" + iter.second.name_custom + "</color>";
}
ui_colors.addentry(string_format( "%-17s <color_%s>%s</color>%s", iter.first.c_str(), sColor.c_str(), sType.c_str(), name_custom.c_str() ) );
i++;
}
ui_colors.addentry(std::string(_("Cancel")));
ui_colors.query();
if ( (size_t)ui_colors.ret < name_color_map.size() ) {
bStuffChanged = true;
iter = name_color_map.begin();
std::advance( iter, ui_colors.ret );
auto &entry = name_color_map[sActive];
if ( iCurrentCol == 1 ) {
entry.name_custom = iter->first;
} else if ( iCurrentCol == 2 ) {
entry.name_invert_custom = iter->first;
}
}
finalize(); // Need to recalculate caches
}
}
if( bStuffChanged && query_yn(_("Save changes?") ) ) {
for( const auto &pr : name_color_map ) {
color_id id = name_to_id( pr.first );
color_array[id].name_custom = pr.second.name_custom;
color_array[id].name_invert_custom = pr.second.name_invert_custom;
}
finalize();
save_custom();
clear();
load_default();
load_custom();
}
}
bool mod_manager::copy_mod_contents(const t_mod_list &mods_to_copy,
const std::string &output_base_path)
{
if (mods_to_copy.empty()) {
// nothing to copy, so technically we succeeded already!
return true;
}
std::vector<std::string> search_extensions;
search_extensions.push_back(".json");
DebugLog( D_INFO, DC_ALL ) << "Copying mod contents into directory: " << output_base_path;
if (!assure_dir_exist(output_base_path)) {
DebugLog( D_ERROR, DC_ALL ) << "Unable to create or open mod directory at [" << output_base_path <<
"] for saving";
return false;
}
std::ostringstream number_stream;
for (size_t i = 0; i < mods_to_copy.size(); ++i) {
number_stream.str(std::string());
number_stream.width(5);
number_stream.fill('0');
number_stream << (i + 1);
MOD_INFORMATION &mod = *mod_map[mods_to_copy[i]];
size_t start_index = mod.path.size();
// now to get all of the json files inside of the mod and get them ready to copy
auto input_files = get_files_from_path(".json", mod.path, true, true);
auto input_dirs = get_directories_with(search_extensions, mod.path, true);
if (input_files.empty() && mod.path.find(MOD_SEARCH_FILE) != std::string::npos) {
// Self contained mod, all data is inside the modinfo.json file
input_files.push_back(mod.path);
start_index = mod.path.find_last_of("/\\");
if (start_index == std::string::npos) {
start_index = 0;
}
}
if (input_files.empty()) {
continue;
}
// create needed directories
std::ostringstream cur_mod_dir;
cur_mod_dir << output_base_path << "/mod_" << number_stream.str();
std::queue<std::string> dir_to_make;
dir_to_make.push(cur_mod_dir.str());
for( auto &input_dir : input_dirs ) {
dir_to_make.push( cur_mod_dir.str() + "/" + input_dir.substr( start_index ) );
}
while (!dir_to_make.empty()) {
if (!assure_dir_exist(dir_to_make.front())) {
DebugLog( D_ERROR, DC_ALL ) << "Unable to create or open mod directory at [" <<
dir_to_make.front() << "] for saving";
}
dir_to_make.pop();
}
std::ofstream fout;
// trim file paths from full length down to just /data forward
for( auto &input_file : input_files ) {
std::string output_path = input_file;
output_path = cur_mod_dir.str() + output_path.substr(start_index);
std::ifstream infile( input_file.c_str(), std::ifstream::in | std::ifstream::binary );
// and stuff it into ram
std::istringstream iss(
std::string(
(std::istreambuf_iterator<char>(infile)),
std::istreambuf_iterator<char>()
)
);
infile.close();
fout.open(output_path.c_str());
fout << iss.str();
fout.close();
}
}
return true;
}
