bool deleteAll(const char* filePath, bool deleteRoot)
{
PHYSFS_Stat fileStat;
if (PHYSFS_stat(filePath, &fileStat) == 0)
{
return false;
}
bool ret = false;
if (fileStat.filetype == PHYSFS_FILETYPE_DIRECTORY)
{
auto paths = PHYSFS_enumerateFiles(filePath);
if (paths != nullptr)
{
auto writeDir = PHYSFS_getWriteDir();
if (writeDir != nullptr)
{
for (char** path = paths; *path != nullptr; path++)
{
auto fullPath = std::string(filePath) + '/' + *path;
if (PHYSFS_stat(fullPath.c_str(), &fileStat) == 0)
{
continue;
}
if (fileStat.filetype == PHYSFS_FILETYPE_DIRECTORY)
{
deleteAll(fullPath.c_str(), true);
}
else
{
auto realDir = PHYSFS_getRealDir(fullPath.c_str());
if (realDir != nullptr)
{
if (std::strcmp(writeDir, realDir) == 0)
{
ret = PHYSFS_delete(fullPath.c_str()) != 0;
}
}
}
}
}
PHYSFS_freeList(paths);
}
if (deleteRoot == true)
{
ret = PHYSFS_delete(filePath) != 0;
}
}
else
{
ret = PHYSFS_delete(filePath) != 0;
}
return ret;
}
bool copyDir(const char* dirSrcName, const char* dirDstName)
{
PHYSFS_Stat stat;
if (PHYSFS_stat(dirSrcName, &stat) == 0 ||
stat.filetype != PHYSFS_FILETYPE_DIRECTORY)
{
return false;
}
if (PHYSFS_stat(dirDstName, &stat) != 0 &&
stat.filetype != PHYSFS_FILETYPE_DIRECTORY)
{
return false;
}
createDir(dirDstName);
auto paths = PHYSFS_enumerateFiles(dirSrcName);
if (paths != nullptr)
{
for (char** path = paths; *path != nullptr; path++)
{
auto fullSrcPath = std::string(dirSrcName) + '/' + *path;
auto fullDstPath = std::string(dirDstName) + '/' + *path;
if (PHYSFS_stat(fullSrcPath.c_str(), &stat) == 0)
{
continue;
}
if (stat.filetype == PHYSFS_FILETYPE_DIRECTORY)
{
copyDir(fullSrcPath.c_str(), fullDstPath.c_str());
}
else
{
// copy file (read source file and write destination)
sf::PhysFSStream fileRead(fullSrcPath);
auto fileWrite = PHYSFS_openWrite(fullDstPath.c_str());
if (fileRead.hasError() == false &&
fileWrite != nullptr)
{
std::vector<uint8_t> data((size_t)fileRead.getSize());
fileRead.read(data.data(), fileRead.getSize());
PHYSFS_writeBytes(fileWrite, data.data(), data.size());
PHYSFS_close(fileWrite);
}
}
}
PHYSFS_freeList(paths);
return true;
}
return false;
}
bool
PhysFSFileSystem::is_directory(const std::string& filename)
{
PHYSFS_Stat statbuf;
PHYSFS_stat(filename.c_str(), &statbuf);
return statbuf.filetype == PHYSFS_FILETYPE_DIRECTORY;
}
bool ex_fsys_issymlink ( const char *_path ) {
#if 0
PHYSFS_Stat stat;
if ( PHYSFS_stat( _path, &stat ) == 0 ) {
ex_error ( "error: %s", PHYSFS_getLastError() );
return false;
}
return (stat.filetype == PHYSFS_FILETYPE_SYMLINK);
#else
return PHYSFS_isSymbolicLink(_path);
#endif
}
bool ex_fsys_isfile ( const char *_path ) {
#if 0
PHYSFS_Stat stat;
if ( PHYSFS_stat( _path, &stat ) == 0 ) {
ex_error ( "error: %s", PHYSFS_getLastError() );
return false;
}
return (stat.filetype == PHYSFS_FILETYPE_REGULAR);
#else
return !PHYSFS_isDirectory(_path);
#endif
}
std::vector<std::string> geDirList(const std::string_view path,
const std::string_view rootPath)
{
std::vector<std::string> vecDirs;
auto dirs = PHYSFS_enumerateFiles(path.data());
if (dirs != nullptr)
{
PHYSFS_Stat fileStat;
for (char** dir = dirs; *dir != nullptr; dir++)
{
if (PHYSFS_stat(*dir, &fileStat) == 0)
{
continue;
}
if (fileStat.filetype != PHYSFS_FILETYPE_DIRECTORY)
{
continue;
}
if (**dir == '.')
{
continue;
}
if (rootPath.empty() == false)
{
auto realDir = PHYSFS_getRealDir(*dir);
if (realDir != nullptr)
{
if (rootPath != realDir)
{
continue;
}
}
}
vecDirs.push_back(*dir);
}
PHYSFS_freeList(dirs);
}
return vecDirs;
}
std::vector<std::string> getFileList(const std::string_view filePath,
const std::string_view fileExt, bool getFullPath)
{
std::vector<std::string> vec;
auto files = PHYSFS_enumerateFiles(filePath.data());
if (files != nullptr)
{
PHYSFS_Stat fileStat;
for (char** file = files; *file != nullptr; file++)
{
auto file2 = std::string(filePath) + '/' + std::string(*file);
if (Utils::endsWith(file2, fileExt) == false)
{
continue;
}
if (PHYSFS_stat(file2.c_str(), &fileStat) == 0)
{
continue;
}
if (fileStat.filetype == PHYSFS_FILETYPE_REGULAR)
{
if (getFullPath == true)
{
vec.push_back(file2);
}
else
{
vec.push_back(std::string(*file));
}
}
}
PHYSFS_freeList(files);
}
return vec;
}
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);
}
