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 }