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;
}
void Game::testAllHelpFiles(){
getGameView()->printStatusMessage( "Testing Help Files...");
std::string filename;
std::string directory = "help/en";
std::string fullname;
char **rc = PHYSFS_enumerateFiles( directory.c_str() );
char **i;
size_t pos;
for (i = rc; *i != NULL; i++) {
fullname = directory;
fullname.append( *i );
filename.assign( *i );
if(PHYSFS_isDirectory(fullname.c_str()))
continue;
pos = filename.rfind( ".xml" );
if( pos != std::string::npos ){
filename.replace( pos, 4 ,"");
std::cerr << "--- Examining " << filename << "\n";
helpWindow->showTopic( filename );
std::cerr << "\n";
}
}
PHYSFS_freeList(rc);
}
static PHYSFSX_counted_list file_getdirlist(const char *dir)
{
ntstring<PATH_MAX - 1> path;
auto dlen = path.copy_if(dir);
if ((!dlen && dir[0] != '\0') || !path.copy_if(dlen, "/"))
return nullptr;
++ dlen;
PHYSFSX_counted_list list{PHYSFS_enumerateFiles(dir)};
if (!list)
return nullptr;
const auto predicate = [&](char *i) -> bool {
if (path.copy_if(dlen, i) && PHYSFS_isDirectory(path))
return false;
free(i);
return true;
};
auto j = std::remove_if(list.begin(), list.end(), predicate);
*j = NULL;
auto NumDirs = j.get() - list.get();
qsort(list.get(), NumDirs, sizeof(char *), string_array_sort_func);
if (*dir)
{
// Put the 'go to parent directory' sequence '..' first
++NumDirs;
auto r = reinterpret_cast<char **>(realloc(list.get(), sizeof(char *)*(NumDirs + 1)));
if (!r)
return list;
list.release();
list.reset(r);
std::move_backward(r, r + NumDirs, r + NumDirs + 1);
list[0] = d_strdup("..");
}
list.set_count(NumDirs);
return list;
}
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 physfsDrive::TestDir(const char * dir) {
char newdir[CROSS_LEN];
strcpy(newdir,basedir);
strcat(newdir,dir);
CROSS_FILENAME(newdir);
dirCache.ExpandName(newdir);
normalize(newdir,basedir);
return (PHYSFS_isDirectory(newdir));
}
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 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);
}
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;
}
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
}
bool physfsDrive::RemoveDir(const char * dir) {
char newdir[CROSS_LEN];
strcpy(newdir,basedir);
strcat(newdir,dir);
CROSS_FILENAME(newdir);
dirCache.ExpandName(newdir);
normalize(newdir,basedir);
if (PHYSFS_isDirectory(newdir) && PHYSFS_delete(newdir)) {
CROSS_FILENAME(newdir);
dirCache.DeleteEntry(newdir,true);
return true;
}
return false;
}
static int cmd_isdir(char *args)
{
int rc;
if (*args == '\"')
{
args++;
args[strlen(args) - 1] = '\0';
} /* if */
rc = PHYSFS_isDirectory(args);
printf("File %s a directory.\n", rc ? "is" : "is NOT");
return(1);
} /* cmd_isdir */
bool physfsDrive::FindNext(DOS_DTA & dta) {
char * dir_ent;
char full_name[CROSS_LEN];
Bit8u srch_attr;char srch_pattern[DOS_NAMELENGTH_ASCII];
Bit8u find_attr;
dta.GetSearchParams(srch_attr,srch_pattern);
Bitu id = dta.GetDirID();
again:
if (!dirCache.FindNext(id,dir_ent)) {
DOS_SetError(DOSERR_NO_MORE_FILES);
return false;
}
if(!WildFileCmp(dir_ent,srch_pattern)) goto again;
char find_name[DOS_NAMELENGTH_ASCII];Bit16u find_date,find_time;Bit32u find_size;
if(strlen(dir_ent)<DOS_NAMELENGTH_ASCII){
strcpy(find_name,dir_ent);
upcase(find_name);
}
strcpy(full_name,srchInfo[id].srch_dir);
strcat(full_name,dir_ent);
dirCache.ExpandName(full_name);
normalize(full_name,basedir);
if (PHYSFS_isDirectory(full_name)) find_attr=DOS_ATTR_DIRECTORY|DOS_ATTR_ARCHIVE;
else find_attr=DOS_ATTR_ARCHIVE;
if (~srch_attr & find_attr & (DOS_ATTR_DIRECTORY | DOS_ATTR_HIDDEN | DOS_ATTR_SYSTEM)) goto again;
/*file is okay, setup everything to be copied in DTA Block */
find_size=(Bit32u)PHYSFS_fileLength(full_name);
time_t mytime = (time_t)PHYSFS_getLastModTime(full_name);
struct tm *time;
if((time=localtime(&mytime))!=0){
find_date=DOS_PackDate((Bit16u)(time->tm_year+1900),(Bit16u)(time->tm_mon+1),(Bit16u)time->tm_mday);
find_time=DOS_PackTime((Bit16u)time->tm_hour,(Bit16u)time->tm_min,(Bit16u)time->tm_sec);
} else {
find_time=6;
find_date=4;
}
dta.SetResult(find_name,find_size,find_date,find_time,find_attr);
return true;
}
bool physfsDrive::GetFileAttr(const char * name,Bit16u * attr) {
char newname[CROSS_LEN];
strcpy(newname,basedir);
strcat(newname,name);
CROSS_FILENAME(newname);
dirCache.ExpandName(newname);
normalize(newname,basedir);
char *last = strrchr(newname,'/');
if (last == NULL) last = newname-1;
*attr = 0;
if (!PHYSFS_exists(newname)) return false;
*attr=DOS_ATTR_ARCHIVE;
if (PHYSFS_isDirectory(newname)) *attr|=DOS_ATTR_DIRECTORY;
return true;
}
void *physfsDrive::opendir(const char *name) {
char myname[CROSS_LEN];
strcpy(myname,name);
normalize(myname,basedir);
if (!PHYSFS_isDirectory(myname)) return NULL;
struct opendirinfo *oinfo = (struct opendirinfo *)malloc(sizeof(struct opendirinfo));
oinfo->files = PHYSFS_enumerateFiles(myname);
if (oinfo->files == NULL) {
LOG_MSG("PHYSFS: nothing found for %s (%s)",myname,PHYSFS_getLastError());
free(oinfo);
return NULL;
}
oinfo->pos = (myname[1] == 0?0:-2);
return (void *)oinfo;
}
OSFILE *OSBasics::open(String filename, String opts) {
OSFILE *retFile = NULL;
if(PHYSFS_exists(filename.c_str())) {
if(!PHYSFS_isDirectory(filename.c_str())) {
retFile = new OSFILE;
retFile->fileType = OSFILE::TYPE_ARCHIVE_FILE;
if(opts.find("a") !=string::npos) {
retFile->physFSFile = PHYSFS_openAppend(filename.c_str());
if(!retFile->physFSFile){
printf("Error opening file from archive (%s)\n", filename.c_str());
return NULL;
}
} else if(opts.find("w") !=string::npos) {
retFile->physFSFile = PHYSFS_openWrite(filename.c_str());
if(!retFile->physFSFile){
printf("Error opening file from archive (%s)\n", filename.c_str());
return NULL;
}
} else {
retFile->physFSFile = PHYSFS_openRead(filename.c_str());
if(!retFile->physFSFile){
printf("Error opening file from archive (%s)\n", filename.c_str());
return NULL;
}
}
return retFile;
}
} else {
// Logger::log("File doesn't exist in archive (%s)\n", filename.c_str());
}
FILE *file = fopen(filename.c_str(), opts.c_str());
if(file) {
retFile = new OSFILE;
retFile->fileType = OSFILE::TYPE_FILE;
retFile->file = file;
return retFile;
}
return NULL;
}
void probeDir(const std::string& dirname)
{
if (PHYSFS_isDirectory(dirname.c_str()) == 0)
{
if (PHYSFS_exists(dirname.c_str()))
{
PHYSFS_delete(dirname.c_str());
}
if (PHYSFS_mkdir(dirname.c_str()))
{
std::cout << PHYSFS_getWriteDir() <<
dirname << " created" << std::endl;
}
else
{
std::cout << "Warning: Creation of" <<
PHYSFS_getWriteDir() << dirname <<
" failed!" << std::endl;
}
}
}
static void add_missions_to_list(mle *mission_list, char *path, char *rel_path, int anarchy_mode)
{
char **find, **i, *ext;
find = PHYSFS_enumerateFiles(path);
for (i = find; *i != NULL; i++)
{
if (strlen(path) + strlen(*i) + 1 >= PATH_MAX)
continue; // path is too long
strcat(rel_path, *i);
if (PHYSFS_isDirectory(path))
{
strcat(rel_path, "/");
add_missions_to_list(mission_list, path, rel_path, anarchy_mode);
*(strrchr(path, '/')) = 0;
}
else if ((ext = strrchr(*i, '.')) && (!strnicmp(ext, ".msn", 4) || !strnicmp(ext, ".mn2", 4)))
if (read_mission_file(&mission_list[num_missions], rel_path, ML_MISSIONDIR))
{
if (anarchy_mode || !mission_list[num_missions].anarchy_only_flag)
{
mission_list[num_missions].builtin_hogsize = 0;
num_missions++;
}
else
d_free(mission_list[num_missions].path);
}
if (num_missions >= MAX_MISSIONS)
{
break;
}
(strrchr(path, '/'))[1] = 0; // chop off the entry
}
PHYSFS_freeList(find);
}
// 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;
}
vector<OSFileEntry> OSBasics::parsePhysFSFolder(String pathString, bool showHidden) {
vector<OSFileEntry> returnVector;
char **rc = PHYSFS_enumerateFiles(pathString.c_str());
char **i;
String fullPath;
String fname;
for (i = rc; *i != NULL; i++) {
fname = string(*i);
fullPath = pathString + "/" + fname;
if((fname.c_str()[0] != '.' || (fname.c_str()[0] == '.' && showHidden)) && fname != "..") {
if(PHYSFS_isDirectory(fullPath.c_str())) {
returnVector.push_back(OSFileEntry(pathString, fname, OSFileEntry::TYPE_FOLDER));
} else {
returnVector.push_back(OSFileEntry(pathString, fname, OSFileEntry::TYPE_FILE));
}
}
}
PHYSFS_freeList(rc);
return returnVector;
}
std::vector<std::string> CResourceManager::ListDirectories(const std::string &directory)
{
std::vector<std::string> result;
if (PHYSFS_isInit())
{
char **files = PHYSFS_enumerateFiles(CleanPath(directory).c_str());
for (char **i = files; *i != nullptr; i++)
{
std::string path = CleanPath(directory) + "/" + (*i);
if (PHYSFS_isDirectory(path.c_str()))
{
result.push_back(*i);
}
}
PHYSFS_freeList(files);
}
return result;
}
void
Sound::loadWaves() {
//Load Waves
std::string filename;
std::string directory = "sounds/";
std::string fullname;
Mix_Chunk *chunk;
SDL_RWops* file;
char **rc = PHYSFS_enumerateFiles( directory.c_str() );
char **i;
for (i = rc; *i != NULL; i++) {
fullname = directory;
fullname.append( *i );
filename.assign( *i );
if(PHYSFS_isDirectory(fullname.c_str()))
continue;
try {
file = getPhysfsSDLRWops( fullname.c_str() );
chunk = Mix_LoadWAV_RW( file, 1);
if(!chunk) {
std::stringstream msg;
msg << "Couldn't read soundfile '" << fullname
<< "': " << SDL_GetError();
throw std::runtime_error(msg.str());
}
std::string idName = getIdName( filename );
waves.insert( std::pair<std::string,Mix_Chunk*>(idName, chunk) );
} catch(std::exception& e) {
std::cerr << "Error: " << e.what() << "\n";
}
}
PHYSFS_freeList(rc);
}
bool physfsDrive::FileCreate(DOS_File * * file,const char * name,Bit16u attributes) {
char newname[CROSS_LEN];
strcpy(newname,basedir);
strcat(newname,name);
CROSS_FILENAME(newname);
dirCache.ExpandName(newname);
normalize(newname,basedir);
/* Test if file exists, don't add to dirCache then */
bool existing_file=PHYSFS_exists(newname);
char *slash = strrchr(newname,'/');
if (slash && slash != newname) {
*slash = 0;
if (!PHYSFS_isDirectory(newname)) return false;
PHYSFS_mkdir(newname);
*slash = '/';
}
PHYSFS_file * hand=PHYSFS_openWrite(newname);
if (!hand){
LOG_MSG("Warning: file creation failed: %s (%s)",newname,PHYSFS_getLastError());
return false;
}
/* Make the 16 bit device information */
*file=new physfsFile(name,hand,0x202,newname,true);
(*file)->flags=OPEN_READWRITE;
if(!existing_file) {
strcpy(newname,basedir);
strcat(newname,name);
CROSS_FILENAME(newname);
dirCache.AddEntry(newname, true);
}
return true;
}
bool FileSystem::isDirectory(const std::string& dirname) const
{
return PHYSFS_isDirectory(dirname.c_str());
}
int realmain(int argc, char *argv[])
{
// The libcrypto startup stuff... May or may not actually be needed for anything at all.
ERR_load_crypto_strings(); // This is needed for descriptive error messages.
OpenSSL_add_all_algorithms(); // Don't actually use the EVP functions, so probably not needed.
OPENSSL_config(nullptr); // What does this actually do?
#ifdef WZ_OS_WIN
RAND_screen(); // Uses a screenshot as a random seed, on systems lacking /dev/random.
#endif
wzMain(argc, argv);
int utfargc = argc;
const char** utfargv = (const char**)argv;
#ifdef WZ_OS_MAC
cocoaInit();
#endif
debug_init();
debug_register_callback( debug_callback_stderr, NULL, NULL, NULL );
#if defined(WZ_OS_WIN) && defined(DEBUG_INSANE)
debug_register_callback( debug_callback_win32debug, NULL, NULL, NULL );
#endif // WZ_OS_WIN && DEBUG_INSANE
// *****
// NOTE: Try *NOT* to use debug() output routines without some other method of informing the user. All this output is sent to /dev/nul at this point on some platforms!
// *****
if (!getUTF8CmdLine(&utfargc, &utfargv))
{
return EXIT_FAILURE;
}
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8")); // make Qt treat all C strings in Warzone as UTF-8
setupExceptionHandler(utfargc, utfargv, version_getFormattedVersionString());
/*** Initialize PhysicsFS ***/
initialize_PhysicsFS(utfargv[0]);
/*** Initialize translations ***/
initI18n();
// find early boot info
if (!ParseCommandLineEarly(utfargc, utfargv))
{
return EXIT_FAILURE;
}
/* Initialize the write/config directory for PhysicsFS.
* This needs to be done __after__ the early commandline parsing,
* because the user might tell us to use an alternative configuration
* directory.
*/
initialize_ConfigDir();
/*** Initialize directory structure ***/
make_dir(ScreenDumpPath, "screenshots", NULL);
make_dir(SaveGamePath, "savegames", NULL);
PHYSFS_mkdir("savegames/campaign");
PHYSFS_mkdir("savegames/skirmish");
make_dir(MultiCustomMapsPath, "maps", NULL); // MUST have this to prevent crashes when getting map
PHYSFS_mkdir("music");
PHYSFS_mkdir("logs"); // a place to hold our netplay, mingw crash reports & WZ logs
PHYSFS_mkdir("userdata"); // a place to store per-mod data user generated data
memset(rulesettag, 0, sizeof(rulesettag)); // tag to add to userdata to find user generated stuff
make_dir(MultiPlayersPath, "multiplay", NULL);
make_dir(MultiPlayersPath, "multiplay", "players");
if (!customDebugfile)
{
// there was no custom debug file specified (--debug-file=blah)
// so we use our write directory to store our logs.
time_t aclock;
struct tm *newtime;
char buf[PATH_MAX];
time( &aclock ); // Get time in seconds
newtime = localtime( &aclock ); // Convert time to struct
// Note: We are using fopen(), and not physfs routines to open the file
// log name is logs/(or \)WZlog-MMDD_HHMMSS.txt
snprintf(buf, sizeof(buf), "%slogs%sWZlog-%02d%02d_%02d%02d%02d.txt", PHYSFS_getWriteDir(), PHYSFS_getDirSeparator(),
newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec );
debug_register_callback( debug_callback_file, debug_callback_file_init, debug_callback_file_exit, buf );
// FIXME: Change this to LOG_WZ on next release
debug(LOG_INFO, "Using %s debug file", buf);
}
// NOTE: it is now safe to use debug() calls to make sure output gets captured.
check_Physfs();
debug(LOG_WZ, "Warzone 2100 - %s", version_getFormattedVersionString());
debug(LOG_WZ, "Using language: %s", getLanguage());
debug(LOG_WZ, "Backend: %s", BACKEND);
debug(LOG_MEMORY, "sizeof: SIMPLE_OBJECT=%ld, BASE_OBJECT=%ld, DROID=%ld, STRUCTURE=%ld, FEATURE=%ld, PROJECTILE=%ld",
(long)sizeof(SIMPLE_OBJECT), (long)sizeof(BASE_OBJECT), (long)sizeof(DROID), (long)sizeof(STRUCTURE), (long)sizeof(FEATURE), (long)sizeof(PROJECTILE));
/* Put in the writedir root */
sstrcpy(KeyMapPath, "keymap.map");
// initialise all the command line states
war_SetDefaultStates();
debug(LOG_MAIN, "initializing");
PhysicsEngineHandler engine; // register abstract physfs filesystem
loadConfig();
// parse the command line
if (!ParseCommandLine(utfargc, utfargv))
{
return EXIT_FAILURE;
}
// Save new (commandline) settings
saveConfig();
// Find out where to find the data
scanDataDirs();
// Now we check the mods to see if they exist or not (specified on the command line)
// They are all capped at 100 mods max(see clparse.c)
// FIX ME: I know this is a bit hackish, but better than nothing for now?
{
char *modname;
char modtocheck[256];
int i = 0;
int result = 0;
// check global mods
for(i=0; i < 100; i++)
{
modname = global_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/global/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The (global) mod (%s) you have specified doesn't exist!", modname);
}
else
{
info("(global) mod (%s) is enabled", modname);
}
}
// check campaign mods
for(i=0; i < 100; i++)
{
modname = campaign_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/campaign/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_ca (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_ca (%s) is enabled", modname);
}
}
// check multiplay mods
for(i=0; i < 100; i++)
{
modname = multiplay_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/multiplay/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_mp (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_mp (%s) is enabled", modname);
}
}
}
if (!wzMain2(war_getFSAA(), war_getFullscreen(), war_GetVsync()))
{
return EXIT_FAILURE;
}
int w = pie_GetVideoBufferWidth();
int h = pie_GetVideoBufferHeight();
char buf[256];
ssprintf(buf, "Video Mode %d x %d (%s)", w, h, war_getFullscreen() ? "fullscreen" : "window");
addDumpInfo(buf);
debug(LOG_MAIN, "Final initialization");
if (!frameInitialise())
{
return EXIT_FAILURE;
}
if (!screenInitialise())
{
return EXIT_FAILURE;
}
if (!pie_LoadShaders())
{
return EXIT_FAILURE;
}
war_SetWidth(pie_GetVideoBufferWidth());
war_SetHeight(pie_GetVideoBufferHeight());
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
pal_Init();
pie_LoadBackDrop(SCREEN_RANDOMBDROP);
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
if (!systemInitialise())
{
return EXIT_FAILURE;
}
//set all the pause states to false
setAllPauseStates(false);
// Copy this info to be used by the crash handler for the dump file
ssprintf(buf,"Using Backend: %s", BACKEND);
addDumpInfo(buf);
ssprintf(buf,"Using language: %s", getLanguageName());
addDumpInfo(buf);
// Do the game mode specific initialisation.
switch(GetGameMode())
{
case GS_TITLE_SCREEN:
startTitleLoop();
break;
case GS_SAVEGAMELOAD:
initSaveGameLoad();
break;
case GS_NORMAL:
startGameLoop();
break;
default:
debug(LOG_ERROR, "Weirdy game status, I'm afraid!!");
break;
}
#if defined(WZ_CC_MSVC) && defined(DEBUG)
debug_MEMSTATS();
#endif
debug(LOG_MAIN, "Entering main loop");
wzMain3();
saveConfig();
systemShutdown();
#ifdef WZ_OS_WIN // clean up the memory allocated for the command line conversion
for (int i=0; i<argc; i++)
{
const char*** const utfargvF = &utfargv;
free((void *)(*utfargvF)[i]);
}
free(utfargv);
#endif
wzShutdown();
debug(LOG_MAIN, "Completed shutting down Warzone 2100");
return EXIT_SUCCESS;
}
bool isDirectory(const char *const fname)
{
return PHYSFS_isDirectory(fname);
}
/* Loads music file names from a given directory or M3U playlist */
void jukebox_load()
{
jukebox_unload();
// Check if it's an M3U file
auto &cfgpath = CGameCfg.CMLevelMusicPath;
size_t musiclen = strlen(cfgpath.data());
if (musiclen > 4 && !d_stricmp(&cfgpath[musiclen - 4], ".m3u"))
read_m3u();
else // a directory
{
class PHYSFS_path_deleter
{
public:
void operator()(const char *const p) const noexcept
{
PHYSFS_removeFromSearchPath(p);
}
};
std::unique_ptr<const char, PHYSFS_path_deleter> new_path;
const char *sep = PHYSFS_getDirSeparator();
size_t seplen = strlen(sep);
// stick a separator on the end if necessary.
if (musiclen >= seplen)
{
auto p = &cfgpath[musiclen - seplen];
if (strcmp(p, sep))
cfgpath.copy_if(musiclen, sep, seplen);
}
const auto p = cfgpath.data();
// Read directory using PhysicsFS
if (PHYSFS_isDirectory(p)) // find files in relative directory
JukeboxSongs.list.reset(PHYSFSX_findFiles(p, jukebox_exts));
else
{
if (PHYSFSX_isNewPath(p))
new_path.reset(p);
PHYSFS_addToSearchPath(p, 0);
// as mountpoints are no option (yet), make sure only files originating from GameCfg.CMLevelMusicPath are aded to the list.
JukeboxSongs.list.reset(PHYSFSX_findabsoluteFiles("", p, jukebox_exts));
}
if (!JukeboxSongs.list)
{
return;
}
JukeboxSongs.num_songs = std::distance(JukeboxSongs.list.begin(), JukeboxSongs.list.end());
}
if (JukeboxSongs.num_songs)
{
con_printf(CON_DEBUG,"Jukebox: %d music file(s) found in %s", JukeboxSongs.num_songs, cfgpath.data());
if (CGameCfg.CMLevelMusicTrack[1] != JukeboxSongs.num_songs)
{
CGameCfg.CMLevelMusicTrack[1] = JukeboxSongs.num_songs;
CGameCfg.CMLevelMusicTrack[0] = 0; // number of songs changed so start from beginning.
}
}
else
{
CGameCfg.CMLevelMusicTrack[0] = -1;
CGameCfg.CMLevelMusicTrack[1] = -1;
con_puts(CON_DEBUG,"Jukebox music could not be found!");
}
}
static int Lua_FS_isDirectory(lua_State *L) {
const char *filename = luaL_checkstring(L, 1);
lua_pushboolean(L, PHYSFS_isDirectory(filename));
return 1;
}
/* helper functions for drive cache */
bool physfsDrive::isdir(const char *name) {
char myname[CROSS_LEN];
strcpy(myname,name);
normalize(myname,basedir);
return PHYSFS_isDirectory(myname);
}
bool
ResourceManager::isDirectory(const std::string &path)
{
return PHYSFS_isDirectory(path.c_str());
}