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



	m_lDisableList.clear();
	m_lEnableList.clear();
	this->Reset();
}
 
void CPackages::setCurrentDir(const Utils::String &dir)
{ 
	m_sCurrentDir = dir;
	if (_pCurrentDir) delete _pCurrentDir;
	_pCurrentDir = new GameDirectory();
	_pCurrentDir->dir = dir;
	_pCurrentDir->id = -1;
 
	m_gameExe.GetDirectoryData(_pCurrentDir);
	_pCurrentDir->langid = this->GetGameLanguage(_pCurrentDir->dir);
	if (_pCurrentDir->langid > 0)

			if ( f->IsFakePatch() ) continue;
			if ( f->CheckFileExt("cat") ) break;
		}
 
		if ( f )
			m_pGameVFS.LoadFilesystem(m_sCurrentDir, f->filePointer(), 0);
		else
			m_pGameVFS.LoadFilesystem(m_sCurrentDir, 0);
	}
	else
		m_pGameVFS.LoadFilesystem(m_sCurrentDir, 0);
}
 
bool CPackages::isOldDir(const Utils::String &dir)
{
	bool oldPlugin = false;

				if ( cmd.Compare("<script>") || cmd.Compare("</scripts>") )
					break;
				else if ( cmd.Compare("spkinstaller") || cmd.Compare("globalfiles") )
					break;
				else if ( cmd.Compare("pluginmanager") )
				{
					oldPlugin = true;
					break;
				}
			}
 

	}
 
	return oldPlugin;
}
 
bool CPackages::Read(CyString dir, CProgressInfo* progress)
{
	return read(dir.ToString(), progress);
}
 
bool CPackages::read(const Utils::String& dir, CProgressInfo* progress)
{
	m_sCurrentDir = dir;
	m_sCurrentDir = m_sCurrentDir.findReplace("\\", "/");
	this->setCurrentDir(dir);
	m_bOldPlugin = false;
	m_lCreatedFiles.Clear();
	m_bRemoveDir = false;
	m_bSurpressProtectedWarning = false;
	m_iSaveGame = -1;

	m_lNonRemovedFiles.Clear();
	m_lGlobals.Clear();
	m_lFakePatchOrder.Clear();
 
	if ( _pOriginalFiles ) delete _pOriginalFiles;
	_pOriginalFiles = new COriginalFiles(m_sCurrentDir);
 
	m_bVanilla = true;
 
	// check the pluginmanager data file exists
	CFileIO datFile(m_sCurrentDir + "/PluginManager/pluginmanager.dat");

 
				Utils::String cmd = line.token(":", 1).lower();
				Utils::String rest = line.tokens(":", 2).removeFirstSpace();
 
				if ( iStatus == READ_GLOBAL )
				{
					if ( cmd == "<script>" )
					{
						packageFile = new CSpkFile();
						iStatus = READ_SCRIPT;
					}
					else if ( cmd == "<ship>" )
					{
						packageFile = new CXspFile();
						iStatus = READ_SCRIPT;
					}
					else if ( cmd == "<base>" )
					{
						packageFile = new CBaseFile();
						iStatus = READ_SCRIPT;
					}
					else if ( cmd == "<archive>" )
					{
						packageFile = new CArchiveFile();
						iStatus = READ_SCRIPT;
					}
					else if ( cmd != "</scripts>" )

						{
							origName = fileName.token("O#", 2);
							fileName = fileName.token("O#", 1);
						}
 
						C_File *newFile = new C_File(m_sCurrentDir + fileName);
						newFile->setGame(game);
						newFile->SetOriginalName(origName);
						newFile->SetDisabled(disabled);
						newFile->setFileType((FileType)line.token(":", 1).toLong());
						newFile->SetCreationTime((time_t)line.token(":", 2).toLong());

						if ( line.token(":", 4).toLong() )
							newFile->SetShared(true);
						newFile->UpdateSigned();
 
						m_lFiles.push_back(newFile);
					}
				}
				else if ( iStatus == READ_SCRIPT )
				{
					if ( cmd == "installspk" )
						packageFile->setFilename(rest);

					}
					else
						packageFile->ParseValueLine(line);
				}
				else if ( iStatus == READ_SCRIPTFILE )
				{
					if ( cmd == "<script>" )
					{
						if ( packageFile->IsMod() && packageFile->IsEnabled() )
							m_pEnabledMod = packageFile;
 

	}
 
	if ( m_pEnabledMod && !m_pEnabledMod->IsEnabled() )
		m_pEnabledMod = NULL;
 
	m_iGame = m_gameExe.GetGameType(m_sCurrentDir) + 1;
	m_pCurrentGameExe = m_gameExe.GetGame(m_gameExe.GetGameType(m_sCurrentDir));
	Utils::String sGameVersion;
	m_iGameVersion = m_gameExe.GetGameVersion(m_sCurrentDir, &sGameVersion) + 1;
	m_sGameVersion = sGameVersion;
	m_iGameFlags = m_gameExe.GetGameFlags(m_iGame - 1);
	m_iMaxPatch = m_gameExe.GetMaxPatch(m_iGame - 1);
 
	// find the fake patch

		{
			CXspFile *p = (CXspFile *)node->Data();
			for ( CListNode<SGameShip> *gNode = m_lGameShips.Front(); gNode; gNode = gNode->next() )
			{
				if ( p->GetShipID().Compare(gNode->Data()->sShipID.ToString()) )
				{
					gNode->Data()->pPackage = p;
					break;
				}
			}
		}
	}
 
	// check the purged time
	this->PurgeGameObjects();
 
	m_bLoaded = true;
 
	return true;
}
 
void CPackages::RemoveCreatedFiles()
{
	for ( SStringList *node = m_lCreatedFiles.Head(); node; node = node->next )
	{
		if ( CFileIO(node->str).ExistsOld() )
			CFileIO::Remove(node->str.ToString());
		else if ( CFileIO(m_sCurrentDir + "/" + node->str.ToString()).ExistsOld() )
			CFileIO::Remove(m_sCurrentDir + "/" + node->str.ToString());
	}
 
	m_lCreatedFiles.Clear();
}
 
void CPackages::PurgeGameObjects()
{
	// check for the log file
	Utils::String logDir = logDirectory();
	CFileIO LogFile(logDir + "/log0" + Utils::String::PadNumber(PMTEXTFILE, 4) + ".txt");
	if ( LogFile.exists() )
	{
		// read the log file to memory
		std::vector<CyString> *lines = LogFile.ReadLines();
		if ( lines )
		{
			for ( int i = 0; i < (int)lines->size(); i++ )
			{
				CyString line(lines->at(i));
				CyString start = line.GetToken(":", 1, 1).ToLower();
				CyString rest = line.GetToken(":", 2, 2).RemoveFirstSpace();

					}
				}
			}
 
			delete lines;
		}
		// remove the log file
		LogFile.remove();
	}
}
 

			if ( !w ) continue;
			if ( w->iType == WARETYPE_DELETED )
				w->iType = WARETYPE_NONE;
		}
		m_lGameWares[i].RemoveEmpty();
	}
}
 
