WzConfig::WzConfig(const QString &name, WzConfig::warning warning, QObject *parent)
: WzConfigHack(name, (int)warning), m_settings(QString("wz::") + name, QSettings::IniFormat, parent), m_overrides()
{
if (m_settings.status() != QSettings::NoError && (warning != ReadOnly || PHYSFS_exists(name.toUtf8().constData())))
{
debug(LOG_FATAL, "Could not open \"%s\"", name.toUtf8().constData());
}
char **diffList = PHYSFS_enumerateFiles("diffs");
char **i;
int j;
for (i = diffList; *i != NULL; i++)
{
std::string str(std::string("diffs/") + *i + std::string("/") + name.toUtf8().constData());
if (!PHYSFS_exists(str.c_str()))
continue;
QSettings tmp(QString("wz::") + str.c_str(), QSettings::IniFormat);
if (tmp.status() != QSettings::NoError)
{
debug(LOG_FATAL, "Could not read an override for \"%s\"", name.toUtf8().constData());
}
QStringList keys(tmp.allKeys());
for (j = 0; j < keys.length(); j++)
{
m_overrides.insert(keys[j],tmp.value(keys[j]));
}
}
PHYSFS_freeList(diffList);
}
WzConfig::WzConfig(const QString &name, WzConfig::warning warning, QObject *parent)
{
UDWORD size;
char *data;
QJsonParseError error;
mFilename = name;
mStatus = true;
mWarning = warning;
if (!PHYSFS_exists(name.toUtf8().constData()))
{
if (warning == ReadOnly)
{
mStatus = false;
debug(LOG_ERROR, "IGNORED %s", name.toUtf8().constData());
return;
}
else if (warning == ReadAndWrite)
{
mJson = QJsonDocument();
mObj = mJson.object();
debug(LOG_ERROR, "PREPARED %s", name.toUtf8().constData());
return;
}
}
if (!loadFile(name.toUtf8().constData(), &data, &size))
{
debug(LOG_FATAL, "Could not open \"%s\"", name.toUtf8().constData());
}
mJson = QJsonDocument::fromJson(QByteArray(data, size), &error);
ASSERT(!mJson.isNull(), "JSON document from %s is invalid: %s", name.toUtf8().constData(), error.errorString().toUtf8().constData());
ASSERT(mJson.isObject(), "JSON document from %s is not an object. Read: \n%s", name.toUtf8().constData(), data);
mObj = mJson.object();
#if 0
char **diffList = PHYSFS_enumerateFiles("diffs");
char **i;
int j;
for (i = diffList; *i != NULL; i++)
{
std::string str(std::string("diffs/") + *i + std::string("/") + name.toUtf8().constData());
if (!PHYSFS_exists(str.c_str()))
continue;
QSettings tmp(QString("wz::") + str.c_str(), QSettings::IniFormat);
if (tmp.status() != QSettings::NoError)
{
debug(LOG_FATAL, "Could not read an override for \"%s\"", name.toUtf8().constData());
}
QStringList keys(tmp.allKeys());
for (j = 0; j < keys.length(); j++)
{
m_overrides.insert(keys[j],tmp.value(keys[j]));
}
}
PHYSFS_freeList(diffList);
#endif
}
int PHYSFSX_exists(const char *filename, int ignorecase)
{
char filename2[PATH_MAX];
if (!ignorecase)
return PHYSFS_exists(filename);
snprintf(filename2, sizeof(filename2), "%s", filename);
PHYSFSEXT_locateCorrectCase(filename2);
return PHYSFS_exists(filename2);
}
File::File(const MountedFilePath& mountedFilePath, DataStream::OpenMode openMode)
: impl(std::make_unique<File_Impl>()), mountedFilePath(mountedFilePath)
{
const char* path = mountedFilePath.path.c_str();
int fileExists = PHYSFS_exists(path);
if (fileExists == 0)
{
throw Exception(std::string("File ") + path + " does not exist in the search path");
}
switch (openMode)
{
case OpenMode::Read:
impl->physfsFileHandle = PHYSFS_openRead(path);
break;
case OpenMode::Write:
impl->physfsFileHandle = PHYSFS_openWrite(path);
break;
case OpenMode::Append:
impl->physfsFileHandle = PHYSFS_openAppend(path);
break;
}
if (impl->physfsFileHandle == nullptr)
{
throw Exception(std::string("Failed to open file ") + path + "\n" + PHYSFS_getLastError());
}
}
bool j1Physfs::OpenFile(const char* file)
{
if (0 == PHYSFS_exists(file))
{
return false; //file doesn't exist
}
PHYSFS_file* myfile = PHYSFS_openRead(file);
// Get the lenght of the file
file_lenght = PHYSFS_fileLength(myfile);
// Get the file data.
file_data = new Uint32[file_lenght];
int length_read = PHYSFS_read(myfile, file_data, 1, file_lenght);
if (length_read != (int)file_lenght)
{
delete[] file_data;
file_data = 0;
return false;
}
PHYSFS_close(myfile);
return true;
}
static bool loadLevFile(const char* filename, searchPathMode datadir, bool ignoreWrf, char const *realFileName)
{
char *pBuffer;
UDWORD size;
if (realFileName == NULL)
{
debug(LOG_WZ, "Loading lev file: \"%s\", builtin\n", filename);
}
else
{
debug(LOG_WZ, "Loading lev file: \"%s\" from \"%s\"\n", filename, realFileName);
}
if (!PHYSFS_exists(filename) || !loadFile(filename, &pBuffer, &size))
{
debug(LOG_ERROR, "loadLevFile: File not found: %s\n", filename);
return false; // only in NDEBUG case
}
if (!levParse(pBuffer, size, datadir, ignoreWrf, realFileName))
{
debug(LOG_ERROR, "loadLevFile: Parse error in %s\n", filename);
return false;
}
free(pBuffer);
return true;
}
//==================================================
//! Load a file from the VFS into memory, can throw a FileIOException
//==================================================
void System::VFS::LoadRaw( const string& strFilename, vector<byte>& data ) {
// Check to see if it exists
if( !PHYSFS_exists(strFilename.c_str()) ) {
THROW_EXCEPTION( FileReadException() << FileIOExceptionFilename(strFilename) );
}
// Open the file
shared_ptr<PHYSFS_file> pFile( PHYSFS_openRead(strFilename.c_str()), PHYSFS_close );
if( pFile.get() == NULL ) {
THROW_EXCEPTION( FileReadException() << FileIOExceptionFilename(strFilename) );
}
// Try to read the number of bytes, fail if we can't
PHYSFS_sint64 nBytes= PHYSFS_fileLength( pFile.get() );
if( nBytes < 0 ) {
THROW_EXCEPTION( FileReadException() << FileIOExceptionFilename(strFilename) );
}
data.resize( unsigned(nBytes) );
// Try to read the data
PHYSFS_sint64 nBytesRead= PHYSFS_read( pFile.get(), &data[0], sizeof(byte), data.size() );
// Check for unexpected length
if( nBytesRead != nBytes ) {
data.resize( unsigned(nBytesRead) );
THROW_EXCEPTION( FileReadException() << FileIOExceptionFilename(strFilename) );
}
}
bool ResourceManager::exists(const std::string &path, bool lookInSearchPath)
{
if (!lookInSearchPath)
return fileExists(path);
return PHYSFS_exists(path.c_str());
}
Block::Block(const ReaderMapping& lisp, const std::string& sprite_file) :
sprite(),
sprite_name(),
default_sprite_name(),
bouncing(false),
breaking(false),
bounce_dir(0),
bounce_offset(0),
original_y(-1)
{
lisp.get("x", bbox.p1.x);
lisp.get("y", bbox.p1.y);
std::string sf;
lisp.get("sprite", sf);
if (sf.empty() || !PHYSFS_exists(sf.c_str())) {
sf = sprite_file;
}
sprite = SpriteManager::current()->create(sf);
sprite_name = sf;
default_sprite_name = sprite_name;
bbox.set_size(32, 32.1f);
set_group(COLGROUP_STATIC);
SoundManager::current()->preload("sounds/upgrade.wav");
SoundManager::current()->preload("sounds/brick.wav");
}
int FS_loadFile(lua_State *L, const char *filename) {
char *buffer; /* buffer for the file */
char *entryPoint; /* entry point of file (differs from buffer, if "#!" in the first line is skipped */
int err;
PHYSFS_file *Hndfile = NULL;
PHYSFS_sint64 fileLength, size;
if (PHYSFS_exists(filename) == 0) {
lua_pushfstring(L, "Error loading '%s': file not found.", filename);
return FILEIO_ERROR;
}
Hndfile = PHYSFS_openRead(filename); /* open file to read! */
if (Hndfile == NULL) {
lua_pushfstring(L, "Error while reading from '%s': %s", filename, PHYSFS_getLastError());
return FILEIO_ERROR;
}
size = PHYSFS_fileLength(Hndfile);
if (size == -1) {
lua_pushfstring(L, "Error while determining the size of %s.", filename);
return FILEIO_ERROR;
}
buffer = (char *)malloc((unsigned int)size);
if (buffer == NULL) {
lua_pushfstring(L, "Error loading %s: Insufficient memory available.", filename);
return FILEIO_ERROR;
}
fileLength = PHYSFS_read(Hndfile, buffer, 1, (unsigned int)size);
if (fileLength < size) {
free(buffer);
lua_pushfstring(L, "Error while reading from %s: %s", filename, PHYSFS_getLastError());
return FILEIO_ERROR;
}
/* close the file */
err = PHYSFS_close(Hndfile);
if (err == 0) {
free(buffer);
lua_pushfstring(L, "Error closing %s: %s", filename, PHYSFS_getLastError());
return FILEIO_ERROR;
}
/* skip #! if nescessary */
entryPoint = buffer;
if (buffer[0] == '#') {
while ((*entryPoint != 0x0D) && (*entryPoint != 0x0A) && (*entryPoint != EOF)) {
entryPoint++;
fileLength--;
}
}
err = luaL_loadbuffer(L, entryPoint, (size_t)fileLength, filename);
free(buffer);
if (err != 0) {
/* error message is on the stack */
return FILEIO_ERROR;
}
return FILEIO_SUCCESS;
}
gSurface *gLoadImage(const char *name)
{
gSurface *ret;
SDL_RWops *ops;
if(!PHYSFS_exists(name))
{
gSetError("gLoadImage was unable to load the image %s", name);
return NULL;
}
ops = PHYSFSRWOPS_openRead(name);
if(!ops)
{
gSetError("gLoadImage was unable to load the image %s: failed _openRead", name);
return NULL;
}
if(!(ret = IMG_Load_RW(ops, true)))
{
gSetError("gLoadImage was unable to load the image %s: %s", name, SDL_GetError());
return NULL;
}
return ret;
}
void SetWindowIcon(photon_window &window, const std::string &filename){
if(PHYSFS_exists(filename.c_str())){
auto fp = PHYSFS_openRead(filename.c_str());
intmax_t length = PHYSFS_fileLength(fp);
if(length > 0){
uint8_t *buffer = new uint8_t[length];
PHYSFS_read(fp, buffer, 1, length);
PHYSFS_close(fp);
SDL_RWops *rw = SDL_RWFromMem(buffer, length);
SDL_Surface *icon = IMG_Load_RW(rw, 1);
if(icon == nullptr){
PrintToLog("ERROR: icon loading failed! %s", IMG_GetError());
}
SDL_SetWindowIcon(window.window_SDL, icon);
SDL_FreeSurface(icon);
delete[] buffer;
}else{
PrintToLog("ERROR: Unable to open image file \"%s\"!");
}
}else{
PrintToLog("ERROR: Image file \"%s\" does not exist!", filename.c_str());
}
}
bool physfsDrive::FileOpen(DOS_File * * file,const char * name,Bit32u flags) {
char newname[CROSS_LEN];
strcpy(newname,basedir);
strcat(newname,name);
CROSS_FILENAME(newname);
dirCache.ExpandName(newname);
normalize(newname,basedir);
PHYSFS_file * hand;
if (!PHYSFS_exists(newname)) return false;
if ((flags&0xf) == OPEN_READ) {
hand = PHYSFS_openRead(newname);
} else {
/* open for reading, deal with writing later */
hand = PHYSFS_openRead(newname);
}
if (!hand) {
if((flags&0xf) != OPEN_READ) {
PHYSFS_file *hmm = PHYSFS_openRead(newname);
if (hmm) {
PHYSFS_close(hmm);
LOG_MSG("Warning: file %s exists and failed to open in write mode.\nPlease mount a write directory (see docs).",newname);
}
}
return false;
}
*file=new physfsFile(name,hand,0x202,newname,false);
(*file)->flags=flags; //for the inheritance flag and maybe check for others.
return true;
}
char* physfs_addmappath(char *path)
{
char *p_path, *p_result;
char *result;
int length;
result = (char *)malloc(PATH_MAX * sizeof(char));
result[0] = '\0';
p_result = result;
length = strlen(path);
if (length >= 3 && strcmp(&path[length-3], ".wz")==0)
{
PHYSFS_mount(path, NULL, 1);
strcat(p_result, "multiplay/maps/");
p_result += strlen("multiplay/maps/");
p_path = strrchr(path, PHYSFS_getDirSeparator()[0]);
if (p_path)
{
// Remove the path
p_path++;
strcpy(p_result, p_path);
path[strlen(path) - strlen(result) - 1] = '\0';
PHYSFS_mount(path, NULL, 1);
}
else
{
strcpy(p_result, path);
}
// remove ".wz" from end
length = strlen(result);
result[length-3] = '\0';
}
else
{
if (PHYSFS_exists("multiplay/maps"))
{
strcat(p_result, "multiplay/maps/");
p_result += strlen("multiplay/maps/");
}
p_path = strrchr(path, PHYSFS_getDirSeparator()[0]);
if (p_path)
{
// Remove the path
p_path++;
strcpy(p_result, p_path);
}
else
{
strcpy(p_result, path);
}
}
return result;
}
Sp<AIOStream> ZipFileSystem::open(const String& uri, AIOStream::Mode mode){
if(!PHYSFS_exists(uri.c_str())){
LOGW("File \"%s\" does not exist in zip archive", uri.c_str());
}
return new ZipInputStream(PHYSFS_openRead(uri.c_str()));
}
boost::shared_ptr<ResourceInfo> Resource::LoadResource(const std::string& name)
{
boost::shared_ptr<ResourceInfo> resource_info = m_resources.LoadResource(name);
if (resource_info.get() == NULL)
{
const char* name_cstr = name.c_str();
// Check if resource exists
if (PHYSFS_exists(name_cstr) && !PHYSFS_isDirectory(name_cstr))
{
// Load the resource
PHYSFS_File* fp = PHYSFS_openRead(name_cstr);
// Load file data into ResourceInfo class
Sint64 length = (Sint64)PHYSFS_fileLength(fp);
char* data = new char[length];
PHYSFS_read(fp, (void*)data, (PHYSFS_uint32)length, 1);
resource_info = m_resources.Construct(name, data, length);
// Close PHYSFS_File
PHYSFS_close(fp);
fp = NULL;
}
else
{
BOOST_THROW_EXCEPTION(ResourceNotFoundException()
<< StringErrorInfo("The requested resource could not be found: " + name));
}
}
return resource_info;
}
// ////////////////////////////////////////////////////////////////////////////
// Load Player Stats
bool loadMultiStats(char *sPlayerName, PLAYERSTATS *st)
{
char fileName[255];
UDWORD size;
char *pFileData;
memset(st, 0, sizeof(PLAYERSTATS)); // clear in case we don't get to load
// Prevent an empty player name (where the first byte is a 0x0 terminating char already)
if (!*sPlayerName)
{
strcpy(sPlayerName, _("Player"));
}
snprintf(fileName, sizeof(fileName), "%s%s.sta", MultiPlayersPath, sPlayerName);
debug(LOG_WZ, "loadMultiStats: %s", fileName);
// check player already exists
if ( !PHYSFS_exists( fileName ) )
{
PLAYERSTATS blankstats;
memset(&blankstats, 0, sizeof(PLAYERSTATS));
saveMultiStats(sPlayerName,sPlayerName,&blankstats); // didnt exist so create.
}
else
{
int num = 0;
loadFile(fileName,&pFileData,&size);
if (strncmp(pFileData, "WZ.STA.v3", 9) != 0)
{
return false; // wrong version or not a stats file
}
num = sscanf(pFileData, "WZ.STA.v3\n%u %u %u %u %u",
&st->wins, &st->losses, &st->totalKills, &st->totalScore, &st->played);
if (num < 5)
{
st->played = 0; // must be old, buggy format still
}
free(pFileData);
}
// reset recent scores
st->recentKills = 0;
st->recentScore = 0;
// clear any skirmish stats.
for(size = 0;size<MAX_PLAYERS;size++)
{
ingame.skScores[size][0] =0;
ingame.skScores[size][1] =0;
}
return true;
}
AddonManager::AddonManager(const std::string& addon_directory,
std::vector<Config::Addon>& addon_config) :
m_downloader(),
m_addon_directory(addon_directory),
m_repository_url("https://raw.githubusercontent.com/SuperTux/addons/master/index-0_5.nfo"),
m_addon_config(addon_config),
m_installed_addons(),
m_repository_addons(),
m_has_been_updated(false),
m_transfer_status()
{
if(!PHYSFS_mkdir(m_addon_directory.c_str()))
{
std::ostringstream msg;
msg << "Couldn't create directory for addons '"
<< m_addon_directory << "': " << PHYSFS_getLastError();
throw std::runtime_error(msg.str());
}
add_installed_addons();
// FIXME: We should also restore the order here
for(auto& addon : m_addon_config)
{
if (addon.enabled)
{
try
{
enable_addon(addon.id);
}
catch(const std::exception& err)
{
log_warning << "failed to enable addon from config: " << err.what() << std::endl;
}
}
}
if(PHYSFS_exists(ADDON_INFO_PATH))
{
try
{
m_repository_addons = parse_addon_infos(ADDON_INFO_PATH);
}
catch(const std::exception& err)
{
log_warning << "parsing repository.nfo failed: " << err.what() << std::endl;
}
}
else
{
log_info << "repository.nfo doesn't exist, not loading" << std::endl;
}
if (!g_config->repository_url.empty() &&
g_config->repository_url != m_repository_url)
{
m_repository_url = g_config->repository_url;
}
}
bool CResourceManager::DirectoryExists(const std::string& directory)
{
if (PHYSFS_isInit())
{
return PHYSFS_exists(CleanPath(directory).c_str()) && PHYSFS_isDirectory(CleanPath(directory).c_str());
}
return false;
}
bool Filesystem::exists(const std::string &filename)
{
if (PHYSFS_exists(filename.c_str())) {
return true;
} else {
return false;
}
}
bool CResourceManager::Exists(const std::string &filename)
{
if (PHYSFS_isInit())
{
return PHYSFS_exists(CleanPath(filename).c_str());
}
return false;
}
bool physfsDrive::FileExists(const char* name) {
char newname[CROSS_LEN];
strcpy(newname,basedir);
strcat(newname,name);
CROSS_FILENAME(newname);
dirCache.ExpandName(newname);
normalize(newname,basedir);
return PHYSFS_exists(newname) && !PHYSFS_isDirectory(newname);
}
bool VFS::DoesExist(const std::string& fileName)
{
// Return true if Physfs_exists returns non-zero number.
if (PHYSFS_exists(fileName.c_str())) {
return true;
} else {
return false;
}
}
bool ClientOptions::LoadFromFile(const std::string &filename, bool default_if_missing)
{
clan::MutexSection mutexSection(&m_Mutex);
try
{
// Load the document
ticpp::Document doc;
if (PHYSFS_exists(filename.c_str()))
{
doc = OpenXml_PhysFS(filename);
}
else if (default_if_missing)
{
// Copy the default config file
try
{
PhysFSHelp::copy_file("Data/default-" + filename, filename);
// Parse the xml
doc = OpenXml_PhysFS(filename);
}
catch (FileSystemException&)
{
return false;
}
}
ticpp::Element* pElem = doc.FirstChildElement();
if (pElem->Value() != m_Type)
FSN_EXCEPT(FileTypeException, filename + " is not a " + m_Type + " file");
ticpp::Iterator< ticpp::Element > child;
for ( child = child.begin( pElem ); child != child.end(); child++ )
{
if (child->Value() == "var")
{
std::string name = child->GetAttribute("name");
if (name.empty()) continue;
std::string value = child->GetAttribute("value");
m_Variables[name] = value;
}
else if (child->Value() == "playeroptions")
{
loadPlayerOptions(child.Get());
}
}
}
catch (ticpp::Exception &ex)
{
FSN_EXCEPT(FileSystemException, ex.what());
}
m_LastFile = filename;
return true;
}
// Load labels
bool loadLabels(const char *filename)
{
if (!PHYSFS_exists(filename))
{
debug(LOG_SAVE, "No %s found -- use fallback method", filename);
return false;
}
WzConfig ini(filename);
if (ini.status() != QSettings::NoError)
{
debug(LOG_ERROR, "No label file %s", filename);
return false;
}
labels.clear();
QStringList list = ini.childGroups();
for (int i = 0; i < list.size(); ++i)
{
ini.beginGroup(list[i]);
labeltype p;
QString label(ini.value("label").toString());
if (labels.contains(label))
{
debug(LOG_ERROR, "Duplicate label found");
}
else if (list[i].startsWith("position"))
{
p.p1 = ini.vector2i("pos");
p.p2 = p.p1;
p.type = POSITION;
p.player = -1;
p.id = -1;
labels.insert(label, p);
}
else if (list[i].startsWith("area"))
{
p.p1 = ini.vector2i("pos1");
p.p2 = ini.vector2i("pos2");
p.type = AREA;
p.player = -1;
p.id = -1;
labels.insert(label, p);
}
else if (list[i].startsWith("object"))
{
p.id = ini.value("id").toInt();
p.type = ini.value("type").toInt();
p.player = ini.value("player").toInt();
labels.insert(label, p);
}
else
{
debug(LOG_ERROR, "Misnamed group in %s", filename);
}
ini.endGroup();
}
return true;
}
bool FS_Exists(const char *file) {
if (PHYSFS_exists(file)) {
if (!PHYSFS_isDirectory(file)) {
return true;
}
}
return false;
}
bool FolderExists(std::string path) {
if (!IsLoaded()) {
Logger::begin("Filesystem", Logger::LogLevel_Error) << "FS not loaded" << Logger::end();
assert(false);
return false;
}
const char* pathC = path.c_str();
return PHYSFS_exists(pathC) && PHYSFS_isDirectory(pathC);
}
PhysFSInputStream::PhysFSInputStream( std::string filePath )
{
File = NULL;
if ( PHYSFS_exists(filePath.c_str()) )
{
File = PHYSFS_openRead(filePath.c_str());
}
}
void
VideoSystem::do_take_screenshot()
{
SDLSurfacePtr surface = make_screenshot();
if (!surface) {
log_warning << "Creating the screenshot has failed" << std::endl;
return;
}
const std::string screenshots_dir = "/screenshots";
if (!PHYSFS_exists(screenshots_dir.c_str())) {
if (!PHYSFS_mkdir(screenshots_dir.c_str())) {
log_warning << "Creating '" << screenshots_dir << "' failed" << std::endl;
return;
}
}
auto find_filename = [&]() -> boost::optional<std::string>
{
for (int num = 0; num < 1000000; ++num)
{
std::ostringstream oss;
oss << "screenshot" << std::setw(6) << std::setfill('0') << num << ".png";
const std::string screenshot_filename = FileSystem::join(screenshots_dir, oss.str());
if (!PHYSFS_exists(screenshot_filename.c_str())) {
return screenshot_filename;
}
}
return boost::none;
};
auto filename = find_filename();
if (!filename)
{
log_info << "Failed to find filename to save screenshot" << std::endl;
}
else
{
if (SDLSurface::save_png(*surface, *filename)) {
log_info << "Wrote screenshot to \"" << *filename << "\"" << std::endl;
}
}
}
static int l_filesystem_isFile(lua_State* state) {
if (!PHYSFS_isInit())
return 0;
const char* name = l_tools_toStringOrError(state, 1);
if(!PHYSFS_isDirectory(name) && PHYSFS_exists(name))
lua_pushboolean(state, 1);
else
lua_pushboolean(state, 0);
return 1;
}
