WebSVN – spk – Diff – /libspk/src/VirtualFileSystem.cpp



	m_pModMap = new FileList;
 
	m_pTexts = new CTextDB();
	m_pModTexts = new CTextDB();
 
	m_sAddon = L"";
 
	m_iLang = 0;
}
 
CVirtualFileSystem::~CVirtualFileSystem(void)

 
	if ( m_pTexts )		delete m_pTexts;
	if ( m_pModTexts )  delete m_pModTexts;
}
 
void CVirtualFileSystem::setAddon(const Utils::WString &addon)
{ 
	m_sAddon = addon; 
}
void CVirtualFileSystem::setLanguage(int iLang)
{
	m_iLang = iLang;
}
 
Utils::WString CVirtualFileSystem::firstShield()
{
	if ( !_lShields || _lShields->empty() ) _updateShields();
	return _returnText(_lShields->first());
}
 
Utils::WString CVirtualFileSystem::nextShield()
{
	return _returnText(_lShields->next());
}
 
Utils::WString CVirtualFileSystem::firstComponentSection()
{
	if ( !_lComponentSections || _lComponentSections->empty() ) _updateComponentSections();
	return _returnLine(_lComponentSections->first());
}
 
Utils::WString CVirtualFileSystem::nextComponentSection()
{
	return _returnLine(_lComponentSections->next());
}
 
Utils::WString CVirtualFileSystem::firstDummySection()
{
	if ( !_lDummySections || _lDummySections->empty() ) _updateDummySections();
	return _returnLine(_lDummySections->first());
}
 
Utils::WString CVirtualFileSystem::nextDummySection()
{
	return _returnLine(_lDummySections->next());
}
 
Utils::WString CVirtualFileSystem::firstBodiesSection()
{
	if ( !_lBodiesSections || _lBodiesSections->empty() ) _updateBodiesSections();
	return _returnLine(_lBodiesSections->first());
}
 
Utils::WString CVirtualFileSystem::nextBodiesSection()
{
	return _returnLine(_lBodiesSections->next());
}
 
std::pair<Utils::WString, Utils::WString> CVirtualFileSystem::nextLaser()
{
	return _returnPair(_lLasers->next());
}
 
std::pair<Utils::WString, Utils::WString>  CVirtualFileSystem::firstLaser()
{
	if ( !_lLasers || _lLasers->empty() ) _updateLasers();
	return _returnPair(_lLasers->first());
}
 
std::pair<Utils::WString, Utils::WString>  CVirtualFileSystem::firstMissile()
{
	if ( !_lMissiles || _lMissiles->empty() ) _updateMissiles();
	return _returnPair(_lMissiles->first());
}
 
std::pair<Utils::WString, Utils::WString> CVirtualFileSystem::nextMissile()
{
	return _returnPair(_lMissiles->next());
}
 
Utils::WString CVirtualFileSystem::firstCockpit()
{
	if ( !_lCockpits || _lCockpits->empty() ) _updateCockpits();
	return _returnID(_lCockpits->first());
}
 
Utils::WString CVirtualFileSystem::nextCockpit()
{
	return _returnID(_lCockpits->next());
}
 
std::pair<Utils::WString, Utils::WString> CVirtualFileSystem::_returnPair(Utils::WStringNode *s)
{
	if ( s && !s->data.empty() && !s->data.left(8).Compare(L"ReadText") ) return std::make_pair<Utils::WString, Utils::WString>(std::move(s->str), std::move(s->data));
	if ( s ) return std::make_pair<Utils::WString, Utils::WString>(std::move(s->str), s->str.token(L";", -2));
	return std::make_pair<Utils::WString, Utils::WString>(Utils::WString::Null(), Utils::WString::Null());
}
 
Utils::WString CVirtualFileSystem::_returnText(Utils::WStringNode *s)
{
	if ( s && !s->data.empty() && !s->data.left(8).Compare(L"ReadText") ) return s->data;
	if ( s ) return s->str.token(L";", -2);
	return Utils::WString::Null();
}
 
Utils::WString CVirtualFileSystem::_returnID(Utils::WStringNode *s)
{
	if ( s ) return s->str.token(L";", -2);
	return Utils::WString::Null();
}
 
Utils::WString CVirtualFileSystem::_returnLine(Utils::WStringNode *s)
{
	if ( s ) return s->str;
	return Utils::WString::Null();
}
 
 
bool CVirtualFileSystem::LoadFilesystem(const Utils::WString &dir, int maxPatch)
{
	return this->LoadFilesystem(dir, L"", maxPatch);
}
 
bool CVirtualFileSystem::LoadFilesystem(const Utils::WString &dir, const Utils::WString &mod, int maxPatch)
{
	m_sDir = dir.findReplace(L"\\", L"/");
 
	this->_clear();
 
	// if we are in the addon directory, then also read the previous directory
	Utils::WString s = dir.token(L"/", -1);
	if ( !this->m_sAddon.empty() && dir.token(L"/", -1).Compare(this->m_sAddon) ) {
		//LoadFilesystem(dir.tokens("/", 1, -2), "", 0);
	}
 
	int number = 1;
	while ( CFileIO::Exists(dir + L"/" + Utils::WString::PadNumber(number, 2) + L".cat") )
	{
		if ( maxPatch && maxPatch < number ) break;
		Utils::WString file = dir + L"/" + Utils::WString::PadNumber(number, 2);
		if ( !CFileIO::Exists(file + L".dat") )
			break;
 
		CCatFile cat;
		if ( cat.open(file + L".cat", m_sAddon, CATREAD_JUSTCONTENTS, false) == CATERR_NONE)
		{
			for(auto itr = cat.GetFiles()->cbegin(); itr != cat.GetFiles()->cend(); itr++)
			{
				this->_addModFile(CFileIO((*itr)->sFile).fullFilename(), file + L".cat", m_pMap);
				m_bLoaded = true;
			}
		}
		++number;
	}

	// add all the files from the mod
	if ( !mod.empty() )
		this->addMod(mod);
 
	// now add all the extracted data
	this->_addDir(m_sDir, L"");
 
	return m_bLoaded;
}
 
 
void CVirtualFileSystem::_addDir(const Utils::WString &sStart, const Utils::WString &sDir)
{
	CDirIO Dir(sStart + L"/" + sDir);
	Utils::WStringList list;
	if (Dir.dirList(list))
	{
		for (auto itr = list.begin(); itr != list.end(); itr++)
		{
			if (CDirIO(Dir.dir((*itr)->str)).isDir()) _addDir(sStart, sDir + L"/" + (*itr)->str);
			else if (CFileIO((*itr)->str).isFileExtension(L"cat")) continue;
			else if (CFileIO((*itr)->str).isFileExtension(L"dat")) continue;
			else this->_addFile(sDir + L"/" + (*itr)->str, Dir.file((*itr)->str), m_pMap);
		}
	}
}
 
 
void CVirtualFileSystem::_removeSameFile(const Utils::WString &sFile, const Utils::WString &sDest, const Utils::WString &ext, FileList *pList)
{
	CFileIO F(sFile);
 
	Utils::WString newFile = F.changeFileExtension(ext);
	newFile = newFile.lower();
 
	FileListItr itr = pList->find(newFile);
	if ( itr != pList->end() ) {
		if ( !CFileIO((*pList)[newFile]).dir().Compare(CFileIO(sDest).dir()) ) {
			pList->erase(newFile);
		}
	}
}
 
void CVirtualFileSystem::_addFile(const Utils::WString &sFile, const Utils::WString &sDest, FileList *pList)
{
	Utils::WString file = sFile.asFilename().removeIf(0, '/');
 
	// check file extension, remove any patching files in previous files
	CFileIO F(file);
	Utils::WString ext = F.extension().toLower();
	if (ext.Compare(L"bob", true) || ext.Compare(L"pbd", true) || ext.Compare(L"bod", true) ) {

	else if (ext.Compare(L"xml", true) || ext.Compare(L"txt", true) )
		_removeSameFile(file, sDest, "pck", pList);
 
	(*pList)[file.lower()] = sDest.findReplace("\\", "/").findReplace("//", "/");
}
void CVirtualFileSystem::_addModFile(const Utils::WString &sFile, const Utils::WString &sMod, FileList *pList)
{
	this->_addFile(sFile, sMod + L"::" + sFile, pList);
}
 
bool CVirtualFileSystem::loadMod(const Utils::WString &mod)
{
	bool loaded = false;
 
	if ( !m_pModMap ) m_pModMap = new FileList;
 
	CCatFile cat;
	if ( CCatFile::Opened(cat.open(mod, m_sAddon, CATREAD_JUSTCONTENTS, false), false))
	{
		for (auto itr = cat.GetFiles()->cbegin(); itr != cat.GetFiles()->cend(); itr++) 
		{
			this->_addModFile(CFileIO((*itr)->sFile).fullFilename(), mod, m_pModMap);
			loaded = true;
		}
	}
 
	return loaded;
}
 
bool CVirtualFileSystem::addMod(const Utils::WString &mod)
{
	bool loaded = false;
 
	if ( !m_pMap ) m_pMap = new FileList;
 
	CCatFile cat;
	if ( CCatFile::Opened(cat.open(mod, m_sAddon, CATREAD_JUSTCONTENTS, false), false))
	{
		for (auto itr = cat.GetFiles()->cbegin(); itr != cat.GetFiles()->cend(); itr++)
		{
			this->_addModFile(CFileIO((*itr)->sFile).fullFilename(), mod, m_pMap);
			loaded = true;
		}
	}
 
	return loaded;

	}
 
	return false;
}
 