void CPackages::PurgeShips()
{
	for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
	{

	m_lGameShips.RemoveEmpty();
}
 
Utils::String CPackages::logDirectory()
{
	Utils::String logDir = m_sCurrentDir;
	if ( m_iGameFlags & EXEFLAG_MYDOCLOG ) {
		SGameExe *exe = m_gameExe.GetGame(m_iGame - 1);
		if ( exe ) {
			if ( !exe->sMyDoc.empty() )
				logDir = m_sMyDoc + "/" + exe->sMyDoc;

	return logDir;
}
 
Utils::String CPackages::logDirectory(const Utils::String &gameExe)
{
	Utils::String logDir = m_sCurrentDir;
	if ( m_iGameFlags & EXEFLAG_MYDOCLOG )
	{
		SGameExe *exe = m_gameExe.gameExe(CFileIO(gameExe).filename());
		if ( exe )
		{

	if ( CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat").ExistsOld() && CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat").ExistsOld() )
		return true;
 
	// if only one of them exists, lets remove them
	if ( CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat").ExistsOld() )
		CFileIO::Remove(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat");
	if ( CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat").ExistsOld() )
		CFileIO::Remove(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat");
 
	// fake patch is not being used
	if ( m_iFakePatch < 0 ) return true;
	// now lets find the fake patch
	Utils::String useFile;
	if ( m_iFakePatch > 0 )
	{
		Utils::String file = Utils::String::PadNumber(m_iFakePatch, 2);
		if ( CheckValidPluginManagerFile(file) )
			useFile = file;
		else if ( CheckIfPluginManagerFile(file) )
			useFile = file;
	}
 
	if ( useFile.empty() )
	{
		int nextfree = this->FindNextFakePatch();
		--nextfree; // gets the end fake patch
 
		// work backwards till we find a valid one
		while ( nextfree > m_iMaxPatch )
		{
			Utils::String file = Utils::String::PadNumber(nextfree, 2);
			if ( CheckValidPluginManagerFile(file) )
			{
				useFile = file;
				break;
			}

	}
 
	CyString addonDir = this->GetAddonDir();
 
	// couldn't find the correct file, lets search for it
	if ( useFile.empty() ) {
		int nextfree = this->FindNextFakePatch();
		--nextfree; // gets the end fake patch
 
		// work backwards till we find a valid one
		while ( nextfree > m_iMaxPatch )
		{
			Utils::String file = Utils::String::PadNumber(nextfree, 2);
			if ( CheckIfPluginManagerFile(file) )
			{
				useFile = file;
				break;
			}
			--nextfree;
		}		
	}
 
	if ( !useFile.empty() )
	{
		// lets check whats in the file first
		CCatFile openCat;
		if ( openCat.open(m_sCurrentDir + "/" + useFile + ".cat", addonDir.ToString(), CATREAD_CATDECRYPT, false) == CATERR_NONE )
		{
			std::vector<SInCatFile *> *files = openCat.GetFiles();
			bool found = false;
			if ( files )
			{

	// no files found, but we have a fake patch ? restore from backup
	else if ( m_iFakePatch > 0 ) {
		CLog::log(CLog::Log_Directory, 1, "PlugMan FakePatch seems to be missing (" + Utils::String::Number(m_iFakePatch) + "), Restoring from backup");
		CFileIO catFile(m_sCurrentDir + "/PluginManager/Backup/PlugMan_Fake.cat");
		if ( catFile.exists() ) {
			catFile.copy(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat");
			CFileIO datFile(m_sCurrentDir + "/PluginManager/Backup/PlugMan_Fake.dat");
			if ( datFile.exists() ) datFile.copy(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat");
		}
	}
 
	// otherwise we didn't need to (hopefully)
	return true;

 
bool CPackages::CheckIfPluginManagerFile(CyString filename)
{
	bool found = false;
 
	CFileIO catFile(m_sCurrentDir + "/" + filename.ToString() + ".cat");
	if ( catFile.exists() && CFileIO::Exists(m_sCurrentDir + "/" + filename.ToString() + ".dat"))
	{
		CCatFile openFile;
		if ( openFile.open(catFile.fullFilename(), this->getAddonDir(), CATREAD_CATDECRYPT, false) == CATERR_NONE )
		{
//			if ( openFile.internaldatFilename().Compare("PlugMan_Fake.dat") ) return true;

}
 
bool CPackages::CheckValidPluginManagerFile(CyString filename)
{
	// both the cat file and dat file exists, lets open it
	CFileIO catFile(m_sCurrentDir + "/" + filename.ToString() + ".cat");
	if ( catFile.exists() && CFileIO::Exists(m_sCurrentDir + "/" + filename.ToString() + ".dat"))
	{
		CCatFile openFile;
		if ( openFile.open(catFile.fullFilename(), this->getAddonDir(), CATREAD_CATDECRYPT, false) == CATERR_NONE )
		{
			if ( openFile.FindData("PlugMan\\TFake.pck") )

			if ( !checkFile ) continue;
 
			if ( checkFile->GetFileType() != FILETYPE_UNINSTALL && checkFile->GetFileType() != FILETYPE_SCRIPT )
				continue;
 
			if ( uf->filename().Compare(checkFile->filename()) )
			{
				if ( RemoveUninstallFile(uf, errors) )
					fNode->DeleteData();
				break;
			}

}
 
void CPackages::_addToFakePatch(CBaseFile *pPackage)
{
	CCatFile cat;
	if ( CCatFile::Opened(cat.open(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat", this->getAddonDir(), CATREAD_DAT)) ) {
		for ( CListNode<C_File> *f = pPackage->GetFileList()->Front(); f; f = f->next() ) {
			if ( f->Data()->GetFileType() != FILETYPE_SHIPSCENE && f->Data()->GetFileType() != FILETYPE_COCKPITSCENE && f->Data()->GetFileType() != FILETYPE_SHIPMODEL && f->Data()->GetFileType() != FILETYPE_SHIPOTHER ) {
				continue;
			}
			if ( CCatFile::IsAddonDir(f->Data()->GetNameDirectory(pPackage).ToString()) ) {

			}
			Utils::String toFile;
			if ( cat.AppendFile(f->Data()->filePointer(), f->Data()->GetNameDirectory(pPackage).ToString(), true, (m_iGameFlags & EXEFLAG_NOXOR) ? false : true, &toFile) ) {
				CLog::logf(CLog::Log_Install, 2, "Adding file: %s into the fake patch", f->Data()->GetNameDirectory(pPackage).c_str());
				CFileIO::Remove(f->Data()->filePointer());
				f->Data()->setFilename(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat::" + toFile);
			}
		}
	}
}
 

				{
					if ( f->Data()->GetBaseName().Left(5).Compare("fake_") )
					{
						shuffle = true;
						C_File *match = package->FindMatchingMod(f->Data());
						Utils::String next = Utils::String::PadNumber(this->FindNextFakePatch(), 2);
						
						CyString oldFilePointer = f->Data()->GetFilePointer();
						f->Data()->setDir("");
						f->Data()->changeBaseName(next);
						if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + "/" + f->Data()->getNameDirectory(package)) )
							f->Data()->setFilename(m_sCurrentDir + "/" + f->Data()->getNameDirectory(package));
 
						if ( match )
						{
							Utils::String oldFilePointer = match->filePointer();
							match->setDir("");
							match->changeBaseName(next);
							if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + "/" + match->getNameDirectory(package)) )
								match->setFilename(m_sCurrentDir + "/" + match->getNameDirectory(package));
						}
					}
					else
					{
						C_File *match = package->FindMatchingMod(f->Data());
 
						f->Data()->setDir("");
						if ( CFileIO(f->Data()->GetFilePointer()).Rename(m_sCurrentDir + "/" + f->Data()->getNameDirectory(package)) )
							f->Data()->setFilename(m_sCurrentDir + "/" + f->Data()->getNameDirectory(package));
						if ( match )
						{
							match->setDir("");
							if ( CFileIO(match->filePointer()).Rename(m_sCurrentDir + "/" + match->getNameDirectory(package)) )
								match->setFilename(m_sCurrentDir + "/" + match->getNameDirectory(package));
						}
					}
				}
			}
 

			{
				if ( !icon->UncompressData() )
					package->SetIcon(NULL, "");
				else
				{
					CFileIO iconFile(m_sCurrentDir + "/PluginManager/Icons/" + package->author() + "_" + package->name() + "." + package->iconExt());
					if ( iconFile.WriteData((const char *)icon->GetData(), icon->GetDataSize()) )
					{
						icon->SetFilename(CyString(package->author()) + "_" + package->name() + "." + package->iconExt());
						icon->SetFullDir(m_sCurrentDir + "/PluginManager/Icons");
					}
					else
						package->SetIcon(NULL, "");
				}

				m_lFiles.remove(f, false);
 
				// if its a readme file, then check if its in the new package
				bool dontRemove = false;
				if ( f->GetFileType() == FILETYPE_README ) {
					if ( package->FindFile(f->filename(), FILETYPE_README) )
						dontRemove = true;
				}
 
				// remove from hard drive
				if ( !dontRemove && RemoveFile(f, errors) )

 
		for ( C_File *uf = uninstallFiles.First(); uf; uf = uninstallFiles.Next() )
		{
			C_File *newFile = new C_File();
			newFile->SetFileType(FILETYPE_SCRIPT);
			newFile->setFilename(uf->filename());
			newFile->SetCreationTime(uf->GetCreationTime());
 
			// other installed packages use this file as well, copy it
			Utils::String newFilename = m_sCurrentDir + "/" + newFile->getNameDirectory(NULL);
			CFileIO file(uf->filePointer());
 
			if ( uf->GetUsed() )
			{
				if ( file.copy(newFilename) )
					this->AddLogEntry(SPKINSTALL_UNINSTALL_COPY, newFile->getNameDirectory(NULL), errors);
				else
				{
					this->AddLogEntry(SPKINSTALL_UNINSTALL_COPY_FAIL, newFile->getNameDirectory(NULL), errors);
					delete newFile;
					newFile = NULL;
				}
			}
			// otherwise just move it
			else
			{
				if ( file.Rename(newFilename) )
					this->AddLogEntry(SPKINSTALL_UNINSTALL_MOVE, newFile->getNameDirectory(NULL), errors);
				else
				{
					this->AddLogEntry(SPKINSTALL_UNINSTALL_MOVE_FAIL, newFile->getNameDirectory(NULL), errors);
					delete newFile;
					newFile = NULL;
				}
 
				m_lFiles.remove(uf, false);

				// first check if theres a matching one
				bool found = false;
				for ( CListNode<C_File> *node = m_lUninstallFiles.Front(); node; node = node->next() )
				{
					C_File *checkFile = node->Data();
					if ( checkFile->filename().Compare(newFile->filename()) )
					{
						found = true;
						break;
					}
				}

 *
 * When existing, program needs to close the directory
 */
bool CPackages::CloseDir ( CyStringList *errors, CProgressInfo *progress, bool removedir )
{
	if ( m_sCurrentDir.empty() )
		return true;
	if ( !m_bLoaded )
		return true;
 
	CLog::log(CLog::Log_Directory, 1, "closing directory: " + m_sCurrentDir);
 
	if ( m_bRenameText ) {
		CLog::log(CLog::Log_Directory, 2, "Creating other language files for game");
		CreateLanguageTextFiles(errors);
	}
 
	CLog::log(CLog::Log_Directory, 2, "Backing up save game files");
 
	if ( CFileIO(m_sCurrentDir + "/mods/PluginManager.dat").ExistsOld() ) {
		CLog::log(CLog::Log_IO, 3, "Removing old PluginManager.dat file");
		CFileIO::Remove(m_sCurrentDir + "/mods/PluginManager.dat");
	}
	if ( CFileIO(m_sCurrentDir + "/mods/PluginManager.cat").ExistsOld() ) {
		CLog::log(CLog::Log_IO, 3, "Removing old PluginManager.cat file");
		CFileIO::Remove(m_sCurrentDir + "/mods/PluginManager.cat");
	}
 
	if ( !m_bVanilla )
	{
		// base mode for Reunion

				while ( fCat && !fCat->IsFakePatch() && !fCat->CheckFileExt("cat") && !fCat->GetBaseName().Compare(fDat->GetBaseName()) )
					fCat = m_pEnabledMod->GetNextFile(fCat);
 
				if ( fCat )
				{
					CFileIO(fDat->GetFilePointer()).copy(m_sCurrentDir + "/mods/PluginManager.dat");
					CFileIO(fCat->GetFilePointer()).copy(m_sCurrentDir + "/mods/PluginManager.cat");
				}
			}
		}
		else if ( m_iGame == GAME_X3 && !m_sSetMod.Empty() && CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod.ToString() + ".cat").ExistsOld() && CFileIO(m_sCurrentDir + "/mods/"; + m_sSetMod.ToString() + ".dat").ExistsOld())
		{
			CLog::log(CLog::Log_Directory, 2, "Copying mod file: " + m_sSetMod.ToString() + ", to PluginManager.cat");
			CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod.ToString() + ";.dat").copy(m_sCurrentDir + "/mods/PluginManager.dat");
			CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod.ToString() + ";.cat").copy(m_sCurrentDir + "/mods/PluginManager.cat");
		}
 
		if ( !CDirIO(m_sCurrentDir).exists("mods") )
			CDirIO(m_sCurrentDir).Create("mods");
 

		CyStringList removeDirs;
		removeDirs.PushBack(".");
		RemoveUnusedDirectories(removeDirs, errors);
	}
 
	this->setCurrentDir("");
		 
	m_bLoaded = false;
	return true;
}
 

	return m_gameExe.GetModKey(m_iGame - 1);
}
CyString CPackages::GetSelectedModName()
{
	if ( !m_pEnabledMod )
	{
		if ( m_sSetMod.Empty() && m_iGame == GAME_X3 )
			return "PluginManager";
		return m_sSetMod;
	}
 

 
	C_File *f = m_pEnabledMod->GetFirstFile(FILETYPE_MOD);
	if ( !f )
		return m_sSetMod;
 
	CyString name = f->filename();
	name = name.Left(-4);
	return name;
 
}
 

 *
 * Writes the current package list data into pluginmanager.dat file
 */
void CPackages::WriteData()
{
	if ( m_sCurrentDir.empty() )
		return;
 
	CLog::log(CLog::Log_Directory, 1, "Writing data file for current directory: " + m_sCurrentDir);
 
	CyStringList lines;
	CyString version;
	version.FromFloat(GetLibraryVersion(), 2);
	version.Prepend("SpkInstaller: ");

	for ( int i = 0; i < WAREBUFFERS; i++ )
	{
		if ( !m_lGameWares[i].size() )
			continue;
		lines.PushBack(CyString("Wares: ") + (long)i + " " + (long)m_lGameWares[i].size());
 
		for ( CListNode<SGameWare> *node = m_lGameWares[i].Front(); node; node = node->next() )
		{
			SGameWare *gm = node->Data();
			lines.PushBack(CyString((long)gm->iPos) + " " + (long)gm->iType + " " + CyString((char)gm->cType) + " " + gm->sWareName);
		}
	}
 
	for ( SStringList *str = m_lNonRemovedFiles.Head(); str; str = str->next )
		lines.PushBack(CyString("NonRemovedFile: ") + str->str);
 
	if ( m_lGameShips.size() )
	{
		lines.PushBack(CyString("Ships: ") + (long)m_lGameShips.size());
 
		for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
		{
			SGameShip *gm = node->Data();
			lines.PushBack(CyString((long)gm->iType) + " $#C:" + gm->sShipClass + " " + gm->sShipID);
		}
	}
 
	// write created Files
	if ( !m_lCreatedFiles.Empty() )
	{

		for ( CListNode<C_File> *node = m_lUninstallFiles.Front(); node; node = node->next() )
		{
			C_File *uf = node->Data();
			CyString uString = "Uninstall: ";
			uString += CyString::Number((long)uf->GetCreationTime()) + " ";
			uString += uf->filename();
			lines.PushBack(uString);
		}
	}
 
	// write the original file data

				break;
			case Ware_BuiltIn:
				lines.PushBack(CyString(Utils::String("BuiltInWarePriceOverride:") + (long)ware->pos + " " + (long)ware->relval));
				if ( ware->bNotority )
					lines.PushBack(CyString(Utils::String("BuiltInWareNotoOverride:") + (long)ware->pos + " " + (long)ware->notority));
				break;
		}
	}
 
	// write the global file list
	lines.PushBack("GlobalFiles:");

			lines.PushBack("Disabled");
		if ( !package->IsModifiedEnabled() )
			lines.PushBack("ModifiedDisabled");
 
		if ( package->GetIcon() )
			lines.PushBack(CyString("Icon: ") + package->iconExt() + " " + package->GetIcon()->filePointer() );
 
		CyString fileline("Files:");
		for ( CListNode<C_File> *fn = package->GetFileList()->Front(); fn; fn = fn->next() )
		{
			C_File *f = fn->Data();

	if ( !Dir.exists("PluginManager") ) {
		CLog::log(CLog::Log_IO, 2, "Creating PluginManager directory");
 		Dir.Create("PluginManager");
	}
 
	CLog::log(CLog::Log_IO, 2, "Writing data file: " + m_sCurrentDir + "/PluginManager/PluginManager.new");
	if ( !datFile.WriteFile(&lines) )
	{
		CLog::log(CLog::Log_IO, 1, "ERROR: Failed to write data file");
	}
	else {
		CLog::log(CLog::Log_IO, 2, "Removing old data file: " + m_sCurrentDir + "/PluginManager/PluginManager.dat");
		if ( !CFileIO::Exists(m_sCurrentDir + &quot;/PluginManager/PluginManager.dat") || CFileIO::Remove(m_sCurrentDir + "/PluginManager/PluginManager.dat") ) {
			CLog::log(CLog::Log_IO, 2, "Renaming data file: PluginManager.new => PluginManager.dat");
			datFile.Rename(m_sCurrentDir + "/PluginManager/PluginManager.dat");
		}
	}
}

	return fileList->size();
}
 
/**
 * Add Log
 *
 * Adds a log entry to displayed at end
 */
void CPackages::AddLogEntry(int type, CyString args, CyStringList *errors)
{
	if ( !errors )
		return;
 
	errors->PushBack(args, ERRORLOG_OLD(type));
}
 
/**
 * Enable a package
 *
 * Enables all files in the package, unless they are already enabled, ie, used by other packages
 * Backs up any original files before attempting to enable the file

 * param: progress		- The progress class, updates a progress screen of the derived class
 *
 * return: boolen - Returns true if the package enabling was successful
 */
bool CPackages::EnablePackage ( CBaseFile *package, CyStringList *errors, CProgressInfo *progress )
{
	ClearError();
 
	// if already enabled, just skip
	if ( package->IsEnabled() )
		return true;
 

	return false;
}
bool CPackages::EnablePreparedPackages ( CyStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *enabledPackages )
{
	ClearError();
 
	// get all files, including children
	CLinkList<C_File> fileList;
	int maxFiles = this->GetAllPackageFiles(&m_lEnableList, &fileList, false);
 
	int fileCount = 0;

		CBaseFile *package = NULL;
		for ( CListNode<CBaseFile> *node = m_lEnableList.Front(); node; node = node->next() )
		{
			CBaseFile *p = node->Data();
			if ( p->IsFileAdded(f) )
			{
				package = p;
				break;
			}
		}
 

		}
 
		// check if theres an original file to backup
		_pOriginalFiles->doBackup(f, errors);
 
		Utils::String newFilename = f->getNameDirectory(package);
 
		// fake patches need to be renamed
		if ( f->IsFakePatch() )
		{
			// first check if the matching file has been done already

		}
 
		this->AddLogEntry(SPKINSTALL_ENABLEFILE, newFilename, errors);
 
		// adjust the internal name to match the new filename
		f->setFilename(m_sCurrentDir + "/" + newFilename);
		// no longer disabled, we need to remove the flag
		f->SetDisabled(false);
	}
 
	// recursive, auto enable all children

	for ( CListNode<C_File> *node = fileList.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		CBaseFile *checkPackage = NULL;
		for ( CListNode<CBaseFile> *node = m_lDisableList.Front(); node; node = node->next() )
		{
			CBaseFile *p = node->Data();
			if ( p->IsFileAdded(f) )
			{
				checkPackage = p;
				break;

			progress->UpdateFile(f);
		}
 
		// only delete files that are not used by any other enabled packages, counter from UpdateUsedFiles()
		if ( f->GetUsed() || (f->IsShared() && !m_bDisableVanilla) )
			continue;
 
		// file is already disabled, no need to disable again
		if ( f->IsDisabled() )
			continue;
 

		{
			bool found = false;
			for ( CListNode<C_File> *uNode = m_lUninstallFiles.Front(); uNode; uNode = uNode->next() )
			{
				C_File *uFile = uNode->Data();
				if ( uFile->filename().Compare(f->filename()) )
				{
					found = true;
					break;
				}
			}

			{
				this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, newFilename, errors);
				continue;
			}
			this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY, newFilename, errors);
		}
 
		// fake patches need a special directory and filename so they dont overright each other as thier filenames are always changes
		// if a package with a fake patch is installed while another one is disabled, it will fill the gap left by the disabled one
		// they will then end up with the same filename, if it gets disabled they would overright each other, so we change the filename to prevent that from happening
		if ( f->IsFakePatch() )
		{
			// find package the fake patch belongs to
			if ( checkPackage )
			{
				newFilename = Utils::String(m_sCurrentDir) + "/PluginManager/Disabled/FakePatches/FakePatch_" + checkPackage->getNameValidFile() + "_" + checkPackage->author() + "_" + f->name();
				shuffle = true;
			}
		}
		else if ( f->isAutoTextFile() )
		{
			if ( checkPackage )
			{
				newFilename = Utils::String(m_sCurrentDir) + "/PluginManager/Disabled/TextFiles/Text_" + checkPackage->getNameValidFile() + "_" + checkPackage->author() + "_" + f->name();
				shuffle = true;
			}
		}
		// otherwise we can just use the standard filename
		else
			newFilename = Utils::String(m_sCurrentDir) + "/PluginManager/Disabled/" + f->GetNameDirectory(checkPackage).ToString();
 
		// now to move the file by renameing it to its new location
		// !!error checking!!
		// check the file, if it doesn't exist, and exists as disabled, we should just adjust the setting instead of an error
		CFileIO currentFile(f->GetFilePointer());

	{
		C_File *f = node->Data();
		if ( f->GetFileType() != filetype )
			continue;
 
		if ( !f->filename().Compare(filename.ToString()) )
			continue;
 
		if ( !dir.Empty() && f->dir().Compare(dir.ToString()) )
			continue;
 
		return f;
	}
 

 */
int CPackages::CheckInstallPackage(CBaseFile *package, int check)
{
	if ( package->GetType() == TYPE_XSP && m_iGame == GAME_X2 )
		return INSTALLCHECK_NOSHIP;
 
	// search for an old version
	CBaseFile *oldPackage = FindPackage(package);
 
	// check versions are newer
	if (oldPackage && (check & IC_OLDVERSION))
	{
		if ( oldPackage->version().compareVersion(package->version()) == COMPARE_OLDER )
			return INSTALLCHECK_OLDVERSION;
	}
 
	// now check for game version
	if ((check & IC_WRONGGAME) || (check & IC_WRONGVERSION))
	{
		if ( package->AnyGameCompatability() )
		{

	// check for modified
	if (m_bVanilla && (check & IC_MODIFIED))
	{
		if ( !package->IsSigned() )
			return INSTALLCHECK_MODIFIED;
	}
 
	return INSTALLCHECK_OK;
}
 
bool CPackages::CheckOtherPackage(CBaseFile *package)
{

	{
		if ( ((CSpkFile *)p)->IsAnotherMod() )
		{
			CBaseFile *parent = this->FindSpkPackage(((CSpkFile *)p)->GetOtherName(), ((CSpkFile *)p)->GetOtherAuthor());
			if ( parent )
			{
				if ( !parent->IsEnabled() )
					return false;
			}
			else
				return false;

		{
			if ( dNode->Data()->sName.Compare("<package>") )
				continue;
			if ( !this->CheckInstalledDependacy(dNode->Data()->sName, dNode->Data()->sAuthor, dNode->Data()->sMinVersion, true, true) )
				return false;
		}
	}
 
	return true;
}
 
bool CPackages::CheckInstalledDependacy(CyString name, CyString author, CyString version, bool onlyEnabled, bool includePrepared)

	CBaseFile *p = this->findSpkPackage(name, author);
	if ( p )
	{
		// now check version
		if (version.compareVersion(p->version()) == COMPARE_OLDER)
			return false;
 
		if ( onlyEnabled && !p->IsEnabled() )
			return false;
 
		return true;

 
bool CPackages::findAllNeededDependacies(CBaseFile *p, const CLinkList<CBaseFile> &packages, CLinkList<CBaseFile> *foundPackages, bool onlyEnabled, bool includePrepared) const
{
	CLinkList<SNeededLibrary> *neededList = p->GetNeededLibraries();
	if (neededList)
	{
		for (CListNode<SNeededLibrary> *node = neededList->Front(); node; node = node->next())
		{
			SNeededLibrary *nl = node->Data();
			if (!checkInstalledDependacy((nl->sName.Compare("<package>")) ? p->name() : nl->sName, (nl->sAuthor.Compare("<author>")) ? p->author() : nl->sAuthor, nl->sMinVersion, (nl->sName.Compare("<package>")) ? false : onlyEnabled, (nl->sName.Compare("<package>")) ? false : includePrepared))
			{

			if ( !found )
			{
				if ( list )
					list->pushBack(spk->GetOtherName(), spk->GetOtherAuthor());
				++count;
			}
		}
	}
 
	return count;
}
 
int CPackages::CheckPreparedInstallRequired(CLinkList<CBaseFile> *list)
{
	// loop through all packages

		{
			C_File *checkFile = fNode->Data();
			if ( checkFile->GetFileType() != FILETYPE_SCRIPT )
				continue;
 
			if ( checkFile->filename().Compare(file->filename()) )
			{
				found = true;
				break;
			}
		}

	for ( CListNode<C_File> *node = m_lFiles.Back(); node; node = node->prev() )
	{
		if ( progress )
			progress->UpdateProgress(files, m_lFiles.size());
		files++;
 
		C_File *file = node->Data();
 
		// only do marked shared files
		if ( !file->IsShared() )
			continue;
 
		// only do ones that are no longer needed
		if ( file->GetUsed() )
			continue;
 
		if ( RemoveSharedFile(file, errors) )
			++done;
		node->ChangeData(NULL);
	}
 
	m_lFiles.RemoveEmpty();
 
	return done;
}
 
/**
 * Any Unused Shared
 *
 * Checks if theres any unused shared files available
 *
 * Any file thats marked as shared, and is no longer connected to any installed package
 */
bool CPackages::AnyUnusedShared()
{
	UpdateUsedFiles();
 
	for ( CListNode<C_File> *node = m_lFiles.Back(); node; node = node->prev() )
	{
		C_File *file = node->Data();
 
		// only do marked shared files
		if ( !file->IsShared() )
			continue;
 
		// only do ones that are no longer needed
		if ( file->GetUsed() )
			continue;
 

		{
			CFileIO moveFile(f->filePointer());
	
			Utils::String newName = SPK::FormatTextName(current, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT)) + "." + moveFile.extension();
			if ( moveFile.Rename(m_sCurrentDir + "/t/" + newName) )
			{
				this->AddLogEntry(SPKINSTALL_AUTOTEXT, f->name() + "~" + newName, errors);
				f->SetName(newName);
			}
			else
				this->AddLogEntry(SPKINSTALL_AUTOTEXT_FAIL, f->name() + "~" + newName, errors);

			if ( sCheck->str.Compare(CyString(p->name())) && sCheck->data.Compare(CyString(p->author())) )
			{
				added = true;
				break;
			}
		}
 
		if ( added ) continue;
 
		bool anyFound = false;
		for ( C_File *file = p->GetFirstFile(FILETYPE_MOD); file; file = p->GetNextFile(file) )
		{
			if ( !file->IsFakePatch() ) continue;
			if ( !file->CheckFileExt("cat") ) continue;

			packages.push_back(p);
	}
 
	// lets adjust the order (only if theres more than 1
	if ( packages.size() > 1 )
	{
		CLinkList<CBaseFile> sortedPackages;
 
		// first add all the packages that dont need to be installed after
		for ( CListNode<CBaseFile> *pNode = packages.Front(); pNode; pNode = pNode->next() )
		{

 
				if ( !lowestFile ) // no more files ?
					break;
 
				// check its filename, it might already be in the correct place
				if ( lowestFile->baseName().toInt() != lowest )
				{
					// if the file already exists, we need to move it elsewhere
					Utils::String nextName = Utils::String::PadNumber(lowest, 2);
					if ( CFileIO::Exists(m_sCurrentDir + "/" + nextName + ".cat") )
					{
						// find the file in our internal file list
						C_File *moveFile = FindFile(FILETYPE_MOD, nextName + ".cat");
						if ( !moveFile ) // must not have it in our list ? lets move to the next
						{

		if ( !f->CheckFileExt("cat") )
			continue;
 
		// now lets check if its greater than our gap
		int check = FindNextFakePatch();
		int patchNum = f->filename().token(".", 1).toInt();
		if ( patchNum <= check )
			continue;
 
		ShufflePatchTo(f, check, errors);
	}
}
 
void CPackages::ShufflePatchTo(C_File *file, int to, CyStringList *errors)
{
	// it is, we need to shift this to fill the gap
	Utils::String newName = Utils::String::PadNumber(to, 2) + "." + file->fileExt();
 
	// now rename the file
	CFileIO moveFile(file->filePointer());
	if ( moveFile.Rename(m_sCurrentDir + "/" + newName) )
	{
		// display moveing
		this->AddLogEntry(SPKINSTALL_FAKEPATCH, file->name() + "~" + newName, errors);
 
		// now find the matching pairing if it exists
		for ( CListNode<C_File> *node2 = m_lFiles.Front(); node2; node2 = node2->next() )
		{
			C_File *f2 = node2->Data();
 

 
			// needs to be the same file
			if ( f2->GetBaseName() != file->GetBaseName() )
				continue;
 
			Utils::String newName2 = Utils::String::PadNumber(to, 2) + "." + f2->fileExt();
			CFileIO moveFile(f2->filePointer());
			if ( moveFile.Rename(m_sCurrentDir + "/" + newName2) )
			{
				this->AddLogEntry(SPKINSTALL_FAKEPATCH, f2->name() + "~" + newName2, errors);
				f2->setName(newName2);
			}
			else
				this->AddLogEntry(SPKINSTALL_FAKEPATCH_FAIL, f2->name() + "~" + newName2, errors);
		}
 
		// finally make sure the internal name matches the new one
		file->setName(newName);
	}
	else
		this->AddLogEntry(SPKINSTALL_FAKEPATCH_FAIL, file->name() + "~" + newName, errors);
}
 
int CPackages::FindLowestFakePatchInstalled()
{
	int lowest = 99;

 * Find next fake patch
 *
 * Searching for the next gap in patches, starting with 01.cat to 99.cat
 */
int CPackages::FindNextFakePatch(int start, CyString dir)
{
	CDirIO Dir((dir.Empty()) ? m_sCurrentDir : dir);
 
	int check = start;
	while ( check < 99 )
	{

	if ( !addFile )
		addFile = FindFile(FILETYPE_TEXT, newFilename + ".pck");
 
	// we have found the file, lets just add it to our scripts
	if ( addFile )
	{
		AddTextFileToScripts(addFile, textid);
		return true;
	}
 
	// first we need to find our text file
	Utils::String filename;
	if ( languageid != -1 )

		lines->insert(lines->begin(), *it);
 
	addFile = new C_File(newFilename + ".xml");
	addFile->SetFileType(FILETYPE_TEXT);
 
	CFileIO writeFile(m_sCurrentDir + "/" + addFile->getNameDirectory(NULL));
	if ( writeFile.WriteFile(lines) )
	{
		this->AddLogEntry(SPKINSTALL_WRITEFILE, addFile->getNameDirectory(NULL), errors);
 
		addFile->SetFilename(m_sCurrentDir + "/" + addFile->getNameDirectory(NULL));
		// now we have the file wrriten, we need to add it to all scripts that need it
		// first we add it to the global list
		m_lFiles.push_back(addFile);
 
		// now add it to the scripts
		AddTextFileToScripts(addFile, textid);
	}
	else
	{
		this->AddLogEntry(SPKINSTALL_WRITEFILE_FAIL, addFile->getNameDirectory(NULL), errors);
		if ( lines )
			delete lines;
		return false;
	}
 

	return true;
}
 
/**
 * Add file to scripts
 *
 * Adds a file to all scripts that need it
 */
void CPackages::AddTextFileToScripts(C_File *file, CyString textid)
{
	// now we need to find all scripts that have a matching file and add this to the list

bool CPackages::RemoveFile(C_File *file, CyStringList *errors)
{
	if ( !file )
		return true;
 
	Utils::String remFileStr = file->filePointer();
	remFileStr.findReplace(m_sCurrentDir, "");
 
	if ( file->filePointer().contains("::")) {
		CFileIO CatFile(file->GetFilePointer().GetToken("::", 1, 1));
		if ( CatFile.exists() ) {
			CCatFile cat;
			if ( cat.open(CatFile.fullFilename(), this->getAddonDir(), CATREAD_DAT, false) == CATERR_NONE ) {
				CyString fileName = file->GetFilePointer().GetToken("::", 2, 2);

				}
			}
		}
	}
	else {
		CFileIO f(file->filePointer());
		if ( f.exists() )
		{
			if ( f.remove() ) this->AddLogEntry(SPKINSTALL_DELETEFILE, remFileStr, errors);
			else if ( errors )
			{

void CPackages::startup(const Utils::String &dir, const Utils::String &tempDir, const Utils::String &myDoc, const Utils::String &mod)
{
	startup(dir, tempDir, myDoc);
	m_sSetMod = mod;
}
/*
void CPackages::Startup(CyString dir, CyString tempDir, CyString myDoc, CyString mod)
{
	startup(dir.ToString(), tempDir.ToString(), myDoc.ToString(), mod.ToString());
}*/
 
int CPackages::GetGameLanguage() const
{
	return this->GetGameLanguage(m_sCurrentDir);
}
int CPackages::GetGameLanguage(const Utils::String &sDir) const
{
	Utils::String dir = sDir;
	if (dir.empty())
		dir = m_sCurrentDir;
	else
		dir = this->getProperDir(dir);
 
	CDirIO Dir(dir);
 

{
	return m_gameExe.GetGameRunExe(dir);
}
Utils::String CPackages::GetGameRunExe()
{
	return m_gameExe.GetGameRunExe(m_sCurrentDir);
}
 
CyString CPackages::GetGameNameFromType(int game)
{
	return m_gameExe.GetGameNameFromType(game - 1);
}
Utils::String CPackages::getGameName() const
{
	return getGameName(m_sCurrentDir);
}
 
Utils::String CPackages::getGameName(const Utils::String &dir) const
{
	return m_gameExe.GetGameName(dir.empty() ? m_sCurrentDir : dir);
}
 
CyString CPackages::GetGameName(CyString dir)
{
	return m_gameExe.GetGameName((dir.Empty()) ? m_sCurrentDir : dir.ToString());
}
CyString CPackages::GetProperDir(CyString dir)
{
	return m_gameExe.GetProperDir((dir.Empty()) ? m_sCurrentDir : dir.ToString());
}
CyString CPackages::GetAddonDir(CyString dir)
{
	return m_gameExe.GetAddonDir((dir.Empty()) ? m_sCurrentDir : dir.ToString());
}
Utils::String CPackages::getProperDir() const
{
	return getProperDir(m_sCurrentDir);
}
Utils::String CPackages::getProperDir(const Utils::String &dir) const
{
	return m_gameExe.GetProperDir((dir.empty()) ? m_sCurrentDir : dir);
}
Utils::String CPackages::getAddonDir() const
{
	return getAddonDir(m_sCurrentDir);
}
Utils::String CPackages::getAddonDir(const Utils::String &dir) const
{
	return m_gameExe.GetAddonDir((dir.empty()) ? m_sCurrentDir : dir);
}
int CPackages::GetGameAddons(Utils::CStringList &exes, const Utils::String &dir)
{
	return m_gameExe.GetGameAddons((dir.empty()) ? m_sCurrentDir : dir, exes);
}
int CPackages::GetGameAddons(Utils::CStringList &exes)
{
	return m_gameExe.GetGameAddons(m_sCurrentDir, exes);
}
 
Utils::String CPackages::getGameTypesString(CBaseFile *package, bool includeVersion)
{
	if ( !package->AnyGameCompatability() )

			}
		}
	}
	else if ( !m_sSetMod.Empty() )
	{
		if ( CFileIO::Exists(m_sCurrentDir + "/mods/" + m_sSetMod.ToString() + ".cat"))
		{
			CCatFile catFile;
			if (catFile.open(m_sCurrentDir + "/mods/"; + m_sSetMod.ToString() + ".cat", addonDir.ToString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)
			{
				if ( catFile.ExtractFile(aFilename, aTo) )
					return 1;
				if ( catFile.error() == CATERR_INVALIDDEST || catFile.error() == CATERR_CANTCREATEDIR )
				{

 
	CDirIO Dir(m_sCurrentDir);
	if ( !Dir.exists("t") )
		Dir.Create("t");
 
	Utils::String filename = SPK::FormatTextName(PMTEXTFILE, lang, (m_iGameFlags & EXEFLAG_TCTEXT));
	CFileIO textFile(m_sCurrentDir + "/t/" + filename + ".xml");
 
	std::vector<CyString> writeData;
 
	writeData.push_back(CyString("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"));

	if ( !Dir.exists("t") )
		Dir.Create("t");
 
	m_iLastUpdated = (int)time(NULL);
 
	Utils::String filename = SPK::FormatTextName(PMTEXTFILE, lang, (m_iGameFlags & EXEFLAG_TCTEXT));
	CFileIO textFile(m_sCurrentDir + "/t/" + filename + ".xml");
 
	std::vector<CyString> writeData;
 
	CLinkList<SGameWare> lWares;

	textFile.remove();
}
 
bool CPackages::isCurrentDir(const Utils::String &dir) const
{
	Utils::String cur = m_sCurrentDir;
 
	if ( dir.Compare(cur) )
		return true;
 
	Utils::String checkDir = cur;

				if ( e )
				{
					CFileIO File((e == -1) ? (str->data + ".pck") : (m_sTempDir + "/" + str->data.ToString() + ".pck"));
					if ( File.exists() )
					{
						File.Rename(m_sCurrentDir + "/" + dir + "/" + str->str.ToString() + ".pck");
						this->AddCreatedFile(dir + "/" + str->str.ToString() + ".pck");
					}
				}
			}
		}

	}
 
	return false;
}
 
bool CPackages::UnPackFile(const Utils::String &filename, bool checkxml)
{
	// compress the file
	CFileIO File(filename);
	size_t fileSize;
	char *fileData = File.ReadToData(&fileSize);

 
				if ( pckFile.isOpened() )
					pckFile.close();
 
				if ( isxml )
					pckFile.Rename(pckFile.changeFileExtension("xml"));
			}
 
			return true;
		}
	}
 
	return false;
}
 
bool CPackages::PackFile(CFileIO *File, CyString sFilename)
{
	Utils::String filename = sFilename.FindReplace(&quot;\\", &quot;/").ToString();
	if ( m_iGame == GAME_X3 )
	{
		CCatFile catFile;
		int error = catFile.open(m_sCurrentDir + "/mods/PluginManager.cat", this->getAddonDir(), CATREAD_CATDECRYPT, true);
		if ( error == CATERR_NONE || error == CATERR_CREATED )
		{
			// it it wrote ok, remove the old ones
			if ( !catFile.AppendFile(File->fullFilename(), filename, true, true) )
				return false;
			return true;
		}
	}
	else

			
			if (p->GetIcon())
			{
				bool addedIcon = false;
				p->ReadIconFileToMemory();
				p->GetIcon()->setFilename(this->tempDirectory().findReplace("\\", "/") + "/" + p->author() + "_" + p->name() + "." + p->iconExt());
				p->GetIcon()->setFullDir(this->tempDirectory());
				if (p->GetIcon()->UncompressData())
				{
					if (p->GetIcon()->writeFilePointer())
						addedIcon = true;
				}

					toFile = toFile.FindReplace("\\", "/");
					toFile = toFile.FindReplace("//", "/");
					if ( fromFile.Compare(toFile) )
					{
						if ( list )
							list->PushBack(CyString((from->filename() + "::" + str->str.ToString(), to->filename() + "::" + toStr->str.ToString())).c_str());
						else
							return true;
					}
				}
			}

Rev 155	Rev 158
Line 73...	Line 73...
73	`m_lDisableList.clear();`	73	`m_lDisableList.clear();`
74	`m_lEnableList.clear();`	74	`m_lEnableList.clear();`
75	`this->Reset();`	75	`this->Reset();`
76	`}`	76	`}`
77		77
78	`void CPackages::SetCurrentDir(CyString dir)`	78	`void CPackages::setCurrentDir(const Utils::String &dir)`
79	`{`	79	`{`
80	`m_sCurrentDir = dir;`	80	`m_sCurrentDir = dir;`
81	`if (_pCurrentDir) delete _pCurrentDir;`	81	`if (_pCurrentDir) delete _pCurrentDir;`
82	`_pCurrentDir = new GameDirectory();`	82	`_pCurrentDir = new GameDirectory();`
83	`_pCurrentDir->dir = dir.ToString();`	83	`_pCurrentDir->dir = dir;`
84	`_pCurrentDir->id = -1;`	84	`_pCurrentDir->id = -1;`
85		85
86	`m_gameExe.GetDirectoryData(_pCurrentDir);`	86	`m_gameExe.GetDirectoryData(_pCurrentDir);`
87	`_pCurrentDir->langid = this->GetGameLanguage(_pCurrentDir->dir);`	87	`_pCurrentDir->langid = this->GetGameLanguage(_pCurrentDir->dir);`
88	`if (_pCurrentDir->langid > 0)`	88	`if (_pCurrentDir->langid > 0)`
Line 201...	Line 201...
201	`if ( f->IsFakePatch() ) continue;`	201	`if ( f->IsFakePatch() ) continue;`
202	`if ( f->CheckFileExt("cat") ) break;`	202	`if ( f->CheckFileExt("cat") ) break;`
203	`}`	203	`}`
204		204
205	`if ( f )`	205	`if ( f )`
206	`m_pGameVFS.LoadFilesystem(m_sCurrentDir.ToString(), f->filePointer(), 0);`	206	`m_pGameVFS.LoadFilesystem(m_sCurrentDir, f->filePointer(), 0);`
207	`else`	207	`else`
208	`m_pGameVFS.LoadFilesystem(m_sCurrentDir.ToString(), 0);`	208	`m_pGameVFS.LoadFilesystem(m_sCurrentDir, 0);`
209	`}`	209	`}`
210	`else`	210	`else`
211	`m_pGameVFS.LoadFilesystem(m_sCurrentDir.ToString(), 0);`	211	`m_pGameVFS.LoadFilesystem(m_sCurrentDir, 0);`
212	`}`	212	`}`
213		213
214	`bool CPackages::isOldDir(const Utils::String &dir)`	214	`bool CPackages::isOldDir(const Utils::String &dir)`
215	`{`	215	`{`
216	`bool oldPlugin = false;`	216	`bool oldPlugin = false;`
Line 228...	Line 228...
228	`if ( cmd.Compare("<script>") \|\| cmd.Compare("</scripts>") )`	228	`if ( cmd.Compare("<script>") \|\| cmd.Compare("</scripts>") )`
229	`break;`	229	`break;`
230	`else if ( cmd.Compare("spkinstaller") \|\| cmd.Compare("globalfiles") )`	230	`else if ( cmd.Compare("spkinstaller") \|\| cmd.Compare("globalfiles") )`
231	`break;`	231	`break;`
232	`else if ( cmd.Compare("pluginmanager") )`	232	`else if ( cmd.Compare("pluginmanager") )`
233	`{`	233	`{`
234	`oldPlugin = true;`	234	`oldPlugin = true;`
235	`break;`	235	`break;`
236	`}`	236	`}`
237	`}`	237	`}`
238		238
Line 241...	Line 241...
241	`}`	241	`}`
242		242
243	`return oldPlugin;`	243	`return oldPlugin;`
244	`}`	244	`}`
245		245
246	`bool CPackages::read(const Utils::String &dir, CProgressInfo *progress)`	246	`bool CPackages::Read(CyString dir, CProgressInfo* progress)`
247	`{`	247	`{`
248	`return Read(CyString(dir), progress);`	248	`return read(dir.ToString(), progress);`
249	`}`	249	`}`
250		250
251	`bool CPackages::Read(CyString dir, CProgressInfo *progress)`	251	`bool CPackages::read(const Utils::String& dir, CProgressInfo* progress)`
252	`{`	252	`{`
253	`m_sCurrentDir = dir;`	253	`m_sCurrentDir = dir;`
254	`m_sCurrentDir = m_sCurrentDir.FindReplace("\\", "/");`	254	`m_sCurrentDir = m_sCurrentDir.findReplace("\\", "/");`
255	`this->SetCurrentDir(dir);`	255	`this->setCurrentDir(dir);`
256	`m_bOldPlugin = false;`	256	`m_bOldPlugin = false;`
257	`m_lCreatedFiles.Clear();`	257	`m_lCreatedFiles.Clear();`
258	`m_bRemoveDir = false;`	258	`m_bRemoveDir = false;`
259	`m_bSurpressProtectedWarning = false;`	259	`m_bSurpressProtectedWarning = false;`
260	`m_iSaveGame = -1;`	260	`m_iSaveGame = -1;`
Line 262...	Line 262...
262	`m_lNonRemovedFiles.Clear();`	262	`m_lNonRemovedFiles.Clear();`
263	`m_lGlobals.Clear();`	263	`m_lGlobals.Clear();`
264	`m_lFakePatchOrder.Clear();`	264	`m_lFakePatchOrder.Clear();`
265		265
266	`if ( _pOriginalFiles ) delete _pOriginalFiles;`	266	`if ( _pOriginalFiles ) delete _pOriginalFiles;`
267	`_pOriginalFiles = new COriginalFiles(m_sCurrentDir.ToString());`	267	`_pOriginalFiles = new COriginalFiles(m_sCurrentDir);`
268		268
269	`m_bVanilla = true;`	269	`m_bVanilla = true;`
270		270
271	`// check the pluginmanager data file exists`	271	`// check the pluginmanager data file exists`
272	`CFileIO datFile(m_sCurrentDir + "/PluginManager/pluginmanager.dat");`	272	`CFileIO datFile(m_sCurrentDir + "/PluginManager/pluginmanager.dat");`
Line 292...	Line 292...
292		292
293	`Utils::String cmd = line.token(":", 1).lower();`	293	`Utils::String cmd = line.token(":", 1).lower();`
294	`Utils::String rest = line.tokens(":", 2).removeFirstSpace();`	294	`Utils::String rest = line.tokens(":", 2).removeFirstSpace();`
295		295
296	`if ( iStatus == READ_GLOBAL )`	296	`if ( iStatus == READ_GLOBAL )`
297	`{`	297	`{`
298	`if ( cmd == "<script>" )`	298	`if ( cmd == "<script>" )`
299	`{`	299	`{`
300	`packageFile = new CSpkFile();`	300	`packageFile = new CSpkFile();`
301	`iStatus = READ_SCRIPT;`	301	`iStatus = READ_SCRIPT;`
302	`}`	302	`}`
303	`else if ( cmd == "<ship>" )`	303	`else if ( cmd == "<ship>" )`
304	`{`	304	`{`
305	`packageFile = new CXspFile();`	305	`packageFile = new CXspFile();`
306	`iStatus = READ_SCRIPT;`	306	`iStatus = READ_SCRIPT;`
307	`}`	307	`}`
308	`else if ( cmd == "<base>" )`	308	`else if ( cmd == "<base>" )`
309	`{`	309	`{`
310	`packageFile = new CBaseFile();`	310	`packageFile = new CBaseFile();`
311	`iStatus = READ_SCRIPT;`	311	`iStatus = READ_SCRIPT;`
312	`}`	312	`}`
313	`else if ( cmd == "<archive>" )`	313	`else if ( cmd == "<archive>" )`
314	`{`	314	`{`
315	`packageFile = new CArchiveFile();`	315	`packageFile = new CArchiveFile();`
316	`iStatus = READ_SCRIPT;`	316	`iStatus = READ_SCRIPT;`
317	`}`	317	`}`
318	`else if ( cmd != "</scripts>" )`	318	`else if ( cmd != "</scripts>" )`
Line 335...	Line 335...
335	`{`	335	`{`
336	`origName = fileName.token("O#", 2);`	336	`origName = fileName.token("O#", 2);`
337	`fileName = fileName.token("O#", 1);`	337	`fileName = fileName.token("O#", 1);`
338	`}`	338	`}`
339		339
340	`C_File *newFile = new C_File(m_sCurrentDir.ToString() + fileName);`	340	`C_File *newFile = new C_File(m_sCurrentDir + fileName);`
341	`newFile->setGame(game);`	341	`newFile->setGame(game);`
342	`newFile->SetOriginalName(origName);`	342	`newFile->SetOriginalName(origName);`
343	`newFile->SetDisabled(disabled);`	343	`newFile->SetDisabled(disabled);`
344	`newFile->setFileType((FileType)line.token(":", 1).toLong());`	344	`newFile->setFileType((FileType)line.token(":", 1).toLong());`
345	`newFile->SetCreationTime((time_t)line.token(":", 2).toLong());`	345	`newFile->SetCreationTime((time_t)line.token(":", 2).toLong());`
Line 347...	Line 347...
347	`if ( line.token(":", 4).toLong() )`	347	`if ( line.token(":", 4).toLong() )`
348	`newFile->SetShared(true);`	348	`newFile->SetShared(true);`
349	`newFile->UpdateSigned();`	349	`newFile->UpdateSigned();`
350		350
351	`m_lFiles.push_back(newFile);`	351	`m_lFiles.push_back(newFile);`
352	`}`	352	`}`
353	`}`	353	`}`
354	`else if ( iStatus == READ_SCRIPT )`	354	`else if ( iStatus == READ_SCRIPT )`
355	`{`	355	`{`
356	`if ( cmd == "installspk" )`	356	`if ( cmd == "installspk" )`
357	`packageFile->setFilename(rest);`	357	`packageFile->setFilename(rest);`
Line 384...	Line 384...
384	`}`	384	`}`
385	`else`	385	`else`
386	`packageFile->ParseValueLine(line);`	386	`packageFile->ParseValueLine(line);`
387	`}`	387	`}`
388	`else if ( iStatus == READ_SCRIPTFILE )`	388	`else if ( iStatus == READ_SCRIPTFILE )`
389	`{`	389	`{`
390	`if ( cmd == "<script>" )`	390	`if ( cmd == "<script>" )`
391	`{`	391	`{`
392	`if ( packageFile->IsMod() && packageFile->IsEnabled() )`	392	`if ( packageFile->IsMod() && packageFile->IsEnabled() )`
393	`m_pEnabledMod = packageFile;`	393	`m_pEnabledMod = packageFile;`
394		394
Line 571...	Line 571...
571	`}`	571	`}`
572		572
573	`if ( m_pEnabledMod && !m_pEnabledMod->IsEnabled() )`	573	`if ( m_pEnabledMod && !m_pEnabledMod->IsEnabled() )`
574	`m_pEnabledMod = NULL;`	574	`m_pEnabledMod = NULL;`
575		575
576	`m_iGame = m_gameExe.GetGameType(m_sCurrentDir.ToString()) + 1;`	576	`m_iGame = m_gameExe.GetGameType(m_sCurrentDir) + 1;`
577	`m_pCurrentGameExe = m_gameExe.GetGame(m_gameExe.GetGameType(m_sCurrentDir.ToString()));`	577	`m_pCurrentGameExe = m_gameExe.GetGame(m_gameExe.GetGameType(m_sCurrentDir));`
578	`Utils::String sGameVersion;`	578	`Utils::String sGameVersion;`
579	`m_iGameVersion = m_gameExe.GetGameVersion(m_sCurrentDir.ToString(), &sGameVersion) + 1;`	579	`m_iGameVersion = m_gameExe.GetGameVersion(m_sCurrentDir, &sGameVersion) + 1;`
580	`m_sGameVersion = sGameVersion;`	580	`m_sGameVersion = sGameVersion;`
581	`m_iGameFlags = m_gameExe.GetGameFlags(m_iGame - 1);`	581	`m_iGameFlags = m_gameExe.GetGameFlags(m_iGame - 1);`
582	`m_iMaxPatch = m_gameExe.GetMaxPatch(m_iGame - 1);`	582	`m_iMaxPatch = m_gameExe.GetMaxPatch(m_iGame - 1);`
583		583
584	`// find the fake patch`	584	`// find the fake patch`
Line 611...	Line 611...
611	`{`	611	`{`
612	`CXspFile p = (CXspFile )node->Data();`	612	`CXspFile p = (CXspFile )node->Data();`
613	`for ( CListNode<SGameShip> *gNode = m_lGameShips.Front(); gNode; gNode = gNode->next() )`	613	`for ( CListNode<SGameShip> *gNode = m_lGameShips.Front(); gNode; gNode = gNode->next() )`
614	`{`	614	`{`
615	`if ( p->GetShipID().Compare(gNode->Data()->sShipID.ToString()) )`	615	`if ( p->GetShipID().Compare(gNode->Data()->sShipID.ToString()) )`
616	`{`	616	`{`
617	`gNode->Data()->pPackage = p;`	617	`gNode->Data()->pPackage = p;`
618	`break;`	618	`break;`
619	`}`	619	`}`
620	`}`	620	`}`
621	`}`	621	`}`
622	`}`	622	`}`
623		623
624	`// check the purged time`	624	`// check the purged time`
625	`this->PurgeGameObjects();`	625	`this->PurgeGameObjects();`
626		626
627	`m_bLoaded = true;`	627	`m_bLoaded = true;`
628		628
629	`return true;`	629	`return true;`
630	`}`	630	`}`
631		631
632	`void CPackages::RemoveCreatedFiles()`	632	`void CPackages::RemoveCreatedFiles()`
633	`{`	633	`{`
634	`for ( SStringList *node = m_lCreatedFiles.Head(); node; node = node->next )`	634	`for ( SStringList *node = m_lCreatedFiles.Head(); node; node = node->next )`
635	`{`	635	`{`
636	`if ( CFileIO(node->str).ExistsOld() )`	636	`if ( CFileIO(node->str).ExistsOld() )`
637	`CFileIO::Remove(node->str.ToString());`	637	`CFileIO::Remove(node->str.ToString());`
638	`else if ( CFileIO(m_sCurrentDir + "/" + node->str).ExistsOld() )`	638	`else if ( CFileIO(m_sCurrentDir + "/" + node->str.ToString()).ExistsOld() )`
639	`CFileIO::Remove((m_sCurrentDir + "/" + node->str).ToString());`	639	`CFileIO::Remove(m_sCurrentDir + "/" + node->str.ToString());`
640	`}`	640	`}`
641		641
642	`m_lCreatedFiles.Clear();`	642	`m_lCreatedFiles.Clear();`
643	`}`	643	`}`
644		644
645	`void CPackages::PurgeGameObjects()`	645	`void CPackages::PurgeGameObjects()`
646	`{`	646	`{`
647	`// check for the log file`	647	`// check for the log file`
648	`Utils::String logDir = logDirectory();`	648	`Utils::String logDir = logDirectory();`
649	`CFileIO LogFile(logDir + "/log0" + Utils::String::PadNumber(PMTEXTFILE, 4) + ".txt");`	649	`CFileIO LogFile(logDir + "/log0" + Utils::String::PadNumber(PMTEXTFILE, 4) + ".txt");`
650	`if ( LogFile.exists() )`	650	`if ( LogFile.exists() )`
651	`{`	651	`{`
652	`// read the log file to memory`	652	`// read the log file to memory`
653	`std::vector<CyString> *lines = LogFile.ReadLines();`	653	`std::vector<CyString> *lines = LogFile.ReadLines();`
654	`if ( lines )`	654	`if ( lines )`
655	`{`	655	`{`
656	`for ( int i = 0; i < (int)lines->size(); i++ )`	656	`for ( int i = 0; i < (int)lines->size(); i++ )`
657	`{`	657	`{`
658	`CyString line(lines->at(i));`	658	`CyString line(lines->at(i));`
659	`CyString start = line.GetToken(":", 1, 1).ToLower();`	659	`CyString start = line.GetToken(":", 1, 1).ToLower();`
660	`CyString rest = line.GetToken(":", 2, 2).RemoveFirstSpace();`	660	`CyString rest = line.GetToken(":", 2, 2).RemoveFirstSpace();`
Line 669...	Line 669...
669	`}`	669	`}`
670	`}`	670	`}`
671	`}`	671	`}`
672		672
673	`delete lines;`	673	`delete lines;`
674	`}`	674	`}`
675	`// remove the log file`	675	`// remove the log file`
676	`LogFile.remove();`	676	`LogFile.remove();`
677	`}`	677	`}`
678	`}`	678	`}`
679		679
Line 688...	Line 688...
688	`if ( !w ) continue;`	688	`if ( !w ) continue;`
689	`if ( w->iType == WARETYPE_DELETED )`	689	`if ( w->iType == WARETYPE_DELETED )`
690	`w->iType = WARETYPE_NONE;`	690	`w->iType = WARETYPE_NONE;`
691	`}`	691	`}`
692	`m_lGameWares[i].RemoveEmpty();`	692	`m_lGameWares[i].RemoveEmpty();`
693	`}`	693	`}`
694	`}`	694	`}`
695		695
696	`void CPackages::PurgeShips()`	696	`void CPackages::PurgeShips()`
697	`{`	697	`{`
698	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`	698	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`
699	`{`	699	`{`
Line 705...	Line 705...
705	`m_lGameShips.RemoveEmpty();`	705	`m_lGameShips.RemoveEmpty();`
706	`}`	706	`}`
707		707
708	`Utils::String CPackages::logDirectory()`	708	`Utils::String CPackages::logDirectory()`
709	`{`	709	`{`
710	`Utils::String logDir = m_sCurrentDir.ToString();`	710	`Utils::String logDir = m_sCurrentDir;`
711	`if ( m_iGameFlags & EXEFLAG_MYDOCLOG ) {`	711	`if ( m_iGameFlags & EXEFLAG_MYDOCLOG ) {`
712	`SGameExe *exe = m_gameExe.GetGame(m_iGame - 1);`	712	`SGameExe *exe = m_gameExe.GetGame(m_iGame - 1);`
713	`if ( exe ) {`	713	`if ( exe ) {`
714	`if ( !exe->sMyDoc.empty() )`	714	`if ( !exe->sMyDoc.empty() )`
715	`logDir = m_sMyDoc + "/" + exe->sMyDoc;`	715	`logDir = m_sMyDoc + "/" + exe->sMyDoc;`
Line 719...	Line 719...
719	`return logDir;`	719	`return logDir;`
720	`}`	720	`}`
721		721
722	`Utils::String CPackages::logDirectory(const Utils::String &gameExe)`	722	`Utils::String CPackages::logDirectory(const Utils::String &gameExe)`
723	`{`	723	`{`
724	`Utils::String logDir = m_sCurrentDir.ToString();`	724	`Utils::String logDir = m_sCurrentDir;`
725	`if ( m_iGameFlags & EXEFLAG_MYDOCLOG )`	725	`if ( m_iGameFlags & EXEFLAG_MYDOCLOG )`
726	`{`	726	`{`
727	`SGameExe *exe = m_gameExe.gameExe(CFileIO(gameExe).filename());`	727	`SGameExe *exe = m_gameExe.gameExe(CFileIO(gameExe).filename());`
728	`if ( exe )`	728	`if ( exe )`
729	`{`	729	`{`
Line 750...	Line 750...
750	`if ( CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat").ExistsOld() && CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat").ExistsOld() )`	750	`if ( CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat").ExistsOld() && CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat").ExistsOld() )`
751	`return true;`	751	`return true;`
752		752
753	`// if only one of them exists, lets remove them`	753	`// if only one of them exists, lets remove them`
754	`if ( CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat").ExistsOld() )`	754	`if ( CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat").ExistsOld() )`
755	`CFileIO::Remove(m_sCurrentDir.ToString() + "/PluginManager/PlugMan_Fake.cat");`	755	`CFileIO::Remove(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat");`
756	`if ( CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat").ExistsOld() )`	756	`if ( CFileIO(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat").ExistsOld() )`
757	`CFileIO::Remove(m_sCurrentDir.ToString() + "/PluginManager/PlugMan_Fake.dat");`	757	`CFileIO::Remove(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat");`
758		758
759	`// fake patch is not being used`	759	`// fake patch is not being used`
760	`if ( m_iFakePatch < 0 ) return true;`	760	`if ( m_iFakePatch < 0 ) return true;`
761	`// now lets find the fake patch`	761	`// now lets find the fake patch`
762	`CyString useFile;`	762	`Utils::String useFile;`
763	`if ( m_iFakePatch > 0 )`	763	`if ( m_iFakePatch > 0 )`
764	`{`	764	`{`
765	`CyString file = CyString::Number(m_iFakePatch).PadNumber(2);`	765	`Utils::String file = Utils::String::PadNumber(m_iFakePatch, 2);`
766	`if ( CheckValidPluginManagerFile(file) )`	766	`if ( CheckValidPluginManagerFile(file) )`
767	`useFile = file;`	767	`useFile = file;`
768	`else if ( CheckIfPluginManagerFile(file) )`	768	`else if ( CheckIfPluginManagerFile(file) )`
769	`useFile = file;`	769	`useFile = file;`
770	`}`	770	`}`
771		771
772	`if ( useFile.Empty() )`	772	`if ( useFile.empty() )`
773	`{`	773	`{`
774	`int nextfree = this->FindNextFakePatch();`	774	`int nextfree = this->FindNextFakePatch();`
775	`--nextfree; // gets the end fake patch`	775	`--nextfree; // gets the end fake patch`
776		776
777	`// work backwards till we find a valid one`	777	`// work backwards till we find a valid one`
778	`while ( nextfree > m_iMaxPatch )`	778	`while ( nextfree > m_iMaxPatch )`
779	`{`	779	`{`
780	`CyString file = CyString::Number(nextfree).PadNumber(2);`	780	`Utils::String file = Utils::String::PadNumber(nextfree, 2);`
781	`if ( CheckValidPluginManagerFile(file) )`	781	`if ( CheckValidPluginManagerFile(file) )`
782	`{`	782	`{`
783	`useFile = file;`	783	`useFile = file;`
784	`break;`	784	`break;`
785	`}`	785	`}`
Line 788...	Line 788...
788	`}`	788	`}`
789		789
790	`CyString addonDir = this->GetAddonDir();`	790	`CyString addonDir = this->GetAddonDir();`
791		791
792	`// couldn't find the correct file, lets search for it`	792	`// couldn't find the correct file, lets search for it`
793	`if ( useFile.Empty() ) {`	793	`if ( useFile.empty() ) {`
794	`int nextfree = this->FindNextFakePatch();`	794	`int nextfree = this->FindNextFakePatch();`
795	`--nextfree; // gets the end fake patch`	795	`--nextfree; // gets the end fake patch`
796		796
797	`// work backwards till we find a valid one`	797	`// work backwards till we find a valid one`
798	`while ( nextfree > m_iMaxPatch )`	798	`while ( nextfree > m_iMaxPatch )`
799	`{`	799	`{`
800	`CyString file = CyString::Number(nextfree).PadNumber(2);`	800	`Utils::String file = Utils::String::PadNumber(nextfree, 2);`
801	`if ( CheckIfPluginManagerFile(file) )`	801	`if ( CheckIfPluginManagerFile(file) )`
802	`{`	802	`{`
803	`useFile = file;`	803	`useFile = file;`
804	`break;`	804	`break;`
805	`}`	805	`}`
806	`--nextfree;`	806	`--nextfree;`
807	`}`	807	`}`
808	`}`	808	`}`
809		809
810	`if ( !useFile.Empty() )`	810	`if ( !useFile.empty() )`
811	`{`	811	`{`
812	`// lets check whats in the file first`	812	`// lets check whats in the file first`
813	`CCatFile openCat;`	813	`CCatFile openCat;`
814	`if ( openCat.open((m_sCurrentDir + "/" + useFile + ".cat").ToString(), addonDir.ToString(), CATREAD_CATDECRYPT, false) == CATERR_NONE )`	814	`if ( openCat.open(m_sCurrentDir + "/" + useFile + ".cat", addonDir.ToString(), CATREAD_CATDECRYPT, false) == CATERR_NONE )`
815	`{`	815	`{`
816	`std::vector<SInCatFile > files = openCat.GetFiles();`	816	`std::vector<SInCatFile > files = openCat.GetFiles();`
817	`bool found = false;`	817	`bool found = false;`
818	`if ( files )`	818	`if ( files )`
819	`{`	819	`{`
Line 864...	Line 864...
864	`// no files found, but we have a fake patch ? restore from backup`	864	`// no files found, but we have a fake patch ? restore from backup`
865	`else if ( m_iFakePatch > 0 ) {`	865	`else if ( m_iFakePatch > 0 ) {`
866	`CLog::log(CLog::Log_Directory, 1, "PlugMan FakePatch seems to be missing (" + Utils::String::Number(m_iFakePatch) + "), Restoring from backup");`	866	`CLog::log(CLog::Log_Directory, 1, "PlugMan FakePatch seems to be missing (" + Utils::String::Number(m_iFakePatch) + "), Restoring from backup");`
867	`CFileIO catFile(m_sCurrentDir + "/PluginManager/Backup/PlugMan_Fake.cat");`	867	`CFileIO catFile(m_sCurrentDir + "/PluginManager/Backup/PlugMan_Fake.cat");`
868	`if ( catFile.exists() ) {`	868	`if ( catFile.exists() ) {`
869	`catFile.copy(m_sCurrentDir.ToString() + "/PluginManager/PlugMan_Fake.cat");`	869	`catFile.copy(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat");`
870	`CFileIO datFile(m_sCurrentDir + "/PluginManager/Backup/PlugMan_Fake.dat");`	870	`CFileIO datFile(m_sCurrentDir + "/PluginManager/Backup/PlugMan_Fake.dat");`
871	`if ( datFile.exists() ) datFile.copy(m_sCurrentDir.ToString() + "/PluginManager/PlugMan_Fake.dat");`	871	`if ( datFile.exists() ) datFile.copy(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat");`
872	`}`	872	`}`
873	`}`	873	`}`
874		874
875	`// otherwise we didn't need to (hopefully)`	875	`// otherwise we didn't need to (hopefully)`
876	`return true;`	876	`return true;`
Line 879...	Line 879...
879		879
880	`bool CPackages::CheckIfPluginManagerFile(CyString filename)`	880	`bool CPackages::CheckIfPluginManagerFile(CyString filename)`
881	`{`	881	`{`
882	`bool found = false;`	882	`bool found = false;`
883		883
884	`CFileIO catFile(m_sCurrentDir + "/" + filename + ".cat");`	884	`CFileIO catFile(m_sCurrentDir + "/" + filename.ToString() + ".cat");`
885	`if ( catFile.exists() && CFileIO(m_sCurrentDir + "/" + filename + ".dat").ExistsOld() )`	885	`if ( catFile.exists() && CFileIO::Exists(m_sCurrentDir + "/" + filename.ToString() + ".dat"))`
886	`{`	886	`{`
887	`CCatFile openFile;`	887	`CCatFile openFile;`
888	`if ( openFile.open(catFile.fullFilename(), this->getAddonDir(), CATREAD_CATDECRYPT, false) == CATERR_NONE )`	888	`if ( openFile.open(catFile.fullFilename(), this->getAddonDir(), CATREAD_CATDECRYPT, false) == CATERR_NONE )`
889	`{`	889	`{`
890	`// if ( openFile.internaldatFilename().Compare("PlugMan_Fake.dat") ) return true;`	890	`// if ( openFile.internaldatFilename().Compare("PlugMan_Fake.dat") ) return true;`
Line 914...	Line 914...
914	`}`	914	`}`
915		915
916	`bool CPackages::CheckValidPluginManagerFile(CyString filename)`	916	`bool CPackages::CheckValidPluginManagerFile(CyString filename)`
917	`{`	917	`{`
918	`// both the cat file and dat file exists, lets open it`	918	`// both the cat file and dat file exists, lets open it`
919	`CFileIO catFile(m_sCurrentDir + "/" + filename + ".cat");`	919	`CFileIO catFile(m_sCurrentDir + "/" + filename.ToString() + ".cat");`
920	`if ( catFile.exists() && CFileIO(m_sCurrentDir + "/" + filename + ".dat").ExistsOld() )`	920	`if ( catFile.exists() && CFileIO::Exists(m_sCurrentDir + "/" + filename.ToString() + ".dat"))`
921	`{`	921	`{`
922	`CCatFile openFile;`	922	`CCatFile openFile;`
923	`if ( openFile.open(catFile.fullFilename(), this->getAddonDir(), CATREAD_CATDECRYPT, false) == CATERR_NONE )`	923	`if ( openFile.open(catFile.fullFilename(), this->getAddonDir(), CATREAD_CATDECRYPT, false) == CATERR_NONE )`
924	`{`	924	`{`
925	`if ( openFile.FindData("PlugMan\\TFake.pck") )`	925	`if ( openFile.FindData("PlugMan\\TFake.pck") )`
Line 1334...	Line 1334...
1334	`if ( !checkFile ) continue;`	1334	`if ( !checkFile ) continue;`
1335		1335
1336	`if ( checkFile->GetFileType() != FILETYPE_UNINSTALL && checkFile->GetFileType() != FILETYPE_SCRIPT )`	1336	`if ( checkFile->GetFileType() != FILETYPE_UNINSTALL && checkFile->GetFileType() != FILETYPE_SCRIPT )`
1337	`continue;`	1337	`continue;`
1338		1338
1339	`if ( uf->GetFilename().Compare(checkFile->GetFilename()) )`	1339	`if ( uf->filename().Compare(checkFile->filename()) )`
1340	`{`	1340	`{`
1341	`if ( RemoveUninstallFile(uf, errors) )`	1341	`if ( RemoveUninstallFile(uf, errors) )`
1342	`fNode->DeleteData();`	1342	`fNode->DeleteData();`
1343	`break;`	1343	`break;`
1344	`}`	1344	`}`
Line 1379...	Line 1379...
1379	`}`	1379	`}`
1380		1380
1381	`void CPackages::_addToFakePatch(CBaseFile *pPackage)`	1381	`void CPackages::_addToFakePatch(CBaseFile *pPackage)`
1382	`{`	1382	`{`
1383	`CCatFile cat;`	1383	`CCatFile cat;`
1384	`if ( CCatFile::Opened(cat.open((m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat").ToString(), this->getAddonDir(), CATREAD_DAT)) ) {`	1384	`if ( CCatFile::Opened(cat.open(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat", this->getAddonDir(), CATREAD_DAT)) ) {`
1385	`for ( CListNode<C_File> *f = pPackage->GetFileList()->Front(); f; f = f->next() ) {`	1385	`for ( CListNode<C_File> *f = pPackage->GetFileList()->Front(); f; f = f->next() ) {`
1386	`if ( f->Data()->GetFileType() != FILETYPE_SHIPSCENE && f->Data()->GetFileType() != FILETYPE_COCKPITSCENE && f->Data()->GetFileType() != FILETYPE_SHIPMODEL && f->Data()->GetFileType() != FILETYPE_SHIPOTHER ) {`	1386	`if ( f->Data()->GetFileType() != FILETYPE_SHIPSCENE && f->Data()->GetFileType() != FILETYPE_COCKPITSCENE && f->Data()->GetFileType() != FILETYPE_SHIPMODEL && f->Data()->GetFileType() != FILETYPE_SHIPOTHER ) {`
1387	`continue;`	1387	`continue;`
1388	`}`	1388	`}`
1389	`if ( CCatFile::IsAddonDir(f->Data()->GetNameDirectory(pPackage).ToString()) ) {`	1389	`if ( CCatFile::IsAddonDir(f->Data()->GetNameDirectory(pPackage).ToString()) ) {`
Line 1395...	Line 1395...
1395	`}`	1395	`}`
1396	`Utils::String toFile;`	1396	`Utils::String toFile;`
1397	`if ( cat.AppendFile(f->Data()->filePointer(), f->Data()->GetNameDirectory(pPackage).ToString(), true, (m_iGameFlags & EXEFLAG_NOXOR) ? false : true, &toFile) ) {`	1397	`if ( cat.AppendFile(f->Data()->filePointer(), f->Data()->GetNameDirectory(pPackage).ToString(), true, (m_iGameFlags & EXEFLAG_NOXOR) ? false : true, &toFile) ) {`
1398	`CLog::logf(CLog::Log_Install, 2, "Adding file: %s into the fake patch", f->Data()->GetNameDirectory(pPackage).c_str());`	1398	`CLog::logf(CLog::Log_Install, 2, "Adding file: %s into the fake patch", f->Data()->GetNameDirectory(pPackage).c_str());`
1399	`CFileIO::Remove(f->Data()->filePointer());`	1399	`CFileIO::Remove(f->Data()->filePointer());`
1400	`f->Data()->SetFilename(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat::" + toFile);`	1400	`f->Data()->setFilename(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat::" + toFile);`
1401	`}`	1401	`}`
1402	`}`	1402	`}`
1403	`}`	1403	`}`
1404	`}`	1404	`}`
1405		1405
Line 1604...	Line 1604...
1604	`{`	1604	`{`
1605	`if ( f->Data()->GetBaseName().Left(5).Compare("fake_") )`	1605	`if ( f->Data()->GetBaseName().Left(5).Compare("fake_") )`
1606	`{`	1606	`{`
1607	`shuffle = true;`	1607	`shuffle = true;`
1608	`C_File *match = package->FindMatchingMod(f->Data());`	1608	`C_File *match = package->FindMatchingMod(f->Data());`
1609	`CyString next = CyString::Number(this->FindNextFakePatch()).PadNumber(2);`	1609	`Utils::String next = Utils::String::PadNumber(this->FindNextFakePatch(), 2);`
1610		1610
1611	`CyString oldFilePointer = f->Data()->GetFilePointer();`	1611	`CyString oldFilePointer = f->Data()->GetFilePointer();`
1612	`f->Data()->SetDir("");`	1612	`f->Data()->setDir("");`
1613	`f->Data()->ChangeBaseName(next);`	1613	`f->Data()->changeBaseName(next);`
1614	`if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + "/" + f->Data()->GetNameDirectory(package)) )`	1614	`if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + "/" + f->Data()->getNameDirectory(package)) )`
1615	`f->Data()->SetFilename(m_sCurrentDir + "/" + f->Data()->GetNameDirectory(package));`	1615	`f->Data()->setFilename(m_sCurrentDir + "/" + f->Data()->getNameDirectory(package));`
1616		1616
1617	`if ( match )`	1617	`if ( match )`
1618	`{`	1618	`{`
1619	`CyString oldFilePointer = match->GetFilePointer();`	1619	`Utils::String oldFilePointer = match->filePointer();`
1620	`match->SetDir("");`	1620	`match->setDir("");`
1621	`match->ChangeBaseName(next);`	1621	`match->changeBaseName(next);`
1622	`if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + "/" + match->GetNameDirectory(package)) )`	1622	`if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + "/" + match->getNameDirectory(package)) )`
1623	`match->SetFilename(m_sCurrentDir + "/" + match->GetNameDirectory(package));`	1623	`match->setFilename(m_sCurrentDir + "/" + match->getNameDirectory(package));`
1624	`}`	1624	`}`
1625	`}`	1625	`}`
1626	`else`	1626	`else`
1627	`{`	1627	`{`
1628	`C_File *match = package->FindMatchingMod(f->Data());`	1628	`C_File *match = package->FindMatchingMod(f->Data());`
1629		1629
1630	`f->Data()->SetDir("");`	1630	`f->Data()->setDir("");`
1631	`if ( CFileIO(f->Data()->GetFilePointer()).Rename(m_sCurrentDir + "/" + f->Data()->GetNameDirectory(package)) )`	1631	`if ( CFileIO(f->Data()->GetFilePointer()).Rename(m_sCurrentDir + "/" + f->Data()->getNameDirectory(package)) )`
1632	`f->Data()->SetFilename(m_sCurrentDir + "/" + f->Data()->GetNameDirectory(package));`	1632	`f->Data()->setFilename(m_sCurrentDir + "/" + f->Data()->getNameDirectory(package));`
1633	`if ( match )`	1633	`if ( match )`
1634	`{`	1634	`{`
1635	`match->SetDir("");`	1635	`match->setDir("");`
1636	`if ( CFileIO(match->GetFilePointer()).Rename(m_sCurrentDir + "/" + match->GetNameDirectory(package)) )`	1636	`if ( CFileIO(match->filePointer()).Rename(m_sCurrentDir + "/" + match->getNameDirectory(package)) )`
1637	`match->SetFilename(m_sCurrentDir + "/" + match->GetNameDirectory(package));`	1637	`match->setFilename(m_sCurrentDir + "/" + match->getNameDirectory(package));`
1638	`}`	1638	`}`
1639	`}`	1639	`}`
1640	`}`	1640	`}`
1641	`}`	1641	`}`
1642		1642
Line 1680...	Line 1680...
1680	`{`	1680	`{`
1681	`if ( !icon->UncompressData() )`	1681	`if ( !icon->UncompressData() )`
1682	`package->SetIcon(NULL, "");`	1682	`package->SetIcon(NULL, "");`
1683	`else`	1683	`else`
1684	`{`	1684	`{`
1685	`CFileIO iconFile(m_sCurrentDir + "/PluginManager/Icons/" + package->author() + "_" + package->name() + "." + package->GetIconExt());`	1685	`CFileIO iconFile(m_sCurrentDir + "/PluginManager/Icons/" + package->author() + "_" + package->name() + "." + package->iconExt());`
1686	`if ( iconFile.WriteData((const char *)icon->GetData(), icon->GetDataSize()) )`	1686	`if ( iconFile.WriteData((const char *)icon->GetData(), icon->GetDataSize()) )`
1687	`{`	1687	`{`
1688	`icon->SetFilename(CyString(package->author()) + "_" + package->name() + "." + package->GetIconExt());`	1688	`icon->SetFilename(CyString(package->author()) + "_" + package->name() + "." + package->iconExt());`
1689	`icon->SetFullDir(m_sCurrentDir + "/PluginManager/Icons");`	1689	`icon->SetFullDir(m_sCurrentDir + "/PluginManager/Icons");`
1690	`}`	1690	`}`
1691	`else`	1691	`else`
1692	`package->SetIcon(NULL, "");`	1692	`package->SetIcon(NULL, "");`
1693	`}`	1693	`}`
Line 1745...	Line 1745...
1745	`m_lFiles.remove(f, false);`	1745	`m_lFiles.remove(f, false);`
1746		1746
1747	`// if its a readme file, then check if its in the new package`	1747	`// if its a readme file, then check if its in the new package`
1748	`bool dontRemove = false;`	1748	`bool dontRemove = false;`
1749	`if ( f->GetFileType() == FILETYPE_README ) {`	1749	`if ( f->GetFileType() == FILETYPE_README ) {`
1750	`if ( package->FindFile(f->GetFilename(), FILETYPE_README) )`	1750	`if ( package->FindFile(f->filename(), FILETYPE_README) )`
1751	`dontRemove = true;`	1751	`dontRemove = true;`
1752	`}`	1752	`}`
1753		1753
1754	`// remove from hard drive`	1754	`// remove from hard drive`
1755	`if ( !dontRemove && RemoveFile(f, errors) )`	1755	`if ( !dontRemove && RemoveFile(f, errors) )`
Line 1938...	Line 1938...
1938		1938
1939	`for ( C_File *uf = uninstallFiles.First(); uf; uf = uninstallFiles.Next() )`	1939	`for ( C_File *uf = uninstallFiles.First(); uf; uf = uninstallFiles.Next() )`
1940	`{`	1940	`{`
1941	`C_File *newFile = new C_File();`	1941	`C_File *newFile = new C_File();`
1942	`newFile->SetFileType(FILETYPE_SCRIPT);`	1942	`newFile->SetFileType(FILETYPE_SCRIPT);`
1943	`newFile->SetFilename(uf->GetFilename());`	1943	`newFile->setFilename(uf->filename());`
1944	`newFile->SetCreationTime(uf->GetCreationTime());`	1944	`newFile->SetCreationTime(uf->GetCreationTime());`
1945		1945
1946	`// other installed packages use this file as well, copy it`	1946	`// other installed packages use this file as well, copy it`
1947	`CyString newFilename = m_sCurrentDir + "/" + newFile->GetNameDirectory(NULL);`	1947	`Utils::String newFilename = m_sCurrentDir + "/" + newFile->getNameDirectory(NULL);`
1948	`CFileIO file(uf->GetFilePointer());`	1948	`CFileIO file(uf->filePointer());`
1949		1949
1950	`if ( uf->GetUsed() )`	1950	`if ( uf->GetUsed() )`
1951	`{`	1951	`{`
1952	`if ( file.copy(newFilename.ToString()) )`	1952	`if ( file.copy(newFilename) )`
1953	`this->AddLogEntry(SPKINSTALL_UNINSTALL_COPY, newFile->GetNameDirectory(NULL), errors);`	1953	`this->AddLogEntry(SPKINSTALL_UNINSTALL_COPY, newFile->getNameDirectory(NULL), errors);`
1954	`else`	1954	`else`
1955	`{`	1955	`{`
1956	`this->AddLogEntry(SPKINSTALL_UNINSTALL_COPY_FAIL, newFile->GetNameDirectory(NULL), errors);`	1956	`this->AddLogEntry(SPKINSTALL_UNINSTALL_COPY_FAIL, newFile->getNameDirectory(NULL), errors);`
1957	`delete newFile;`	1957	`delete newFile;`
1958	`newFile = NULL;`	1958	`newFile = NULL;`
1959	`}`	1959	`}`
1960	`}`	1960	`}`
1961	`// otherwise just move it`	1961	`// otherwise just move it`
1962	`else`	1962	`else`
1963	`{`	1963	`{`
1964	`if ( file.Rename(newFilename) )`	1964	`if ( file.Rename(newFilename) )`
1965	`this->AddLogEntry(SPKINSTALL_UNINSTALL_MOVE, newFile->GetNameDirectory(NULL), errors);`	1965	`this->AddLogEntry(SPKINSTALL_UNINSTALL_MOVE, newFile->getNameDirectory(NULL), errors);`

Subversion Repositories spk

(root)//libspk/src/Packages.cpp – Rev 155 → 158