bool vfs::CVirtualFileSystem::removeFileFromFS(vfs::Path const& sFilePath)
{
vfs::Path sPath,sFile;
sFilePath.splitLast(sPath,sFile);
vfs::CVirtualProfile *pProf = m_oProfileStack.getWriteProfile();
if(pProf)
{
vfs::IBaseLocation *pBL = pProf->getLocation(sPath);
if(pBL && pBL->implementsWritable())
{
vfs::TDirectory<vfs::IWritable> *pDir = dynamic_cast<vfs::TDirectory<vfs::IWritable>*>(pBL);
if(pDir)
{
bool bSuccess = false;
// remove file from virtual structures first
vfs::IBaseFile* file = pDir->getFile(sFilePath);
if(file)
{
vfs::Path sDir,sFile;
sFilePath.splitLast(sDir,sFile);
vfs::CVirtualLocation *pVLoc = this->getVirtualLocation(sDir);
if(pVLoc)
{
bSuccess = pVLoc->removeFile(file);
}
}
// delete actual file
return bSuccess && pDir->deleteFileFromDirectory(sFilePath);
}
}
}
return false;
}
void vfs::Path::splitFirst(vfs::Path &rsFirst, vfs::Path &rsTail) const
{
pathSplitFirst(_path, rsFirst._path, rsTail._path, _sep.first, _sep.last);
getFirstLastSeparator(rsFirst.c_str(), rsFirst._sep.first, rsFirst._sep.last);
getFirstLastSeparator(rsTail.c_str(), rsTail._sep.first, rsTail._sep.last);
// no need to check, as the original path is already checked
//rPath.doCheck();
//rFile.doCheck();
}
/**
* Downloads a single file from the specified server.
*/
bool GetOneFile(
const launcher::Settings &settings,
const std::string &filename, const Signature crc) {
Trace("Attempting to download " << filename);
core::net::NetClient client(core::net::eConnectionMode::TCP_ASYNC);
std::string hostName;
for (auto server = settings.get_patch_server_begin(); server != settings.get_patch_server_end(); ++server) {
client.start(settings.get_patch_server(0));
if (client.valid()) {
hostName = wrappers::net::http::Uri(server->get_dns_name()).getHost();
break;
}
}
if (!client.valid()) {
Log(LL::Error) << "Unable to connect to any servers." << std::endl;
return false;
}
wrappers::net::http::HttpHeader header = wrappers::net::http::HttpHeader::Builder()
.setRequestType(wrappers::net::http::HttpHeader::eRequestType::HTTP_REQUEST_GET)
.setRequestPath(std::string("/") + settings.get_server_patch_dir() + filename)
.addHeader("host", hostName)
.build();
if (!header.valid()) {
return false;
}
client.send(header.asBlob());
const vfs::Path outputPath = GetOutputPath(filename);
vfs::ofstream outfile(outputPath, std::ios::binary | std::ios::out);
if (!outfile.is_open()) {
Log(LL::Error) << "Unable to open file: " << outputPath.str() << std::endl;
return false;
}
wrappers::net::http::HttpFileHandler fileHandler(outfile);
while (client.valid() && !fileHandler.done()) {
client.update(fileHandler);
core::thread::thisthread::yield();
}
client.stop();
outfile.flush();
if (!fileHandler.success()) {
return false;
}
return CheckSignature(outputPath, crc);
}
IniFilePtr IniFile::ConstructFromFile(vfs::Path filename)
{
// Start parsing
std::ifstream iniFile(filename.toString().c_str());
if (!iniFile)
{
Logger::warning( "[IniFile]: Cannot open file " + filename.toString() );
return IniFilePtr();
}
return ConstructFromStream(iniFile);
}
void IniFile::ExportToFile(vfs::Path file, const std::string& headerComments) const
{
std::ofstream stream(file.toString().c_str());
if (!headerComments.empty())
{
// Split the header text into lines and export it as INI comment
std::vector<std::string> lines = StringHelper::split( headerComments, "\n" );
for (std::size_t i = 0; i < lines.size(); ++i)
{
stream << "# " << lines[i] << std::endl;
}
// add some additional line break after the header
stream << std::endl;
}
for (Sections::const_iterator i = _settings.begin(); i != _settings.end(); ++i)
{
stream << "[" << i->first << "]" << std::endl;
for (Options::const_iterator kv = i->second.begin(); kv != i->second.end(); ++kv)
{
stream << kv->key << " = " << kv->value << std::endl;
}
stream << std::endl;
}
}
VariantMap SaveAdapter::load( const vfs::Path& filename )
{
Logger::warning( "SaveAdapter: try load model from " + filename.toString() );
NFile f = NFile::open( filename );
return load( f );
}
bool vfs::CVirtualFileSystem::createNewFile(vfs::Path const& sFilename)
{
vfs::Path sPath,sFile;
sFilename.splitLast(sPath,sFile);
vfs::CVirtualProfile *pProf = m_oProfileStack.getWriteProfile();
if(pProf)
{
bool bIsExclusive = false;
bool bNewLocation = false;
vfs::IBaseLocation *pProfLoc = pProf->getLocation(sPath);
if(!pProfLoc)
{
// try to find closest match
vfs::Path sTemp, sCreateDir, sRight, sLeft = sPath;
while(!pProfLoc && !sLeft.empty())
{
sLeft.splitLast(sTemp,sRight);
sLeft = sTemp;
sCreateDir = sRight + sCreateDir;
pProfLoc = pProf->getLocation(sLeft);
}
// see if the closest match is exclusive
// if yes, then the the new path is a subdirectory and has to be exclusive too
vfs::CVirtualLocation *pVLoc = this->getVirtualLocation(sLeft,true);
if(pVLoc)
{
bIsExclusive = pVLoc->getIsExclusive();
}
//else
//{
// VFS_THROW(L"location (closest match) should exist");
//}
bNewLocation = true;
}
if(pProfLoc && pProfLoc->implementsWritable())
{
// create file and add to location
vfs::TDirectory<vfs::IWritable> *pDir = dynamic_cast<vfs::TDirectory<vfs::IWritable>*>(pProfLoc);
vfs::IBaseFile* pFile = pDir->addFile(sFilename);
if(bNewLocation)
{
pProf->addLocation(pProfLoc);
}
if(pFile)
{
CVirtualLocation* pLoc = this->getVirtualLocation(sPath,true);
if(bIsExclusive)
{
pLoc->setIsExclusive(bIsExclusive);
}
pLoc->addFile(pFile,pProf->cName);
return true;
}
}
}
// throw ?
return false;
}
bool Addon::open(vfs::Path path)
{
# ifdef CAESARIA_PLATFORM_WIN
_d->library = ::LoadLibraryA(path.toString().c_str());
# else
_d->library = ::dlopen(path.toString().c_str(), RTLD_LAZY);
# endif
if( _d->library != 0 )
{
_d->isOpened = true;
_d->funcInit = _d->initFunction<addonInitFunctor>( "initialize" );
_d->funcGetVersion = _d->initFunction<addonGetVersionFunctor>( "getVersion" );
_d->funcGetLevel = _d->initFunction<addonGetLevelFunctor>( "getLevel" );
}
return _d->isOpened;
}
void PictureBank::Impl::loadAtlas(const vfs::Path& filePath)
{
if( !filePath.exist() )
{
Logger::warning( "PictureBank: cant find atlas " + filePath.toString() );
return;
}
VariantMap info = config::load( filePath );
vfs::Path texturePath = info.get( "texture" ).toString();
vfs::NFile file = vfs::NFile::open( texturePath );
Picture mainTexture;
if( file.isOpen() )
{
mainTexture = PictureLoader::instance().load( file );
}
else
{
Logger::warning( "PictureBank: load atlas failed for texture" + texturePath.toString() );
mainTexture = Picture::getInvalid();
}
//SizeF mainRectSize = mainTexture.size().toSizeF();
if( !info.empty() )
{
VariantMap items = info.get( framesSection ).toMap();
for( auto& i : items )
{
VariantList rInfo = i.second.toList();
Picture pic = mainTexture;
Point start( rInfo.get( 0 ).toInt(), rInfo.get( 1 ).toInt() );
Size size( rInfo.get( 2 ).toInt(), rInfo.get( 3 ).toInt() );
pic.setOriginRect( Rect( start, size ) );
setPicture( i.first, pic );
}
}
}
/**
* @return true if the {@code crc} is 0, or matches the computed CRC of the file
*/
bool CheckSignature(const vfs::Path &filePath, const Signature crc) {
Trace("Checking signature matches [" << crc << "] for file " << filePath.str());
vfs::ifstream infile(filePath, std::ios::binary | std::ios::in);
if (!infile.is_open()) {
return false;
}
const Signature downloadCrc = core::hash::CRC32(
std::istreambuf_iterator<char>(infile.rdbuf()),
std::istreambuf_iterator<char>());
Trace("Crc was: " << downloadCrc);
return (crc == 0 || crc == downloadCrc);
}
UpdateController::UpdateController(IUpdateView& view, vfs::Path executableName, UpdaterOptions& options) :
_view(view),
_curStep(Init),
_updater(options, executableName.baseName()),
_abortFlag(false),
_differentialUpdatePerformed(false)
{
_progress = ProgressHandlerPtr( new ProgressHandler(_view) );
_progress->drop();
_updater.SetDownloadProgressCallback( ptr_cast<Updater::DownloadProgress>( _progress ));
_updater.SetFileOperationProgressCallback( ptr_cast<Updater::FileOperationProgress>( _progress ));
}
int BmFontUtil::main() {
g_inputFile.checkSet();
g_outputFile.checkSet();
vfs::Mount("./", "./", std::ios::in | std::ios::out | std::ios::binary);
const vfs::Path filename(g_inputFile.get());
const vfs::Path rootPath(filename.dir());
std::string content;
if (!appshared::parseFileToString(filename, content)) {
Log(LL::Error) << "Unable to open input font set: " << g_inputFile.get() << std::endl;
return eExitCode::BAD_FILE;
}
XmlNode doc;
if (!doc.parse(content)) {
Log(LL::Error) << "Unable to parse XML document." << std::endl;
return eExitCode::BAD_DATA;
}
u32 nodeIndex;
if (!doc.getChild("font", nodeIndex)) {
Log(LL::Error) << "XML is not a valid font file. Missing top level 'font' node." << std::endl;
return eExitCode::BAD_DATA;
}
FontDef def;
if (!ParseDocument(def, rootPath, doc.getChild(nodeIndex), g_exportAsDistanceFont.get())) {
return eExitCode::BAD_DATA;
}
if (!appshared::serializeProtoToFile(vfs::Path(g_outputFile.get()), def)) {
Log(LL::Error) << "Unable to write output." << std::endl;
return eExitCode::EXCEPTION;
}
return eExitCode::OK;
}
vfs::CVirtualFileSystem::CMatchingIterator::CMatchingIterator(vfs::Path const& sPattern, vfs::CVirtualFileSystem* pVFS)
: tBaseClass(), m_VFS(pVFS)
{
if(sPattern() == vfs::Const::STAR())
{
m_sLocPattern = vfs::Path(vfs::Const::STAR());
m_sFilePattern = vfs::Path(vfs::Const::STAR());
}
else
{
sPattern.splitLast(m_sLocPattern,m_sFilePattern);
}
_vloc_iter = m_VFS->m_mapFS.begin();
while(_vloc_iter != m_VFS->m_mapFS.end())
{
if( matchPattern(m_sLocPattern(),_vloc_iter->second->cPath()) )
{
bool bExclusiveVLoc = _vloc_iter->second->getIsExclusive();
_vfile_iter = _vloc_iter->second->iterate();
while(!_vfile_iter.end())
{
vfs::IBaseFile* pFile = NULL;
if(bExclusiveVLoc)
{
pFile = _vfile_iter.value()->file(vfs::CVirtualFile::SF_STOP_ON_WRITABLE_PROFILE);
}
else
{
pFile = _vfile_iter.value()->file(vfs::CVirtualFile::SF_TOP);
}
if(pFile)
{
vfs::Path const& filename = pFile->getName();
if( matchPattern(m_sFilePattern(),filename()) )
{
return;
}
}
_vfile_iter.next();
}
}
_vloc_iter++;
}
}
void FontCollection::addFont(const int key, const std::string& name, vfs::Path pathFont, const int size, const NColor& color )
{
TTF_Font* ttf = TTF_OpenFont(pathFont.toCString(), size);
if( ttf == NULL )
{
std::string errorStr( TTF_GetError() );
#ifdef CAESARIA_PLATFORM_WIN
errorStr += "\n Is it only latin symbols in path to game?";
#endif
OSystem::error( "CRITICAL!!! ", errorStr );
THROW( errorStr );
}
Font font0;
font0._d->ttfFont = ttf;
SDL_Color c = { color.red(), color.green(), color.blue(), color.alpha() };
font0._d->color = c;
setFont( key, name, font0);
}
void Saver::save(const vfs::Path& filename, const Game& game )
{
VariantMap vm;
vm[ SaverOptions::version ] = 1;
vm[ "timemultiplier" ] = game.timeMultiplier();
VariantMap vm_scenario;
vm_scenario[ "date" ] = game::Date::current();
vm_scenario[ "events" ] = events::Dispatcher::instance().save();
vm_scenario[ "translation" ] = SETTINGS_VALUE( lastTranslation );
vm_scenario[ "climate" ] = (int)game.city()->climate();
vm[ "scenario" ] = vm_scenario;
vm[ SaverOptions::restartFile ] = Variant( _restartFile );
VariantMap vm_empire;
game.empire()->save( vm_empire );
vm[ "empire" ] = vm_empire;
VariantMap plm;
game.player()->save( plm );
vm[ "player" ] = plm;
VariantMap vm_city;
game.city()->save( vm_city );
vm[ "city" ] = vm_city;
VariantMap vm_pantheon;
religion::rome::Pantheon::instance().save( vm_pantheon );
vm[ "pantheon" ] = vm_pantheon;
gui::Minimap* minimap = gui::findChildA<gui::Minimap*>( true, game.gui()->rootWidget() );
if( minimap )
{
vfs::Path imgPath = filename.changeExtension( "png" );
minimap->saveImage( imgPath.toString() );
}
config::save( vm, filename );
}
void PictureInfoBank::initialize(vfs::Path filename)
{
Logger::warning( "PictureInfoBank: start load offsets from " + filename.toString() );
VariantMap m = config::load( filename );
foreach( it, m )
{
Variant v = it->second;
Logger::warning( "Set offset for " + it->first );
if( v.type() == Variant::Map )
{
VariantMap vm = v.toMap();
int startIndex = vm[ "start" ];
int stopIndex = vm[ "stop" ];
std::string rc = vm[ "rc" ].toString();
Point offset = vm[ "offset" ].toPoint();
_d->setRange( rc.empty() ? it->first : rc, startIndex, stopIndex, offset );
}
else if( v.type() == Variant::List )
{
VariantList vl = v.toList();
_d->setOne( it->first, vl.get( idxIndex ), vl.get( idxXOffset ), vl.get( idxYOffset ) );
}
}
bool operator==(vfs::Path const& p1, const vfs::String::char_t* p2)
{
return vfs::StrCmp::Equal(p1.c_str(), p2);
}
bool operator==(vfs::Path const& p1, vfs::String::str_t const& p2)
{
return vfs::StrCmp::Equal(p1.c_str(), p2);
}
void Game::Impl::initFontCollection( vfs::Path resourcePath )
{
Logger::warning( "Game: load fonts" );
std::string fontname = SETTINGS_STR( font );
FontCollection::instance().initialize( resourcePath.toString(), fontname );
}
iResourceLoader::eLoadState::type FontFromFile::postload() {
if (m_fontDef.get_texture_size() == 0) {
Log(LL::Error) << "Font has no textures in it." << std::endl;
return eLoadState::LOAD_FAILURE;
}
// Load material
if (!m_material.getHandle().isValid()) {
MaterialDef::Builder materialBuilder;
// Create temp textures
for (u32 i = 0; i < m_fontDef.get_texture_size(); ++i) {
const vfs::Path filename = vfs::Path("memfile/")
+ vfs::Path(vfs::Path(m_fontDef.get_texture(i).get_filename()).file());
const std::string &data = m_fontDef.get_texture(i).get_image_data();
vfs::getStaticMemFileSystem()->create(filename, core::memory::ConstBlob((const u8 *) data.data(), data.size()));
materialBuilder.add_textures(filename.str());
}
if (m_fontDef.get_texture(0).get_is_distancefield()) {
materialBuilder.set_alpha_test(fsengine::render::eAlphaTestMode::ALPHA_TEST_GEQUAL);
materialBuilder.set_alpha_cutoff(0.5f);
materialBuilder.set_blend_mode(fsengine::render::eBlendMode::BLEND_NONE);
materialBuilder.set_name("font");
materialBuilder.set_shader("data/shaders/tex0cutoffcolor");
} else {
materialBuilder.set_blend_mode(fsengine::render::eBlendMode::BLEND_NORMAL);
materialBuilder.set_name("font");
materialBuilder.set_shader("data/shaders/tex0color");
}
{
const MaterialDef materialDef = materialBuilder.build();
const vfs::Path filename = vfs::Path("memfile/")
+ vfs::Path(vfs::Path(m_id + "_mat").file());
const size_t sz = materialDef.byte_size();
m_materialData.resize(sz, ' ');
core::memory::Blob blob((u8 *) &m_materialData[0], sz);
core::base::BlobSink sink(blob);
sink << materialBuilder.build();
vfs::getStaticMemFileSystem()->create(filename, core::memory::ConstBlob((const u8 *) m_materialData.data(), m_materialData.size()));
m_material = m_pLoader->asyncLoadResource<Material, MaterialFromFile>(filename.str());
}
}
if (!m_material) {
if (m_material.getManager()->isValidOrLocked(m_material.getHandle())) {
return eLoadState::LOAD_DEPENDENCY;
} else {
return eLoadState::LOAD_FAILURE;
}
}
// Create font
if (!m_pResource->loadFromDef(m_fontDef)) {
return eLoadState::LOAD_FAILURE;
}
// cleanup
for (u32 i = 0; i < m_fontDef.get_texture_size(); ++i) {
m_pResource->setTexture(i, m_material->m_pTexture[i]);
const vfs::Path filename = vfs::Path("memfile/")
+ vfs::Path(vfs::Path(m_fontDef.get_texture(i).get_filename()).file());
vfs::util::Remove(filename);
}
const vfs::Path filename = vfs::Path("memfile/")
+ vfs::Path(vfs::Path(m_id + "_mat").file());
vfs::util::Remove(filename);
m_pResource->setMaterial(m_material);
return eLoadState::LOAD_SUCCESS;
}
//! returns true if the file maybe is able to be loaded by this class
//! based on the file extension (e.g. ".tga")
bool PictureLoaderPng::isALoadableFileExtension(const vfs::Path& filename) const
{
return filename.isMyExtension( ".png" );
}