Utils::WString CVirtualFileSystem::findText(int iLang, int iPage, int iID) const
{
	if ( iLang <= 0 ) iLang = m_iLang;
 
	if ( m_pTexts ) {
		if ( m_pTexts->exists(iLang, iPage, iID) ) return m_pTexts->get(iLang, iPage, iID);
	}
	if ( m_pModTexts ) {
		if ( m_pModTexts->exists(iLang, iPage, iID) ) return m_pModTexts->get(iLang, iPage, iID);
	}
 
	return Utils::WString(L"ReadText") + (long)iPage + L"-" + (long)iID;
}
 
const Utils::WString &CVirtualFileSystem::directory() const
{
	return m_sDir;
}
 
bool CVirtualFileSystem::isFileAvailable(const Utils::WString &file) const
{
	return !this->_findFile(file).empty();
}
 
bool CVirtualFileSystem::isTextUpdated() const
{
	if ( m_pTexts ) return m_pTexts->anyTextLoaded();
	return false;
}
 
Utils::WString CVirtualFileSystem::_findFile(const Utils::WString &file) const
{
	Utils::WString toFile = file.findReplace(L"\\", L"/").lower();
 
	if ( m_pModMap && !m_pModMap->empty() ) {
		if ( !m_sAddon.empty() ) {
			FileListItr aitr = m_pModMap->find(CFileIO(m_sAddon + L"/" + toFile).fullFilename().lower().c_str());
			if ( aitr == m_pModMap->end() ) aitr = m_pModMap->find(CFileIO(_convertExtension(m_sAddon + L"/" + toFile)).fullFilename().lower().c_str());
			if ( aitr != m_pModMap->end() ) return aitr->second;
		}
		FileListItr itr = m_pModMap->find(CFileIO(toFile).fullFilename().lower().c_str());
		if ( itr == m_pModMap->end() ) itr = m_pModMap->find(CFileIO(_convertExtension(toFile)).fullFilename().lower().c_str());
		if ( itr != m_pModMap->end() ) return itr->second;
	}
 
	if ( m_pMap && !m_pMap->empty() ) {
		if ( !m_sAddon.empty() ) {
			FileListItr aitr = m_pMap->find(CFileIO(m_sAddon + L"/" + toFile).fullFilename().lower().c_str());
			if ( aitr == m_pMap->end() ) aitr = m_pMap->find(CFileIO(_convertExtension(m_sAddon + L"/" + file)).fullFilename().lower().c_str());
			if ( aitr != m_pMap->end() ) return aitr->second;
		}
		FileListItr itr = m_pMap->find(CFileIO(file).fullFilename().lower().c_str());
		if ( itr == m_pMap->end() ) itr = m_pMap->find(CFileIO(_convertExtension(file)).fullFilename().lower().c_str());
		if ( itr != m_pMap->end() ) return itr->second;
	}
	return L"";
}
 
Utils::WString CVirtualFileSystem::_extractFromCat(const Utils::WString &sCat, const Utils::WString &sFile, const Utils::WString &sTo)
{
	CCatFile catFile;
	if ( catFile.open(sCat, m_sAddon, CATREAD_CATDECRYPT, false) == CATERR_NONE)
	{
		// check for the file
		if ( catFile.extractFile(sFile, sTo)) return sTo;
		if ( catFile.error() == CATERR_INVALIDDEST || catFile.error() == CATERR_CANTCREATEDIR ) {
			if ( catFile.extractFile(sFile) ) return sFile;
		}
	}
 
	return "";
}
 
Utils::WString CVirtualFileSystem::_extract(const Utils::WString &sFile, const Utils::WString &sTo)
{
	// check if we need to unpack the file
	if ( CCatFile::CheckPackedExtension(sFile) ) {
		CFileIO File(sFile);
		C_File f(File.fullFilename());
		if ( !f.readFromFile(File) ) return L"";
		if ( !f.UnPCKFile() ) return L"";
		if ( !f.writeToFile(sTo) ) return L"";
		return sTo;
	}
	return sFile;
}
 
Utils::WString CVirtualFileSystem::extractGameFile(const Utils::WString &file, const Utils::WString &to)
{
	Utils::WString sIn = _findFile(file);
	Utils::WString sFile = file;
 
 
 
	if (sIn.empty()) return L"";
 
	if (sIn.contains(L"::"))
	{
		sFile = sIn.token(L"::", 2);
		sIn = sIn.token(L"::", 1);
		return _extractFromCat(sIn, sFile, to);
	}
	
	return _extract(sIn, to);
}
 
Utils::WString CVirtualFileSystem::_convertExtension(const Utils::WString &sFile) const
{
	CFileIO File(sFile);
	if ( File.isFileExtension(L"pck") ) {
		return File.changeFileExtension(L"xml");
	}
	else if ( File.isFileExtension(L"xml") ) {
		return File.changeFileExtension(L"pck");
	}
	else if ( File.isFileExtension(L"pbb") ) {
		return File.changeFileExtension(L"bob");
	}
	else if ( File.isFileExtension(L"bob") ) {
		return File.changeFileExtension(L"pbb");
	}
	else if ( File.isFileExtension(L"pbd") ) {
		return File.changeFileExtension(L"bod");
	}
	else if ( File.isFileExtension(L"bod") ) {
		return File.changeFileExtension(L"pbd");
	}
 
	return sFile;
}
 
Utils::WStringList *CVirtualFileSystem::getTShipsEntries()
{
	if ( !_lShips || _lShips->empty() ) _updateShips();
	return _lShips;
}
 
C_File *CVirtualFileSystem::extractGameFileToPackage(CBaseFile *pPackage, const Utils::WString &sFile, FileType iFileType)
{
	return this->extractGameFileToPackage(pPackage, sFile, iFileType, sFile);
}
 
C_File *CVirtualFileSystem::extractGameFileToPackage(CBaseFile *pPackage, const Utils::WString &sFile, FileType iFileType, const Utils::WString &sTo)
{
	Utils::WString to = this->extractGameFile(sFile, CPackages::tempDirectory() + L"tmp.dat");
	if ( !to.empty() ) {
		CFileIO File(to);
 
		C_File *f = pPackage->addFile(CFileIO(sTo).filename(), CFileIO(sTo).dir(), iFileType);
		if ( f ) {
			if ( f->readFromFile(CPackages::tempDirectory() + L"tmp.dat") ) {
				File.remove();
				return f;
			}
		}
 
		File.remove();
	}
 
	return NULL;
}
 
Utils::WString CVirtualFileSystem::getTShipsEntry(const Utils::WString &sId)
{
	if ( !_lShips || _lShips->empty() ) _updateShips();
	return _lShips->findData(sId, true);
}
 
void CVirtualFileSystem::extractTexts(CXspFile *pPackage, int textId)
{
	//TODO: check for better finding of files in map
	for ( FileListItr itr = m_pMap->begin(); itr != m_pMap->end(); ++itr ) {
		Utils::WString str = itr->first;
 
		if ( !m_sAddon.empty() ) {
			if ( !str.left(m_sAddon.length() + 3).Compare(m_sAddon + L"/t/") && !str.left(m_sAddon.length() + 3).Compare(m_sAddon + L"\\t\\") )
				continue;
		}
		else {
			if ( !str.left(2).Compare(L"t\\") && !str.left(2).Compare(L"t/") && !str.left(8).Compare(L"addon\t\\") && !str.left(8).Compare(L"addon/t/") )
				continue;
		}
 
		Utils::WString sTo = this->extractGameFile(str, CPackages::tempDirectory() + L"tmp.dat");
		if ( !sTo.empty() ) {
			pPackage->addTextFromFile(sTo, textId);
			CFileIO::Remove(sTo);
		}
	}
}
 

void CVirtualFileSystem::updateTexts(int iPage)
{
	this->_updateTexts(iPage, iPage, m_pMap, m_pTexts);
}
void CVirtualFileSystem::updateModTexts(int iFromPage, int iToPage)
{
	this->_updateTexts(iFromPage, iToPage, m_pModMap, m_pModTexts);
}
void CVirtualFileSystem::updateModTexts(int iPage)
{
	this->_updateTexts(iPage, iPage, m_pModMap, m_pModTexts);
}
 
