void FS_Init(const char *argv0) { int err = PHYSFS_init(argv0); if (err == 0) { Con_Errorf(ERR_FATAL, "Error in PHYSFS_init: %s", PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode())); return; } const char *baseDir = PHYSFS_getBaseDir(); fs_basepath = Con_GetVarDefault("fs.basepath", baseDir, CONVAR_STARTUP); fs_basegame = Con_GetVarDefault("fs.basegame", "base", CONVAR_STARTUP); fs_game = Con_GetVarDefault("fs.game", DEFAULT_GAME, CONVAR_STARTUP); bool modLoaded = fs_game->string[0] != '\0'; char **baseFiles, **gameFiles; // get the file listing for the basegame dir, then immediately unmount const char *fullBasePath = tempstr("%s/%s", fs_basepath->string, fs_basegame->string); PHYSFS_mount(fullBasePath, "/", 1); baseFiles = PHYSFS_enumerateFiles("/"); PHYSFS_removeFromSearchPath(fullBasePath); // if fs_game is set, do the same thing for the fs_game dir if (modLoaded) { const char *fullGamePath = tempstr("%s/%s", fs_basepath->string, fs_game->string); PHYSFS_mount(fullGamePath, "/", 1); gameFiles = PHYSFS_enumerateFiles("/"); PHYSFS_removeFromSearchPath(fullGamePath); // mount the mod dir first, then mount mod PK3s PHYSFS_mount(tempstr("%s/%s", fs_basepath->string, fs_game->string), "/", 1); FS_AddPaksFromList(gameFiles, fs_basepath->string, fs_game->string); PHYSFS_freeList(gameFiles); } // then mount the base game dir, then the mount base game PK3s PHYSFS_mount(tempstr("%s/%s", fs_basepath->string, fs_basegame->string), "/", 1); FS_AddPaksFromList(baseFiles, fs_basepath->string, fs_basegame->string); PHYSFS_freeList(baseFiles); // print all the files we've found in order of priority Con_Printf("Current filesystem search path:\n"); PHYSFS_getSearchPathCallback(printSearchPath, NULL); Con_Printf("\n"); // add command handler for dir to view virtual filesystem Con_AddCommand("dir", Cmd_Dir_f); }
static int Lua_FS_setSearchPath(lua_State *L) { const char *str; char **search_path = PHYSFS_getSearchPath(); char **copy = search_path; int n, maxn; luaL_checktype(L, 1, LUA_TTABLE); /* clear the search path */ while (*copy != NULL) { PHYSFS_removeFromSearchPath(*copy++); } PHYSFS_freeList(search_path); maxn = lua_objlen(L, 1); for (n = 1; n <= maxn; n++) { lua_pushinteger(L, n); lua_gettable(L, -2); str = lua_tostring(L, -1); if (PHYSFS_addToSearchPath(str, 1) == 0) { return luaL_error(L, "Error: Could not add directory or archive '%s' " "to search path: %s", str, PHYSFS_getLastError()); } /* remove the string */ lua_pop(L, 1); } return 0; }
void AddonManager::disable_addon(const AddonId& addon_id) { log_debug << "disabling addon " << addon_id << std::endl; Addon& addon = get_installed_addon(addon_id); if (!addon.is_enabled()) { log_warning << "Tried disabling already disabled Add-On" << std::endl; } else { log_debug << "Removing archive \"" << addon.get_install_filename() << "\" from search path" << std::endl; if (PHYSFS_removeFromSearchPath(addon.get_install_filename().c_str()) == 0) { log_warning << "Could not remove " << addon.get_install_filename() << " from search path: " << PHYSFS_getLastError() << std::endl; } else { if(addon.get_type() == Addon::LANGUAGEPACK) { PHYSFS_enumerateFilesCallback(addon.get_id().c_str(), remove_from_dictionary_path, NULL); } addon.set_enabled(false); } } }
void removeSubdirs( const char * basedir, const char * subdir, char * checkList[] ) { char tmpstr[PATH_MAX]; char ** subdirlist = PHYSFS_enumerateFiles( subdir ); char ** i = subdirlist; while( *i != NULL ) { #ifdef DEBUG debug( LOG_NEVER, "removeSubdirs: Examining subdir: [%s]", *i ); #endif // DEBUG if( !checkList || inList( checkList, *i ) ) { snprintf(tmpstr, sizeof(tmpstr), "%s%s%s%s", basedir, subdir, PHYSFS_getDirSeparator(), *i); #ifdef DEBUG debug( LOG_NEVER, "removeSubdirs: Removing [%s] from search path", tmpstr ); #endif // DEBUG if (!PHYSFS_removeFromSearchPath( tmpstr )) { #ifdef DEBUG // spams a ton! debug(LOG_NEVER, "Couldn't remove %s from search path because %s", tmpstr, PHYSFS_getLastError()); #endif // DEBUG } } i++; } PHYSFS_freeList( subdirlist ); }
bool ResourceManager::removeFromSearchPath(const std::string& path) { if(!PHYSFS_removeFromSearchPath(path.c_str())) return false; //g_logger.debug(stdext::format("Remove search path %s", path)); return true; }
bool Resources::removeFromSearchPath(const char* directory) { if(!PHYSFS_removeFromSearchPath(directory)) { PError << "Couldn't remove '" << directory << "' from searchpath: " << PHYSFS_getLastError() << endl; return PFalse; }; return PTrue; }
int ex_fsys_unmount ( const char *_dir ) { #if 0 __PHYSFS_CHECK( PHYSFS_unmount(_dir) ); return 0; #else __PHYSFS_CHECK( PHYSFS_removeFromSearchPath(_dir) ); return 0; #endif }
bool CResourceManager::RemoveLocation(const std::string &location) { if (!PHYSFS_removeFromSearchPath(location.c_str())) { GetLogger()->Error("Error while unmounting \"%s\": %s\n", location.c_str(), PHYSFS_getLastError()); return false; } return true; }
bool Lux::Core::FileHandler::RemoveResourcePath(const String a_Path) { int res = PHYSFS_removeFromSearchPath(a_Path.c_str()); if (res == 0) { LUX_LOG(Utility::logWARNING) << "Directory " << a_Path << " was not removed from the search path. " << PHYSFS_getLastError(); return false; } return true; }
int PHYSFSX_removeRelFromSearchPath(const char *relname) { char relname2[PATH_MAX], pathname[PATH_MAX]; snprintf(relname2, sizeof(relname2), "%s", relname); PHYSFSEXT_locateCorrectCase(relname2); if (!PHYSFSX_getRealPath(relname2, pathname)) return 0; return PHYSFS_removeFromSearchPath(pathname); }
bool buildMapList() { if (!loadLevFile("gamedesc.lev", mod_campaign, false, NULL)) { return false; } loadLevFile("addon.lev", mod_multiplay, false, NULL); WZ_Maps.clear(); MapFileList realFileNames = listMapFiles(); for (MapFileList::iterator realFileName = realFileNames.begin(); realFileName != realFileNames.end(); ++realFileName) { bool mapmod = false; struct WZmaps CurrentMap; std::string realFilePathAndName = PHYSFS_getRealDir(realFileName->c_str()) + *realFileName; PHYSFS_addToSearchPath(realFilePathAndName.c_str(), PHYSFS_APPEND); char **filelist = PHYSFS_enumerateFiles(""); for (char **file = filelist; *file != NULL; ++file) { std::string checkfile = *file; size_t len = strlen(*file); if (len > 10 && !strcasecmp(*file + (len - 10), ".addon.lev")) // Do not add addon.lev again { loadLevFile(*file, mod_multiplay, true, realFileName->c_str()); } // add support for X player maps using a new name to prevent conflicts. if (len > 13 && !strcasecmp(*file + (len - 13), ".xplayers.lev")) { loadLevFile(*file, mod_multiplay, true, realFileName->c_str()); } } PHYSFS_freeList(filelist); if (PHYSFS_removeFromSearchPath(realFilePathAndName.c_str()) == 0) { debug(LOG_ERROR, "Could not unmount %s, %s", realFilePathAndName.c_str(), PHYSFS_getLastError()); } mapmod = CheckInMap(realFilePathAndName.c_str(), "WZMap", "WZMap"); if (!mapmod) { mapmod = CheckInMap(realFilePathAndName.c_str(), "WZMap", "WZMap/multiplay"); } CurrentMap.MapName = realFileName->c_str(); CurrentMap.isMapMod = mapmod; WZ_Maps.push_back(CurrentMap); } return true; }
bool FileSystem::removePath(const char *path_or_zip) { bool ret = true; if (PHYSFS_removeFromSearchPath(path_or_zip) == 0) { LOG("%s %s", "Failure on removing directory or file on search path", path_or_zip); LOG("%s", "Error:", PHYSFS_getLastError()); ret = false; } return ret; }
// Removes content added above when quitting game void PHYSFSX_removeArchiveContent() { char **list = NULL; static const char *const archive_exts[] = { ".zip", ".7z", NULL }; char *file[2]; int i = 0; // find files in Searchpath ... list = PHYSFSX_findFiles("", archive_exts); // if found, remove them... for (i = 0; list[i] != NULL; i++) { MALLOC(file[0], char, PATH_MAX); MALLOC(file[1], char, PATH_MAX); snprintf(file[0], sizeof(char)*PATH_MAX, "%s", list[i]); PHYSFSX_getRealPath(file[0],file[1]); PHYSFS_removeFromSearchPath(file[1]); d_free(file[0]); d_free(file[1]); } PHYSFS_freeList(list); list = NULL; // find files in DEMO_DIR ... list = PHYSFSX_findFiles(DEMO_DIR, archive_exts); // if found, remove them... for (i = 0; list[i] != NULL; i++) { MALLOC(file[0], char, PATH_MAX); MALLOC(file[1], char, PATH_MAX); snprintf(file[0], sizeof(char)*PATH_MAX, "%s%s", DEMO_DIR, list[i]); PHYSFSX_getRealPath(file[0],file[1]); PHYSFS_removeFromSearchPath(file[1]); d_free(file[0]); d_free(file[1]); } PHYSFS_freeList(list); list = NULL; }
void setupPHYSFS() { std::string separator = PHYSFS_getDirSeparator(); // Game should be playable out of the source package on all // platforms PHYSFS_addToSearchPath("data", 1); PHYSFS_addToSearchPath("data/gfx.zip", 1); PHYSFS_addToSearchPath("data/sounds.zip", 1); PHYSFS_addToSearchPath("data/scripts.zip", 1); PHYSFS_addToSearchPath("data/backgrounds.zip", 1); #if defined(WIN32) // Just write in installation directory PHYSFS_setWriteDir("data"); #else // handle the case when it is installed PHYSFS_addToSearchPath(BLOBBY_INSTALL_PREFIX "/share/blobby", 1); PHYSFS_addToSearchPath(BLOBBY_INSTALL_PREFIX "/share/blobby/gfx.zip", 1); PHYSFS_addToSearchPath(BLOBBY_INSTALL_PREFIX "/share/blobby/sounds.zip", 1); PHYSFS_addToSearchPath(BLOBBY_INSTALL_PREFIX "/share/blobby/scripts.zip", 1); PHYSFS_addToSearchPath(BLOBBY_INSTALL_PREFIX "/share/blobby/backgrounds.zip", 1); // Create a search path in the home directory and ensure that // all paths exist and are actually directories std::string userdir = PHYSFS_getUserDir(); std::string userAppend = ".blobby"; std::string homedir = userdir + userAppend; PHYSFS_addToSearchPath(userdir.c_str(), 0); PHYSFS_setWriteDir(userdir.c_str()); probeDir(userAppend); probeDir(userAppend + separator + "replays"); probeDir(userAppend + separator + "gfx"); probeDir(userAppend + separator + "sounds"); probeDir(userAppend + separator + "scripts"); probeDir(userAppend + separator + "backgrounds"); PHYSFS_removeFromSearchPath(userdir.c_str()); PHYSFS_setWriteDir(homedir.c_str()); PHYSFS_addToSearchPath(homedir.c_str(), 0); #if defined(GAMEDATADIR) // A global installation path makes only sense on non-Windows // platforms std::string basedir = GAMEDATADIR; PHYSFS_addToSearchPath(basedir.c_str(), 1); PHYSFS_addToSearchPath((basedir + separator + "gfx.zip").c_str(), 1); PHYSFS_addToSearchPath((basedir + separator + "sounds.zip").c_str(), 1); PHYSFS_addToSearchPath((basedir + separator + "scripts.zip").c_str(), 1); PHYSFS_addToSearchPath((basedir + separator + "backgrounds.zip").c_str(), 1); #endif #endif }
static int cmd_removearchive(char *args) { if (*args == '\"') { args++; args[strlen(args) - 1] = '\0'; } /* if */ if (PHYSFS_removeFromSearchPath(args)) printf("Successful.\n"); else printf("Failure. reason: %s.\n", PHYSFS_getLastError()); return(1); } /* cmd_removearchive */
bool FileSystem::removeAllSearchPaths() { bool ret = false; char **paths; for (paths = PHYSFS_getSearchPath(); *paths != NULL; paths++) { PHYSFS_removeFromSearchPath(*paths); } if (*(paths = PHYSFS_getSearchPath()) == NULL) ret = true; PHYSFS_freeList(paths); return ret; }
// Mount the archive under the mountpoint, and enumerate the archive according to lookin static bool CheckInMap(const char *archive, const char *mountpoint,const char *lookin) { bool mapmod = false; if (!PHYSFS_mount(archive, mountpoint, PHYSFS_APPEND)) { // We already checked to see if this was valid before, and now, something went seriously wrong. debug(LOG_FATAL, "Could not mount %s, because: %s. Please delete the file, and run the game again. Game will now exit.", archive, PHYSFS_getLastError()); exit(-1); } std::string checkpath = lookin; checkpath.append("/"); char **filelist = PHYSFS_enumerateFiles(lookin); for (char **file = filelist; *file != NULL; ++file) { std::string checkfile = *file; if (PHYSFS_isDirectory((checkpath+checkfile).c_str())) { if (checkfile.compare("wrf")==0 || checkfile.compare("stats")==0 ||checkfile.compare("components")==0 || checkfile.compare("anims")==0 || checkfile.compare("effects")==0 ||checkfile.compare("messages")==0 || checkfile.compare("audio")==0 || checkfile.compare("sequenceaudio")==0 ||checkfile.compare("misc")==0 || checkfile.compare("features")==0 || checkfile.compare("script")==0 ||checkfile.compare("structs")==0 || checkfile.compare("tileset")==0 || checkfile.compare("images")==0 || checkfile.compare("texpages")==0 || checkfile.compare("skirmish")==0 ) { debug(LOG_WZ, "Detected: %s %s" , archive, checkfile.c_str()); mapmod = true; break; } } } PHYSFS_freeList(filelist); if (!PHYSFS_removeFromSearchPath(archive)) { debug(LOG_ERROR, "Could not unmount %s, %s", archive, PHYSFS_getLastError()); } return mapmod; }
void AddonManager::add_installed_archive(const std::string& archive, const std::string& md5) { const char* realdir = PHYSFS_getRealDir(archive.c_str()); if (!realdir) { log_warning << "PHYSFS_getRealDir() failed for " << archive << ": " << PHYSFS_getLastError() << std::endl; } else { std::string os_path = FileSystem::join(realdir, archive); PHYSFS_addToSearchPath(os_path.c_str(), 0); std::string nfo_filename = scan_for_info(os_path); if (nfo_filename.empty()) { log_warning << "Couldn't find .nfo file for " << os_path << std::endl; } else { try { std::unique_ptr<Addon> addon = Addon::parse(nfo_filename); addon->set_install_filename(os_path, md5); m_installed_addons.push_back(std::move(addon)); } catch (const std::runtime_error& e) { log_warning << "Could not load add-on info for " << archive << ": " << e.what() << std::endl; } } PHYSFS_removeFromSearchPath(os_path.c_str()); } }
bool buildMapList() { if (!loadLevFile("gamedesc.lev", mod_campaign, false, NULL)) { return false; } loadLevFile("addon.lev", mod_multiplay, false, NULL); MapFileList realFileNames = listMapFiles(); for (MapFileList::iterator realFileName = realFileNames.begin(); realFileName != realFileNames.end(); ++realFileName) { std::string realFilePathAndName = PHYSFS_getRealDir(realFileName->c_str()) + *realFileName; PHYSFS_addToSearchPath(realFilePathAndName.c_str(), PHYSFS_APPEND); char **filelist = PHYSFS_enumerateFiles(""); for (char **file = filelist; *file != NULL; ++file) { size_t len = strlen(*file); if (len > 10 && !strcasecmp(*file + (len - 10), ".addon.lev")) // Do not add addon.lev again { loadLevFile(*file, mod_multiplay, true, realFileName->c_str()); } // add support for X player maps using a new name to prevent conflicts. if (len > 13 && !strcasecmp(*file + (len - 13), ".xplayers.lev")) { loadLevFile(*file, mod_multiplay, true, realFileName->c_str()); } } PHYSFS_freeList(filelist); PHYSFS_removeFromSearchPath(realFilePathAndName.c_str()); } return true; }
void removeFromSearchPath(const std::string& location) { if (!PHYSFS_removeFromSearchPath(location.c_str())) throw Exception(PHYSFS_getLastError()); }
bool removeFromSearchPath(const char *const oldDir) { return PHYSFS_removeFromSearchPath(oldDir); }
// Initialise PhysicsFS, set up basic search paths and add arguments from .ini file. // The .ini file can be in either the user directory or the same directory as the program. // The user directory is searched first. void PHYSFSX_init(int argc, char *argv[]) { #if defined(__unix__) const char *path = NULL; #endif #ifdef macintosh // Mac OS 9 char base_dir[PATH_MAX]; int bundle = 0; #else #define base_dir PHYSFS_getBaseDir() #endif PHYSFS_init(argv[0]); atexit(PHYSFSX_deinit); PHYSFS_permitSymbolicLinks(1); #ifdef macintosh strcpy(base_dir, PHYSFS_getBaseDir()); if (strstr(base_dir, ".app:Contents:MacOSClassic")) // the Mac OS 9 program is still in the .app bundle { char *p; bundle = 1; if (base_dir[strlen(base_dir) - 1] == ':') base_dir[strlen(base_dir) - 1] = '\0'; p = strrchr(base_dir, ':'); *p = '\0'; // path to 'Contents' p = strrchr(base_dir, ':'); *p = '\0'; // path to bundle p = strrchr(base_dir, ':'); *p = '\0'; // path to directory containing bundle } #endif #if (defined(__APPLE__) && defined(__MACH__)) // others? chdir(base_dir); // make sure relative hogdir paths work #endif #if defined(__unix__) char fullPath[PATH_MAX + 5]; # if !(defined(__APPLE__) && defined(__MACH__)) path = "~/.d2x-rebirth/"; # else path = "~/Library/Preferences/D2X Rebirth/"; # endif if (path[0] == '~') // yes, this tilde can be put before non-unix paths. { const char *home = PHYSFS_getUserDir(); strcpy(fullPath, home); // prepend home to the path path++; if (*path == *PHYSFS_getDirSeparator()) path++; strncat(fullPath, path, PATH_MAX + 5 - strlen(home)); } else strncpy(fullPath, path, PATH_MAX + 5); PHYSFS_setWriteDir(fullPath); if (!PHYSFS_getWriteDir()) { // need to make it char *p; char ancestor[PATH_MAX + 5]; // the directory which actually exists char child[PATH_MAX + 5]; // the directory relative to the above we're trying to make strcpy(ancestor, fullPath); while (!PHYSFS_getWriteDir() && ((p = strrchr(ancestor, *PHYSFS_getDirSeparator())))) { if (p[1] == 0) { // separator at the end (intended here, for safety) *p = 0; // kill this separator if (!((p = strrchr(ancestor, *PHYSFS_getDirSeparator())))) break; // give up, this is (usually) the root directory } p[1] = 0; // go to parent PHYSFS_setWriteDir(ancestor); } strcpy(child, fullPath + strlen(ancestor)); for (p = child; (p = strchr(p, *PHYSFS_getDirSeparator())); p++) *p = '/'; PHYSFS_mkdir(child); PHYSFS_setWriteDir(fullPath); } PHYSFS_addToSearchPath(PHYSFS_getWriteDir(), 1); #endif PHYSFS_addToSearchPath(base_dir, 1); InitArgs( argc,argv ); PHYSFS_removeFromSearchPath(base_dir); if (!PHYSFS_getWriteDir()) { PHYSFS_setWriteDir(base_dir); if (!PHYSFS_getWriteDir()) Error("can't set write dir: %s\n", PHYSFS_getLastError()); else PHYSFS_addToSearchPath(PHYSFS_getWriteDir(), 0); } //tell PHYSFS where hogdir is if (GameArg.SysHogDir) PHYSFS_addToSearchPath(GameArg.SysHogDir,1); #if defined(__unix__) else if (!GameArg.SysNoHogDir) PHYSFS_addToSearchPath(SHAREPATH, 1); #endif PHYSFSX_addRelToSearchPath("data", 1); // 'Data' subdirectory // For Macintosh, add the 'Resources' directory in the .app bundle to the searchpaths #if defined(__APPLE__) && defined(__MACH__) { ProcessSerialNumber psn = { 0, kCurrentProcess }; FSRef fsref; OSStatus err; err = GetProcessBundleLocation(&psn, &fsref); if (err == noErr) err = FSRefMakePath(&fsref, (ubyte *)fullPath, PATH_MAX); if (err == noErr) { strncat(fullPath, "/Contents/Resources/", PATH_MAX + 4 - strlen(fullPath)); fullPath[PATH_MAX + 4] = '\0'; PHYSFS_addToSearchPath(fullPath, 1); } } #elif defined(macintosh) if (bundle) { base_dir[strlen(base_dir)] = ':'; // go back in the bundle base_dir[strlen(base_dir)] = ':'; // go back in 'Contents' strncat(base_dir, ":Resources:", PATH_MAX - 1 - strlen(base_dir)); base_dir[PATH_MAX - 1] = '\0'; PHYSFS_addToSearchPath(base_dir, 1); } #endif }
/*! * \brief Rebuilds the PHYSFS searchPath with mode specific subdirs * * Priority: * maps > mods > base > base.wz */ bool rebuildSearchPath( searchPathMode mode, bool force ) { static searchPathMode current_mode = mod_clean; static std::string current_current_map; wzSearchPath * curSearchPath = searchPathRegistry; char tmpstr[PATH_MAX] = "\0"; if (mode != current_mode || (current_map != NULL? current_map : "") != current_current_map || force || (use_override_mods && strcmp(override_mod_list, getModList()))) { if (mode != mod_clean) { rebuildSearchPath( mod_clean, false ); } current_mode = mode; current_current_map = current_map != NULL? current_map : ""; // Start at the lowest priority while( curSearchPath->lowerPriority ) curSearchPath = curSearchPath->lowerPriority; switch ( mode ) { case mod_clean: debug(LOG_WZ, "Cleaning up"); clearLoadedMods(); while( curSearchPath ) { #ifdef DEBUG debug(LOG_WZ, "Removing [%s] from search path", curSearchPath->path); #endif // DEBUG // Remove maps and mods removeSubdirs( curSearchPath->path, "maps", NULL ); removeSubdirs( curSearchPath->path, "mods/music", NULL ); removeSubdirs( curSearchPath->path, "mods/global", NULL ); removeSubdirs( curSearchPath->path, "mods/campaign", NULL ); removeSubdirs( curSearchPath->path, "mods/multiplay", NULL ); removeSubdirs( curSearchPath->path, "mods/autoload", NULL ); // Remove multiplay patches sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "mp"); PHYSFS_removeFromSearchPath( tmpstr ); sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "mp.wz"); PHYSFS_removeFromSearchPath( tmpstr ); // Remove plain dir PHYSFS_removeFromSearchPath( curSearchPath->path ); // Remove base files sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "base"); PHYSFS_removeFromSearchPath( tmpstr ); sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "base.wz"); PHYSFS_removeFromSearchPath( tmpstr ); // remove video search path as well sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "sequences.wz"); PHYSFS_removeFromSearchPath( tmpstr ); curSearchPath = curSearchPath->higherPriority; } break; case mod_campaign: debug(LOG_WZ, "*** Switching to campaign mods ***"); clearLoadedMods(); while (curSearchPath) { // make sure videos override included files sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "sequences.wz"); PHYSFS_addToSearchPath(tmpstr, PHYSFS_APPEND); curSearchPath = curSearchPath->higherPriority; } curSearchPath = searchPathRegistry; while (curSearchPath->lowerPriority) curSearchPath = curSearchPath->lowerPriority; while( curSearchPath ) { #ifdef DEBUG debug(LOG_WZ, "Adding [%s] to search path", curSearchPath->path); #endif // DEBUG // Add global and campaign mods PHYSFS_addToSearchPath( curSearchPath->path, PHYSFS_APPEND ); addSubdirs( curSearchPath->path, "mods/music", PHYSFS_APPEND, NULL, false ); addSubdirs( curSearchPath->path, "mods/global", PHYSFS_APPEND, use_override_mods?override_mods:global_mods, true ); addSubdirs( curSearchPath->path, "mods", PHYSFS_APPEND, use_override_mods?override_mods:global_mods, true ); addSubdirs( curSearchPath->path, "mods/autoload", PHYSFS_APPEND, use_override_mods?override_mods:NULL, true ); addSubdirs( curSearchPath->path, "mods/campaign", PHYSFS_APPEND, use_override_mods?override_mods:campaign_mods, true ); if (!PHYSFS_removeFromSearchPath( curSearchPath->path )) { debug(LOG_WZ, "* Failed to remove path %s again", curSearchPath->path); } // Add plain dir PHYSFS_addToSearchPath( curSearchPath->path, PHYSFS_APPEND ); // Add base files sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "base"); PHYSFS_addToSearchPath( tmpstr, PHYSFS_APPEND ); sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "base.wz"); PHYSFS_addToSearchPath( tmpstr, PHYSFS_APPEND ); curSearchPath = curSearchPath->higherPriority; } break; case mod_multiplay: debug(LOG_WZ, "*** Switching to multiplay mods ***"); clearLoadedMods(); while (curSearchPath) { // make sure videos override included files sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "sequences.wz"); PHYSFS_addToSearchPath(tmpstr, PHYSFS_APPEND); curSearchPath = curSearchPath->higherPriority; } // Add the selected map first, for mapmod support if (current_map != NULL) { std::string realPathAndDir = std::string(PHYSFS_getRealDir(current_map)) + current_map; PHYSFS_addToSearchPath(realPathAndDir.c_str(), PHYSFS_APPEND); } curSearchPath = searchPathRegistry; while (curSearchPath->lowerPriority) curSearchPath = curSearchPath->lowerPriority; while( curSearchPath ) { #ifdef DEBUG debug(LOG_WZ, "Adding [%s] to search path", curSearchPath->path); #endif // DEBUG // Add global and multiplay mods PHYSFS_addToSearchPath( curSearchPath->path, PHYSFS_APPEND ); addSubdirs( curSearchPath->path, "mods/music", PHYSFS_APPEND, NULL, false ); addSubdirs( curSearchPath->path, "mods/global", PHYSFS_APPEND, use_override_mods?override_mods:global_mods, true ); addSubdirs( curSearchPath->path, "mods", PHYSFS_APPEND, use_override_mods?override_mods:global_mods, true ); addSubdirs( curSearchPath->path, "mods/autoload", PHYSFS_APPEND, use_override_mods?override_mods:NULL, true ); addSubdirs( curSearchPath->path, "mods/multiplay", PHYSFS_APPEND, use_override_mods?override_mods:multiplay_mods, true ); PHYSFS_removeFromSearchPath( curSearchPath->path ); // Add multiplay patches sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "mp"); PHYSFS_addToSearchPath( tmpstr, PHYSFS_APPEND ); sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "mp.wz"); PHYSFS_addToSearchPath( tmpstr, PHYSFS_APPEND ); // Add plain dir PHYSFS_addToSearchPath( curSearchPath->path, PHYSFS_APPEND ); // Add base files sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "base"); PHYSFS_addToSearchPath( tmpstr, PHYSFS_APPEND ); sstrcpy(tmpstr, curSearchPath->path); sstrcat(tmpstr, "base.wz"); PHYSFS_addToSearchPath( tmpstr, PHYSFS_APPEND ); curSearchPath = curSearchPath->higherPriority; } break; default: debug(LOG_ERROR, "Can't switch to unknown mods %i", mode); return false; } if (use_override_mods && mode != mod_clean) { if (strcmp(getModList(),override_mod_list)) { debug(LOG_POPUP, _("The required mod could not be loaded: %s\n\nWarzone will try to load the game without it."), override_mod_list); } clearOverrideMods(); current_mode = mod_override; } // User's home dir must be first so we allways see what we write PHYSFS_removeFromSearchPath(PHYSFS_getWriteDir()); PHYSFS_addToSearchPath( PHYSFS_getWriteDir(), PHYSFS_PREPEND ); #ifdef DEBUG printSearchPath(); #endif // DEBUG } else if (use_override_mods) { // override mods are already the same as current mods, so no need to do anything clearOverrideMods(); } return true; }
static MapFileList listMapFiles() { MapFileList ret, filtered, oldSearchPath; char **subdirlist = PHYSFS_enumerateFiles("maps"); for (char **i = subdirlist; *i != NULL; ++i) { std::string wzfile = *i; if (*i[0] == '.' || wzfile.substr(wzfile.find_last_of(".")+1) != "wz") { continue; } std::string realFileName = std::string("maps/") + *i; ret.push_back(realFileName); } PHYSFS_freeList(subdirlist); // save our current search path(s) debug(LOG_WZ, "Map search paths:"); char **searchPath = PHYSFS_getSearchPath(); for (char **i = searchPath; *i != NULL; i++) { debug(LOG_WZ, " [%s]", *i); oldSearchPath.push_back(*i); PHYSFS_removeFromSearchPath(*i); } PHYSFS_freeList(searchPath); for (MapFileList::iterator realFileName = ret.begin(); realFileName != ret.end(); ++realFileName) { std::string realFilePathAndName = PHYSFS_getWriteDir() + *realFileName; PHYSFS_addToSearchPath(realFilePathAndName.c_str(), PHYSFS_APPEND); int unsafe = 0; char **filelist = PHYSFS_enumerateFiles("multiplay/maps"); for (char **file = filelist; *file != NULL; ++file) { std::string isDir = std::string("multiplay/maps/") + *file; if (PHYSFS_isDirectory(isDir.c_str())) continue; std::string checkfile = *file; debug(LOG_WZ,"checking ... %s", *file); if (checkfile.substr(checkfile.find_last_of(".")+ 1) == "gam") { if (unsafe++ > 1) { debug(LOG_ERROR, "Map packs are not supported! %s NOT added.", realFilePathAndName.c_str()); break; } } } PHYSFS_freeList(filelist); if (unsafe < 2) { filtered.push_back(realFileName->c_str()); } PHYSFS_removeFromSearchPath(realFilePathAndName.c_str()); } // restore our search path(s) again for (MapFileList::iterator restorePaths = oldSearchPath.begin(); restorePaths != oldSearchPath.end(); ++restorePaths) { PHYSFS_addToSearchPath(restorePaths->c_str(), PHYSFS_APPEND); } debug(LOG_WZ, "Search paths restored"); printSearchPath(); return filtered; }
void removeFromSearchPath(const string& oldDir) { PHYSFS_removeFromSearchPath(oldDir.c_str()); }
void operator()(const char *const p) const noexcept { PHYSFS_removeFromSearchPath(p); }
void FileSystem::removeFromSearchPath(const std::string& dirname) { PHYSFS_removeFromSearchPath(dirname.c_str()); }
void removeFromSearchPath(const char* directory) { if(!PHYSFS_removeFromSearchPath(directory)) throw Exception("Couldn't remove '%s' from searchpath: %s", directory, PHYSFS_getLastError()); }
bool buildMapList() { if (!loadLevFile("gamedesc.lev", mod_campaign, false, NULL)) { return false; } loadLevFile("addon.lev", mod_multiplay, false, NULL); WZ_Maps.clear(); MapFileList realFileNames = listMapFiles(); for (MapFileList::iterator realFileName = realFileNames.begin(); realFileName != realFileNames.end(); ++realFileName) { bool mapmod = false; struct WZmaps CurrentMap; std::string realFilePathAndName = PHYSFS_getRealDir(realFileName->c_str()) + *realFileName; PHYSFS_addToSearchPath(realFilePathAndName.c_str(), PHYSFS_APPEND); char **filelist = PHYSFS_enumerateFiles(""); for (char **file = filelist; *file != NULL; ++file) { std::string checkfile = *file; size_t len = strlen(*file); if (len > 10 && !strcasecmp(*file + (len - 10), ".addon.lev")) // Do not add addon.lev again { loadLevFile(*file, mod_multiplay, true, realFileName->c_str()); } // add support for X player maps using a new name to prevent conflicts. if (len > 13 && !strcasecmp(*file + (len - 13), ".xplayers.lev")) { loadLevFile(*file, mod_multiplay, true, realFileName->c_str()); } } PHYSFS_freeList(filelist); if (PHYSFS_removeFromSearchPath(realFilePathAndName.c_str()) == 0) { debug(LOG_ERROR, "Could not unmount %s", PHYSFS_getLastError()); } // check what kind of map it is if (!PHYSFS_mount(realFilePathAndName.c_str(), "WZMap", PHYSFS_APPEND)) { debug(LOG_FATAL, "Could not mount %s, because: %s. Please delete the file, and run the game again. Game will now exit.", realFilePathAndName.c_str(), PHYSFS_getLastError()); exit(-1); } filelist = PHYSFS_enumerateFiles("WZMap"); for (char **file = filelist; *file != NULL; ++file) { if (PHYSFS_isDirectory(*file)) { std::string checkfile = *file; if (checkfile.compare("wrf")==0 || checkfile.compare("stats")==0 ||checkfile.compare("components")==0 || checkfile.compare("anims")==0 || checkfile.compare("effects")==0 ||checkfile.compare("messages")==0 || checkfile.compare("audio")==0 || checkfile.compare("sequenceaudio")==0 ||checkfile.compare("misc")==0 || checkfile.compare("features")==0 || checkfile.compare("script")==0 ||checkfile.compare("structs")==0 || checkfile.compare("tileset")==0 || checkfile.compare("images")==0 || checkfile.compare("texpages")==0 ) { mapmod = true; break; } } } PHYSFS_freeList(filelist); CurrentMap.MapName = realFileName->c_str(); CurrentMap.isMapMod = mapmod; WZ_Maps.push_back(CurrentMap); if (PHYSFS_removeFromSearchPath(realFilePathAndName.c_str()) == 0) { debug(LOG_ERROR, "Could not unmount %s", PHYSFS_getLastError()); } } return true; }
void Virtual_file_system::unmount(const std::string& path) const { PHYSFS_removeFromSearchPath(path.c_str()); }