int main(int argc, char* argv[])
#endif
{
vfs::Directory workdir;
#ifdef CAESARIA_PLATFORM_ANDROID
workdir = vfs::Path( SDL_AndroidGetExternalStoragePath() );
#else
workdir = vfs::Path( argv[0] ).directory();
#endif
Logger::registerWriter( Logger::consolelog, "" );
game::Settings::instance().setwdir( workdir.toString() );
game::Settings::instance().checkwdir( argv, argc );
Logger::registerWriter( Logger::filelog, workdir.toString() );
Logger::warning( "Game: setting workdir to " + SETTINGS_VALUE( workDir ).toString() );
Logger::warning( "Game: load game settings" );
game::Settings::load();
game::Settings::instance().checkCmdOptions( argv, argc );
game::Settings::instance().checkC3present();
Logger::warning( "Game: setting language to " + SETTINGS_VALUE( language ).toString() );
Logger::warning( "Game: using native C3 resources from " + SETTINGS_VALUE( c3gfx ).toString() );
Logger::warning( "Game: set cell width %d", SETTINGS_VALUE( cellw ).toInt() );
#ifdef CAESARIA_USE_STEAM
if( !steamapi::connect() )
return EXIT_FAILURE;
#endif
try
{
Game game;
game.initialize();
while( game.exec() );
}
catch( Exception& e )
{
Logger::warning( "Critical error: " + e.getDescription() );
Stacktrace::print();
}
#ifdef CAESARIA_USE_STEAM
steamapi::close();
#endif
return 0;
}
// Android paths
void setPaths() {
PATH_CONF = std::string(SDL_AndroidGetInternalStoragePath()) + "/config";
PATH_USER = std::string(SDL_AndroidGetInternalStoragePath()) + "/userdata";
createDir(PATH_CONF);
createDir(PATH_USER);
createDir(PATH_USER + "/mods");
createDir(PATH_USER + "/saves");
std::string mods_folder = "data/org.flare.app/files";
if (SDL_AndroidGetExternalStorageState() != 0)
{
PATH_DATA = std::string(SDL_AndroidGetExternalStoragePath());
}
else if (dirExists("/sdcard/Android"))
{
PATH_DATA = "/sdcard/Android/" + mods_folder;
}
else if (dirExists("/mnt/sdcard/Android"))
{
PATH_DATA = "/mnt/sdcard/Android/" + mods_folder;
}
else if (dirExists("storage/sdcard0/Android"))
{
PATH_DATA = "/storage/sdcard0/Android/" + mods_folder;
}
else if (dirExists("/storage/emulated/0/Android"))
{
PATH_DATA = "/storage/emulated/0/Android/" + mods_folder;
}
else if (dirExists("/storage/emulated/legacy/Android"))
{
PATH_DATA = "/storage/emulated/legacy/Android/" + mods_folder;
}
else
{
logError("Settings: Android external storage unavailable: %s", SDL_GetError());
}
PATH_CONF = PATH_CONF + "/";
PATH_USER = PATH_USER + "/";
PATH_DATA = PATH_DATA + "/";
}
bool SetupDefaultDirs(const char *exefilepath, const char *auxfilepath, bool from_bundle)
{
datadir = StripFilePart(exefilepath);
auxdir = auxfilepath ? StripFilePart(SanitizePath(auxfilepath).c_str()) : datadir;
writedir = auxdir;
// FIXME: use SDL_GetBasePath() instead?
#ifdef __APPLE__
if (from_bundle)
{
// default data dir is the Resources folder inside the .app bundle
CFBundleRef mainBundle = CFBundleGetMainBundle();
CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle);
char path[PATH_MAX];
auto res = CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)path, PATH_MAX);
CFRelease(resourcesURL);
if (!res)
return false;
datadir = string(path) + "/";
#ifdef __IOS__
writedir = StripFilePart(path) + "Documents/"; // there's probably a better way to do this in CF
#else
// FIXME: this should probably be ~/Library/Application Support/AppName,
// but for now this works for non-app store apps
writedir = datadir;
#endif
}
#elif defined(__ANDROID__)
SDL_Init(0); // FIXME, is this needed? bad dependency.
auto internalstoragepath = SDL_AndroidGetInternalStoragePath();
auto externalstoragepath = SDL_AndroidGetExternalStoragePath();
Output(OUTPUT_INFO, internalstoragepath);
Output(OUTPUT_INFO, externalstoragepath);
if (internalstoragepath) datadir = internalstoragepath + string("/");
if (externalstoragepath) writedir = externalstoragepath + string("/");
// for some reason, the above SDL functionality doesn't actually work,
// we have to use the relative path only to access APK files:
datadir = "";
auxdir = writedir;
#endif
(void)from_bundle;
return true;
}
void init(const char* company, const char* app)
{
if (_fsInitialized)
return;
_fsInitialized = true;
#ifdef __S3E__
_nfs.setPath("rom://");
_nfsWrite.setPath("ram://");
#elif EMSCRIPTEN
//mkdir("data-ram/", S_IRWXU|S_IRWXG|S_IRWXO);
//_nfsWrite.setPath("data-ram/");
#elif __ANDROID__
log::messageln("internal %s", SDL_AndroidGetInternalStoragePath());
log::messageln("external %s", SDL_AndroidGetExternalStoragePath());
_nfsWrite.setPath(SDL_AndroidGetInternalStoragePath());
#elif OXYGINE_EDITOR
#elif __APPLE__
_nfsWrite.setPath(getSupportFolder().c_str());
#else
if (company && app && *company && *app)
{
char* base_path = SDL_GetPrefPath(company, app);
if (base_path)
{
_nfsWrite.setPath(base_path);
SDL_free(base_path);
}
}
else
{
# ifdef _WIN32
_mkdir("../data-ram/");
# else
mkdir("../data-ram/", ACCESSPERMS);
# endif
_nfsWrite.setPath("../data-ram/");
}
#endif
_nfs.mount(&_nfsWrite);
}
void init()
{
#ifdef __S3E__
_nfs.setPath("rom://");
_nfsWrite.setPath("ram://");
#endif
#ifdef __ANDROID__
log::messageln("internal %s", SDL_AndroidGetInternalStoragePath());
log::messageln("external %s", SDL_AndroidGetExternalStoragePath());
_nfsWrite.setPath(SDL_AndroidGetInternalStoragePath());
#endif // __ANDROID__
#ifdef WIN32
_mkdir("../data-ram/");
_nfsWrite.setPath("../data-ram/");
#endif
_nfs.mount(&_nfsWrite);
//_nfs.mount(&_nfsExtended);
}
int
set_modulepath(char *path, size_t len)
{
struct stat sb;
char *homepath;
#ifdef ANDROID
const char *extpath;
char *p, ep_buf[MAX_PATH], p6dir_buf[MAX_PATH];
FILE *fp;
p6dir_buf[0] = '\0';
extpath = SDL_AndroidGetExternalStoragePath();
p6logd("extpath:%s", extpath);
// get the Android external path (.ex /storage/emulated/0)
strcpy(p6dir_buf, extpath);
p = strstr(p6dir_buf, "/Android/data/com.fc2.blog45.hissorii/files");
if (p != NULL) {
*p = '\0';
p6logd("extpath2:%s", p6dir_buf);
strcat(p6dir_buf, "/px68k");
p6logd("p6dir_buf:%s", p6dir_buf);
// if there is the px68k directory ...
if (stat(p6dir_buf, &sb) == 0 && S_ISDIR(sb.st_mode)) {
goto set_dir;
}
}
if (extpath != NULL) {
// read Android/data/com.fc2.blog45.hissorii/files/dir.txt
sprintf(ep_buf, "%s/dir.txt", extpath);
if ((fp = fopen(ep_buf, "r")) != NULL) {
fgets(p6dir_buf, MAX_PATH - 1, fp);
p6logd("p6dir:%s", p6dir_buf);
fclose(fp);
}
}
// if everything failed, try /sdcard/px68k directory
if (p6dir_buf[0] == '\0') {
strcpy(p6dir_buf, "/sdcard/px68k");
}
set_dir:
strcpy(path, p6dir_buf);
p6logd("path:%s", path);
sprintf(winx68k_ini, "%s/config", p6dir_buf);
p6logd("config:%s", winx68k_ini);
return 0;
#endif
#if TARGET_OS_IPHONE && TARGET_IPHONE_SIMULATOR == 0
puts("Iphone...");
sprintf(path, "/var/mobile/px68k");
sprintf(winx68k_ini, "/var/mobile/px68k/config");
return 0;
#endif
homepath = getenv("HOME");
if (homepath == 0)
homepath = ".";
snprintf(path, len, "%s/%s", homepath, ".keropi");
if (stat(path, &sb) < 0) {
#ifdef WIN32
if (mkdir(path) < 0) {
#else
if (mkdir(path, 0700) < 0) {
#endif
perror(path);
return 1;
}
} else {
if ((sb.st_mode & S_IFDIR) == 0) {
fprintf(stderr, "%s isn't directory.\n", path);
return 1;
}
}
snprintf(winx68k_ini, sizeof(winx68k_ini), "%s/%s", path, "config");
if (stat(winx68k_ini, &sb) >= 0) {
if (sb.st_mode & S_IFDIR) {
fprintf(stderr, "%s is directory.\n", winx68k_ini);
return 1;
}
}
return 0;
}
void LoadConfig(void)
{
int i, j;
char buf[CFGLEN];
FILEH fp;
winx = GetPrivateProfileInt(ini_title, "WinPosX", 0, winx68k_ini);
winy = GetPrivateProfileInt(ini_title, "WinPosY", 0, winx68k_ini);
#ifdef PSP
Config.FrameRate = (BYTE)GetPrivateProfileInt(ini_title, "FrameRate", 5, winx68k_ini);
#else
Config.FrameRate = (BYTE)GetPrivateProfileInt(ini_title, "FrameRate", 7, winx68k_ini);
#endif
if (!Config.FrameRate) Config.FrameRate = 7;
GetPrivateProfileString(ini_title, "StartDir", "", buf, MAX_PATH, winx68k_ini);
if (buf[0] != 0)
strncpy(filepath, buf, sizeof(filepath));
else
filepath[0] = 0;
Config.OPM_VOL = GetPrivateProfileInt(ini_title, "OPM_Volume", 12, winx68k_ini);
Config.PCM_VOL = GetPrivateProfileInt(ini_title, "PCM_Volume", 15, winx68k_ini);
Config.MCR_VOL = GetPrivateProfileInt(ini_title, "MCR_Volume", 13, winx68k_ini);
#ifdef PSP
Config.SampleRate = GetPrivateProfileInt(ini_title, "SampleRate", 11025, winx68k_ini);
#else
Config.SampleRate = GetPrivateProfileInt(ini_title, "SampleRate", 22050, winx68k_ini);
#endif
Config.BufferSize = GetPrivateProfileInt(ini_title, "BufferSize", 50, winx68k_ini);
Config.MouseSpeed = GetPrivateProfileInt(ini_title, "MouseSpeed", 10, winx68k_ini);
GetPrivateProfileString(ini_title, "FDDStatWin", "1", buf, CFGLEN, winx68k_ini);
Config.WindowFDDStat = solveBOOL(buf);
GetPrivateProfileString(ini_title, "FDDStatFullScr", "1", buf, CFGLEN, winx68k_ini);
Config.FullScrFDDStat = solveBOOL(buf);
GetPrivateProfileString(ini_title, "DSAlert", "1", buf, CFGLEN, winx68k_ini);
Config.DSAlert = solveBOOL(buf);
GetPrivateProfileString(ini_title, "SoundLPF", "1", buf, CFGLEN, winx68k_ini);
Config.Sound_LPF = solveBOOL(buf);
GetPrivateProfileString(ini_title, "UseRomeo", "0", buf, CFGLEN, winx68k_ini);
Config.SoundROMEO = solveBOOL(buf);
GetPrivateProfileString(ini_title, "MIDI_SW", "1", buf, CFGLEN, winx68k_ini);
Config.MIDI_SW = solveBOOL(buf);
GetPrivateProfileString(ini_title, "MIDI_Reset", "0", buf, CFGLEN, winx68k_ini);
Config.MIDI_Reset = solveBOOL(buf);
Config.MIDI_Type = GetPrivateProfileInt(ini_title, "MIDI_Type", 1, winx68k_ini);
GetPrivateProfileString(ini_title, "JoySwap", "0", buf, CFGLEN, winx68k_ini);
Config.JoySwap = solveBOOL(buf);
GetPrivateProfileString(ini_title, "JoyKey", "0", buf, CFGLEN, winx68k_ini);
Config.JoyKey = solveBOOL(buf);
GetPrivateProfileString(ini_title, "JoyKeyReverse", "0", buf, CFGLEN, winx68k_ini);
Config.JoyKeyReverse = solveBOOL(buf);
GetPrivateProfileString(ini_title, "JoyKeyJoy2", "0", buf, CFGLEN, winx68k_ini);
Config.JoyKeyJoy2 = solveBOOL(buf);
GetPrivateProfileString(ini_title, "SRAMBootWarning", "1", buf, CFGLEN, winx68k_ini);
Config.SRAMWarning = solveBOOL(buf);
GetPrivateProfileString(ini_title, "WinDrvLFN", "1", buf, CFGLEN, winx68k_ini);
Config.LongFileName = solveBOOL(buf);
GetPrivateProfileString(ini_title, "WinDrvFDD", "1", buf, CFGLEN, winx68k_ini);
Config.WinDrvFD = solveBOOL(buf);
Config.WinStrech = GetPrivateProfileInt(ini_title, "WinStretch", 1, winx68k_ini);
GetPrivateProfileString(ini_title, "DSMixing", "0", buf, CFGLEN, winx68k_ini);
Config.DSMixing = solveBOOL(buf);
Config.XVIMode = (BYTE)GetPrivateProfileInt(ini_title, "XVIMode", 0, winx68k_ini);
GetPrivateProfileString(ini_title, "CDROM_ASPI", "1", buf, CFGLEN, winx68k_ini);
Config.CDROM_ASPI = solveBOOL(buf);
Config.CDROM_SCSIID = (BYTE)GetPrivateProfileInt(ini_title, "CDROM_SCSIID", 6, winx68k_ini);
Config.CDROM_ASPI_Drive = (BYTE)GetPrivateProfileInt(ini_title, "CDROM_ASPIDrv", 0, winx68k_ini);
Config.CDROM_IOCTRL_Drive = (BYTE)GetPrivateProfileInt(ini_title, "CDROM_CTRLDrv", 16, winx68k_ini);
GetPrivateProfileString(ini_title, "CDROM_Enable", "1", buf, CFGLEN, winx68k_ini);
Config.CDROM_Enable = solveBOOL(buf);
GetPrivateProfileString(ini_title, "SSTP_Enable", "0", buf, CFGLEN, winx68k_ini);
Config.SSTP_Enable = solveBOOL(buf);
Config.SSTP_Port = GetPrivateProfileInt(ini_title, "SSTP_Port", 11000, winx68k_ini);
GetPrivateProfileString(ini_title, "ToneMapping", "0", buf, CFGLEN, winx68k_ini);
Config.ToneMap = solveBOOL(buf);
GetPrivateProfileString(ini_title, "ToneMapFile", "", buf, MAX_PATH, winx68k_ini);
if (buf[0] != 0)
strcpy(Config.ToneMapFile, buf);
else
Config.ToneMapFile[0] = 0;
Config.MIDIDelay = GetPrivateProfileInt(ini_title, "MIDIDelay", Config.BufferSize*5, winx68k_ini);
Config.MIDIAutoDelay = GetPrivateProfileInt(ini_title, "MIDIAutoDelay", 1, winx68k_ini);
Config.VkeyScale = GetPrivateProfileInt(ini_title, "VkeyScale", 4, winx68k_ini);
Config.VbtnSwap = GetPrivateProfileInt(ini_title, "VbtnSwap", 0, winx68k_ini);
Config.JoyOrMouse = GetPrivateProfileInt(ini_title, "JoyOrMouse", 0, winx68k_ini);
Config.HwJoyAxis[0] = GetPrivateProfileInt(ini_title, "HwJoyAxis0", 0, winx68k_ini);
Config.HwJoyAxis[1] = GetPrivateProfileInt(ini_title, "HwJoyAxis1", 1, winx68k_ini);
Config.HwJoyHat = GetPrivateProfileInt(ini_title, "HwJoyHat", 0, winx68k_ini);
for (i = 0; i < 8; i++) {
sprintf(buf, "HwJoyBtn%d", i);
Config.HwJoyBtn[i] = GetPrivateProfileInt(ini_title, buf, i, winx68k_ini);
}
Config.NoWaitMode = GetPrivateProfileInt(ini_title, "NoWaitMode", 0, winx68k_ini);
for (i=0; i<2; i++)
{
for (j=0; j<8; j++)
{
sprintf(buf, "Joy%dButton%d", i+1, j+1);
Config.JOY_BTN[i][j] = GetPrivateProfileInt(ini_title, buf, j, winx68k_ini);
}
}
for (i = 0; i < 2; i++) {
sprintf(buf, "FDD%d", i);
GetPrivateProfileString(ini_title, buf, "", Config.FDDImage[i], MAX_PATH, winx68k_ini);
}
for (i=0; i<16; i++)
{
sprintf(buf, "HDD%d", i);
GetPrivateProfileString(ini_title, buf, "", Config.HDImage[i], MAX_PATH, winx68k_ini);
}
#if 0
fp = File_OpenCurDir(KEYCONFFILE);
if (fp)
{
File_Read(fp, KeyTable, 512);
File_Close(fp);
}
#endif
}
void PlatformSetPaths() {
const std::string externalSDList[] = {
"/mnt/extSdCard/Android",
"/storage/extSdCard/Android"
};
const int externalSDList_size = 2;
PATH_CONF = std::string(SDL_AndroidGetInternalStoragePath()) + "/config";
const std::string package_name = AndroidGetPackageName();
const std::string user_folder = "data/" + package_name + "/files";
if (SDL_AndroidGetExternalStorageState() != 0)
{
PATH_USER = std::string(SDL_AndroidGetExternalStoragePath());
}
// NOTE: Next condition shouldn't be needed, but in theory SDL_AndroidGetExternalStoragePath() can fail.
else
{
const std::string internalSDList[] = {
"/sdcard/Android",
"/mnt/sdcard/Android",
"/storage/sdcard0/Android",
"/storage/emulated/0/Android",
"/storage/emulated/legacy/Android",
};
const int internalSDList_size = 5;
for (int i = 0; i < internalSDList_size; i++)
{
if (dirExists(internalSDList[i]))
{
PATH_USER = internalSDList[i] + "/" + user_folder;
break;
}
}
}
if (PATH_USER.empty())
{
logError("Settings: Android external storage unavailable: %s", SDL_GetError());
}
for (int i = 0; i < externalSDList_size; i++)
{
if (dirExists(externalSDList[i]))
{
PATH_DATA = externalSDList[i] + "/" + user_folder;
if (!dirExists(PATH_DATA))
{
createDir(externalSDList[i] + "/data" + package_name);
createDir(externalSDList[i] + "/data" + package_name + "/files");
}
break;
}
}
PATH_USER += "/userdata";
createDir(PATH_CONF);
createDir(PATH_USER);
createDir(PATH_USER + "/mods");
createDir(PATH_USER + "/saves");
PATH_CONF += "/";
PATH_USER += "/";
PATH_DATA += "/";
}
int main(int argc, char* argv[])
#endif
{
#ifdef CAESARIA_USE_STEAM
if( !steamapi::Handler::checkSteamRunning() )
return EXIT_FAILURE;
if( !steamapi::Handler::init() )
return EXIT_FAILURE;
#endif
vfs::Directory workdir;
#ifdef CAESARIA_PLATFORM_ANDROID
workdir = vfs::Path( SDL_AndroidGetExternalStoragePath() );
#else
workdir = vfs::Path( argv[0] ).directory();
#endif
Logger::registerWriter( Logger::consolelog, "" );
Logger::warning( "Options: working directory is " + workdir.toString() );
GameSettings::instance().setwdir( workdir.toString() );
for (int i = 0; i < (argc - 1); i++)
{
if( !strcmp( argv[i], "-R" ) )
{
const char* opts = argv[i+1];
workdir = vfs::Path( opts );
Logger::warning( "Options: setting workdir to %s", opts );
GameSettings::instance().setwdir( std::string( opts, strlen( opts ) ) );
i++;
}
else if( !strcmp( argv[i], "-Lc" ) )
{
const char* opts = argv[i+1];
Logger::warning( "Options: setting language to %s", opts );
GameSettings::set( GameSettings::language, Variant( opts ) );
i++;
}
else if( !strcmp( argv[i], "-c3gfx" ) )
{
const char* opts = argv[i+1];
Logger::warning( "Options: using native C3 resources from %s", opts );
GameSettings::set( GameSettings::c3gfx, Variant( opts ) );
i++;
}
}
Logger::registerWriter( Logger::filelog, workdir.toString() );
try
{
Game game;
game.initialize();
while( game.exec() );
}
catch( Exception& e )
{
Logger::warning( "Critical error: " + e.getDescription() );
Stacktrace::print();
}
#ifdef CAESARIA_USE_STEAM
steamapi::Handler::close();
#endif
return 0;
}
void setupPHYSFS()
{
FileSystem& fs = FileSystem::getSingleton();
std::string separator = fs.getDirSeparator();
// Game should be playable out of the source package on all
// relevant platforms.
std::string baseSearchPath("data" + separator);
// Android and iOS are needing a special path
#ifdef __ANDROID__
baseSearchPath = SDL_AndroidGetExternalStoragePath() + separator;
#endif
#ifdef __APPLE__
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
baseSearchPath = PHYSFS_getBaseDir();
#endif
#ifdef MAC_OS_X
baseSearchPath = PHYSFS_getBaseDir() + std::string("Contents") + separator + std::string("Resources") + separator + std::string("data") + separator;
#endif
#endif
fs.addToSearchPath(baseSearchPath);
fs.addToSearchPath(baseSearchPath + "gfx.zip");
fs.addToSearchPath(baseSearchPath + "sounds.zip");
fs.addToSearchPath(baseSearchPath + "scripts.zip");
fs.addToSearchPath(baseSearchPath + "backgrounds.zip");
fs.addToSearchPath(baseSearchPath + "rules.zip");
#if defined(WIN32)
// Just write in installation directory
fs.setWriteDir("data");
// handle the case when it is installed
fs.addToSearchPath(BLOBBY_INSTALL_PREFIX "/share/blobby");
fs.addToSearchPath(BLOBBY_INSTALL_PREFIX "/share/blobby/gfx.zip");
fs.addToSearchPath(BLOBBY_INSTALL_PREFIX "/share/blobby/sounds.zip");
fs.addToSearchPath(BLOBBY_INSTALL_PREFIX "/share/blobby/scripts.zip");
fs.addToSearchPath(BLOBBY_INSTALL_PREFIX "/share/blobby/backgrounds.zip");
fs.addToSearchPath(BLOBBY_INSTALL_PREFIX "/share/blobby/rules.zip");
#else
#ifndef __ANDROID__
// Create a search path in the home directory and ensure that
// all paths exist and are actually directories
#ifdef __APPLE__
#if TARGET_OS_IPHONE
std::string userdir = baseSearchPath + "../Documents/";
#else
std::string userdir = fs.getUserDir();
#endif
#else
std::string userdir = fs.getUserDir();
#endif
std::string userAppend = ".blobby";
std::string homedir = userdir + userAppend;
/// \todo please review this code and determine if we really need to add userdir to serach path
/// only to remove it later
fs.setWriteDir(userdir);
fs.probeDir(userAppend);
/// \todo why do we need separator here?
fs.probeDir(userAppend + separator + "replays");
fs.probeDir(userAppend + separator + "gfx");
fs.probeDir(userAppend + separator + "sounds");
fs.probeDir(userAppend + separator + "scripts");
fs.probeDir(userAppend + separator + "backgrounds");
fs.probeDir(userAppend + separator + "rules");
fs.removeFromSearchPath(userdir);
// here we set the write dir anew!
fs.setWriteDir(homedir);
#if defined(GAMEDATADIR)
{
// A global installation path makes only sense on non-Windows
// platforms
std::string basedir = GAMEDATADIR;
fs.addToSearchPath(basedir);
fs.addToSearchPath(basedir + separator + "gfx.zip");
fs.addToSearchPath(basedir + separator + "sounds.zip");
fs.addToSearchPath(basedir + separator + "scripts.zip");
fs.addToSearchPath(basedir + separator + "backgrounds.zip");
fs.addToSearchPath(basedir + separator + "rules.zip");
}
#endif
#else
fs.setWriteDir(baseSearchPath);
fs.probeDir("replays");
fs.probeDir("gfx");
fs.probeDir("sounds");
fs.probeDir("scripts");
fs.probeDir("backgrounds");
fs.probeDir("rules");
#endif
#endif
}