void CVirtualFileSystem::_clear()
{

 
void CVirtualFileSystem::_updateTexts(int iFromPage, int iToPage, FileList *pFileList, CTextDB *pTextList)
{
	// read all text files
	for ( FileListItr itr = pFileList->begin(); itr != pFileList->end(); ++itr ) {
		Utils::WString str = itr->first;
 
		if ( !m_sAddon.empty() ) {
			if ( !str.left(m_sAddon.length() + 3).Compare(m_sAddon + L"/t/") && !str.left(m_sAddon.length() + 3).Compare(m_sAddon + L"\\t\\") )
				continue;
		}
		else {
			if ( !str.left(2).Compare(L"t\\") && !str.left(2).Compare(L"t/") )
				continue;
		}
 
		Utils::WString sTo = this->extractGameFile(str, CPackages::tempDirectory() + L"tmp.dat");
		if ( !sTo.empty() ) {
			// add all texts into the map, id=(pageid, tid) data=text
			Utils::WString baseFile = CFileIO(str).baseName();
			int lang = (baseFile.contains(L"-L")) ? baseFile.right(3) : baseFile.truncate(-4);
 

 
	if ( m_pModTexts ) delete m_pModTexts;
	m_pModTexts = new CTextDB();
}
 
Utils::WStringList *CVirtualFileSystem::_updateList(const Utils::WString &typesFile, int iTextPos)
{
	Utils::WStringList *list = new Utils::WStringList();
 
	Utils::WString file = this->extractGameFile(L"types\\" + typesFile + L".pck", CPackages::tempDirectory() + L"/" + typesFile + L".txt");
 
	CFileIO f(file);
 
	if ( f.exists() && f.startRead() ) {
		int itemsLeft = -1;
 
		while(!f.atEnd()) {
			// read the next line
			Utils::WString line = f.readEndOfLineStr();
 
			// remove the unneeded characters
			line.removeChar('\r');
			line.removeChar(9);
			line.removeFirstSpace();
 
			// blank line ? skip it
			if ( line.empty() ) continue;
			// skip anything starting with / as its a comment
			if ( line[0] == '/' ) continue;
 
			// first line is the count
			if ( itemsLeft == -1 )
				itemsLeft = line.token(L";", 2);
			else {
				if ( iTextPos == 0 )
					list->pushBack(line, line);
				else if ( iTextPos == -1 ) 
					list->pushBack(line, line.token(L";", -2));
				else
					list->pushBack(line, this->findText(m_iLang, TEXTPAGE_OBJECTS, line.token(L";", iTextPos).toLong()));
				--itemsLeft;
			}
		}
		
		f.close();

}
 
void CVirtualFileSystem::_updateShields()
{
	DELETELIST(_lShields);
	_lShields = _updateList(L"TShields", 7);
}
 
void CVirtualFileSystem::_updateLasers()
{
	DELETELIST(_lLasers);
	_lLasers = _updateList(L"TLaser", 7);
}
 
void CVirtualFileSystem::_updateMissiles()
{
	DELETELIST(_lMissiles);
	_lMissiles = _updateList(L"TMissiles", 7);
}
 
void CVirtualFileSystem::_updateCockpits()
{
	DELETELIST(_lCockpits);
	_lCockpits = _updateList(L"TCockpits", -1);
}
 
void CVirtualFileSystem::_updateShips()
{
	DELETELIST(_lShips);
	_lShips = _updateList(L"TShips", -1);
}
 
void CVirtualFileSystem::_updateComponentSections()
{
	DELETELIST(_lComponentSections);
 
	_lComponentSections = new Utils::WStringList();
 
	Utils::WString file = this->extractGameFile(L"types\\Components.pck", CPackages::tempDirectory() + L"/Components.txt");
 
	CFileIO f(file);
 
	if ( f.exists() && f.startRead() ) {
		int sectionRemaining = 0;
		int itemsRemaining = 0;
 
		while(!f.atEnd()) {
			// read the next line
			Utils::WString line = f.readEndOfLineStr();
 
			// remove the unneeded characters
			line.removeChar('\r');
			line.removeChar(9);
			line.removeFirstSpace();
 
			// blank line ? skip it
			if ( line.empty() ) continue;
			// skip anything starting with / as its a comment
			if ( line[0] == L'/' ) continue;
 
			if ( itemsRemaining )
				--itemsRemaining;
			else if ( !sectionRemaining )
			{
				sectionRemaining = line.token(L";", 2).toLong();
				Utils::WString section = line.token(L";", 1);
				if ( !section.empty() )
					_lComponentSections->pushBack(section, section);
			}
			else if ( !itemsRemaining )
			{
				itemsRemaining = line.token(L";", 2).toLong();
				--sectionRemaining;
			}
		}
		
		f.close();
		f.remove();
	}
 
	if ( _lComponentSections->empty() )
	{
		_lComponentSections->pushBack(L"SCTYPE_LASER", L"SCTYPE_LASER");
		_lComponentSections->pushBack(L"SCTYPE_COCKPIT", L"SCTYPE_COCKPIT");
		_lComponentSections->pushBack(L"SCTYPE_DOCKING", L"SCTYPE_DOCKING");
	}
}
 
Utils::WStringList *CVirtualFileSystem::_updateSectionList(const Utils::WString &sFile, bool singleEntry)
{
	Utils::WStringList *list = new Utils::WStringList();
 
	Utils::WString file = this->extractGameFile(L"types\\" + sFile + L".pck", CPackages::tempDirectory() + L"/" + sFile + L".txt");
 
	CFileIO f(file);
 
	if ( f.exists() && f.startRead() ) {
		int sectionRemaining = 0;
 
		while(!f.atEnd()) {
			// read the next line
			Utils::WString line = f.readEndOfLineStr();
 
			// remove the unneeded characters
			line.removeChar('\r');
			line.removeChar(9);
			line.removeFirstSpace();
 
			// blank line ? skip it
			if ( line.empty() ) continue;
			// skip anything starting with / as its a comment
			if ( line[0] == L'/' ) continue;
 
			if ( !sectionRemaining )
			{
				sectionRemaining = line.token(L";", 2).toLong();
				Utils::WString section = line.token(L";", 1);
				if ( !section.empty() )
					list->pushBack(section, section);
			}
			else {
				if ( singleEntry )
					sectionRemaining -= (line.countToken(L";") - 1);
				else 
					--sectionRemaining;
			}
		}
		

 
void CVirtualFileSystem::_updateDummySections()
{
	DELETELIST(_lDummySections);
 
	_lDummySections = _updateSectionList(L"Dummies", false);
 
	if ( _lDummySections->empty() )
	{
		_lDummySections->pushBack(L"SDTYPE_ANIMATED", L"SDTYPE_ANIMATED");
		_lDummySections->pushBack(L"SDTYPE_DOCK", L"SDTYPE_DOCK");
		_lDummySections->pushBack(L"SDTYPE_DOORWAY", L"SDTYPE_DOORWAY");
		_lDummySections->pushBack(L"SDTYPE_GUN", L"SDTYPE_GUN");
		_lDummySections->pushBack(L"SDTYPE_CONNECTION", L"SDTYPE_CONNECTION");
	}
}
 
void CVirtualFileSystem::_updateBodiesSections()
{
	DELETELIST(_lBodiesSections);
 
	_lBodiesSections = _updateSectionList(L"Bodies", true);
 
	if ( _lBodiesSections->empty() )
	{
		_lBodiesSections->pushBack(L"SBTYPE_2D", L"SBTYPE_2D");
		_lBodiesSections->pushBack(L"SBTYPE_FACECAMERA", L"SBTYPE_FACECAMERA");
		_lBodiesSections->pushBack(L"SBTYPE_2D2", L"SBTYPE_2D2");
		_lBodiesSections->pushBack(L"SBTYPE_2DY", L"SBTYPE_2DY");
		_lBodiesSections->pushBack(L"SBTYPE_LOGO", L"SBTYPE_LOGO");
		_lBodiesSections->pushBack(L"SBTYPE_FC", L"SBTYPE_FC");
		_lBodiesSections->pushBack(L"SBTYPE_TURRET", L"SBTYPE_TURRET");
		_lBodiesSections->pushBack(L"SBTYPE_JET", L"SBTYPE_JET");
		_lBodiesSections->pushBack(L"SBTYPE_RADAR", L"SBTYPE_RADAR");
		_lBodiesSections->pushBack(L"SBTYPE_CONTAINER", L"SBTYPE_CONTAINER");
		_lBodiesSections->pushBack(L"SBTYPE_DISPLAY", L"SBTYPE_DISPLAY");
		_lBodiesSections->pushBack(L"SBTYPE_DOCKPOINT", L"SBTYPE_DOCKPOINT");
		_lBodiesSections->pushBack(L"SBTYPE_SMALLJET", L"SBTYPE_SMALLJET");
	}
}
 
 
/////////////////////////////////////////////////////////////////////////////////////////
//	DEBUG Functions
 
 
void CVirtualFileSystem::DEBUG_LogContents(const Utils::WString &sFile)
{
	CFileIO File(sFile);
 
	if ( File.startWrite() ) {
		if ( m_pMap ) {
			for(FileListItr itr = m_pMap->begin(); itr != m_pMap->end(); itr++) {
				Utils::WString line = itr->first + L" => " + itr->second + L"\r\n";
				std::string str = std::string(line.begin(), line.end());
				File.write(str.c_str(), str.length());
			}
		}
 
		File.close();
	}

Rev 196	Rev 197
Line 26...	Line 26...
26	`m_pModMap = new FileList;`	26	`m_pModMap = new FileList;`
27		27
28	`m_pTexts = new CTextDB();`	28	`m_pTexts = new CTextDB();`
29	`m_pModTexts = new CTextDB();`	29	`m_pModTexts = new CTextDB();`
30		30
31	`m_sAddon = "";`	31	`m_sAddon = L"";`
32		32
33	`m_iLang = 0;`	33	`m_iLang = 0;`
34	`}`	34	`}`
35		35
36	`CVirtualFileSystem::~CVirtualFileSystem(void)`	36	`CVirtualFileSystem::~CVirtualFileSystem(void)`
Line 39...	Line 39...
39		39
40	`if ( m_pTexts ) delete m_pTexts;`	40	`if ( m_pTexts ) delete m_pTexts;`
41	`if ( m_pModTexts ) delete m_pModTexts;`	41	`if ( m_pModTexts ) delete m_pModTexts;`
42	`}`	42	`}`
43		43
44	`void CVirtualFileSystem::setAddon(const Utils::String &addon)`	44	`void CVirtualFileSystem::setAddon(const Utils::WString &addon)`
45	`{`	45	`{`
46	`m_sAddon = addon;`	46	`m_sAddon = addon;`
47	`}`	47	`}`
48	`void CVirtualFileSystem::setLanguage(int iLang)`	48	`void CVirtualFileSystem::setLanguage(int iLang)`
49	`{`	49	`{`
50	`m_iLang = iLang;`	50	`m_iLang = iLang;`
51	`}`	51	`}`
52		52
53	`Utils::String CVirtualFileSystem::firstShield()`	53	`Utils::WString CVirtualFileSystem::firstShield()`
54	`{`	54	`{`
55	`if ( !_lShields \|\| _lShields->empty() ) _updateShields();`	55	`if ( !_lShields \|\| _lShields->empty() ) _updateShields();`
56	`return _returnText(_lShields->first());`	56	`return _returnText(_lShields->first());`
57	`}`	57	`}`
58		58
59	`Utils::String CVirtualFileSystem::nextShield()`	59	`Utils::WString CVirtualFileSystem::nextShield()`
60	`{`	60	`{`
61	`return _returnText(_lShields->next());`	61	`return _returnText(_lShields->next());`
62	`}`	62	`}`
63		63
64	`Utils::String CVirtualFileSystem::firstComponentSection()`	64	`Utils::WString CVirtualFileSystem::firstComponentSection()`
65	`{`	65	`{`
66	`if ( !_lComponentSections \|\| _lComponentSections->empty() ) _updateComponentSections();`	66	`if ( !_lComponentSections \|\| _lComponentSections->empty() ) _updateComponentSections();`
67	`return _returnLine(_lComponentSections->first());`	67	`return _returnLine(_lComponentSections->first());`
68	`}`	68	`}`
69		69
70	`Utils::String CVirtualFileSystem::nextComponentSection()`	70	`Utils::WString CVirtualFileSystem::nextComponentSection()`
71	`{`	71	`{`
72	`return _returnLine(_lComponentSections->next());`	72	`return _returnLine(_lComponentSections->next());`
73	`}`	73	`}`
74		74
75	`Utils::String CVirtualFileSystem::firstDummySection()`	75	`Utils::WString CVirtualFileSystem::firstDummySection()`
76	`{`	76	`{`
77	`if ( !_lDummySections \|\| _lDummySections->empty() ) _updateDummySections();`	77	`if ( !_lDummySections \|\| _lDummySections->empty() ) _updateDummySections();`
78	`return _returnLine(_lDummySections->first());`	78	`return _returnLine(_lDummySections->first());`
79	`}`	79	`}`
80		80
81	`Utils::String CVirtualFileSystem::nextDummySection()`	81	`Utils::WString CVirtualFileSystem::nextDummySection()`
82	`{`	82	`{`
83	`return _returnLine(_lDummySections->next());`	83	`return _returnLine(_lDummySections->next());`
84	`}`	84	`}`
85		85
86	`Utils::String CVirtualFileSystem::firstBodiesSection()`	86	`Utils::WString CVirtualFileSystem::firstBodiesSection()`
87	`{`	87	`{`
88	`if ( !_lBodiesSections \|\| _lBodiesSections->empty() ) _updateBodiesSections();`	88	`if ( !_lBodiesSections \|\| _lBodiesSections->empty() ) _updateBodiesSections();`
89	`return _returnLine(_lBodiesSections->first());`	89	`return _returnLine(_lBodiesSections->first());`
90	`}`	90	`}`
91		91
92	`Utils::String CVirtualFileSystem::nextBodiesSection()`	92	`Utils::WString CVirtualFileSystem::nextBodiesSection()`
93	`{`	93	`{`
94	`return _returnLine(_lBodiesSections->next());`	94	`return _returnLine(_lBodiesSections->next());`
95	`}`	95	`}`
96		96
97	`std::pair<Utils::String, Utils::String> CVirtualFileSystem::nextLaser()`	97	`std::pair<Utils::WString, Utils::WString> CVirtualFileSystem::nextLaser()`
98	`{`	98	`{`
99	`return _returnPair(_lLasers->next());`	99	`return _returnPair(_lLasers->next());`
100	`}`	100	`}`
101		101
102	`std::pair<Utils::String, Utils::String> CVirtualFileSystem::firstLaser()`	102	`std::pair<Utils::WString, Utils::WString> CVirtualFileSystem::firstLaser()`
103	`{`	103	`{`
104	`if ( !_lLasers \|\| _lLasers->empty() ) _updateLasers();`	104	`if ( !_lLasers \|\| _lLasers->empty() ) _updateLasers();`
105	`return _returnPair(_lLasers->first());`	105	`return _returnPair(_lLasers->first());`
106	`}`	106	`}`
107		107
108	`std::pair<Utils::String, Utils::String> CVirtualFileSystem::firstMissile()`	108	`std::pair<Utils::WString, Utils::WString> CVirtualFileSystem::firstMissile()`
109	`{`	109	`{`
110	`if ( !_lMissiles \|\| _lMissiles->empty() ) _updateMissiles();`	110	`if ( !_lMissiles \|\| _lMissiles->empty() ) _updateMissiles();`
111	`return _returnPair(_lMissiles->first());`	111	`return _returnPair(_lMissiles->first());`
112	`}`	112	`}`
113		113
114	`std::pair<Utils::String, Utils::String> CVirtualFileSystem::nextMissile()`	114	`std::pair<Utils::WString, Utils::WString> CVirtualFileSystem::nextMissile()`
115	`{`	115	`{`
116	`return _returnPair(_lMissiles->next());`	116	`return _returnPair(_lMissiles->next());`
117	`}`	117	`}`
118		118
119	`Utils::String CVirtualFileSystem::firstCockpit()`	119	`Utils::WString CVirtualFileSystem::firstCockpit()`
120	`{`	120	`{`
121	`if ( !_lCockpits \|\| _lCockpits->empty() ) _updateCockpits();`	121	`if ( !_lCockpits \|\| _lCockpits->empty() ) _updateCockpits();`
122	`return _returnID(_lCockpits->first());`	122	`return _returnID(_lCockpits->first());`
123	`}`	123	`}`
124		124
125	`Utils::String CVirtualFileSystem::nextCockpit()`	125	`Utils::WString CVirtualFileSystem::nextCockpit()`
126	`{`	126	`{`
127	`return _returnID(_lCockpits->next());`	127	`return _returnID(_lCockpits->next());`
128	`}`	128	`}`
129		129
130	`std::pair<Utils::String, Utils::String> CVirtualFileSystem::_returnPair(Utils::SStringList *s)`	130	`std::pair<Utils::WString, Utils::WString> CVirtualFileSystem::_returnPair(Utils::WStringNode *s)`
131	`{`	131	`{`
132	`if ( s && !s->data.empty() && !s->data.left(8).Compare("ReadText") ) return std::make_pair<Utils::String, Utils::String>(std::move(s->str), std::move(s->data));`	132	`if ( s && !s->data.empty() && !s->data.left(8).Compare(L"ReadText") ) return std::make_pair<Utils::WString, Utils::WString>(std::move(s->str), std::move(s->data));`
133	`if ( s ) return std::make_pair<Utils::String, Utils::String>(std::move(s->str), s->str.token(";", -2));`	133	`if ( s ) return std::make_pair<Utils::WString, Utils::WString>(std::move(s->str), s->str.token(L";", -2));`
134	`return std::make_pair<Utils::String, Utils::String>(Utils::String::Null(), Utils::String::Null());`	134	`return std::make_pair<Utils::WString, Utils::WString>(Utils::WString::Null(), Utils::WString::Null());`
135	`}`	135	`}`
136		136
137	`Utils::String CVirtualFileSystem::_returnText(Utils::SStringList *s)`	137	`Utils::WString CVirtualFileSystem::_returnText(Utils::WStringNode *s)`
138	`{`	138	`{`
139	`if ( s && !s->data.empty() && !s->data.left(8).Compare("ReadText") ) return s->data;`	139	`if ( s && !s->data.empty() && !s->data.left(8).Compare(L"ReadText") ) return s->data;`
140	`if ( s ) return s->str.token(";", -2);`	140	`if ( s ) return s->str.token(L";", -2);`
141	`return Utils::String::Null();`	141	`return Utils::WString::Null();`
142	`}`	142	`}`
143		143
144	`Utils::String CVirtualFileSystem::_returnID(Utils::SStringList *s)`	144	`Utils::WString CVirtualFileSystem::_returnID(Utils::WStringNode *s)`
145	`{`	145	`{`
146	`if ( s ) return s->str.token(";", -2);`	146	`if ( s ) return s->str.token(L";", -2);`
147	`return Utils::String::Null();`	147	`return Utils::WString::Null();`
148	`}`	148	`}`
149		149
150	`Utils::String CVirtualFileSystem::_returnLine(Utils::SStringList *s)`	150	`Utils::WString CVirtualFileSystem::_returnLine(Utils::WStringNode *s)`
151	`{`	151	`{`
152	`if ( s ) return s->str;`	152	`if ( s ) return s->str;`
153	`return Utils::String::Null();`	153	`return Utils::WString::Null();`
154	`}`	154	`}`
155		155
156		156
157	`bool CVirtualFileSystem::LoadFilesystem(const Utils::String &dir, int maxPatch)`	157	`bool CVirtualFileSystem::LoadFilesystem(const Utils::WString &dir, int maxPatch)`
158	`{`	158	`{`
159	`return this->LoadFilesystem(dir, "", maxPatch);`	159	`return this->LoadFilesystem(dir, L"", maxPatch);`
160	`}`	160	`}`
161		161
162	`bool CVirtualFileSystem::LoadFilesystem(const Utils::String &dir, const Utils::String &mod, int maxPatch)`	162	`bool CVirtualFileSystem::LoadFilesystem(const Utils::WString &dir, const Utils::WString &mod, int maxPatch)`
163	`{`	163	`{`
164	`m_sDir = dir.findReplace("\\", "/");`	164	`m_sDir = dir.findReplace(L"\\", L"/");`
165		165
166	`this->_clear();`	166	`this->_clear();`
167		167
168	`// if we are in the addon directory, then also read the previous directory`	168	`// if we are in the addon directory, then also read the previous directory`
169	`Utils::String s = dir.token("/", -1);`	169	`Utils::WString s = dir.token(L"/", -1);`
170	`if ( !this->m_sAddon.empty() && dir.token("/", -1).Compare(this->m_sAddon) ) {`	170	`if ( !this->m_sAddon.empty() && dir.token(L"/", -1).Compare(this->m_sAddon) ) {`
171	`//LoadFilesystem(dir.tokens("/", 1, -2), "", 0);`	171	`//LoadFilesystem(dir.tokens("/", 1, -2), "", 0);`
172	`}`	172	`}`
173		173
174	`int number = 1;`	174	`int number = 1;`
175	`while ( CFileIO::Exists(dir + "/" + Utils::String::PadNumber(number, 2) + ".cat") )`	175	`while ( CFileIO::Exists(dir + L"/" + Utils::WString::PadNumber(number, 2) + L".cat") )`
176	`{`	176	`{`
177	`if ( maxPatch && maxPatch < number ) break;`	177	`if ( maxPatch && maxPatch < number ) break;`
178	`Utils::String file = dir + "/" + Utils::String::PadNumber(number, 2);`	178	`Utils::WString file = dir + L"/" + Utils::WString::PadNumber(number, 2);`
179	`if ( !CFileIO::Exists(file + ".dat") )`	179	`if ( !CFileIO::Exists(file + L".dat") )`
180	`break;`	180	`break;`
181		181
182	`CCatFile cat;`	182	`CCatFile cat;`
183	`if ( cat.open(file + ".cat", m_sAddon, CATREAD_JUSTCONTENTS, false) == CATERR_NONE )`	183	`if ( cat.open(file + L".cat", m_sAddon, CATREAD_JUSTCONTENTS, false) == CATERR_NONE)`
184	`{`	184	`{`
185	`for(auto itr = cat.GetFiles()->cbegin(); itr != cat.GetFiles()->cend(); itr++)`	185	`for(auto itr = cat.GetFiles()->cbegin(); itr != cat.GetFiles()->cend(); itr++)`
186	`{`	186	`{`
187	`this->_addModFile(CFileIO((*itr)->sFile).fullFilenameStr(), file + ".cat", m_pMap);`	187	`this->_addModFile(CFileIO((*itr)->sFile).fullFilename(), file + L".cat", m_pMap);`
188	`m_bLoaded = true;`	188	`m_bLoaded = true;`
189	`}`	189	`}`
190	`}`	190	`}`
191	`++number;`	191	`++number;`
192	`}`	192	`}`
Line 194...	Line 194...
194	`// add all the files from the mod`	194	`// add all the files from the mod`
195	`if ( !mod.empty() )`	195	`if ( !mod.empty() )`
196	`this->addMod(mod);`	196	`this->addMod(mod);`
197		197
198	`// now add all the extracted data`	198	`// now add all the extracted data`
199	`this->_addDir(m_sDir, "");`	199	`this->_addDir(m_sDir, L"");`
200		200
201	`return m_bLoaded;`	201	`return m_bLoaded;`
202	`}`	202	`}`
203		203
204		204
205	`void CVirtualFileSystem::_addDir(const Utils::String &sStart, const Utils::String &sDir)`	205	`void CVirtualFileSystem::_addDir(const Utils::WString &sStart, const Utils::WString &sDir)`
206	`{`	206	`{`
207	`CDirIO Dir(sStart + "/" + sDir);`	207	`CDirIO Dir(sStart + L"/" + sDir);`
208	`Utils::WStringList list;`	208	`Utils::WStringList list;`
209	`if (Dir.dirList(list))`	209	`if (Dir.dirList(list))`
210	`{`	210	`{`
211	`for (auto itr = list.begin(); itr != list.end(); itr++)`	211	`for (auto itr = list.begin(); itr != list.end(); itr++)`
212	`{`	212	`{`
213	`if (CDirIO(Dir.dir((itr)->str)).isDir()) _addDir(sStart, sDir + "/" + (itr)->str.toString());`	213	`if (CDirIO(Dir.dir((itr)->str)).isDir()) _addDir(sStart, sDir + L"/" + (itr)->str);`
214	`else if (CFileIO((*itr)->str).isFileExtension(L"cat")) continue;`	214	`else if (CFileIO((*itr)->str).isFileExtension(L"cat")) continue;`
215	`else if (CFileIO((*itr)->str).isFileExtension(L"dat")) continue;`	215	`else if (CFileIO((*itr)->str).isFileExtension(L"dat")) continue;`
216	`else this->_addFile(sDir + "/" + (itr)->str.toString(), Dir.file((itr)->str).toString(), m_pMap);`	216	`else this->_addFile(sDir + L"/" + (itr)->str, Dir.file((itr)->str), m_pMap);`
217	`}`	217	`}`
218	`}`	218	`}`
219	`}`	219	`}`
220		220
221		221
222	`void CVirtualFileSystem::_removeSameFile(const Utils::String &sFile, const Utils::String &sDest, const Utils::String &ext, FileList *pList)`	222	`void CVirtualFileSystem::_removeSameFile(const Utils::WString &sFile, const Utils::WString &sDest, const Utils::WString &ext, FileList *pList)`
223	`{`	223	`{`
224	`CFileIO F(sFile);`	224	`CFileIO F(sFile);`
225		225
226	`Utils::String newFile = F.changeFileExtension(ext).toString();`	226	`Utils::WString newFile = F.changeFileExtension(ext);`
227	`newFile = newFile.lower();`	227	`newFile = newFile.lower();`
228		228
229	`FileListItr itr = pList->find(newFile);`	229	`FileListItr itr = pList->find(newFile);`
230	`if ( itr != pList->end() ) {`	230	`if ( itr != pList->end() ) {`
231	`if ( !CFileIO((*pList)[newFile]).dir().Compare(CFileIO(sDest).dir()) ) {`	231	`if ( !CFileIO((*pList)[newFile]).dir().Compare(CFileIO(sDest).dir()) ) {`
232	`pList->erase(newFile);`	232	`pList->erase(newFile);`
233	`}`	233	`}`
234	`}`	234	`}`
235	`}`	235	`}`
236		236
237	`void CVirtualFileSystem::_addFile(const Utils::String &sFile, const Utils::String &sDest, FileList *pList)`	237	`void CVirtualFileSystem::_addFile(const Utils::WString &sFile, const Utils::WString &sDest, FileList *pList)`
238	`{`	238	`{`
239	`Utils::String file = sFile.asFilename().removeIf(0, '/');`	239	`Utils::WString file = sFile.asFilename().removeIf(0, '/');`
240		240
241	`// check file extension, remove any patching files in previous files`	241	`// check file extension, remove any patching files in previous files`
242	`CFileIO F(file);`	242	`CFileIO F(file);`
243	`Utils::WString ext = F.extension().toLower();`	243	`Utils::WString ext = F.extension().toLower();`
244	`if (ext.Compare(L"bob", true) \|\| ext.Compare(L"pbd", true) \|\| ext.Compare(L"bod", true) ) {`	244	`if (ext.Compare(L"bob", true) \|\| ext.Compare(L"pbd", true) \|\| ext.Compare(L"bod", true) ) {`
Line 249...	Line 249...
249	`else if (ext.Compare(L"xml", true) \|\| ext.Compare(L"txt", true) )`	249	`else if (ext.Compare(L"xml", true) \|\| ext.Compare(L"txt", true) )`
250	`_removeSameFile(file, sDest, "pck", pList);`	250	`_removeSameFile(file, sDest, "pck", pList);`
251		251
252	`(*pList)[file.lower()] = sDest.findReplace("\\", "/").findReplace("//", "/");`	252	`(*pList)[file.lower()] = sDest.findReplace("\\", "/").findReplace("//", "/");`
253	`}`	253	`}`
254	`void CVirtualFileSystem::_addModFile(const Utils::String &sFile, const Utils::String &sMod, FileList *pList)`	254	`void CVirtualFileSystem::_addModFile(const Utils::WString &sFile, const Utils::WString &sMod, FileList *pList)`
255	`{`	255	`{`
256	`this->_addFile(sFile, sMod + "::" + sFile, pList);`	256	`this->_addFile(sFile, sMod + L"::" + sFile, pList);`
257	`}`	257	`}`
258		258
259	`bool CVirtualFileSystem::loadMod(const Utils::String &mod)`	259	`bool CVirtualFileSystem::loadMod(const Utils::WString &mod)`
260	`{`	260	`{`
261	`bool loaded = false;`	261	`bool loaded = false;`
262		262
263	`if ( !m_pModMap ) m_pModMap = new FileList;`	263	`if ( !m_pModMap ) m_pModMap = new FileList;`
264		264
265	`CCatFile cat;`	265	`CCatFile cat;`
266	`if ( CCatFile::Opened(cat.open(mod, m_sAddon, CATREAD_JUSTCONTENTS, false), false) )`	266	`if ( CCatFile::Opened(cat.open(mod, m_sAddon, CATREAD_JUSTCONTENTS, false), false))`
267	`{`	267	`{`
268	`for (auto itr = cat.GetFiles()->cbegin(); itr != cat.GetFiles()->cend(); itr++)`	268	`for (auto itr = cat.GetFiles()->cbegin(); itr != cat.GetFiles()->cend(); itr++)`
269	`{`	269	`{`
270	`this->_addModFile(CFileIO((*itr)->sFile).fullFilenameStr(), mod, m_pModMap);`	270	`this->_addModFile(CFileIO((*itr)->sFile).fullFilename(), mod, m_pModMap);`
271	`loaded = true;`	271	`loaded = true;`
272	`}`	272	`}`
273	`}`	273	`}`
274		274
275	`return loaded;`	275	`return loaded;`
276	`}`	276	`}`
277		277
278	`bool CVirtualFileSystem::addMod(const Utils::String &mod)`	278	`bool CVirtualFileSystem::addMod(const Utils::WString &mod)`
279	`{`	279	`{`
280	`bool loaded = false;`	280	`bool loaded = false;`
281		281
282	`if ( !m_pMap ) m_pMap = new FileList;`	282	`if ( !m_pMap ) m_pMap = new FileList;`
283		283
284	`CCatFile cat;`	284	`CCatFile cat;`
285	`if ( CCatFile::Opened(cat.open(mod, m_sAddon, CATREAD_JUSTCONTENTS, false), false) )`	285	`if ( CCatFile::Opened(cat.open(mod, m_sAddon, CATREAD_JUSTCONTENTS, false), false))`
286	`{`	286	`{`
287	`for (auto itr = cat.GetFiles()->cbegin(); itr != cat.GetFiles()->cend(); itr++)`	287	`for (auto itr = cat.GetFiles()->cbegin(); itr != cat.GetFiles()->cend(); itr++)`
288	`{`	288	`{`
289	`this->_addModFile(CFileIO((*itr)->sFile).fullFilenameStr(), mod, m_pMap);`	289	`this->_addModFile(CFileIO((*itr)->sFile).fullFilename(), mod, m_pMap);`
290	`loaded = true;`	290	`loaded = true;`
291	`}`	291	`}`
292	`}`	292	`}`
293		293
294	`return loaded;`	294	`return loaded;`
Line 306...	Line 306...
306	`}`	306	`}`
307		307
308	`return false;`	308	`return false;`
309	`}`	309	`}`
310		310
311	`Utils::String CVirtualFileSystem::findText(int iLang, int iPage, int iID) const`	311	`Utils::WString CVirtualFileSystem::findText(int iLang, int iPage, int iID) const`
312	`{`	312	`{`
313	`if ( iLang <= 0 ) iLang = m_iLang;`	313	`if ( iLang <= 0 ) iLang = m_iLang;`
314		314
315	`if ( m_pTexts ) {`	315	`if ( m_pTexts ) {`
316	`if ( m_pTexts->exists(iLang, iPage, iID) ) return m_pTexts->get(iLang, iPage, iID);`	316	`if ( m_pTexts->exists(iLang, iPage, iID) ) return m_pTexts->get(iLang, iPage, iID);`
317	`}`	317	`}`
318	`if ( m_pModTexts ) {`	318	`if ( m_pModTexts ) {`
319	`if ( m_pModTexts->exists(iLang, iPage, iID) ) return m_pModTexts->get(iLang, iPage, iID);`	319	`if ( m_pModTexts->exists(iLang, iPage, iID) ) return m_pModTexts->get(iLang, iPage, iID);`
320	`}`	320	`}`
321		321
322	`return Utils::String("ReadText") + (long)iPage + "-" + (long)iID;`	322	`return Utils::WString(L"ReadText") + (long)iPage + L"-" + (long)iID;`
323	`}`	323	`}`
324		324
325	`const Utils::String &CVirtualFileSystem::directory() const`	325	`const Utils::WString &CVirtualFileSystem::directory() const`
326	`{`	326	`{`
327	`return m_sDir;`	327	`return m_sDir;`
328	`}`	328	`}`
329		329
330	`bool CVirtualFileSystem::isFileAvailable(const Utils::String &file) const`	330	`bool CVirtualFileSystem::isFileAvailable(const Utils::WString &file) const`
331	`{`	331	`{`
332	`return !this->_findFile(file).empty();`	332	`return !this->_findFile(file).empty();`
333	`}`	333	`}`
334		334
335	`bool CVirtualFileSystem::isTextUpdated() const`	335	`bool CVirtualFileSystem::isTextUpdated() const`
336	`{`	336	`{`
337	`if ( m_pTexts ) return m_pTexts->anyTextLoaded();`	337	`if ( m_pTexts ) return m_pTexts->anyTextLoaded();`
338	`return false;`	338	`return false;`
339	`}`	339	`}`
340		340
341	`Utils::String CVirtualFileSystem::_findFile(const Utils::String &file) const`	341	`Utils::WString CVirtualFileSystem::_findFile(const Utils::WString &file) const`
342	`{`	342	`{`
343	`Utils::String toFile = file.findReplace("\\", "/").lower();`	343	`Utils::WString toFile = file.findReplace(L"\\", L"/").lower();`
344		344
345	`if ( m_pModMap && !m_pModMap->empty() ) {`	345	`if ( m_pModMap && !m_pModMap->empty() ) {`
346	`if ( !m_sAddon.empty() ) {`	346	`if ( !m_sAddon.empty() ) {`
347	`FileListItr aitr = m_pModMap->find(CFileIO(m_sAddon + "/" + toFile).fullFilenameStr().lower().c_str());`	347	`FileListItr aitr = m_pModMap->find(CFileIO(m_sAddon + L"/" + toFile).fullFilename().lower().c_str());`
348	`if ( aitr == m_pModMap->end() ) aitr = m_pModMap->find(CFileIO(_convertExtension(m_sAddon + "/" + toFile)).fullFilenameStr().lower().c_str());`	348	`if ( aitr == m_pModMap->end() ) aitr = m_pModMap->find(CFileIO(_convertExtension(m_sAddon + L"/" + toFile)).fullFilename().lower().c_str());`
349	`if ( aitr != m_pModMap->end() ) return aitr->second;`	349	`if ( aitr != m_pModMap->end() ) return aitr->second;`
350	`}`	350	`}`
351	`FileListItr itr = m_pModMap->find(CFileIO(toFile).fullFilenameStr().lower().c_str());`	351	`FileListItr itr = m_pModMap->find(CFileIO(toFile).fullFilename().lower().c_str());`
352	`if ( itr == m_pModMap->end() ) itr = m_pModMap->find(CFileIO(_convertExtension(toFile)).fullFilenameStr().lower().c_str());`	352	`if ( itr == m_pModMap->end() ) itr = m_pModMap->find(CFileIO(_convertExtension(toFile)).fullFilename().lower().c_str());`
353	`if ( itr != m_pModMap->end() ) return itr->second;`	353	`if ( itr != m_pModMap->end() ) return itr->second;`
354	`}`	354	`}`
355		355
356	`if ( m_pMap && !m_pMap->empty() ) {`	356	`if ( m_pMap && !m_pMap->empty() ) {`
357	`if ( !m_sAddon.empty() ) {`	357	`if ( !m_sAddon.empty() ) {`
358	`FileListItr aitr = m_pMap->find(CFileIO(m_sAddon + "/" + toFile).fullFilenameStr().lower().c_str());`	358	`FileListItr aitr = m_pMap->find(CFileIO(m_sAddon + L"/" + toFile).fullFilename().lower().c_str());`
359	`if ( aitr == m_pMap->end() ) aitr = m_pMap->find(CFileIO(_convertExtension(m_sAddon + "/" + file)).fullFilenameStr().lower().c_str());`	359	`if ( aitr == m_pMap->end() ) aitr = m_pMap->find(CFileIO(_convertExtension(m_sAddon + L"/" + file)).fullFilename().lower().c_str());`
360	`if ( aitr != m_pMap->end() ) return aitr->second;`	360	`if ( aitr != m_pMap->end() ) return aitr->second;`
361	`}`	361	`}`
362	`FileListItr itr = m_pMap->find(CFileIO(file).fullFilenameStr().lower().c_str());`	362	`FileListItr itr = m_pMap->find(CFileIO(file).fullFilename().lower().c_str());`
363	`if ( itr == m_pMap->end() ) itr = m_pMap->find(CFileIO(_convertExtension(file)).fullFilenameStr().lower().c_str());`	363	`if ( itr == m_pMap->end() ) itr = m_pMap->find(CFileIO(_convertExtension(file)).fullFilename().lower().c_str());`
364	`if ( itr != m_pMap->end() ) return itr->second;`	364	`if ( itr != m_pMap->end() ) return itr->second;`
365	`}`	365	`}`
366	`return "";`	366	`return L"";`
367	`}`	367	`}`
368		368
369	`Utils::String CVirtualFileSystem::_extractFromCat(const Utils::String &sCat, const Utils::String &sFile, const Utils::String &sTo)`	369	`Utils::WString CVirtualFileSystem::_extractFromCat(const Utils::WString &sCat, const Utils::WString &sFile, const Utils::WString &sTo)`
370	`{`	370	`{`
371	`CCatFile catFile;`	371	`CCatFile catFile;`
372	`if ( catFile.open(sCat, m_sAddon, CATREAD_CATDECRYPT, false) == CATERR_NONE )`	372	`if ( catFile.open(sCat, m_sAddon, CATREAD_CATDECRYPT, false) == CATERR_NONE)`
373	`{`	373	`{`
374	`// check for the file`	374	`// check for the file`
375	`if ( catFile.extractFile(sFile, sTo) ) return sTo;`	375	`if ( catFile.extractFile(sFile, sTo)) return sTo;`
376	`if ( catFile.error() == CATERR_INVALIDDEST \|\| catFile.error() == CATERR_CANTCREATEDIR ) {`	376	`if ( catFile.error() == CATERR_INVALIDDEST \|\| catFile.error() == CATERR_CANTCREATEDIR ) {`
377	`if ( catFile.extractFile(sFile) ) return sFile;`	377	`if ( catFile.extractFile(sFile) ) return sFile;`
378	`}`	378	`}`
379	`}`	379	`}`
380		380
381	`return "";`	381	`return "";`
382	`}`	382	`}`
383		383
384	`Utils::String CVirtualFileSystem::_extract(const Utils::String &sFile, const Utils::String &sTo)`	384	`Utils::WString CVirtualFileSystem::_extract(const Utils::WString &sFile, const Utils::WString &sTo)`
385	`{`	385	`{`
386	`// check if we need to unpack the file`	386	`// check if we need to unpack the file`
387	`if ( CCatFile::CheckPackedExtension(sFile) ) {`	387	`if ( CCatFile::CheckPackedExtension(sFile) ) {`
388	`CFileIO File(sFile);`	388	`CFileIO File(sFile);`
389	`C_File f(File.fullFilenameStr());`	389	`C_File f(File.fullFilename());`
390	`if ( !f.readFromFile(File) ) return "";`	390	`if ( !f.readFromFile(File) ) return L"";`
391	`if ( !f.UnPCKFile() ) return "";`	391	`if ( !f.UnPCKFile() ) return L"";`
392	`if ( !f.writeToFile(sTo) ) return "";`	392	`if ( !f.writeToFile(sTo) ) return L"";`
393	`return sTo;`	393	`return sTo;`
394	`}`	394	`}`
395	`return sFile;`	395	`return sFile;`
396	`}`	396	`}`
397		397
398	`Utils::String CVirtualFileSystem::ExtractGameFile(const Utils::String &file, const Utils::String &to)`	398	`Utils::WString CVirtualFileSystem::extractGameFile(const Utils::WString &file, const Utils::WString &to)`
399	`{`	399	`{`
400	`Utils::String sIn = _findFile(file);`	400	`Utils::WString sIn = _findFile(file);`
401	`Utils::String sFile = file;`	401	`Utils::WString sFile = file;`
402		-
403	`if ( sIn.empty() ) return "";`	-
404		402
-		403	`if (sIn.empty()) return L"";`
-		404
405	`if ( sIn.isin("::") ) {`	405	`if (sIn.contains(L"::"))`
-		406	`{`
406	`sFile = sIn.token("::", 2);`	407	`sFile = sIn.token(L"::", 2);`
407	`sIn = sIn.token("::", 1);`	408	`sIn = sIn.token(L"::", 1);`
408	`return _extractFromCat(sIn, sFile, to);`	409	`return _extractFromCat(sIn, sFile, to);`
409	`}`	410	`}`
410		411
411	`return _extract(sIn, to);`	412	`return _extract(sIn, to);`
412	`}`	413	`}`
413		414
414	`Utils::String CVirtualFileSystem::_convertExtension(const Utils::String &sFile) const`	415	`Utils::WString CVirtualFileSystem::_convertExtension(const Utils::WString &sFile) const`
415	`{`	416	`{`
416	`CFileIO File(sFile);`	417	`CFileIO File(sFile);`
417	`if ( File.isFileExtension(L"pck") ) {`	418	`if ( File.isFileExtension(L"pck") ) {`
418	`return File.changeFileExtension(L"xml").toString();`	419	`return File.changeFileExtension(L"xml");`
419	`}`	420	`}`
420	`else if ( File.isFileExtension(L"xml") ) {`	421	`else if ( File.isFileExtension(L"xml") ) {`
421	`return File.changeFileExtension(L"pck").toString();`	422	`return File.changeFileExtension(L"pck");`
422	`}`	423	`}`
423	`else if ( File.isFileExtension(L"pbb") ) {`	424	`else if ( File.isFileExtension(L"pbb") ) {`
424	`return File.changeFileExtension(L"bob").toString();`	425	`return File.changeFileExtension(L"bob");`
425	`}`	426	`}`
426	`else if ( File.isFileExtension(L"bob") ) {`	427	`else if ( File.isFileExtension(L"bob") ) {`
427	`return File.changeFileExtension(L"pbb").toString();`	428	`return File.changeFileExtension(L"pbb");`
428	`}`	429	`}`
429	`else if ( File.isFileExtension(L"pbd") ) {`	430	`else if ( File.isFileExtension(L"pbd") ) {`
430	`return File.changeFileExtension(L"bod").toString();`	431	`return File.changeFileExtension(L"bod");`
431	`}`	432	`}`
432	`else if ( File.isFileExtension(L"bod") ) {`	433	`else if ( File.isFileExtension(L"bod") ) {`
433	`return File.changeFileExtension(L"pbd").toString();`	434	`return File.changeFileExtension(L"pbd");`
434	`}`	435	`}`
435		436
436	`return sFile;`	437	`return sFile;`
437	`}`	438	`}`
438		439
439	`Utils::CStringList *CVirtualFileSystem::getTShipsEntries()`	440	`Utils::WStringList *CVirtualFileSystem::getTShipsEntries()`
440	`{`	441	`{`
441	`if ( !_lShips \|\| _lShips->empty() ) _updateShips();`	442	`if ( !_lShips \|\| _lShips->empty() ) _updateShips();`
442	`return _lShips;`	443	`return _lShips;`
443	`}`	444	`}`
444		445
445	`C_File CVirtualFileSystem::extractGameFileToPackage(CBaseFile pPackage, const Utils::String &sFile, FileType iFileType)`	446	`C_File CVirtualFileSystem::extractGameFileToPackage(CBaseFile pPackage, const Utils::WString &sFile, FileType iFileType)`
446	`{`	447	`{`
447	`return this->extractGameFileToPackage(pPackage, sFile, iFileType, sFile);`	448	`return this->extractGameFileToPackage(pPackage, sFile, iFileType, sFile);`
448	`}`	449	`}`
449		450
450	`C_File CVirtualFileSystem::extractGameFileToPackage(CBaseFile pPackage, const Utils::String &sFile, FileType iFileType, const Utils::String &sTo)`	451	`C_File CVirtualFileSystem::extractGameFileToPackage(CBaseFile pPackage, const Utils::WString &sFile, FileType iFileType, const Utils::WString &sTo)`
451	`{`	452	`{`
452	`Utils::String to = this->ExtractGameFile(sFile, CPackages::tempDirectory() + "tmp.dat");`	453	`Utils::WString to = this->extractGameFile(sFile, CPackages::tempDirectory() + L"tmp.dat");`
453	`if ( !to.empty() ) {`	454	`if ( !to.empty() ) {`
454	`CFileIO File(to);`	455	`CFileIO File(to);`
455		456
456	`C_File *f = pPackage->addFile(CFileIO(sTo).filenameStr(), CFileIO(sTo).dir().toString(), iFileType);`	457	`C_File *f = pPackage->addFile(CFileIO(sTo).filename(), CFileIO(sTo).dir(), iFileType);`
457	`if ( f ) {`	458	`if ( f ) {`
458	`if ( f->readFromFile(CPackages::tempDirectory() + "tmp.dat") ) {`	459	`if ( f->readFromFile(CPackages::tempDirectory() + L"tmp.dat") ) {`
459	`File.remove();`	460	`File.remove();`
460	`return f;`	461	`return f;`
461	`}`	462	`}`
462	`}`	463	`}`
463		464
464	`File.remove();`	465	`File.remove();`
465	`}`	466	`}`
466		467
467	`return NULL;`	468	`return NULL;`
468	`}`	469	`}`
469		470
470	`Utils::String CVirtualFileSystem::getTShipsEntry(const Utils::String &sId)`	471	`Utils::WString CVirtualFileSystem::getTShipsEntry(const Utils::WString &sId)`
471	`{`	472	`{`
472	`if ( !_lShips \|\| _lShips->empty() ) _updateShips();`	473	`if ( !_lShips \|\| _lShips->empty() ) _updateShips();`
473	`return _lShips->findData(sId, true);`	474	`return _lShips->findData(sId, true);`
474	`}`	475	`}`
475		476
476	`void CVirtualFileSystem::extractTexts(CXspFile *pPackage, int textId)`	477	`void CVirtualFileSystem::extractTexts(CXspFile *pPackage, int textId)`
477	`{`	478	`{`
478	`//TODO: check for better finding of files in map`	479	`//TODO: check for better finding of files in map`
479	`for ( FileListItr itr = m_pMap->begin(); itr != m_pMap->end(); ++itr ) {`	480	`for ( FileListItr itr = m_pMap->begin(); itr != m_pMap->end(); ++itr ) {`
480	`Utils::String str = itr->first;`	481	`Utils::WString str = itr->first;`
481		482
482	`if ( !m_sAddon.empty() ) {`	483	`if ( !m_sAddon.empty() ) {`
483	`if ( !str.left(m_sAddon.length() + 3).Compare(m_sAddon + "/t/") && !str.left(m_sAddon.length() + 3).Compare(m_sAddon + "\\t\\") )`	484	`if ( !str.left(m_sAddon.length() + 3).Compare(m_sAddon + L"/t/") && !str.left(m_sAddon.length() + 3).Compare(m_sAddon + L"\\t\\") )`
484	`continue;`	485	`continue;`
485	`}`	486	`}`
486	`else {`	487	`else {`
487	`if ( !str.left(2).Compare("t\\") && !str.left(2).Compare("t/") && !str.left(8).Compare("addon\t\\") && !str.left(8).Compare("addon/t/") )`	488	`if ( !str.left(2).Compare(L"t\\") && !str.left(2).Compare(L"t/") && !str.left(8).Compare(L"addon\t\\") && !str.left(8).Compare(L"addon/t/") )`
488	`continue;`	489	`continue;`
489	`}`	490	`}`
490		491
491	`Utils::String sTo = this->ExtractGameFile(str, CPackages::tempDirectory() + "tmp.dat");`	492	`Utils::WString sTo = this->extractGameFile(str, CPackages::tempDirectory() + L"tmp.dat");`
492	`if ( !sTo.empty() ) {`	493	`if ( !sTo.empty() ) {`
493	`pPackage->AddTextFromFile(sTo, textId);`	494	`pPackage->addTextFromFile(sTo, textId);`
494	`CFileIO::Remove(sTo);`	495	`CFileIO::Remove(sTo);`
495	`}`	496	`}`
496	`}`	497	`}`
497	`}`	498	`}`
498		499
Line 503...	Line 504...
503	`void CVirtualFileSystem::updateTexts(int iPage)`	504	`void CVirtualFileSystem::updateTexts(int iPage)`
504	`{`	505	`{`
505	`this->_updateTexts(iPage, iPage, m_pMap, m_pTexts);`	506	`this->_updateTexts(iPage, iPage, m_pMap, m_pTexts);`
506	`}`	507	`}`
507	`void CVirtualFileSystem::updateModTexts(int iFromPage, int iToPage)`	508	`void CVirtualFileSystem::updateModTexts(int iFromPage, int iToPage)`
508	`{`	509	`{`
509	`this->_updateTexts(iFromPage, iToPage, m_pModMap, m_pModTexts);`	510	`this->_updateTexts(iFromPage, iToPage, m_pModMap, m_pModTexts);`
510	`}`	511	`}`
511	`void CVirtualFileSystem::updateModTexts(int iPage)`	512	`void CVirtualFileSystem::updateModTexts(int iPage)`
512	`{`	513	`{`
513	`this->_updateTexts(iPage, iPage, m_pModMap, m_pModTexts);`	514	`this->_updateTexts(iPage, iPage, m_pModMap, m_pModTexts);`
514	`}`	515	`}`
515		516
516	`void CVirtualFileSystem::_clear()`	517	`void CVirtualFileSystem::_clear()`
517	`{`	518	`{`
Line 534...	Line 535...
534		535
535	`void CVirtualFileSystem::_updateTexts(int iFromPage, int iToPage, FileList pFileList, CTextDB pTextList)`	536	`void CVirtualFileSystem::_updateTexts(int iFromPage, int iToPage, FileList pFileList, CTextDB pTextList)`
536	`{`	537	`{`
537	`// read all text files`	538	`// read all text files`
538	`for ( FileListItr itr = pFileList->begin(); itr != pFileList->end(); ++itr ) {`	539	`for ( FileListItr itr = pFileList->begin(); itr != pFileList->end(); ++itr ) {`
539	`Utils::String str = itr->first;`	540	`Utils::WString str = itr->first;`
540		541
541	`if ( !m_sAddon.empty() ) {`	542	`if ( !m_sAddon.empty() ) {`
542	`if ( !str.left(m_sAddon.length() + 3).Compare(m_sAddon + "/t/") && !str.left(m_sAddon.length() + 3).Compare(m_sAddon + "\\t\\") )`	543	`if ( !str.left(m_sAddon.length() + 3).Compare(m_sAddon + L"/t/") && !str.left(m_sAddon.length() + 3).Compare(m_sAddon + L"\\t\\") )`
543	`continue;`	544	`continue;`
544	`}`	545	`}`
545	`else {`	546	`else {`
546	`if ( !str.left(2).Compare("t\\") && !str.left(2).Compare("t/") )`	547	`if ( !str.left(2).Compare(L"t\\") && !str.left(2).Compare(L"t/") )`
547	`continue;`	548	`continue;`
548	`}`	549	`}`
549		550
550	`Utils::String sTo = this->ExtractGameFile(str, CPackages::tempDirectory() + "tmp.dat");`	551	`Utils::WString sTo = this->extractGameFile(str, CPackages::tempDirectory() + L"tmp.dat");`
551	`if ( !sTo.empty() ) {`	552	`if ( !sTo.empty() ) {`
552	`// add all texts into the map, id=(pageid, tid) data=text`	553	`// add all texts into the map, id=(pageid, tid) data=text`
553	`Utils::WString baseFile = CFileIO(str).baseName();`	554	`Utils::WString baseFile = CFileIO(str).baseName();`

Subversion Repositories spk

(root)/libspk/src/VirtualFileSystem.cpp – Rev 196 → 197