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



typedef struct SComponantEntry {
	Utils::String		sSection;
	CLinkList<SComponantEntry2>	lEntries;
} SComponantEntry;
 
Utils::WString CPackages::m_sTempDir;
 
//////////////////////////////////////////////////////////////////////////////////////
 
//////////////////////////////////////////////////////////////////////////////////////
 

	m_lDisableList.clear();
	m_lEnableList.clear();
	this->Reset();
}
 
void CPackages::setCurrentDir(const Utils::WString &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.toString());
	if (_pCurrentDir->langid > 0)
		_pCurrentDir->langname = this->ConvertLanguage(_pCurrentDir->langid).toWString();
 
	updateFoundPackages("");
}
 
 

		}
	}
	m_bVanilla = b;
}
 
void CPackages::setMod(const Utils::WString &mod)
{
	if (mod != L"PluginManager")
		m_sSetMod = mod;
}
 
void CPackages::setSaveGameManager(bool managed)
{

		// find new save directory
		CDirIO dir(this->saveDirectory());
		if (dir.exists())
		{
			int id = 1;
			while (dir.exists(Utils::WString::PadNumber(id, 4)))
				++id;
			Utils::WString d = Utils::WString::PadNumber(id, 4);
			dir.create(d);
			_sSaveDir = d;
 
			CDirIO destDir1(dir.dir(d));
			destDir1.create(L"Vanilla");
			destDir1.cd(L"Vanilla");
			CDirIO destDir2(dir.dir(d));
			destDir2.create(L"Modified");
			destDir2.cd(L"Modified");
 
			Utils::WStringList files;
			if (dir.dirList(files, Utils::WString::Null(), L"*.sav"))
			{
				for (auto itr = files.begin(); itr != files.end(); ++itr)
				{
					Utils::WString f = dir.file((*itr)->str);
					CFileIO(f).copy(destDir1.file((*itr)->str));

	m_lFoundPackages.MemoryClear();
	m_lInstallList.MemoryClear();
	m_lEnableList.MemoryClear();
	m_lDisableList.MemoryClear();
 
	_lCreatedFiles.clear();
	_lNonRemovedFiles.clear();
	_lGlobals.clear();
	_lFakePatchOrder.clear();
	if (_pCurrentDir)
		delete _pCurrentDir;
	_pCurrentDir = NULL;
}
 

	}
 
	return oldPlugin;
}
 
bool CPackages::read(const Utils::WString& dir, CProgressInfo* progress)
{
	m_sCurrentDir = dir;
	m_sCurrentDir = m_sCurrentDir.findReplace("\\", "/");
	this->setCurrentDir(dir);
	m_bOldPlugin = false;
	_lCreatedFiles.clear();
	m_bRemoveDir = false;
	m_bSurpressProtectedWarning = false;
	m_iSaveGame = -1;
	m_iSaveGameManager = -1;
	_lNonRemovedFiles.clear();
	_lGlobals.clear();
	_lFakePatchOrder.clear();
 
	if ( _pOriginalFiles ) delete _pOriginalFiles;
	_pOriginalFiles = new COriginalFiles(m_sCurrentDir);
 
	m_bVanilla = true;
 
	// check the pluginmanager data file exists
	CFileIO datFile(m_sCurrentDir + L"/PluginManager/pluginmanager.dat");
	if ( datFile.exists() )
	{
		std::vector<Utils::WString> readFile;
		if(datFile.readLines(readFile))
		{
			float fVersion = 0;
			bool spkinstaller = false;
			float fBeta = 0;
 

			int iCount = 0;
			int iWare = -1;
			int iShip = -1;
 
			CBaseFile *packageFile = 0;
 
			for ( int i = 0; i < (int)readFile.size(); i++ )
			{
				Utils::WString line(readFile.at(i));
 
				Utils::WString cmd = line.token(L":", 1).lower();
				Utils::WString rest = line.tokens(L":", 2).removeFirstSpace();
 
				if ( iStatus == READ_GLOBAL )
				{
					if ( cmd == L"<script>" )
					{
						packageFile = new CSpkFile();
						iStatus = READ_SCRIPT;
					}
					else if ( cmd == L"<ship>" )
					{
						packageFile = new CXspFile();
						iStatus = READ_SCRIPT;
					}
					else if ( cmd == L"<base>" )
					{
						packageFile = new CBaseFile();
						iStatus = READ_SCRIPT;
					}
					else if ( cmd == L"<archive>" )
					{
						packageFile = new CArchiveFile();
						iStatus = READ_SCRIPT;
					}
					else if ( cmd != L"</scripts>" )
					{
						int game = 0;
						bool disabled = false;
						Utils::WString fileName = line.tokens(L":", 5);
						Utils::WString origName;
						if ( fileName.left(2) == L"D#" )
						{
							fileName.erase(0, 2);
							disabled = true;
						}
						if ( fileName.left(2) == L"G#" ) {
							fileName.erase(0, 2);
							game = fileName.token(L"#", 1).toLong();
							fileName = fileName.tokens(L"#", 2);
						}
						if ( fileName.isin(L"O#") )
						{
							origName = fileName.token(L"O#", 2);
							fileName = fileName.token(L"O#", 1);
						}
 
						C_File *newFile = new C_File(m_sCurrentDir + fileName);
						newFile->setGame(game);
						newFile->SetOriginalName(origName);
						newFile->SetDisabled(disabled);
						newFile->setFileType(static_cast<FileType>(line.token(L&quot;:", 1).toLong()));
						newFile->SetCreationTime(static_cast<time_t>(line.token(L&quot;:", 2).toLong()));
						newFile->setDir(line.token(L":", 3));
						if ( line.token(L":", 4).toLong() )
							newFile->SetShared(true);
						newFile->UpdateSigned();
 
						m_lFiles.push_back(newFile);
					}
				}
				else if ( iStatus == READ_SCRIPT )
				{
					if ( cmd == L"installspk" )
						packageFile->setFilename(rest);
					else if ( cmd == L"files" )
					{
						iStatus = READ_SCRIPTFILE;
						if ( spkinstaller )
						{
							std::vector<Utils::WString> files;
							rest.tokenise(L"; &quot;, files);
 
							for (size_t i = 0; i < files.size(); i++ )
							{
								int fileNum = files[i].toLong();
								if ( fileNum >= 0 && fileNum < m_lFiles.size() )
									packageFile->AddFile(m_lFiles[fileNum]);
							}
 
 
						}
					}
					else if ( cmd == L"disabled" )
						packageFile->SetEnabled(false);
					else if ( cmd == L"modifieddisabled" )
						packageFile->SetModifiedEnabled(false);
					else if ( cmd == L"icon" )
					{
						C_File *icon = new C_File(rest.tokens(L" ", 2));
						packageFile->setIcon(icon, rest.token(L" ", 1).toString());
					}
					else
						packageFile->ParseValueLine(line.toString());
				}
				else if ( iStatus == READ_SCRIPTFILE )
				{
					if ( cmd == L"<script>" )
					{
						if ( packageFile->IsMod() && packageFile->IsEnabled() )
							m_pEnabledMod = packageFile;
 
						m_lPackages.push_back(packageFile);
						this->ConvertOldPackage(packageFile);
						packageFile = new CSpkFile();
						iStatus = READ_SCRIPT;
 
					}
					else if ( cmd == L"<ship>" )
					{
						m_lPackages.push_back(packageFile);
						this->ConvertOldPackage(packageFile);
						packageFile = new CXspFile();
						iStatus = READ_SCRIPT;
					}
					else if ( cmd == L"<base>" )
					{
						m_lPackages.push_back(packageFile);
						this->ConvertOldPackage(packageFile);
						packageFile = new CBaseFile();
						iStatus = READ_SCRIPT;
					}
 
 
 
 
 
 
 
					else if ( cmd == L"<archive>" )
					{
						m_lPackages.push_back(packageFile);
						this->ConvertOldPackage(packageFile);
						packageFile = new CArchiveFile();
						iStatus = READ_SCRIPT;
					}
					else if ( cmd == L"</scripts>" )
					{
						if ( packageFile->IsMod() && packageFile->IsEnabled() )
							m_pEnabledMod = packageFile;
 
						m_lPackages.push_back(packageFile);
						this->ConvertOldPackage(packageFile);
					}
					else
					{
						int fileNum = line.token(L"::", 1).toLong();
						if ( fileNum >= 0 && fileNum < m_lFiles.size() )
							packageFile->AddFile(m_lFiles[fileNum]);
					}
				}
				else if ( iWare != -1 )
				{
					--iCount;
 
					SGameWare *gm = new SGameWare;
					gm->iPos = line.token(L" ", 1).toLong();
					gm->iType = line.token(L" ", 2).toLong();
					gm->cType = line.token(L" ", 3)[0];
					gm->pWare = NULL;
					gm->sWareName = line.tokens(L" ", 4);
					m_lGameWares[iWare].push_back(gm);
					if ( iCount <= 0 )
						iWare = -1;
				}
				else if ( iShip != -1 )
				{
					--iCount;
 
					SGameShip *gm = new SGameShip;
					gm->iType = line.token(L" ", 1).toLong();
					if ( line.token(L" ", 2).left(4) == L"$#C:" )
					{
						gm->sShipClass = line.token(L" ", 2).right(-4);
						gm->sShipID = line.tokens(L" ", 3);
					}
					else
					{
						gm->sShipID = line.tokens(L" ", 2);
						gm->sShipClass = L"OBJ_SHIP_M5";
					}
					gm->pPackage = NULL;
					m_lGameShips.push_back(gm);
					if ( iCount <= 0 )
						iShip = -1;
				}
				else if ( cmd.Compare(L"savegamemanager") )
					m_iSaveGameManager = rest.toLong();
				else if ( cmd.Compare(L"savegame") )
					m_iSaveGame = rest.toLong();
				else if ( cmd == L"fakepatch" )
					m_iFakePatch = rest.toLong();
				else if ( cmd == L"updatetime" )
					m_iLastUpdated = rest.toLong();
				else if ( cmd == L"surpressprotectedwarning" )
					m_bSurpressProtectedWarning = true;
				else if ( cmd == L"pluginmanager" )
				{
					fVersion = rest.toFloat();
					m_bOldPlugin = true;
				}
				else if ( cmd == L"setmod" )
					m_sSetMod = rest;
				else if ( cmd == L"shipbuffer" )
					m_iShipBuffer = rest.toLong();
				else if(cmd == L"savedir")
					_sSaveDir = rest;
				else if ( cmd == L"warebuffers" )
				{
					int max = rest.countToken(L" ");
					for ( int i = 0; i < WAREBUFFERS; i++ )
					{
						if ( i > max )
							m_iWareBuffer[i] = 0;
						else
							m_iWareBuffer[i] = rest.token(L" ", i + 1).toLong();
					}
				}
				else if ( cmd == L"createdfile" )
					_lCreatedFiles.pushBack(rest);
				else if ( cmd == L"wares" )
				{
					iWare = rest.token(L" ", 1).toLong();
					iCount = rest.token(L" ", 2).toLong();
				}
				else if ( cmd == L"ships" )
				{
					iShip = 1;
					iCount = rest.token(L" ", 1).toLong();
				}
				else if ( cmd == L"modified" )
					m_bVanilla = false;
				else if ( cmd == L"spkinstaller" )
				{
					fVersion = rest.toFloat();
					spkinstaller = true;
				}
				else if ( cmd == L"betaversion" )
					fBeta = rest.toFloat();
				else if ( cmd == L"uninstall" )
				{
					C_File *uf = new C_File();
					uf->setFileType(FILETYPE_SCRIPT);
					uf->SetCreationTime(rest.token(L" ", 1).toLong());
					uf->setFilename(m_sCurrentDir + L"/Scripts/" + rest.tokens(L" ", 2));
					m_lUninstallFiles.push_back(uf);
				}
				else if ( cmd == L"nonremovedfile" )
				{
					if ( !CFileIO::Remove(rest) )
						_lNonRemovedFiles.pushBack(rest);
				}
				else if ( cmd == L"original" )
					_pOriginalFiles->parse(rest);
				else if ( cmd.Compare(L"GlobalSetting") )
					_lGlobals.pushBack(rest.token(L":", 1), rest.tokens(L":", 2));
				else if ( cmd.Compare(L"FakePatchOrder") )
					_lFakePatchOrder.pushBack(rest.token(L":", 1), rest.tokens(L":", 2));
				else if ( cmd.Compare(L"EMPPriceOverride") )
					this->addEMPPriceOverride(rest.token(L" ", 1).toLong(), rest.token(L" ", 2).toLong());
				else if ( cmd.Compare(L"EMPNotoOverride") )
					this->addEMPNotoOverride(rest.token(L" ", 1).toLong(), rest.token(L" ", 2).toLong());
				else if ( cmd.Compare(L"BuiltInWarePriceOverride") )
					this->addBuiltInWarePriceOverride(rest.token(L" ", 1).toLong(), rest.token(L" ", 2).toLong());
				else if ( cmd.Compare(L"BuiltInWareNotoOverride") )
					this->addBuiltInWareNotoOverride(rest.token(L" ", 1).toLong(), rest.token(L" ", 2).toLong());
				else if ( cmd.Compare(L"CustomWarePriceOverride") )
					this->addCustomWarePriceOverride(rest.token(L";", 1), rest.token(L";", 2).toLong());
				else if ( cmd.Compare(L"CustomWareNotoOverride") )
					this->addCustomWareNotoOverride(rest.token(L";", 1), rest.token(L";", 2).toLong());
				else if ( cmd == L"globalfiles" )
					iStatus = READ_GLOBAL;
 
				if ( progress )
				{
					progress->UpdateProgress((long)i, static_cast<long>(readFile.size()));
				}
			}
			readFile.clear();
 
			if ( !spkinstaller )
				m_bRedo = true;
 
 
		}
	}
 
	if ( m_pEnabledMod && !m_pEnabledMod->IsEnabled() )
		m_pEnabledMod = NULL;
 
	m_iGame = m_gameExe.getGameType(m_sCurrentDir) + 1;
	m_pCurrentGameExe = m_gameExe.game(m_gameExe.getGameType(m_sCurrentDir));
	Utils::WString sGameVersion;
	m_iGameVersion = m_gameExe.getGameVersion(m_sCurrentDir, &sGameVersion) + 1;
	_sGameVersion = sGameVersion;
	m_iGameFlags = m_gameExe.gameFlags(m_iGame - 1);
	m_iMaxPatch = m_gameExe.maxPatch(m_iGame - 1);
 
	// find the fake patch
	if ( !ReadyFakePatch() )
		return false;
 

		else if ( node->Data()->GetType() == TYPE_XSP )
		{
			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;
				}
			}

	return true;
}
 
void CPackages::RemoveCreatedFiles()
{
	for(auto itr = _lCreatedFiles.begin(); itr != _lCreatedFiles.end(); itr++)
	{
		if ( CFileIO::Exists((*itr)->str) )
			CFileIO::Remove((*itr)->str);
		else if ( CFileIO::Exists(m_sCurrentDir + L"/" + (*itr)->str) )
			CFileIO::Remove(m_sCurrentDir + L"/" + (*itr)->str);
	}
 
	_lCreatedFiles.clear();
}
 
void CPackages::PurgeGameObjects()
{
	// check for the log file
	Utils::WString logDir = logDirectory();
	CFileIO LogFile(logDir + L"/log0" + Utils::WString::PadNumber(PMTEXTFILE, 4) + L".txt");
	if ( LogFile.exists() )
	{
		// read the log file to memory
		std::vector<Utils::String> *lines = LogFile.readLines();
		if ( lines )

			node->Data()->iType = WARETYPE_NONE;
	}
	m_lGameShips.RemoveEmpty();
}
 
Utils::WString CPackages::logDirectory()
{
	Utils::WString logDir = m_sCurrentDir;
	if ( m_iGameFlags & EXEFLAG_MYDOCLOG ) {
		SGameExe *exe = m_gameExe.game(m_iGame - 1);
		if ( exe ) {
			if ( !exe->sMyDoc.empty() )
				logDir = m_sMyDoc + L"/" + exe->sMyDoc;
		}
	}
 
	return logDir;
}
 
Utils::WString CPackages::logDirectory(const Utils::WString &gameExe)
{
	Utils::WString logDir = m_sCurrentDir;
	if ( m_iGameFlags & EXEFLAG_MYDOCLOG )
	{
		SGameExe *exe = m_gameExe.gameExe(CFileIO(gameExe).filename());
		if ( exe )
		{
			if ( !exe->sMyDoc.empty() )
				logDir = m_sMyDoc + L"/" + exe->sMyDoc;
		}
	}
 
	return CFileIO(logDir).fullFilename();
}
 
Utils::WString CPackages::saveDirectory()
{
	Utils::WString logDir = this->logDirectory();
	if ( m_iGameFlags & EXEFLAG_NOSAVESUBDIR )
		return logDir;
 
	return logDir + L"/save";
}
 
bool CPackages::ReadyFakePatch()
{
	// already exists, lets skip it

		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::WString useFile;
	if ( m_iFakePatch > 0 )
	{
		Utils::WString file = Utils::WString::PadNumber(m_iFakePatch, 2);
		if (checkValidPluginManagerFile(file))
			useFile = file;
		else if (checkIfPluginManagerFile(file))
			useFile = file;
	}

		--nextfree; // gets the end fake patch
 
		// work backwards till we find a valid one
		while ( nextfree > m_iMaxPatch )
		{
			Utils::WString file = Utils::WString::PadNumber(nextfree, 2);
			if (checkValidPluginManagerFile(file))
			{
				useFile = file;
				break;
			}
			--nextfree;
		}
	}
 
	Utils::WString 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::WString file = Utils::WString::PadNumber(nextfree, 2);
			if (checkIfPluginManagerFile(file))
			{
				useFile = file;
				break;
			}

 
	if ( !useFile.empty() )
	{
		// lets check whats in the file first
		CCatFile openCat;
		if ( openCat.open((m_sCurrentDir + L"/" + useFile + L".cat").toString(), addonDir.toString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)
		{
			std::vector<SInCatFile *> *files = openCat.GetFiles();
			bool found = false;
			if ( files )
			{
				Utils::WString useAddonDir = addonDir;
				if ( !useAddonDir.empty() ) useAddonDir += L"\\";
				for (auto itr = files->cbegin(); itr != files->cend(); itr++)
				{
					if ((*itr)->sFile.Compare("PlugMan\\TFake.pck") )
						continue;
					if ((*itr)->sFile.Compare(useAddonDir.toString() + "t\\44" + Utils::String::PadNumber(PMTEXTFILE, 4) + &quot;.pck"))
						continue;
					if ((*itr)->sFile.Compare(useAddonDir.toString() + "t\\" + Utils::String::PadNumber(PMTEXTFILE, 4) + ";-L044.pck"))
						continue;
 
					found = true;
					break;
				}
			}
 
			// no files, jsut delete them
			CFileIO catFile(m_sCurrentDir + L"/" + useFile + L".cat");
			if ( !files || !found )
			{
				if ( catFile.remove() )
				{
					CFileIO datFile(m_sCurrentDir + L"/" + useFile + L".dat");
					if ( datFile.remove() )
						return true;
				}
			}
			else
			{
				if ( catFile.Rename(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat") )
				{
					CFileIO datFile(m_sCurrentDir + L"/" + useFile + L".dat");
 
					if ( datFile.Rename(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat") )
						return true;
 
					// TODO: it failed, restore cat file and do error

	// otherwise we didn't need to (hopefully)
	return true;
}
 
 
bool CPackages::checkIfPluginManagerFile(const Utils::WString &filename) const
{
	bool found = false;
 
	CFileIO catFile(m_sCurrentDir + L"/" + filename + L".cat");
	if ( catFile.exists() && CFileIO::Exists(m_sCurrentDir + L"/" + filename + L".dat"))
	{
		CCatFile openFile;
		if ( openFile.open(catFile.fullFilenameStr(), this->getAddonDir().toString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)
		{
//			if ( openFile.internaldatFilename().Compare("PlugMan_Fake.dat") ) return true;
			int count = 0;
			int noncount = 0;
 
			// check for some of the files
			for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {
				if ( node->Data()->fullDir().contains(L"::") ) {
					if (CFileIO(node->Data()->fullDir().token(L"::", 1)).filename().Compare(L"PlugMan_Fake.cat") ) {
						Utils::WString filename = node->Data()->filePointer().token(L"::", 2);
						filename = filename.findReplace(L"/", L"\\");
						if ( openFile.findData(filename) )
							++count;
						else
							++noncount;
					}

	}
 
	return found;
}
 
bool CPackages::checkValidPluginManagerFile(const Utils::WString &filename) const
{
	// both the cat file and dat file exists, lets open it
	CFileIO catFile(m_sCurrentDir + L"/" + filename + L".cat");
	if ( catFile.exists() && CFileIO::Exists(m_sCurrentDir + L"/" + filename + L".dat"))
	{
		CCatFile openFile;
		if ( openFile.open(catFile.fullFilenameStr(), this->getAddonDir().toString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)
		{
			if ( openFile.findData("PlugMan\\TFake.pck") )
				return true;
			if ( openFile.findData("pluginmanagerfake.pck") )
				return true;

			if ( gNode->Data()->iVersion == 0 )
				gNode->Data()->iGame = 0;
			else
			{
				int version = 0;
				gNode->Data()->iGame = m_gameExe.convertGameType(gNode->Data()->iVersion, &version);
				gNode->Data()->iVersion = version;
			}
		}
	}
 

 
	m_bRedo = false;
	return true;
}
 
int CPackages::checkOpenPackage(const Utils::WString &file, int *error)
{
	// first check if it exists
	if (!CFileIO::Exists(file))
	{
		*error = INSTALLERR_NOEXIST;

	}
 
	return check;
}
 
CMultiSpkFile *CPackages::openMultiPackage(const Utils::WString &file, int *error, CProgressInfo *progress)
{
	int check = checkOpenPackage(file, error);
	if ( *error == -1 )
		return false;
 

 
	delete package;
	return NULL;
}
 
bool CPackages::openMultiPackage(const Utils::WString &file, CLinkList<CBaseFile> *packageList, int *error, CProgressInfo *progress )
{
	int check = checkOpenPackage(file, error);
	if ( *error == -1 )
		return false;
 

	delete package;
 
	return count;
}
 
CBaseFile *CPackages::openPackage(const Utils::WString &file, int *error, CProgressInfo *progress, int readtype, int flags)
{
	int check = checkOpenPackage(file, error);
	if ( *error == -1 )
		return NULL;
 

		case SPKFILE_INVALID:
			// convert xsp
			if ( CFileIO(file).isFileExtension(L"xsp") )
			{
				installFile = new CXspFile();
				if ( !((CXspFile *)installFile)->ConvertOld(file.toString()) )
				{
					delete installFile;
					return NULL;
				}
				break;
			}
			*error = INSTALLERR_INVALID;
			return NULL;
		case SPKFILE_BASE:
			installFile = new CBaseFile();
			if ( !installFile->readFile(file.toString(), readtype, progress))
			{
				delete installFile;
				return NULL;
			}
			break;
		case SPKFILE_SINGLE:
			installFile = new CSpkFile();
			if ( !((CSpkFile *)installFile)->readFile(file.toString(), readtype, progress))
			{
				delete installFile;
				return NULL;
			}
			break;
		case SPKFILE_MULTI:
			*error = INSTALLERR_NOMULTI;
			return NULL;
		case SPKFILE_SINGLESHIP:
			installFile = new CXspFile();
			if ( !((CXspFile *)installFile)->readFile(file.toString(), readtype, progress))
			{
				delete installFile;
				return NULL;
			}
			break;

	this->ConvertOldPackage (installFile);
 
	return installFile;
}
 
void CPackages::purgeUninstallScripts(CBaseFile *package, Utils::WStringList *errors)
{
	for ( CListNode<C_File> *fNode = m_lUninstallFiles.Front(); fNode; fNode = fNode->next() )
	{
		C_File *uf = fNode->Data();
		// check against any script files

	m_lUninstallFiles.RemoveEmpty();
 
	this->WriteData();
}
 
int CPackages::installPreparedPackages(Utils::WStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *errored, CLinkList<CBaseFile> *installedList)
{
	if ( m_lInstallList.empty() ) return false;
	int installed = 0;
	for ( CListNode<CBaseFile> *node = m_lInstallList.Front(); node; node = node->next() )
	{

}
 
void CPackages::_addToFakePatch(CBaseFile *pPackage)
{
	CCatFile cat;
	if ( CCatFile::Opened(cat.open((m_sCurrentDir + L"/PluginManager/PlugMan_Fake.cat";).toString(), 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)) ) {

			}
			// check if its already in the fake patch
			if ( f->Data()->fullDir().contains("::") ) {
				continue;
			}
			Utils::WString toFile;
			if ( cat.appendFile(f->Data()->filePointer(), f->Data()->getNameDirectory(pPackage), 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 + L"/PluginManager/PlugMan_Fake.cat::" + toFile);
			}
		}
	}
}
 

		disabled = prevDisabled;
 
	return disabled;
}
 
Utils::WString CPackages::getCurrentDirectory() const
{ 
	return (_pCurrentDir) ? _pCurrentDir->dir : Utils::WString::Null();
}
 
 
bool CPackages::installPackage(CBaseFile *package, Utils::WStringList *errors, CProgressInfo *progress, bool disabled)
{
	CLog::logf(CLog::Log_Install, 1, "Starting to install new package, %s by %s (Version: %s)", package->name().c_str(), package->author().c_str(), package->version().c_str());
	
	CBaseFile *oldPackage = findPackage(package);
	disabled = _checkForDisable(package, disabled, oldPackage);

 
	CLog::log(CLog::Log_Install, 3, "Reading all files into memory");
	package->ReadAllFilesToMemory();
 
	CLog::log(CLog::Log_Install, 3, "Starting to install files");
	if ( !package->installFiles (m_sCurrentDir.toString(), progress, &m_lFiles, errors, !disabled, this))
	{
		CLog::log(CLog::Log_Install, 2, "There was an error installing files!!");
 
		// TODO: clear up installed files
		return false;

 
				if ( findMatching )
				{
					// copy accross all mods
					CCatFile catTo, catFrom;
					if ( catFrom.open(f->Data()->filePointer(), this->getAddonDir().toString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)
					{
						if ( catTo.open(findMatching->filePointer(), this->getAddonDir().toString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)
						{
							for (unsigned int i = 0; i < catFrom.GetNumFiles(); i++ )
							{
								SInCatFile *c = catFrom.GetFile(i);								 
								catTo.appendFile(f->Data()->filePointer() + "::" + c->sFile, c->sFile);

					{
						shuffle = true;
						C_File *match = package->findMatchingMod(f->Data());
						Utils::String next = Utils::String::PadNumber(this->findNextFakePatch(), 2);
						
						Utils::WString oldFilePointer = f->Data()->filePointer();
						f->Data()->setDir(L"");
						f->Data()->changeBaseName(next);
						if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + L"/" + f->Data()->getNameDirectory(package)))
							f->Data()->setFilename(m_sCurrentDir + L"/" + f->Data()->getNameDirectory(package));
 
						if ( match )
						{
							Utils::WString oldFilePointer = match->filePointer();
							match->setDir(L"");
							match->changeBaseName(next);
							if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + L"/" + match->getNameDirectory(package)))
								match->setFilename(m_sCurrentDir + L"/" + match->getNameDirectory(package));
						}
					}
					else
					{
						C_File *match = package->findMatchingMod(f->Data());
 
						f->Data()->setDir(L"");
						if ( CFileIO(f->Data()->filePointer()).Rename(m_sCurrentDir + L"/" + f->Data()->getNameDirectory(package)))
							f->Data()->setFilename(m_sCurrentDir + L"/" + f->Data()->getNameDirectory(package));
						if ( match )
						{
							match->setDir(L"");
							if ( CFileIO(match->filePointer()).Rename(m_sCurrentDir + L"/" + match->getNameDirectory(package)))
								match->setFilename(m_sCurrentDir + L"/" + match->getNameDirectory(package));
						}
					}
				}
			}
 

			delete package;
			package = oldPackage;
			oldPackage = false;
			dontAdd = true;
 
			CDirIO(m_sCurrentDir).removeDir(L"temp");
			CDirIO(m_sCurrentDir).removeDir(L"Mods/temp");
		}
	}
 
	// if theres an icon, write it
	if (package->icon())

			{
				if ( !icon->UncompressData() )
					package->setIcon(NULL, "");
				else
				{
					CFileIO iconFile(m_sCurrentDir + L"/PluginManager/Icons/" + package->author().toWString() + L";_" + package->name().toWString() + L"." + package->iconExt());
					if ( iconFile.WriteData((const char *)icon->GetData(), icon->GetDataSize()) )
					{
						icon->setFilename(package->author().toWString() + L";_" + package->name().toWString() + L"." + package->iconExt());
						icon->setFullDir(m_sCurrentDir + L"/PluginManager/Icons");
					}
					else
						package->setIcon(NULL, "");
				}
			}

 
	CLog::log(CLog::Log_Install, 1, "Installation Finished");
	return true;
}
 
bool CPackages::uninstallPreparedPackages(Utils::WStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *uninstalledPackages, CLinkList<CBaseFile> *disabledPackages)
{
	if ( m_lInstallList.empty() ) return false;
 
	// update the used status, excluding all packages we are about to remove
	UpdateUsedFiles(&m_lInstallList);
 
	Utils::WStringList removeDirs;
	CLinkList<C_File> uninstallFiles;
	CLinkList<C_File> fileList;
	bool readme = false, original = false, shuffle = false;
 
	// find all files that need to be removed

 
		if ( f->GetFileType() == FILETYPE_README )
			readme = true;
		else if ( f->GetFileType() == FILETYPE_UNINSTALL || f->GetFileType() == FILETYPE_MAP || f->GetFileType() == FILETYPE_SOUND || f->GetFileType() == FILETYPE_EXTRA || f->GetFileType() == FILETYPE_SHIPSCENE || f->GetFileType() == FILETYPE_COCKPITSCENE || f->GetFileType() == FILETYPE_SHIPOTHER || f->GetFileType() == FILETYPE_SHIPMODEL || f->GetFileType() == FILETYPE_ADVERT )
		{
			Utils::WString dir = f->getDirectory(NULL);
			if(!removeDirs.contains(dir))
				removeDirs.pushBack(dir);
			dir = dir.findReplace(L"\\", L"/");
			if ( dir.contains(L"/") )
			{
				for ( int i = dir.countToken(L"/"); i; i-- )
				{
					Utils::WString remDir = dir.tokens(L"/", 1, i);
					if(!removeDirs.contains(remDir))
						removeDirs.pushBack(remDir);
				}
			}
		}
 
		if (f->GetFileType() == FILETYPE_EXTRA && f->dir().left(6).lower() == L"extras")
		{
			if (!removeDirs.contains(L"Extras"))
				removeDirs.pushBack(L"Extras");
		}
 
		if (removeFile(f, errors))
			original = _pOriginalFiles->restoreFile(f, errors);
		else // problem removeing (try when the program closes)
			_lNonRemovedFiles.pushBack(f->filePointer());
 
		// check for fake patchs
		if ( f->IsFakePatch() )
			shuffle = true;
		else if ( f->isAutoTextFile() )

	m_lInstallList.clear();
 
	// check unistall files
	if ( !uninstallFiles.empty() )
	{
		removeDirs.pushBack(L"PluginManager/Uninstall");
 
		// make sure the scripts directory is created, even thou it should always be there anyways
		CDirIO scriptDir(m_sCurrentDir);
		if ( !scriptDir.exists(L"scripts") )
		{
			if ( scriptDir.create(L"Scripts") )
				this->addLogEntry(SPKINSTALL_CREATEDIRECTORY, L"Scripts", errors);
			else
				this->addLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, L"Scripts", 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::WString newFilename = m_sCurrentDir + L"/" + newFile->getNameDirectory(NULL);
			CFileIO file(uf->filePointer());
 
			if ( uf->getUsed() )
			{
				if ( file.copy(newFilename) )

	uninstallFiles.clear();
 
	// remove all directies that we're not using
	if ( readme )
	{
		removeDirs.pushBack(L"PluginManager/Readme");
		removeDirs.pushBack(L"Readme");
	}
	if ( original ) {
		removeDirs.pushBack(L"PluginManager/Original/Replacements");
		removeDirs.pushBack(L"PluginManager/Original");
	}
	removeDirs.pushBack(L"PluginManager/Disabled");
	removeUnusedDirectories(removeDirs, errors);
 
	// finally lets shuffle any fake patchs to fill in gaps
	if ( shuffle )
	{

			m_lInstallList.remove(package, true);
		}
	}
}
 
wchar_t CPackages::ConvertWareTypeBack(int w)
{
	switch ( w )
	{
		case WARES_BIO:
			return L'b';
		case WARES_ENERGY:
			return L'e';
		case WARES_FOOD:
			return L'f';
		case WARES_MINERAL:
			return L'm';
		case WARES_TECH:
			return L't';
		case WARES_NATURAL:
			return L'n';
	}
	return L't';
}
int CPackages::ConvertWareType(wchar_t w)
{
	switch ( LOWER(w) )
	{
		case L'b':
			return WARES_BIO;
		case L'e':
			return WARES_ENERGY;
		case L'f':
			return WARES_FOOD;
		case L'm':
			return WARES_MINERAL;
		case L't':
			return WARES_TECH;
		case L'n':
			return WARES_NATURAL;
	}
	return WARES_TECH;
}
 

					wNode->Data()->iType = WARETYPE_DISABLED;
				else
					wNode->Data()->iType = WARETYPE_ADDED;
				found = true;
				wNode->Data()->pPackage = p;
				wNode->Data()->sShipClass = p->GetShipClass().toWString();
				break;
			}
		}
 
		if ( found || !p->IsEnabled() )

 
		// none found, create one
		if ( !gw )
		{
			gw = new SGameShip;
			gw->sShipID = p->GetShipID().toWString();
			gw->sShipClass = p->GetShipClass().toWString();
			gw->pPackage = p;
			m_lGameShips.push_back(gw);
		}
		gw->iType = WARETYPE_ADDED;
	}

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

				fDat = m_pEnabledMod->GetNextFile(fDat);
 
			if ( fDat )
			{
				C_File *fCat = m_pEnabledMod->GetFirstFile(FILETYPE_MOD);
				while ( fCat && !fCat->IsFakePatch() && !fCat->checkFileExt(L"cat") && !fCat->baseName().Compare(fDat->baseName()) )
					fCat = m_pEnabledMod->GetNextFile(fCat);
 
				if ( fCat )
				{
					CFileIO(fDat->filePointer()).copy(m_sCurrentDir + L"/mods/PluginManager.dat");
					CFileIO(fCat->filePointer()).copy(m_sCurrentDir + L"/mods/PluginManager.cat");
				}
			}
		}
		else if ( m_iGame == GAME_X3 && !m_sSetMod.empty() && CFileIO::Exists(m_sCurrentDir + L"/mods/" + m_sSetMod + L".cat") && CFileIO::Exists(m_sCurrentDir + L"/mods/" + m_sSetMod + L".dat"))
		{
			CLog::log(CLog::Log_Directory, 2, L"Copying mod file: " + m_sSetMod + L", to PluginManager.cat");
			CFileIO(m_sCurrentDir + L"/mods/" + m_sSetMod + L".dat").copy(m_sCurrentDir + L"/mods/PluginManager.dat");
			CFileIO(m_sCurrentDir + L"/mods/" + m_sSetMod + L".cat").copy(m_sCurrentDir + L"/mods/PluginManager.cat");
		}
 
		if ( !CDirIO(m_sCurrentDir).exists(L"mods") )
			CDirIO(m_sCurrentDir).create(L"mods");
 
		SetupWares();
		SetupShips();
		createEMPFile();
		CreateWareFiles();

 
	WriteData();
	if ( removedir && m_bRemoveDir )
	{
		m_bRemoveDir = false;
		Utils::WStringList removeDirs;
		removeDirs.pushBack(L".");
		removeUnusedDirectories(removeDirs, errors);
	}
 
	this->setCurrentDir(L"");
		 
	m_bLoaded = false;
	return true;
}
 
Utils::WString CPackages::getModKey() const
{
	return m_gameExe.getModKey(m_iGame - 1);
}
Utils::WString CPackages::selectedModName() const
{
	if ( !m_pEnabledMod )
	{
		if ( m_sSetMod.empty() && m_iGame == GAME_X3 )
			return L"PluginManager";
		return m_sSetMod;
	}
 
	if ( !m_pEnabledMod->IsEnabled() )
		return m_sSetMod;
 
	C_File *f = m_pEnabledMod->GetFirstFile(FILETYPE_MOD);
	if ( !f )
		return m_sSetMod;
 
	Utils::WString name = f->filename();
	name = name.left(-4);
	return name;
 
}
 

	CLog::log(CLog::Log_Directory, 1, "Restoring PluginManager fake patch into game");
 	m_iFakePatch = -1;
 
	CFileIO catFile(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat");
	CFileIO datFile(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat");
 
	// if only 1 exists, remove it
	if ( catFile.exists() && !datFile.exists() ) {
		CLog::log(CLog::Log_Directory, 1, "WARNING: cat/dat file mismatch, dat file seems to be missing, removing cat file");
		if ( !catFile.remove() ) return false;
	}

	// if both exists, lets rename them
	if ( catFile.exists() && datFile.exists() )
	{
		CLog::log(CLog::Log_Directory, 3, "Creating pluginmanagerfake.txt file to add to Fake Patch");
		// we need to add the plugin manager file in
		Utils::WString file = m_sTempDir;
		if ( !file.empty() )
			file += L"/";
		file += L"pluginmanagerfake.txt";
		file = file.findReplace(L"\\", L"/");
		CFileIO fakeFile(file);
		std::vector<Utils::String> lines;
		lines.push_back("//pluginmanager fake patch");
		CLog::log(CLog::Log_Directory, 3, "Writing pluginmanagerfake.txt file to add to Fake Patch");
		if ( !fakeFile.writeFile(&lines) ) {

			}	*/		
		}
 
		// backup existing mod files incase something happens to them
		if ( !datFile.exists() || !catFile.exists() ) {
			CLog::log(CLog::Log_Directory, 2, Utils::WString("ERROR: ") + (!catFile.exists() ? L"cat" : L"dat") + L" file appears to be missing");
		}
		else {
			catFile.GetDirIO().create(L"Backup");
			catFile.copy(catFile.dir() + L"/Backup/" + catFile.filename());
			datFile.copy(datFile.dir() + L"/Backup/" + datFile.filename());
		}
 
 
		// find next available fake patch
		m_iFakePatch = this->findNextFakePatch();
		CLog::log(CLog::Log_Directory, 2, "Finding next available fake patch number: " + (long)m_iFakePatch);
 
		Utils::WString filename = Utils::WString::PadNumber(m_iFakePatch, 2);
		CLog::log(CLog::Log_Directory, 2, L"Renaming cat file to: " + filename + L".cat");
		if ( catFile.Rename(m_sCurrentDir + L"/" + filename + L".cat") )
		{
			CLog::log(CLog::Log_Directory, 2, L"Renaming dat file to: " + filename + L".dat");
			if ( datFile.Rename(m_sCurrentDir + L"/" + filename + L".dat") ){
				CLog::log(CLog::Log_Directory, 3, L"Deleting pluginmanagerfake.txt temporary file");
				fakeFile.remove();
				return true;
			}
			else {
				CLog::log(CLog::Log_Directory, 2, L"ERROR: failed to rename dat file");
			}
 
			// TODO: restore cat file
		}
		else {
			CLog::log(CLog::Log_Directory, 2, L"ERROR: failed to rename cat file");
		}
 
		CLog::log(CLog::Log_Directory, 3, L"Deleting pluginmanagerfake.txt temporary file");
		fakeFile.remove();
		return false;
	}
 
	return true;

void CPackages::WriteData()
{
	if ( m_sCurrentDir.empty() )
		return;
 
	CLog::log(CLog::Log_Directory, 1, L"Writing data file for current directory: " + m_sCurrentDir);
 
	Utils::WStringList lines;
	Utils::WString version = L"SpkInstaller: " + Utils::WString::FromFloat(GetLibraryVersion(), 2);
	lines.pushBack(version);
 
	lines.pushBack(Utils::WString(L"UpdateTime: ") + (long)m_iLastUpdated);
	if ( m_iFakePatch != -1 )
		lines.pushBack(Utils::WString(L"FakePatch: ") + (long)m_iFakePatch);
	if ( m_iSaveGame != -1 )
		lines.pushBack(Utils::WString(L"SaveGame: ") + (long)m_iSaveGame);
	lines.pushBack(Utils::WString(L"SaveGameManager: ") + (long)m_iSaveGameManager);
	if ( !m_bVanilla )
		lines.pushBack(L"Modified");
	if ( m_bUsedWare )
		lines.pushBack(L"UsedWare");
	if ( m_bSurpressProtectedWarning )
		lines.pushBack(L"SurpressProtectedWarning");
	if ( !m_sSetMod.empty() )
		lines.pushBack(L"SetMod: " + m_sSetMod);
	if (!_sSaveDir.empty())
		lines.pushBack(L"SaveDir: " + _sSaveDir);
	lines.pushBack(L"ShipBuffer: " + (long)m_iShipBuffer);
	Utils::WString wareBuffer = L"WareBuffers:";
	for ( int i = 0; i < WAREBUFFERS; i++ )
		wareBuffer += Utils::WString(L" ") + (long)m_iWareBuffer[i];
	lines.pushBack(wareBuffer);
	for ( int i = 0; i < WAREBUFFERS; i++ )
	{
		if ( !m_lGameWares[i].size() )
			continue;
		lines.pushBack(Utils::WString(L"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(Utils::WString((long)gm->iPos) + L" " + (long)gm->iType + L" " + Utils::WString((char)gm->cType) + L" " + gm->sWareName);
		}
	}
 
	for(auto itr = _lNonRemovedFiles.begin(); itr != _lNonRemovedFiles.end(); itr++)
		lines.pushBack(L"NonRemovedFile: " + (*itr)->str);
 
	if ( m_lGameShips.size() )
	{
		lines.pushBack(Utils::String(L"Ships: ") + (long)m_lGameShips.size());
 
		for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
		{
			SGameShip *gm = node->Data();
			lines.pushBack(Utils::WString((long)gm->iType) + L" $#C:" + gm->sShipClass + L" " + gm->sShipID);
		}
	}
 
	// write created Files
	if ( !_lCreatedFiles.empty() )
	{
		for(auto itr = _lCreatedFiles.begin(); itr != _lCreatedFiles.end(); itr++)
			lines.pushBack(L"CreatedFile: " + (*itr)->str.findRemove(m_sCurrentDir));
	}
 
	// write uninstall files
	if ( !m_lUninstallFiles.empty() )
	{
		for ( CListNode<C_File> *node = m_lUninstallFiles.Front(); node; node = node->next() )
		{
			C_File *uf = node->Data();
			Utils::WString uString = L"Uninstall: ";
			uString += Utils::WString::Number((long)uf->GetCreationTime()) + L" ";
			uString += uf->filename();
			lines.pushBack(uString);
		}
	}
 
	// write the original file data
	_pOriginalFiles->writeData(lines);
 
	// write the global changes
	if ( !_lGlobals.empty() )
	{
		for(auto itr = _lGlobals.begin(); itr != _lGlobals.end(); itr++)
			lines.pushBack(L"GlobalSetting: " + (*itr)->str + L":" + (*itr)->data.findRemove(L";"));
	}
 
	// write the fake patch ordering
	if ( !_lFakePatchOrder.empty() )
	{
		for(auto itr = _lFakePatchOrder.begin(); itr != _lFakePatchOrder.end(); itr++)
			lines.pushBack(L"FakePatchOrder: " + (*itr)->str + L":" + (*itr)->data);
	}
 
	for(CListNode<SWarePriceOverride> *node = m_lWarePrices.Front(); node; node = node->next()) {
		SWarePriceOverride *ware = node->Data();
		switch(ware->type) {
			case Ware_EMP:
				lines.pushBack(Utils::WString(L"EMPPriceOverride:") + (long)ware->pos + L" " + (long)ware->relval);
				if ( ware->bNotority )
					lines.pushBack(Utils::WString(L"EMPNotoOverride:") + (long)ware->pos + L" " + (long)ware->notority);
				break;
			case Ware_Custom:
				lines.pushBack(Utils::WString(L"CustomWarePriceOverride:") + ware->id + L";" + (long)ware->relval);
				if ( ware->bNotority )
					lines.pushBack(Utils::WString(L"CustomWareNotoOverride:") + ware->id + L";" + (long)ware->notority);
				break;
			case Ware_BuiltIn:
				lines.pushBack(Utils::WString(L"BuiltInWarePriceOverride:") + (long)ware->pos + L" " + (long)ware->relval);
				if ( ware->bNotority )
					lines.pushBack(Utils::WString(L"BuiltInWareNotoOverride:") + (long)ware->pos + L" " + (long)ware->notority);
				break;
		}
	}
 
	// write the global file list
	lines.pushBack(L"GlobalFiles:");
	int num = 0;
	for ( CListNode<C_File> *fn = m_lFiles.Front(); fn; fn = fn->next() )
	{
		C_File *f = fn->Data();
		f->SetPos(num++);
 
		Utils::WString line = Utils::WString::Number(f->GetFileType()) + L":" + Utils::WString::Number((long)f->GetCreationTime()) + L":" + f->dir() + L":";
		if ( f->IsShared() && !f->IsFakePatch() )
			line += L"1:";
		else
			line += L"0:";
 
		Utils::WString filename = f->filePointer().findRemove(m_sCurrentDir);
 
		if ( f->IsDisabled() )
			line += L"D#";
 
		line += L"G#";
		line += (long)f->GetGame();
		line += L"#";
 
		line += filename;
 
		if ( !f->originalName().empty() )
		{
			line += L"O#";
			line += f->originalName();
		}
 
		lines.pushBack(line);
	}

	for ( CListNode<CBaseFile> *pn = m_lPackages.Front(); pn; pn = pn->next() )
	{
		CBaseFile *package = pn->Data();
 
		if ( package->GetType() == TYPE_SPK )
			lines.pushBack(L"<script>");
		else if ( package->GetType() == TYPE_XSP )
			lines.pushBack(L"<ship>");
		else if ( package->GetType() == TYPE_ARCHIVE )
			lines.pushBack(L"<archive>");
		else if ( package->GetType() == TYPE_BASE )
			lines.pushBack(L"<base>");
		else
			continue;
 
		if ( !package->filename().empty() )
			lines.pushBack(L"Installspk: " + package->filename());
 
		Utils::WString valuesline = package->createValuesLine();
		if ( valuesline.back() == '\n')
			valuesline.truncate((int)valuesline.length() - 1);
		lines.pushBack(valuesline);
 
		if ( !package->IsEnabled() )
			lines.pushBack(L"Disabled");
		if ( !package->IsModifiedEnabled() )
			lines.pushBack(L"ModifiedDisabled");
 
		if (package->icon())
			lines.pushBack(L"Icon: " + package->iconExt() + L" " + package->icon()->filePointer() );
 
		Utils::WString fileline(L"Files:");
		for ( CListNode<C_File> *fn = package->GetFileList()->Front(); fn; fn = fn->next() )
		{
			C_File *f = fn->Data();
			fileline += L" ";
			fileline += Utils::WString::Number(f->GetPos());
		}
		lines.pushBack(fileline);
	}
 
	lines.pushBack(L"</scripts>");
 
	CFileIO datFile(m_sCurrentDir + L"/PluginManager/PluginManager.new");
 
	CDirIO Dir(m_sCurrentDir);
	if ( !Dir.exists(L"PluginManager") ) {
		CLog::log(CLog::Log_IO, 2, L"Creating PluginManager directory");
 		Dir.create(L"PluginManager");
	}
 
	CLog::log(CLog::Log_IO, 2, L"Writing data file: " + m_sCurrentDir + L"/PluginManager/PluginManager.new");
	if ( !datFile.writeFile(&lines) )
 
		CLog::log(CLog::Log_IO, 1, L"ERROR: Failed to write data file");
 
	else {
		CLog::log(CLog::Log_IO, 2, L"Removing old data file: " + m_sCurrentDir + L"/PluginManager/PluginManager.dat");
		if ( !CFileIO::Exists(m_sCurrentDir + L"/PluginManager/PluginManager.dat") || CFileIO::Remove(m_sCurrentDir + L"/PluginManager/PluginManager.dat") ) {
			CLog::log(CLog::Log_IO, 2, L"Renaming data file: PluginManager.new => PluginManager.dat");
			datFile.Rename(m_sCurrentDir + L"/PluginManager/PluginManager.dat");
		}
	}
}
 
 
/**
 * Get All Files
 *
 * Gets a list of all files, includes any child package files
 */
int CPackages::GetAllPackageFiles(CBaseFile *package, CLinkList<C_File> *fileList, bool includeChild)
{
	for ( CListNode<C_File> *node = package->GetFileList()->Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		if ( !fileList->FindData(f) )
			fileList->push_back(f);
	}
 
	if ( includeChild )
	{
		CLinkList<CBaseFile> childList;
		if ( this->GetChildPackages(package, &childList) )
		{
			for ( CBaseFile *child = childList.First(); child; child = childList.Next() )
				this->GetAllPackageFiles(child, fileList, includeChild);
		}
	}
 
	// disablign for vanilla, make sure we add all files
	if ( m_bDisableVanilla )
	{
		for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
		{
			C_File *f = node->Data();
			if ( !fileList->FindData(f) )
				fileList->push_back(f);
		}
	}
 
	return fileList->size();
}
 
int CPackages::GetAllPackageFiles(CLinkList<CBaseFile> *list, CLinkList<C_File> *fileList, bool includeChild)
{
	for ( CListNode<CBaseFile> *node = list->Front(); node; node = node->next() )
		this->GetAllPackageFiles(node->Data(), fileList, includeChild);

 * Add Log
 *
 * Adds a log entry to displayed at end
 */
 
void CPackages::addLogEntry(int type, const Utils::WString &args, Utils::WStringList *errors)
{
	if (!errors)
		return;
 
	errors->pushBack(args, ERRORLOG(type));

 * param: errors		- The string list for all the status for debugging, ie has an entry for whats happened to every 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, Utils::WStringList *errors, CProgressInfo *progress )
{
	ClearError();
 
	// if already enabled, just skip
	if ( package->IsEnabled() )

	if ( this->PrepareEnablePackage(package) )
		return this->enablePreparedPackages(errors, progress);
 
	return false;
}
bool CPackages::enablePreparedPackages(Utils::WStringList *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;
	// we use this list to match cat and dat files
	Utils::WStringList fakePatches;
	for ( CListNode<C_File> *node = fileList.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		if (!f->isForGame(m_iGame))
			continue;
		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::WString newFilename = f->getNameDirectory(package);
 
		// fake patches need to be renamed
		if ( f->IsFakePatch() )
		{
			// first check if the matching file has been done already
			if (fakePatches.contains(f->baseName()))
				newFilename = fakePatches.findString(f->baseName()) + L"." + f->fileExt();
			// we need to find the next available number instead
			else
			{
				Utils::WString newPos = Utils::WString::PadNumber(findNextFakePatch(), 2);
				newFilename = newPos + L"." + f->fileExt();
				// and wee need to push this onto the string list so we can adjust the matchign pair
				fakePatches.pushBack(f->baseName(), newPos);
			}
		}
 
		// lets actually move the file back now
		// !!error checking!!
		CFileIO currentFile(f->filePointer());
		CFileIO newFile(m_sCurrentDir + L"/" + newFilename);
		if ( !currentFile.exists() )
		{
			// missing file ??
			if ( !newFile.exists() )
			{
				this->addLogEntry(SPKINSTALL_MISSINGFILE, newFilename.toString(), errors);
				continue;
			}
		}
		// remove existing file
		// file exists, so lets try to move it
		else
		{
			if ( newFile.exists() )
				newFile.remove();
 
			if ( !currentFile.Rename(newFile.fullFilename()) )
			{
				this->addLogEntry(SPKINSTALL_ENABLEFILE_FAIL, newFilename.toString(), errors);
				continue;
			}
		}
 
		this->addLogEntry(SPKINSTALL_ENABLEFILE, newFilename.toString(), errors);
 
		// adjust the internal name to match the new filename
		f->setFilename((m_sCurrentDir + L"/" + newFilename).toString());
		// no longer disabled, we need to remove the flag
		f->SetDisabled(false);
	}
 
	// recursive, auto enable all children

	// disabled the mod
	if ( oldMod && oldMod != m_pEnabledMod && !m_bForceModInstall )
		this->disablePackage(oldMod, errors, progress);
 
	// lets remove all the directories we might have left empty
	Utils::WStringList removeDirs;
	removeDirs.pushBack(L"PluginManager/Disabled");
	removeUnusedDirectories(removeDirs, errors);
 
	m_lEnableList.clear();
 
	this->WriteData();
 
	return true;
}
 
 
bool CPackages::disablePreparedPackages(Utils::WStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *disabledPackages )
{
	if ( progress )
		progress->UpdateStatus(PROGRESS_DISABLEFILE);
 
	UpdateUsedFiles(&m_lDisableList, false);
 
	// checks if there are any original files to restore and if any fake patches were disabled to reshuffle
	bool original = false, shuffle = false;
 
	// holds our list of directories that we might need to remove, only empty ones from this list will actually be removed
	Utils::WStringList removeDirs;
 
	// get all files, including children
	CLinkList<C_File> fileList;
	int maxFiles = this->GetAllPackageFiles(&m_lDisableList, &fileList, true);
 

			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;
 
		// readmes, uninstall and extra files dont need to be disabled
		// Extra files not in the "Extras" directory could be anywhere, so these should be disabled incase they are game changing files, ie in "types"
		if ( f->GetFileType() == FILETYPE_README || f->GetFileType() == FILETYPE_UNINSTALL || (f->GetFileType() == FILETYPE_EXTRA && f->dir().left(5).lower() == "Extra") )
			continue;

		// check if there is a matching uninstall file, ie there the script file is also an uninstall script file for a previously uninstalled package that has yet to be removed
		if ( f->GetFileType() == FILETYPE_SCRIPT )
		{
			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;

			if ( found )
				continue;
		}
 
		if ( f->GetFileType() == FILETYPE_MOD && !f->IsFakePatch() && f->checkFileExt("cat") )
		{
			if ( f->baseName().Compare(m_sSetMod.toString()) )
				m_sSetMod = Utils::WString::Null();
		}
 
		// file is not being used by any enabled package
		// set disabled and move to disabled directory
		CDirIO Dir(m_sCurrentDir);
		Utils::WString newFilename = L"PluginManager/Disabled/";
 
		// fake patches have thier own special directory
		if ( f->IsFakePatch() )
			newFilename += L"FakePatches";
		// otherwise we put them in thier usual directory structure inside the disabled dir
		else
			newFilename += f->getDirectory(NULL);
 
		// make sure the directory exists so we can move the file

		// 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 = m_sCurrentDir + L&quot;/PluginManager/Disabled/FakePatches/FakePatch_&quot; + checkPackage-&gt;getNameValidFile() + L"_" + checkPackage->author().toWString() + L"_" + f->name();
				shuffle = true;
			}
		}
		else if ( f->isAutoTextFile() )
		{
			if ( checkPackage )
			{
				newFilename = m_sCurrentDir + L&quot;/PluginManager/Disabled/TextFiles/Text_&quot; + checkPackage-&gt;getNameValidFile() + L"_" + checkPackage->author().toWString() + L"_" + f->name();
				shuffle = true;
			}
		}
		// otherwise we can just use the standard filename
		else
			newFilename = m_sCurrentDir + L"/PluginManager/Disabled/" + f->getNameDirectory(checkPackage);
 
		// 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->filePointer());

			if(!removeDirs.contains(f->getDirectory(checkPackage)))
				removeDirs.pushBack(f->getDirectory(checkPackage));
		}
 
		// change the filename
		f->setFilename(newFilename.toString());
 
		// finally mark the file as disabled so we know not to try to move it again
		f->SetDisabled(true);
	}
 
	// a fake patch has been disabled, we need to reshuffle the rest to fill in any gaps
	if ( shuffle )
	{
		if ( progress )

		shuffleTextFiles(errors);
	}
 
	// original files were restored, check to remove the original file directory if its now empty
	if ( original )
		removeDirs.pushBack(L"PluginManager/Original");
 
	// remove any empty directories that we might have left
	if ( !removeDirs.empty() )
		removeUnusedDirectories(removeDirs, errors);
 

			disabledPackages->push_back(child);
	}
 
	// disabling has completed successfully, we hope
	m_bDisableVanilla = false;
	m_lDisableList.clear();
 
	this->WriteData();
 
	return true;
}
 

 * param: errors	- A string list used to add the status as it progresses, used in debugging output
 * param: progress	- The progress class, updates the progress of the current disabling.  Needs a divered class to report the progress somewhere
 *
 * return: boolean, true if there was no errors, otherwise false
 */
bool CPackages::disablePackage(CBaseFile *package, Utils::WStringList *errors, CProgressInfo *progress )
{
	// if already disabled, just skip
	if ( !package->IsEnabled() )
		return true;
 

 * Find a File
 *
 * Searches for a file matching the filetype and filename
 * Optional dir is used for extras files
 */
C_File *CPackages::findFile(FileType filetype, const Utils::WString &filename, const Utils::WString &dir) const
{
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		if ( f->GetFileType() != filetype )

			continue;
 
		// now compare the name and author, "Compare" is a non case senseative check, opposed to ==.
		if ( file->name().Compare(name) )
			return (CArchiveFile *)file;
	}
 
	// nothing found
	return 0;
}
 
/**

 
	// nothing found
	return 0;
}
 
CBaseFile* CPackages::findPackage(const Utils::WString &name, const Utils::WString &author) const
{
	// interate through all packages
	for (CListNode<CBaseFile>* node = m_lPackages.Front(); node; node = node->next())
	{
		CBaseFile* file = node->Data();
 
		// now compare the name and author, "Compare" is a non case senseative check, opposed to ==.
		if (file->name().toWString().Compare(name) &;& file->author().toWString().Compare(author))
			return file;
	}
 
	// nothing found
	return 0;

}
 
/**
 * Removes all empty directories that might have been created
 */
void CPackages::removeUnusedDirectories(const Utils::WStringList& dirs, Utils::WStringList* errors)
{
	CDirIO Dir(m_sCurrentDir);
	for(auto itr = dirs.begin(); itr != dirs.end(); itr++)
	{
		Utils::WString dir = (*itr)->str;
 
		Utils::WStringList removedDir;
		if (Dir.removeDir(dir, false, true, &removedDir) || !removedDir.empty())
		{
			for(auto rItr = removedDir.begin(); rItr != removedDir.end(); rItr++)
			{
				Utils::WString displayName = (*rItr)->str;
				displayName = displayName.findRemove(m_sCurrentDir);
				this->addLogEntry(SPKINSTALL_REMOVEDIR, displayName, errors);
			}
		}
	}

	{
		if ( package->AnyGameCompatability() )
		{
			if ( (check & IC_WRONGGAME) && (!package->CheckGameCompatability(m_iGame)) )
				return INSTALLCHECK_WRONGGAME;
			else if ( (check & IC_WRONGVERSION) && (!package->checkGameVersionCompatability(m_iGame, _sGameVersion, m_iGameVersion)) )
				return INSTALLCHECK_WRONGVERSION;
		}
	}
 
	// check for modified

		// now check version
		if (version.compareVersion(p->version()) == COMPARE_OLDER)
			return false;
 
		if ( onlyEnabled && !p->IsEnabled() )
			return false;
 
		return true;
	}
 
	// now check the prepared list
	if ( includePrepared )
	{
		for ( CListNode<CBaseFile> *node = m_lInstallList.Front(); node; node = node->next() )

			p = node->Data();
			if ( !p )
				continue;
 
			if ( p->name().Compare(name) && p->author().Compare(author) )
			{
				if (version.compareVersion(p->version()) == COMPARE_OLDER)
					continue;
 
				if ( onlyEnabled && !p->IsEnabled() )
					continue;

			{
				bool found = false;
				for (auto itr = packages.Front(); itr; itr = itr->next())
				{
					if (itr->Data()->name().Compare(nl->sName) && itr->Data()->author().Compare(nl->sAuthor) && nl->sMinVersion.compareVersion(itr->Data()->version()) >= 0)
					{
						if (!findAllNeededDependacies(itr->Data(), packages, foundPackages, onlyEnabled, includePrepared))
							return false;
						if (foundPackages)
						{
							bool added = false;
							for (auto itr2 = foundPackages->Front(); itr2; itr2 = itr2->next())
							{

									added = true;
									break;
								}
							}
							if(!added)
								foundPackages->push_front(itr->Data());
						}
						found = true;
						break;
					}
				}
				if (!found)
					return false;
			}

		CSpkFile *spk = (CSpkFile *)p;
		if (spk->isAnotherMod())
		{
			bool found = true;
			if (!this->findSpkPackage(spk->otherName(), spk->otherAuthor()))
			{
				if (includePrepared)
				{
					found = false;
					for (CListNode<CBaseFile> *pNode = m_lInstallList.Front(); pNode; pNode = pNode->next())
					{

							break;
						}
					}
				}
				else
					found = false;
			}
 
			if (!found)
			{
				for (auto itr = packages.Front(); itr; itr = itr->next())

					}
				}
 
				if(!found)
					return false;
			}
		}
	}
 
	return true;
 
}
 
size_t CPackages::getDownloadableDependacies(CBaseFile* p, std::vector<const SAvailablePackage*>& list, bool onlyEnabled, bool includePrepared) const
{
	size_t count = 0;
	CLinkList<SNeededLibrary>* neededList = p->GetNeededLibraries();

		{
			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))
			{
				const SAvailablePackage *available = findAvailablePackage((nl->sName.Compare("<package>")) ? p->name() : nl->sName, (nl->sAuthor.Compare("<author>")) ? p->author() : nl->sAuthor);
				if (available)
					list.push_back(available);
				++count;
			}
		}
	}
 
	if (p->GetType() == TYPE_SPK)

int CPackages::GetMissingDependacies(CBaseFile *p, Utils::CStringList *list, bool onlyEnabled, bool includePrepared)
{
	int count = 0;
	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) )
			{

		bool missingDep = false;
		if ( !this->CheckOtherPackage(p) )
			missingDep = true;
		else if ( this->GetMissingDependacies(p, NULL, false, true) )
			missingDep = true;
 
		if ( missingDep )
		{
			if ( list )
			{
				node->ChangeData(NULL);

/**
 * Remove uninstall file
 *
 * Removes a single uninstall file
 */
bool CPackages::removeUninstallFile(C_File *file, Utils::WStringList *errors)
{
	CFileIO fio(file->filePointer());
	if ( fio.exists() )
	{
		if ( fio.remove() ) {

 * Remove uninstall scripts
 *
 * Removes any unused unisntall scripts
 * Finds if any scripts are in the current package
 */
int CPackages::removeUninstallScripts(Utils::WStringList *errors, CProgressInfo *progress)
{
	if ( m_lUninstallFiles.empty() )
		return 0;
 
	UpdateUsedFiles();

/**
 * Remove unused shared file
 *
 * Removes a single file
 */
bool CPackages::removeSharedFile(C_File *file, Utils::WStringList *errors)
{
	CFileIO fio(file->filePointer());
	if ( fio.exists() )
	{
		if ( fio.remove() ) {

 * Files that have been marked as shared will not be removed or disabled when the last package is removed
 * This function will remove any that are no longer connected with packages
 *
 * Marked shared fiels are mainly used for library scripts that arn't always added to packages
 */
int CPackages::removeUnusedSharedFiles(Utils::WStringList *errors, CProgressInfo *progress)
{
	UpdateUsedFiles();
	int files = 0;
	int done = 0;
 

 
	return false;
 
}
 
void CPackages::shuffleTextFiles(Utils::WStringList *errors)
{
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		// only do files that are enabled

		int current = findNextTextFile();
		if ( current < f->textFileID() )
		{
			CFileIO moveFile(f->filePointer());
	
			Utils::WString newName = SPK::FormatTextName(current, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT)) + L"." + moveFile.extension();
			if ( moveFile.Rename(m_sCurrentDir + L"/t/" + newName) )
			{
				this->addLogEntry(SPKINSTALL_AUTOTEXT, f->name() + L"~" + newName, errors);
				f->setName(newName.toString());
			}
			else
				this->addLogEntry(SPKINSTALL_AUTOTEXT_FAIL, f->name() + L"~" + newName, errors);
		}
	}
}
 
/**

 *
 * Rename the fake patches so they are always in sequence to be loaded into the game
 *
 * IE, when one is removed, the rest need to be shuffled down so theres no gaps
 */
void CPackages::shuffleFakePatches(Utils::WStringList *errors)
{
	int check = findNextFakePatch();
 
	// lets make sure our order is correct
	// find Lowest Fake Patch Installed

		if (spk)
		{
			if (spk->IsAnotherMod())
			{
				auto package = findPackage(spk->otherName(), spk->otherAuthor());
				if (package)
				{
					packagesBefore.insert(package);
					packagesAfter[p].insert(package);
				}
			}
		}
 
		if (!p->getFakePatchBeforeOrder().empty())

				}
			}
		}
	}
 
	auto addOrderedList = [](const std::vector<CBaseFile*>& addList, const Utils::WStringList& orderList, std::vector<CBaseFile*>& addTo, const CPackages *packages)
	{
		// add all the items in the ordered list first
		for (auto itr = orderList.begin(); itr != orderList.end(); itr++)
		{
			auto p = packages->findPackage((*itr)->str, (*itr)->data);

		{
			for (auto itr = packagesBefore.begin(); itr != packagesBefore.end(); itr++)
				packagesOrder.push_back(*itr);
		}
 
		addOrderedList(packagesOrder, _lFakePatchOrder, order, this);
		removeList(packagesOrder, packagesBefore);
	}
 
	// now add the remaining list ordered list
	for (auto itr = _lFakePatchOrder.begin(); itr != _lFakePatchOrder.end(); itr++)
	{
		auto p = findPackage((*itr)->str, (*itr)->data);
		if (p)
		{
			auto findItr = std::find(order.begin(), order.end(), p);

			{
				C_File *lowestFile = NULL;
				for ( C_File *file = package->GetFirstFile(FILETYPE_MOD); file; file = package->GetNextFile(file) )
				{
					if (!file->IsFakePatch()) continue;
					if (!file->checkFileExt(L"cat")) continue; // only do the cat file, we can shuffle the dat file to match later
					if (doneList.FindData(file)) continue; // already done?
 
					if ( !lowestFile )
						lowestFile = file;
					else

 
				// 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::WString nextName = Utils::WString::PadNumber(lowest, 2);
					if ( CFileIO::Exists(m_sCurrentDir + L"/" + nextName + L".cat") )
					{
						// find the file in our internal file list
						C_File *moveFile = findFile(FILETYPE_MOD, nextName + L".cat");
						if ( !moveFile ) // must not have it in our list ? lets move to the next
						{
							lowest++;
							continue;
						}

		if (!f->checkFileExt("cat"))
			continue;
 
		// now lets check if its greater than our gap
		int check = findNextFakePatch();
		int patchNum = f->filename().token(L".", 1).toInt();
		if ( patchNum <= check )
			continue;
 
		shufflePatchTo(f, check, errors);
	}
}
 
void CPackages::shufflePatchTo(C_File *file, int to, Utils::WStringList *errors)
{
	// it is, we need to shift this to fill the gap
	Utils::WString newName = Utils::WString::PadNumber(to, 2) + L"." + file->fileExt();
 
	// now rename the file
	CFileIO moveFile(file->filePointer());
	if ( moveFile.Rename(m_sCurrentDir + L"/" + newName) )
	{
		// display moveing
		this->addLogEntry(SPKINSTALL_FAKEPATCH, file->name() + L"~" + 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->baseName() != file->baseName() )
				continue;
 
			Utils::WString newName2 = Utils::WString::PadNumber(to, 2) + L"." + f2->fileExt();
			CFileIO moveFile(f2->filePointer());
			if ( moveFile.Rename(m_sCurrentDir + L"/" + newName2) )
			{
				this->addLogEntry(SPKINSTALL_FAKEPATCH, f2->name() + L"~" + newName2, errors);
				f2->setName(newName2.toString());
			}
			else
				this->addLogEntry(SPKINSTALL_FAKEPATCH_FAIL, f2->name() + L"~" + newName2, errors);
		}
 
		// finally make sure the internal name matches the new one
		file->setName(newName.toString());
	}
	else
		this->addLogEntry(SPKINSTALL_FAKEPATCH_FAIL, file->name() + L"~" + newName, errors);
}
 
int CPackages::FindLowestFakePatchInstalled()
{
	int lowest = 99;

 
		// now get all fake patches
		for ( C_File *file = p->GetFirstFile(FILETYPE_MOD); file; file = p->GetNextFile(file) )
		{
			if (!file->IsFakePatch()) continue;
			if (file->checkFileExt(L"dat")) continue;
			int check = file->baseName().toInt();
			if ( check < lowest )
				lowest = check;
		}
	}
 
	return lowest;
}
 
int CPackages::findLastFakePatch(int start, const Utils::WString &dir) const
{
	CDirIO Dir((dir.empty()) ? m_sCurrentDir : dir);
 
	int check = start;
	while ( check > 0 )
	{
		Utils::WString checkStr = Utils::String::PadNumber(check, 2);
 
		// check if a cat file exists
		if ( !Dir.exists(checkStr + L".cat") )
		{
			// it doen't, check if theres a dat file (incase of package error)
			if ( !Dir.exists(checkStr + L".dat") )
				break;
		}
		--check;
	}
 
	return check;
}
 
/**
 * Find next fake patch
 *
 * Searching for the next gap in patches, starting with 01.cat to 99.cat
 */
int CPackages::findNextFakePatch(int start, const Utils::WString &dir) const
{
	CDirIO Dir((dir.empty()) ? m_sCurrentDir : dir);
 
	int check = start;
	while ( check < 99 )
	{
		++check;
		Utils::WString checkStr = Utils::WString::PadNumber(check, 2);
 
		// check if a cat file exists
		if ( !Dir.exists(checkStr + L".cat") )
		{
			// it doen't, check if theres a dat file (incase of package error)
			if ( !Dir.exists(checkStr + L".dat") )
				break;
		}
	}
 
	return check;

 * Searching for the next gap in automatic text files, start with 0004-LXXX or XX0004
 */
unsigned int CPackages::findNextTextFile(unsigned int start) const
{
	return findNextTextFile(Utils::String::Null(), start);
}
unsigned int CPackages::findNextTextFile(const Utils::WString &dir, unsigned int start) const
{
	int check = start;
	if ( check < 2 ) check = 2;
	while ( check < 9999 )
	{
		++check;
		Utils::WString newFilename = SPK::FormatTextName(check, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT));
 
		// check the vfs
		if ( m_pGameVFS.isFileAvailable(L"t/" + newFilename + L".pck") ) continue;
		if ( m_pGameVFS.isFileAvailable(L"t/" + newFilename + L".xml") ) continue;
 
		break;
	}
 
	return check;
}
 
int CPackages::findLastTextFile(int start, const Utils::WString& dir) const
{
	CDirIO Dir((dir.empty()) ? m_sCurrentDir : dir);
	Dir.cd(L"t");
 
	int check = start;
	while ( check < 9999 )
	{
		++check;
		Utils::WString newFilename = SPK::FormatTextName(check, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT));
 
		// check if a packed file exists
		if ( !Dir.exists(newFilename + L".pck") )
		{
			// it doen't, check if theres an unpacked file
			if ( !Dir.exists(newFilename + L".xml") )
				break;
		}
	}
 
	return check;
}
 
/**
 * Read game language
 *
 * Reads the lang.dat file from the game directory for the language id

/**
 * Create Language Text File
 *
 * Creates text files for all packages into the correct language
 */
void CPackages::CreateLanguageTextFiles(Utils::WStringList *errors)
{
	// no need to create them if theres no language to use
	if ( !m_iLanguage )
		return;
 
	// find all text files
	Utils::WStringList ids;
 
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		// only do text fiels
		if ( f->GetFileType() != FILETYPE_TEXT )
			continue;
 
		Utils::WString id, lang;
		if ( m_iGameFlags & EXEFLAG_TCTEXT )
		{
			id = f->baseName().token(L"-", 1);
			lang = f->baseName().token(L"-", 2);
			if ( lang.empty() )
				lang = L"NULL";
			else
				lang = lang.erase(0, 1);  // remove the "L"
		}
		else
		{
			lang = Utils::WString::PadNumber(f->baseName().left((int)f->baseName().length() - 4), 3);
			id = f->baseName().mid(((int)f->baseName().length() - 4) + 1, 4);
		}
 
 
		// not added, add a new one
		if (!ids.contains(id))
			ids.pushBack(id, lang);
		else
		{
			Utils::WString data = ids.findString(id);
			if (data.empty())
				data = lang;
			else
			{
				data += L":";
				data += lang;
			}
			ids.changeData(id, data);
		}
	}
 
	// we should now have a list of all text files, we need to remove those that have a matching language
	for(auto itr = ids.begin(); itr != ids.end(); itr++)
	{
		int size = 0;
		std::vector<Utils::WString> data;
		if(!(*itr)-&gt;data.tokenise(L":", data))			
 
			continue; // huh ? we shouldn't have this
 
 
 
		// lets search for a matching id
		int useId = 0;
		bool found = false;
		for ( int i = 0; i < size; i++ )
		{
			if ( data[i] == L"NULL" )
				useId = -1;
			else
			{
				int num = data[i].toInt();
				if ( num == m_iLanguage )

					useId = num;
			}
		}
 
		if (found)
 
 
			continue;
 
 
		if ( !useId )
			useId = data[0].toInt();
		if ( !useId )
			useId = -1;
 
 
		renameTextFile((*itr)->str, useId, errors);
	}
}
 
/**
 * Rename a text file
 *
 * Creates a new text file for the selected langage by copying an existing one
 */
bool CPackages::renameTextFile(const Utils::WString &textid, int languageid, Utils::WStringList *errors)
{
	// lets check if the file already exists
	Utils::WString newFilename = SPK::FormatTextName(textid.toInt(), m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT));
	C_File *addFile = findFile(FILETYPE_TEXT, newFilename + L".xml");
	if ( !addFile )
		addFile = findFile(FILETYPE_TEXT, newFilename + L".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::WString filename;
	if ( languageid != -1 )
		filename = SPK::FormatTextName(textid.toInt(), languageid, (m_iGameFlags & EXEFLAG_TCTEXT));
	else
		filename = textid;
 
	C_File *textFile = findFile(FILETYPE_TEXT, filename + L".xml");
	if ( !textFile )
	{
		textFile = findFile(FILETYPE_TEXT, filename + L".pck");
		if ( !textFile )
			return false;
	}
 
	// now lets create out new text file
	CFileIO readFile(textFile->filePointer());
 
	std::vector<Utils::WString> lines;
	readFile.readLines(lines);
 
	// find the language id in the lines
	std::vector<Utils::WString> frontLines;
	for(std::vector<Utils::WString>::iterator it = lines.begin(); it != lines.end(); ++it)
	{
		Utils::WString line = *it;
		int pos = line.findPos(L"<language id");
		if ( pos != -1)
		{
			Utils::WString newLine = L"<language id=\"";
			newLine += Utils::WString::Number(m_iLanguage);
			newLine += L"\">";
			newLine += line.tokens(L">", 2);
 
			frontLines.insert(frontLines.begin(), newLine);
 
			lines.erase(lines.begin(), ++it);
			break;
		}
		frontLines.insert(frontLines.begin(), line);
	}
 
	for(std::vector<Utils::WString>::iterator it = frontLines.begin(); it != frontLines.end(); ++it)
		lines.insert(lines.begin(), *it);
 
	addFile = new C_File(newFilename + ".xml");
	addFile->setFileType(FILETYPE_TEXT);
 
	CFileIO writeFile(m_sCurrentDir + L"/" + addFile->getNameDirectory(NULL));
	if ( writeFile.writeFile(lines) )
	{
		this->addLogEntry(SPKINSTALL_WRITEFILE, addFile->getNameDirectory(NULL), errors);
 
		addFile->setFilename(m_sCurrentDir + L"/" + 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);
 
 
		return false;
	}
 
 
 
 
 
	return true;
}
 
/**
 * Add file to scripts
 *
 * Adds a file to all scripts that need it
 */
void CPackages::addTextFileToScripts(C_File *file, const Utils::WString &textid)
{
	// now we need to find all scripts that have a matching file and add this to the list
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
	{
		CBaseFile *package = node->Data();

		{
			C_File *tFile = fNode->Data();
			if ( tFile->GetFileType() != FILETYPE_TEXT )
				continue;
 
			Utils::WString id = tFile->baseName().token(L"-", 1);
			if ( id == textid )
			{
				found = true;
				break;
			}

		if ( found )
			package->GetFileList()->push_back(file);
	}
}
 
bool CPackages::removeFile(C_File *file, Utils::WStringList *errors)
{
	if ( !file )
		return true;
 
	Utils::WString remFileStr = file->filePointer().findReplace(m_sCurrentDir, L"");
 
 
	if ( file->filePointer().contains(L"::")) {
		CFileIO CatFile(file->filePointer().token(L"::", 1));
		if ( CatFile.exists() ) {
			CCatFile cat;
			if ( cat.open(CatFile.fullFilenameStr(), this->getAddonDir(), CATREAD_DAT, false) == CATERR_NONE) {
				Utils::WString fileName = file->filePointer().token(L"::", 2);
				if ( cat.findData(fileName) ) {
					if ( cat.removeFile(fileName) ) {
						this->addLogEntry(SPKINSTALL_DELETEFILE, remFileStr, errors);
					}
					else {

	}
 
	return true;
}
 
int CPackages::removeAllPackages(Utils::WStringList *errors, CProgressInfo *progress)
{
	int files = 0;
 
	// remove all files
	int max = m_lFiles.size() + _pOriginalFiles->count() + m_lUninstallFiles.size();

		return Dir.file(L"../Data/" + file);
 
	return Utils::WString::Null();
}
 
void CPackages::startup(const Utils::WString &dir, const Utils::WString &tempDir, const Utils::WString &myDoc)
{
	this->setTempDirectory(tempDir);
	this->setMyDocuments(myDoc);
 
	// need to read the game exe versions

 
	Utils::WString exeFile = this->findDataDir(dir, L"exe");
 
	// if file exists, read it, otherwise, just add
	if (!exeFile.empty() && CFileIO::Exists(exeFile))
		m_gameExe.readFile(exeFile);
	else
	{
		m_gameExe.parseExe(L"x2.exe|0:5:NOSAVESUBDIR:HKCU/Software/EgoSoftware/X2/ModName:X2 The Threat:!GAMEDIR!:2:1604608!2150400:1.4 Artifical Life:1974272:1.5 Uplink");
		m_gameExe.parseExe(L"x3.exe|30:5:0:HKCU/Software/Egosoft/X3/ModName:X3 Reunion:Egosoft/X3:2:2347008:2.0 Bala Gi:2367488!2375680:2.5 Uplink");
		m_gameExe.parseExe(L"x3tc.exe|35:5:NO_XOR|TC_TEXT|MYDOCLOG:HKCU/Software/Egosoft/X3TC/ModName:X3 Terran Conflict:Egosoft/X3TC:3:1933464!1933520:2.0 Aldrin Expansion:-1:2.5 A New Home (Superbox):-1:3.0 Balance of Power");
		m_gameExe.parseExe(L"x3ap.exe|38:2:NO_XOR|TC_TEXT|MYDOCLOG|ADDON:HKCU/Software/Egosoft/X3AP/ModName:X3 Albion Prelude:Egosoft/X3AP:addon!x3tc.exe:3:-1:2.0 The War Continues:-1:2.5 Operation Loose Ends:-1:3.0 Shady Business");
		m_gameExe.parseExe(L"x3fl.exe|39:3:NO_XOR|TC_TEXT|MYDOCLOG|ADDON:HKCU/Software/Egosoft/X3FL/ModName:X3 Farnham's Legacy:Egosoft/X3FL:addon2!x3tc.exe:0");
	}
}
void CPackages::startup(const Utils::WString &dir, const Utils::WString &tempDir, const Utils::WString &myDoc, const Utils::WString &mod)
{
	startup(dir, tempDir, myDoc);
	m_sSetMod = mod;
}
 
int CPackages::getGameLanguage() const
{
	return this->getGameLanguage(m_sCurrentDir);
}
int CPackages::getGameLanguage(const Utils::WString &sDir) const
{
	Utils::WString dir = sDir;
	if (dir.empty())
		dir = m_sCurrentDir;
	else
		dir = this->getProperDir(dir);
 
	CDirIO Dir(dir);
 
	// check for lang.dat file
	if ( Dir.exists(L"lang.dat") )
	{
		CFileIO File(Dir.file(L"lang.dat"));
 
		size_t size;
		char *data = File.ReadToData(&size);
 
		if ( data )

		}
	}
 
	return 0;
}
Utils::WString CPackages::getGameRunExe(const Utils::WString &dir) const
{
	return m_gameExe.gameRunExe(dir);
}
Utils::WString CPackages::getGameRunExe() const
{
	return m_gameExe.gameRunExe(m_sCurrentDir);
}
 
Utils::WString CPackages::getGameNameFromType(int game) const
{
	return m_gameExe.gameNameFromType(game - 1);
}
Utils::WString CPackages::getGameName() const
{
	return getGameName(m_sCurrentDir);
}
 
Utils::WString CPackages::getGameName(const Utils::WString &dir) const
{
	return m_gameExe.gameName(dir.empty() ? m_sCurrentDir : dir);
}
 
Utils::WString CPackages::getProperDir() const
{
	return getProperDir(m_sCurrentDir);
}
Utils::WString CPackages::getProperDir(const Utils::WString &dir) const
{
	return m_gameExe.properDir((dir.empty()) ? m_sCurrentDir : dir);
}
Utils::WString CPackages::getAddonDir() const
{
	return getAddonDir(m_sCurrentDir);
}
Utils::WString CPackages::getAddonDir(const Utils::WString &dir) const
{
	return m_gameExe.addonDir((dir.empty()) ? m_sCurrentDir : dir);
}
int CPackages::getGameAddons(Utils::WStringList &exes, const Utils::WString &dir) const
{
	return m_gameExe.getGameAddons((dir.empty()) ? m_sCurrentDir : dir, exes);
}
int CPackages::getGameAddons(Utils::WStringList &exes) const
{
	return m_gameExe.getGameAddons(m_sCurrentDir, exes);
}
 
Utils::WString CPackages::getGameTypesString(CBaseFile *package, bool includeVersion) const
{
	if ( !package->AnyGameCompatability() )
		return L"";
 
	Utils::WString sGames;
	for ( CListNode<SGameCompat> *gNode = package->GetGameCompatabilityList()->Front(); gNode; gNode = gNode->next() ) {
		if ( !sGames.empty() )
			sGames += L", ";
		sGames += m_gameExe.gameNameFromType(gNode->Data()->iGame - 1);
		if ( includeVersion ) {
			Utils::WString version = m_gameExe.gameVersionFromType(gNode->Data()->iGame - 1, gNode->Data()->iVersion - 1, gNode->Data()->sVersion);
			if ( !version.empty() ) {
				sGames += L" (";
				sGames += version;
				sGames += L")";
			}
		}
	}
	return sGames;
}
 
Utils::WString CPackages::getGameVersionString(CBaseFile *package) const
{
	for ( CListNode<SGameCompat> *gNode = package->GetGameCompatabilityList()->Front(); gNode; gNode = gNode->next() ) {
		if ( gNode->Data()->iGame == m_iGame ) {
			return m_gameExe.gameVersionFromType(m_iGame - 1, gNode->Data()->iVersion - 1, gNode->Data()->sVersion);
		}
	}
 
	return Utils::WString::Null();
}
 
Utils::WString CPackages::getGameVersionFromType(int game, int version, const Utils::WString &sVersion) const
{
	return m_gameExe.gameVersionFromType(game - 1, version - 1, sVersion);
}
 
int CPackages::CountBuiltInPackages(bool onlyEnabled)
{
	int count = 0;

	}
 
	return count;
}
 
int CPackages::extractGameFile(const Utils::WString &aFilename, const Utils::WString &aTo, const Utils::WString &aDir, const Utils::WString &addon) const
{
	// first check the enabled mod
	Utils::WString dir = aDir;
	if (dir.empty())
		dir = m_sCurrentDir;
 
	Utils::WString addonDir = addon;
	if (addonDir.empty()) addonDir = this->getAddonDir(dir);
 
	if (m_pEnabledMod && m_pEnabledMod->AnyFileType(FILETYPE_MOD))
	{
		for (C_File* file = m_pEnabledMod->GetFirstFile(FILETYPE_MOD); file; file = m_pEnabledMod->GetNextFile(file))
		{
			if (!file->checkFileExt(L"cat"))
				continue;
 
			CCatFile catFile;
			if (catFile.open(file->filePointer(), addonDir, CATREAD_CATDECRYPT, false) == CATERR_NONE)
			{

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

		}
	}
 
	// find the highest cat number
	int catNumber = 1;
	while (CFileIO::Exists(dir + L"/" + Utils::WString::PadNumber(catNumber, 2) + L".cat") && catNumber < 99)
		++catNumber;
 
	// get the last one, not the next free one
	--catNumber;
 
	// work backwards until we find the file
	for (; catNumber; catNumber--)
	{
		CCatFile catFile;
		if (catFile.open((dir + L"/" + Utils::WString::PadNumber(catNumber, 2) + L".cat"), addonDir.toString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)
		{
			// check for the file
			if (catFile.extractFile(aFilename, aTo))
				return 1;
			if (catFile.error() == CATERR_INVALIDDEST || catFile.error() == CATERR_CANTCREATEDIR)

		// its empty, no need to create ware files
		if ( !m_lGameWares[i].size() )
			continue;
 
		// lets extract the ware file
		wchar_t wareType = CPackages::ConvertWareTypeBack(i);
		Utils::WString wareFile = L"TWare";
		wareFile += (wchar_t)UPPER(wareType);
 
		Utils::WString openFile;
 
		int e;
		if ( i == WARES_TECH && CFileIO::Exists(m_sTempDir + L"/TWareT.txt") )
			openFile = m_sTempDir + L"/TWareT.txt";
		else {
			e = extractGameFile(L"types/" + wareFile + L".pck", m_sTempDir + L"/" + wareFile + L".txt");
			if ( e == 1 )
				openFile = m_sTempDir + L"/" + wareFile + L".txt";
			else if ( e == -2 )
				openFile = wareFile + L".txt";
		}
 
		if ( !openFile.empty() )
		{
			// read the file into memory
			Utils::WStringList wareLines;
			size_t oldSize = -1;
			int version = -1;
 
			// read first number
			CFileIO readFile(m_sTempDir + L"/" + wareFile + L".txt");
			std::vector<Utils::WString> lines;
			if(readFile.readLines(lines))
			{
				for(auto itr = lines.begin(); itr != lines.end(); itr++)
				{
					Utils::WString line = *itr;
					line.removeFirstSpace();
					line.removeChar(9);
					line.removeChar('\r');
					if ( line.empty() )
						continue;
					if ( line[0] == '/' )
						continue;
 
					if ( oldSize == -1 )
					{
						version = line.token(L";", 1).toInt();
						oldSize = line.token(L";", 2).toInt();
					}
					else
					{
						line.removeEndSpace();
						if ( line.back() != L';')
							line += L";";
						wareLines.pushBack(line);
						if ( wareLines.size() >= oldSize )
							break;
					}
				}
 
 
 
				// apply the buffer
				if ( m_iWareBuffer[i] <= 0 )
					m_iWareBuffer[i] = wareLines.size() + 10;
				// last resort, readjust the buffer
				else if ( wareLines.size() > static_cast<size_t>(m_iWareBuffer[i]) )
					m_iWareBuffer[i] = wareLines.size();
 
				// add the buffers
				while ( wareLines.size() < static_cast<size_t>(m_iWareBuffer[i]) )
					wareLines.pushBack(L"27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;SS_WARE_FILLER;");
 
				// add the ware lines
				bool create = false;
				for ( CListNode<SGameWare> *node = m_lGameWares[i].Front(); node; node = node->next() )
				{
					SGameWare *w = node->Data();
 
					if ( w->iType == WARETYPE_NONE )
						continue;
					else if ( w->iType == WARETYPE_DISABLED )
					{
						create = true;
						wareLines.pushBack(L"27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;" + w->sWareName + L"_DISABLED;");
					}
					else if ( w->iType == WARETYPE_DELETED || !w->pWare )
					{
						create = true;
						wareLines.pushBack(L"27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;SS_WARE_DELETED;");
					}
					else if ( w->iType == WARETYPE_ADDED )
					{
						create = true;
						w->pWare->iDescID = wareTextID;

						long price = this->customWareOveridePrice(w->pWare->sID);
						int notority = w->pWare->iNotority;
						if ( !this->customWareOverideNoto(w->pWare->sID, &notority) ) notority = w->pWare->iNotority;
						if ( !price ) price = w->pWare->iPrice;
 
						wareLines.pushBack(Utils::WString("28;0;0;0;0;") + (long)wareLines.size() + L";" + (long)(w->iText + 3) + L";" + (long)w->pWare->iVolumn + L";" + price + L";1;1;" + (long)w->pWare->iSize + L";" + price + L";" + (long)notority + L";0;0;" + w->sWareName.upper() + L";");
					}
				}
 
				if ( create )
				{
					wareLines.pushFront(Utils::String::Number(version) + ";" + Utils::String::Number(wareLines.size()) + ";", Utils::String::Null());
 
					Utils::WString strV = Utils::WString::FromFloat(GetLibraryVersion(), 2);
					wareLines.pushFront("// Created by SPKInstaller Libraries V" + strV, Utils::WString::Null());
					if ( readFile.writeFile(&wareLines) )
						this->packFile(&readFile, L"types\\" + wareFile + L".pck");
				}
			}
			readFile.remove();
		}
	}
}
 
Utils::WString CPackages::empWaresForGame(size_t *maxsize)
{
	if ( maxsize ) (*maxsize) = 0;
 
	if ( m_iGame == GAME_X3TC )
	{
		if ( maxsize ) (*maxsize) = EMP_X3TC;
		return GetX3TCEmp();
	}
	else if (m_iGame == GAME_X3AP)
	{
		if (maxsize) (*maxsize) = EMP_X3AP;
		return GetX3TCEmp();
	}
	else if (m_iGame == GAME_X3FL)
	{
		if (maxsize) (*maxsize) = EMP_X3FL;
		return GetX3TCEmp();
	}
	else if ( m_iGame == GAME_X3 )
	{
		if ( maxsize ) (*maxsize) = EMP_X3;
		return GetX3Emp();
	}
 
	return Utils::String::Null();
}
 
void CPackages::_addWareOverride(enum WareTypes type, int pos, const Utils::WString &id, int value, bool noto)
{
	for(CListNode<SWarePriceOverride> *node = m_lWarePrices.Front(); node; node = node->next()) {
		SWarePriceOverride *wp = node->Data();
		if ( wp->type == type ) {
			if ( wp->type == Ware_Custom && !wp->id.Compare(id) ) continue;

 
	m_lWarePrices.push_back(ware);
}
 
void CPackages::addEMPPriceOverride(int empId, int price)
{
	_addWareOverride(Ware_EMP, empId, Utils::WString::Null(), price, false);
}
 
void CPackages::addEMPNotoOverride(int empId, int noto)
{
	_addWareOverride(Ware_EMP, empId, Utils::WString::Null(), noto, true);
}
 
void CPackages::addBuiltInWarePriceOverride(int empId, int price)
{
	_addWareOverride(Ware_BuiltIn, empId, Utils::WString::Null(), price, false);
}
 
void CPackages::addBuiltInWareNotoOverride(int empId, int noto)
{
	_addWareOverride(Ware_BuiltIn, empId, Utils::WString::Null(), noto, false);
}
 
void CPackages::addCustomWarePriceOverride(const Utils::WString &id, int price)
{
	_addWareOverride(Ware_Custom, 0, id, price, false);
}
 
void CPackages::addCustomWareNotoOverride(const Utils::WString &id, int noto)
{
	_addWareOverride(Ware_Custom, 0, id, noto, true);
}
 
 
void CPackages::createEMPFile(const Utils::String &progDir)
{
	// do emp wares
	size_t maxsize = 0;
	Utils::WString empWares = empWaresForGame(&maxsize);
 
	if ( maxsize )
	{
		int e = extractGameFile(L"types/TWareT.pck", m_sTempDir + L"/TWareT.txt");
		if (e)
		{
			// read the file into memory
			Utils::WStringList wareLines;
			size_t oldSize = -1;
			int version = -1;
 
			// read first number
			CFileIO readFile((e == -1) ? L"TWareT.txt" : m_sTempDir + L"/TWareT.txt");
			std::vector<Utils::WString> lines;
			if(readFile.readLines(lines))
			{
				for ( int i = 0; i < (int)lines.size(); i++ )
				{
					Utils::WString line(lines.at(i));
					line.removeFirstSpace();
					line.removeChar('\r');
					line.removeChar(9);
					if ( line[0] == '/' )
						continue;
 
					if ( oldSize == -1 )
					{
						version = line.token(L";", 1).toLong();
						oldSize = line.token(L";", 2).toLong();
					}
					else
					{
						line.removeEndSpace();
						if ( line.right(1) != L";" )
							line += L";";
 
						// check for any override values for built in wares
						if ( (i >= 62 && i <= 81) || (i >= 88 && i <= 93) ) {
							int pos = i - ((i >= 88) ? 88 : 62);
							int price = this->builtInWareOveridePrice(pos);
							if ( price ) {
								line = line.replaceToken(L";", 9, Utils::WString::Number(price));
								line = line.replaceToken(L";", 13, Utils::WString::Number(price));
							}
 
							int noto = 0;
							if ( this->builtInWareOverideNoto(pos, &noto) ) {
								line = line.replaceToken(L";", 14, Utils::WString::Number(noto));
							}
						}
 
						// check for any override values for EMP
						if ( i >= 116 ) {
							int price = this->empOveridePrice(i - 116);
							if ( price ) {
								line = line.replaceToken(L";", 9, Utils::WString::Number(price));
								line = line.replaceToken(L";", 13, Utils::WString::Number(price));
							}
 
							int noto = 0;
							if ( this->empOverideNoto(i - 116, &noto) ) {
								line = line.replaceToken(L";", 14, Utils::WString::Number(noto));
							}
						}
 
						wareLines.pushBack(line);
						if ( wareLines.size() >= oldSize )
							break;
					}
				}
			}
 
			// now we too add/remove entries to match
			// need filler entries
			while ( wareLines.size() < maxsize )
				wareLines.pushBack(L"27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;SS_WARE_FILLER;");
 
 
			std::vector<Utils::WString&gt; empStr;
 
			if(empWares.tokenise(L&quot;\n", empStr))
			{
				// apply any price overrides
				size_t empEntries = empStr.size();
				for(size_t i = 0; i < empEntries; i++) {
					int price = this->empOveridePrice(i);
					if ( price ) {
						empStr[i] = empStr[i].replaceToken(L";", 9, Utils::WString::Number(price));
						empStr[i] = empStr[i].replaceToken(L";", 13, Utils::WString::Number(price));
					}
 
					int noto = 0;
					if ( this->empOverideNoto(i, &noto) ) {
						empStr[i] = empStr[i].replaceToken(L";", 14, Utils::WString::Number(noto));
					}
				}
				// remove any empty end entries
				while ( empStr[empEntries - 1].empty() )
					--empEntries;
 
				Utils::WStringList addAfter;
				if ( wareLines.size() > maxsize )
				{
					// force emp, remove entries to allow them to be added
					if ( m_bForceEMP )
					{
						// more after emp
						if ( wareLines.size() > (maxsize + empEntries) )
						{
							for (size_t i = (maxsize + empEntries); i < wareLines.size(); i++)
							{
								auto node = wareLines.get(i);
								addAfter.pushBack(node->str);
							}
						}
 

					}
					else if ( m_iGame == GAME_X3TC || m_iGame == GAME_X3AP || m_iGame == GAME_X3FL) // check if old emp is included, and convert it
					{
						if ( wareLines.size() > 128 )
						{
							Utils::WString test = wareLines.get(128)->str;
							if ( test.tokens(L";", -2).Compare(L"SS_WARE_SW_CUSTOM16_1;") )
							{
								// if theres any at the end, remove the last emp entry
								if ( wareLines.size() > (maxsize + empEntries - 1) )
								{
									wareLines.removeAt(maxsize + empEntries - 2);
								}
								wareLines.insertAt(128, L"0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;128;");
							}
						}
					}
				}
 
				// too many entries, need to remove the first set of EMP wares
				size_t i = 0;
				if ( wareLines.size() > maxsize )
					i = wareLines.size() - maxsize;
 
				for ( ; i < empEntries; i++ )
				{
					Utils::WString str = empStr[i];
					str.removeEndSpace();
					str.removeChar(9);
					str.removeChar('\r');
					if ( str.empty() )
						continue;
					if ( str.right(1) != L";")
						str += L";";
					wareLines.pushBack(str);
				}
 
				for(auto afterItr = addAfter.begin(); afterItr != addAfter.end(); afterItr++)
					wareLines.pushBack((*afterItr)->str);
 
				// finally we write the whole file
				wareLines.pushFront(Utils::WString::Number(version) + ";" + Utils::WString::Number(wareLines.size()) + L";", Utils::WString::Null());
				wareLines.pushFront(L"// Created by SPKInstaller Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2), Utils::WString::Null());
				if ( readFile.writeFile(&wareLines) )
					this->packFile(&readFile, L"types\\TWareT.pck");
			}
 
		}
	}
}
 
Utils::WString parseXmlText(const Utils::WString &str)
{
	Utils::WString newStr(str);
	Utils::WStringList changes;
 
	// find all XML commands, &<command>;
	Utils::WString sStr = str;
	Utils::WString::size_type pos = sStr.find_first_of(L"&", 0);
	while ( pos != Utils::WString::npos ) {
		// find the next space and next ;.  If ; comes first, assume its acommand
		Utils::WString::size_type spacePos = sStr.find_first_of(L" ", pos);
		Utils::WString::size_type colonPos = sStr.find_first_of(L";", pos);
		if ( colonPos != Utils::WString::npos && colonPos < spacePos ) {
			// replace with <::command::> so they the & doesn't get replaced
			Utils::WString repStr = sStr.substr(pos, (colonPos + 1) - pos);
			Utils::WString repWithStr = L"<::" + sStr.substr(pos + 1, colonPos - pos - 1) + L"::>";
			newStr = newStr.findReplace(repStr, repWithStr);
			changes.pushBack(repStr, repWithStr);
		}
 
		// find the next command
		pos = sStr.find_first_of(L"&", pos + 1);
	}
 
	// replace the & now
	newStr = newStr.findReplace(L"&", L"&amp;");
 
	// restore the commands
	for(auto itr = changes.begin(); itr != changes.end(); itr++)
		newStr = newStr.findReplace((*itr)->data, (*itr)->str);
 
	return newStr;
}
 
Utils::WString CPackages::convertTextString(const Utils::WString &sText)
{
	//process any &
	Utils::WString text = parseXmlText(sText);
 
	// change special cases
	text = text.findReplace(L"(", L"\\(");
	text = text.findReplace(L")", L"\\)");
	text = text.findReplace(L"[", L"{");
	text = text.findReplace(L"]", L"}");
	text = text.findReplace(L">", L"&gt;");
	text = text.findReplace(L"<", L"&lt;");
	return text;
}
 
int CPackages::_gameTextNumber() const
{
	int gameNumber = (m_pCurrentGameExe) ? m_pCurrentGameExe->iTextNum : -1;
	if ( gameNumber != -1 ) return gameNumber;
 
	switch(m_iGame) {
		case GAME_X3: return 30;

		case GAME_X3FL: return 39;
		default: return 0;
	}
}
 
void CPackages::createPluginManagerOpenText()
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
{
	int gameNumber = _gameTextNumber();
 
	int lang = m_iLanguage;
	if ( !lang || lang < 0 )
		lang = 44;
 
	CDirIO Dir(m_sCurrentDir);
	if ( !Dir.exists("t") )
		Dir.create("t");
 
	Utils::WString filename = SPK::FormatTextName(PMTEXTFILE, lang, (m_iGameFlags & EXEFLAG_TCTEXT));
	CFileIO textFile(m_sCurrentDir + L"/t/" + filename + L".xml");
 
	std::vector<Utils::WString> writeData;
 
	writeData.push_back(L"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
	writeData.push_back(L"<language id=\"" + Utils::WString::Number(lang) + L"\">");
 
	if ( !gameNumber )
		writeData.push_back(L"	<page id=\"" + Utils::WString::Number(PMTEXTFILE) + L"\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
	else
		writeData.push_back(L"	<page id=\"" + (long)gameNumber + Utils::WString::PadNumber(PMTEXTFILE, 4) + L"\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
 
	writeData.push_back(L"		<t id=\"99998\">[author]Plugin Manager[/author]It appears the plugin manager hasn't been closed properly.  Make sure its closed before running the game otherwise things may not work correctly</t>");
	writeData.push_back(L"		<t id=\"99999\">2</t>");	
	writeData.push_back(L"	</page>");
 
	writeData.push_back(L"</language>");
	textFile.writeFileUTF(&writeData);
 
	size_t fileSize;
	char *fileData = CFileIO(textFile.fullFilename()).ReadToData(&fileSize);
 
	if ( fileData && fileSize)
	{
		size_t newFileSize;
		unsigned char *pckData = PCKData((unsigned char *)fileData, fileSize, &newFileSize, true);
		if ( pckData )
		{
			CFileIO pckFile(m_sCurrentDir + L"/t/" + filename + L".pck");
			pckFile.WriteData((char *)pckData, newFileSize);
			this->addCreatedFile(pckFile.fullFilenameStr());
		}
	}
	textFile.remove();
}
 
void CPackages::CreatePluginManagerText()
{
	int gameNumber = _gameTextNumber();
 
	int lang = m_iLanguage;
	if ( !lang || lang < 0 )
		lang = 44;
 
	CDirIO Dir(m_sCurrentDir);
	if ( !Dir.exists(L"t") )
		Dir.create(L"t");
 
	m_iLastUpdated = (int)time(NULL);
 
	Utils::WString filename = SPK::FormatTextName(PMTEXTFILE, lang, (m_iGameFlags & EXEFLAG_TCTEXT));
	CFileIO textFile(m_sCurrentDir + L"/t/" + filename + L".xml");
 
	std::vector<Utils::WString> writeData;
 
	CLinkList<SGameWare> lWares;
	CLinkList<SGameShip> lShips;
	for ( int i = 0; i < WAREBUFFERS; i++ )
	{

		if ( node->Data()->iType == WARETYPE_NONE )
			continue;
		lShips.push_back(node->Data());
	}
 
	writeData.push_back(L"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
	writeData.push_back(L"<language id=\"" + Utils::WString::Number(lang) + "\">");
 
	if ( !gameNumber )
		writeData.push_back(L"	<page id=\"" + Utils::WString::Number(PMTEXTFILE) + L"\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
	else
		writeData.push_back(L"	<page id=\"" + Utils::WString::Number(gameNumber) + Utils::WString::PadNumber(PMTEXTFILE, 4) + L"\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
 
	// write the heading
	int start = 10000;
	writeData.push_back(L"		<t id=\"1\">" + Utils::WString::Number(m_iLastUpdated) + L"</t>");
	writeData.push_back(L"		<t id=\"2\">" + Utils::WString::Number(this->countPackages(TYPE_SPK, true)) + L"</t>");
	writeData.push_back(L"		<t id=\"3\">" + Utils::WString::Number(start) + L"</t>");
	writeData.push_back(L"		<t id=\"4\">" + Utils::WString::Number(lWares.size()) + L"</t>");
	writeData.push_back(L"		<t id=\"6\">" + Utils::WString::Number(lShips.size()) + L"</t>");
 
	// write some generic texts
	writeData.push_back(L"		<t id=\"110\">" + Utils::WString::Number((long)m_iLanguage) + L"</t>");
	writeData.push_back(L"		<t id=\"109\">Plugin Manager: \\033GPoll Gui Data\\033X</t>");
	writeData.push_back(L"		<t id=\"107\">Plugin Manager: \\033GExport Game Data\\033X </t>");
	writeData.push_back(L"		<t id=\"100\">\\n</t>");
	writeData.push_back(L"		<t id=\"101\">\\033B</t>");
	writeData.push_back(L"		<t id=\"102\">\\033G</t>");
	writeData.push_back(L"		<t id = \"103\">\\033B</t>");
	writeData.push_back(L"		<t id=\"104\">\\033X</t>");
	writeData.push_back(L"		<t id=\"105\">\\033Y</t>");
	writeData.push_back(L"		<t id=\"106\">\\033C</t>");
	writeData.push_back(L"		<t id=\"108\">\\033</t>");
 
	writeData.push_back(L"		<t id=\"99998\">[author]Plugin Manager[/author]It appears the plugin manager hasn't been closed properly.  Make sure its closed before running the game otherwise things may not work correctly</t>");
	writeData.push_back(L"		<t id=\"99999\">1</t>");
	// now write each package
	int settingStart = 100000;
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
	{
		CBaseFile *p = node->Data();

			continue;
 
		CSpkFile *spk = (CSpkFile *)p;
 
		// count text files
		Utils::WString textEntries;
		int textCount = 0;
		C_File *f = p->GetFirstFile(FILETYPE_TEXT);
		while ( f )
		{
			Utils::WString sLang;
			Utils::WString id;
			if ( m_iGameFlags & EXEFLAG_TCTEXT )
			{
				id = f->baseName().token(L"-", 1);
				sLang = f->baseName().token(L"-", 2);
				if ( sLang.empty() )
					sLang = L"NULL";
				else
					sLang = sLang.erase(0, 1);  // remove the "L"
			}
			else
			{
				sLang = f->baseName().left((int)f->baseName().length() - 4).padNumber(3);
				id = f->baseName().mid(((int)f->baseName().length() - 4) + 1, 4);
			}
 
			if ( sLang != L"NULL" )
			{
				if ( sLang.toInt() == lang )
				{
					++textCount;
					if ( !textEntries.empty() )
						textEntries += L" ";
					textEntries += id;
				}
			}
			f = p->GetNextFile(f);
		}
 
		Utils::WString sTextCount((long)textCount);
		writeData.push_back(L"		<t id=\"" + Utils::WString::Number((long)start) + L"\">" + this->convertTextString(p->name()) + L"</t>");
		writeData.push_back(L"		<t id=\"" + Utils::WString::Number((long)(start + 1)) + L"\">" + this->convertTextString(p->author()) + L"</t>");
		writeData.push_back(L"		<t id=\"" + Utils::WString::Number((long)(start + 2)) + L"\">" + this->convertTextString(p->version()) + L"</t>");
		writeData.push_back(L"		<t id=\"" + Utils::WString::Number((long)(start + 3)) + L"\">" + this->convertTextString(p->name(lang)) + L"</t>");
 
		CLinkList<SSettingType> *settings = spk->GetSettingsList();
		if ( settings && settings->size() )
		{
			writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(start + 4) + L"\">" + (long)settings->size() + L"</t>");
			writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(start + 5) + L"\">" + (long)settingStart + L"</t>");
 
			for ( CListNode<SSettingType> *sNode = settings->Front(); sNode; sNode = sNode->next() )
			{
				SSettingType *st = sNode->Data();
				writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(settingStart++) + L"\">" + st->sKey.toWString() + L"</t>");
				writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(settingStart++) + L"\">" + spk->GetSetting(st).toWString() + L"</t>");
			}
		}
		else
			writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(start + 4) + L"\">0</t>");
 
		writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(start + 6) + L"\">" + sTextCount + L"</t>");
		if ( textCount )
			writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(start + 7) + L"\">" + textEntries + L"</t>");
 
		start += 10;
	}
 
	// write ware names
	if ( lWares.size() )
	{
		writeData.push_back(L"		<t id=\"5\">" + Utils::WString::Number(start) + L"</t>");
		for ( CListNode<SGameWare> *node = lWares.Front(); node; node = node->next() )
		{
			SGameWare *w = node->Data();
			if ( w->pWare && w->iType == WARETYPE_ADDED )
				writeData.push_back(Utils::WString(L"		<t id=\"") + (long)start + L"\">" + this->convertTextString(w->sWareName) + L"</t>");
			else
				writeData.push_back(Utils::WString(L"		<t id=\"") + (long)start + L"\">-1</t>");
			writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(start + 1) + L"\">" + Utils::WString(w->cType) + L"</t>");
			writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(start + 2) + L"\">" + (long)w->iPos + L"</t>");
			start += 10;
		}
	}
 
	if ( lShips.size() )
	{
		writeData.push_back(L"		<t id=\"7\">" + Utils::WString::Number(start) + L"</t>");
		for ( CListNode<SGameShip> *node = lShips.Front(); node; node = node->next() )
		{
			SGameShip *gs = node->Data();
			if ( gs->iType == WARETYPE_NONE )
				continue;
			if ( gs->pPackage && gs->iType == WARETYPE_ADDED )
				writeData.push_back(Utils::WString(L"		<t id=\"") + (long)start + L"\">" + gs->sShipID + L"</t>");
			else
				writeData.push_back(Utils::WString(L"		<t id=\"") + (long)start + L"\">-1</t>");
			writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(start + 1) + L"\">" + (long)gs->iPos + L"</t>");
			writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(start + 2) + L"\">Ship</t>");
 
			// write shipyard info
			if ( gs->pPackage )
			{
				int doStart = start + 5;
				for ( int i = SHIPYARD_ARGON; i <= SHIPYARD_MAX; i *= 2 )
				{
					writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(doStart) + L"\">" + ((gs->pPackage->IsShipyard(i)) ? Utils::WString::Number(1) : Utils::WString::Number(0)) + L"</t>");
					++doStart;
				}
			}
 
			start += 20;
		}
	}
 
	writeData.push_back(L"	</page>");
 
	// do emp
	if (m_iGame == GAME_X3TC || m_iGame == GAME_X3 || m_iGame == GAME_X3AP || m_iGame == GAME_X3FL)
	{
		writeData.push_back(L"  <page id=\"17\" title=\"Plugin Manager Objects\">");
		writeData.push_back(GetEMPText());
		writeData.push_back(L"  </page>");
	}
 
	// wares
	if ( m_iGame == GAME_X3AP || m_iGame == GAME_X3TC || m_iGame == GAME_X3FL || m_iGame == GAME_X3 || lWares.size() || lShips.size() )
	{
 
		if ( !gameNumber )
			writeData.push_back(L"  <page id=\"17\" title=\"Plugin Manager Objects\">");
		else
			writeData.push_back(Utils::WString(L"  <page id=\"") + (long)gameNumber + L"0017\" title=\"Plugin Manager Objects\">");
 
		writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(SHIPSTARTTEXT - 1) + L"\">ZZ_BLANKSHIP</t>");
 
		// object names
		for ( CListNode<SGameWare> *node = lWares.Front(); node; node = node->next() )
		{
			SGameWare *w = node->Data();
			if ( !w->pWare || w->iType != WARETYPE_ADDED )
				continue;
 
			// find the correct text for the language
			Utils::WString name = CSpkFile::GetWareText(w->pWare, m_iLanguage);
			Utils::WString desc = CSpkFile::GetWareDesc(w->pWare, m_iLanguage);
			if ( !name.empty() )
				writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(w->iText + 3) + L"\">" + this->convertTextString(name) + L"</t>");
			if ( !desc.empty() )
				writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(w->iText + 4) + L"\">" + this->convertTextString(desc) + L"</t>");
		}
		for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
		{
			SGameShip *s = node->Data();
			if ( !s->pPackage || s->iType != WARETYPE_ADDED )
				continue;
			if ( s->pPackage->GetOriginalDescription() )
				continue;
 
			Utils::WString name = s->pPackage->GetTextName(m_iLanguage);
			Utils::WString desc = s->pPackage->GetTextDescription(m_iLanguage);
			if ( !name.empty() )
				writeData.push_back(Utils::WString(L"		<t id=\"") + (long)s->iText + L"\">" + this->convertTextString(name) + L"</t>");
			if ( !desc.empty() )
				writeData.push_back(Utils::WString(L"		<t id=\"") + (long)(s->iText + 1) + L"\">" + this->convertTextString(desc) + L"</t>");
		}
		writeData.push_back(L"  </page>");
	}
	writeData.push_back(L"</language>");
	textFile.writeFileUTF(&writeData);
 
	size_t fileSize;
	char *fileData = CFileIO(textFile.fullFilename()).ReadToData(&fileSize);
 

	{
		size_t newFileSize;
		unsigned char *pckData = PCKData((unsigned char *)fileData, fileSize, &newFileSize, true);
		if ( pckData )
		{
			CFileIO pckFile(m_sCurrentDir + L"/t/" + filename + L".pck");
			pckFile.WriteData((char *)pckData, newFileSize);
			this->addCreatedFile(pckFile.fullFilenameStr());
		}
	}
	textFile.remove();
}
 
bool CPackages::isCurrentDir(const Utils::WString &dir) const
{
	Utils::WString cur = m_sCurrentDir;
 
	if ( dir.Compare(cur) )
		return true;
 
	Utils::WString checkDir = cur;
	checkDir = checkDir.findReplace(L"/", L"\\");
	if ( checkDir.Compare(dir) )
		return true;
 
	checkDir = checkDir.findReplace(L"\\", L"/");
	if ( checkDir.Compare(dir) )
		return true;
 
	return false;
}

		if (!gameSaveDir.exists(dir))
			gameSaveDir.create(dir);
		gameSaveDir.cd(dir);
 
		// backup the saves
		Utils::WStringList files;
		if(saveDir.dirList(files, Utils::WString::Null(), L"*.sav"))
		{
			for(auto itr = files.begin(); itr != files.end(); ++itr)
			{
				CFileIO File(saveDir.file((*itr)->str));
				if (!File.isFileExtension(L"sav"))

				}
			}
			*/
 
			// now we copy of the backed up save games
			Utils::WStringList files;
			if(restoreDir.dirList(files, Utils::WString::Null(), L"*.sav"))
			{
				for(auto itr = files.begin(); itr != files.end(); itr++)
				{
					CFileIO File(restoreDir.file((*itr)->str));
					// remove the file if already exists

		Utils::String name = p->GetCustomStartName();
		if ( name.empty() )
			continue;
 
		// find if maps file exists
		Utils::WStringList createFiles;
		createFiles.pushBack(name, L"maps/x3_universe");
		createFiles.pushBack(name, L"types/Jobs");
		createFiles.pushBack(name, L"types/JobWings");
 
		for(auto itr = createFiles.begin(); itr != createFiles.end(); itr++)
		{
			Utils::WString dir = CFileIO((*itr)->data).dir();
			FileType type = FileType::FILETYPE_EXTRA;
			if ( dir.Compare(L"maps") )
				type = FileType::FILETYPE_MAP;
 
			if ( !p->findFile((*itr)->str + L".xml", type) && !p->findFile((*itr)->str + L".pck", type))
			{
				// create a maps files
				int e = this->extractGameFile((*itr)->data + L".pck", m_sTempDir + L"/" + (*itr)->data + L".pck");
				if ( e )
				{
					CFileIO File((e == -1) ? ((*itr)->data + L".pck") : (m_sTempDir + L"/" + (*itr)->data + L".pck"));
					if ( File.exists() )
					{
						File.Rename(m_sCurrentDir + L";/&quot; + dir + L"/"; + (*itr)->str + L".pck");
						this->addCreatedFile(dir + L"/" + (*itr)->str + L".pck");
					}
				}
			}
		}
	}
}
 
void CPackages::addCreatedFile(const Utils::WString &sFile)
{
	Utils::WString file = sFile.findRemove(m_sCurrentDir);
	while ( file[0] == '/' )
		file.erase(0, 1);
	while ( file[0] == '\\' )
		file.erase(0, 1);
 
	if(!_lCreatedFiles.contains(file, true))
		_lCreatedFiles.pushBack(file);
}
 
void CPackages::CreateComponants()
{
	// first check we have any ships

 
bool CPackages::readWares(int iLang, CLinkList<SWareEntry> &list)
{
	if ( iLang == 0 ) iLang = m_iLanguage;
 
	Utils::WString empWares = this->empWaresForGame();
 
	for(CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next()) {
		if ( !node->Data()->IsEnabled() ) continue;
		node->Data()->readWares(iLang, list, empWares);
	}

	}
 
	return true;
}
 
int CPackages::_warePriceOverride(enum WareTypes type, int pos, const Utils::WString &id)
{
	for(CListNode<SWarePriceOverride> *node = m_lWarePrices.Front(); node; node = node->next()) {
		if ( node->Data()->type == type ) {
			if ( node->Data()->type == Ware_Custom && id.Compare(node->Data()->id) ) return node->Data()->relval;
			else if ( node->Data()->type != Ware_Custom && node->Data()->pos == pos ) return node->Data()->relval;
		}
	}
	return 0;
}
 
bool CPackages::_wareNotoOverride(enum WareTypes type, int pos, const Utils::WString &id, int *noto)
{
	for(CListNode<SWarePriceOverride> *node = m_lWarePrices.Front(); node; node = node->next()) {
		if ( node->Data()->type == type && node->Data()->bNotority ) {
			if ( node->Data()->type == Ware_Custom && !id.Compare(node->Data()->id) ) continue;
			else if ( node->Data()->type != Ware_Custom && node->Data()->pos != pos ) continue;

		}
	}
	return false;
}
 
void CPackages::_removeWareOverride(enum WareTypes type, int pos, const Utils::WString &id)
{
	for(CListNode<SWarePriceOverride> *node = m_lWarePrices.Front(); node; node = node->next()) {
		if ( node->Data()->type == type ) {
			if ( node->Data()->type == Ware_Custom && !id.Compare(node->Data()->id) ) continue;
			else if ( node->Data()->type != Ware_Custom && node->Data()->pos != pos ) continue;

	}
}
 
int CPackages::empOveridePrice(int id)
{
	return _warePriceOverride(Ware_EMP, id, Utils::WString::Null()); 
}
 
bool CPackages::empOverideNoto(int id, int *noto)
{
	return _wareNotoOverride(Ware_EMP, id, Utils::WString::Null(), noto);
}
 
int CPackages::builtInWareOveridePrice(int id)
{
	return _warePriceOverride(Ware_BuiltIn, id, Utils::WString::Null()); 
}
 
bool CPackages::builtInWareOverideNoto(int id, int *noto)
{
	return _wareNotoOverride(Ware_BuiltIn, id, Utils::WString::Null(), noto);
}
 
int CPackages::customWareOveridePrice(const Utils::WString &id)
{
	return _warePriceOverride(Ware_Custom, 0, id); 
}
 
bool CPackages::customWareOverideNoto(const Utils::WString &id, int *noto)
{
	return _wareNotoOverride(Ware_Custom, 0, id, noto);
}
 
void CPackages::removeEmpOverride(int pos)
{
	_removeWareOverride(Ware_EMP, pos, Utils::WString::Null());
}
 
void CPackages::removeBuiltinWareOverride(int pos)
{
	_removeWareOverride(Ware_BuiltIn, pos, Utils::WString::Null());
}
 
void CPackages::removeCustomWareOverride(const Utils::WString &id)
{
	_removeWareOverride(Ware_Custom, 0, id);
}
 
 
bool CPackages::readGlobals(Utils::WStringList &globals) const
{
	int e = extractGameFile(L"types/Globals.pck", m_sTempDir);
	if ( e )
	{
		CFileIO File((e == -1) ? L"Globals.txt" : m_sTempDir + L"/Globals.txt");
		if ( File.exists() )
		{
			std::vector<Utils::WString> lines;
			if(File.readLines(lines))
			{
				int entries = -1;
				for(auto itr = lines.begin(); itr != lines.end(); itr++)
				{
					Utils::WString str = itr->remove('\r').remove(9);
					str.removeFirstSpace();
 
					if ( str.empty() )
						continue;
					if ( str[0] == L'/' )
						continue;
 
					// remove comments
					if (str.contains(L"/") ) 
						str = str.token(L"/", 1);
 
					if ( entries == -1 )
						entries = str.token(L";", 1).toInt();
					else
						globals.pushBack(str.token(L";", 1), str.token(L";", 2));
				}
 
				return true;
			}
		}

	return false;
}
 
void CPackages::CreateGlobals()
{
	if ( _lGlobals.empty() )
		return; // no global settings
 
	Utils::WStringList globals;
	if (readGlobals(globals))
	{
		// apply out settings
		for(auto itr = _lGlobals.begin(); itr != _lGlobals.end(); itr++)
			globals.changeData((*itr)->str, (*itr)->data);
 
		// now write it
		Utils::WStringList writeList;
		for(auto itr = globals.begin(); itr != globals.end(); itr++)
			writeList.pushBack((*itr)->str + L";" + (*itr)->data + L";");
		
		// finally, write the file
		writeList.pushFront(Utils::WString::Number(writeList.size()) + L"; /globals amount", "");
		writeList.pushFront(L"// Globals file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2), L"");
 
		CFileIO WriteFile(m_sTempDir + L"/Globals.txt");
		if ( WriteFile.writeFile(&writeList) )
		{
			this->packFile(&WriteFile, L"types/Globals.pck");
			WriteFile.remove();
		}
	}
}
 

							if ( shipData.readShipData(line) )
							{
								for ( CListNode<SGameShip> *node = shipOverrides.Front(); node; node = node->next() )
								{
									SGameShip *s = node->Data();
									if ( !s->pPackage->GetShipID().toWString().Compare(shipData.sID))
										continue;
									s->iText = shiptext;
									if ( !s->pPackage->GetOriginalDescription() )
										shiptext += 2;
									s->iPos = tshipsList.size();

		}
	}
 
}
 
bool CPackages::packFile(const Utils::WString &filename) const
{
	// compress the file
	CFileIO File(filename);
	size_t fileSize;
	char *fileData = File.ReadToData(&fileSize);

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

		unsigned char *pckData = UnPCKData((unsigned char *)fileData, fileSize, &newFileSize, false);
		if ( !pckData )
			pckData = UnPCKData((unsigned char *)fileData, fileSize, &newFileSize, true);
 
		if ( pckData )
		{
			Utils::WString ext = L"txt";
			if ( File.isFileExtension(L"pbb") )
				ext = L"bob";
			else if ( File.isFileExtension(L"pbd") )
				ext = L"bod";

			if ( checkxml )
			{
				int readmaxlines = 20;
				bool isxml = false;
				do {
					Utils::String line = pckFile.readEndOfLineStr();
					if ( line.contains("<language id=") )
					{
						isxml = true;
						break;
					}

	}
 
	return false;
}
 
bool CPackages::packFile(CFileIO* File, const Utils::WString &sFilename) const
{
	Utils::WString filename = sFilename.findReplace(L"\\", L"/");
	if ( m_iGame == GAME_X3 )
	{
		CCatFile catFile;
		int error = catFile.open(m_sCurrentDir + L"/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

			unsigned char *pckData = PCKData((unsigned char *)fileData, fileSize, &newFileSize, true);
			if ( pckData )
			{
//				if ( !this->GetAddonDir().Empty() && CCatFile::IsAddonDir(filename) )
//					filename = this->GetAddonDir() + "/" + filename;
				CFileIO pckFile(m_sCurrentDir + L"/" + filename);
				if ( !CDirIO(pckFile.dir()).exists() )
					CDirIO(pckFile.dir()).create();
				pckFile.WriteData((char *)pckData, newFileSize);
				const_cast<CPackages *>(this)->addCreatedFile(pckFile.fullFilename());
				return true;
			}
		}
	}
 

		return false;
 
	Utils::CStringList gameAddons;
	for (unsigned int i = 0; i < m_gameExe.gameCount(); ++i)
	{
		SGameExe *exe = m_gameExe.game(i);
		if (!exe->sAddon.empty())
			gameAddons.pushBack(Utils::String::Number(i + 1), exe->sAddon.toString());
	}
 
	return baseFile->extractAll(dir, game, gameAddons, includedir, progress);
}
 

		return false;
 
	Utils::CStringList gameAddons;
	for (unsigned int i = 0; i < m_gameExe.gameCount(); ++i)
	{
		SGameExe *exe = m_gameExe.game(i);
		if (!exe->sAddon.empty())
			gameAddons.pushBack(Utils::String::Number(i + 1), exe->sAddon.toString());
	}
 
	return baseFile->GeneratePackagerScript(wildcard, list, game, gameAddons, datafile);
}
 
CBaseFile *CPackages::loadPackagerScript(const Utils::WString &filename, int compression, Utils::WString (*askFunc)(const Utils::WString &), Utils::WStringList *malformedLines, Utils::WStringList *unknownCommands, Utils::WStringList *variables, CProgressInfo *progress)
{
	// check the file exists
	if ( !CFileIO::Exists(filename) )
		return NULL;
 
	// read all the lines
	CFileIO File(filename);
	if ( !File.startRead() ) 
		return NULL;
 
	Utils::WStringList fileData;
 
	int iLine = 0;
 
	CBaseFile *package = NULL;
 
	while(!File.atEnd()) {
		// read the next line in the file
		Utils::WString line = File.readEndOfLineStr();
 
		// filter out any characters we dont really want
		line.removeChar(L"\t\r");
		line.removeFirstSpace();
 
		if ( line.empty() ) continue;
 
		// check for any comments (so we can ignore them)
		if ( line.left(2).Compare(L"//") || line[0] == L'#' ) continue;
 
		++iLine;
 
		// all commands start with a keyword followed by a colon, if one doesn't exist, it cant be a valid line
		if ( !line.contains(L':') )
		{
			// there are some exeptions, and these are one word entrys only
			line.removeEndSpace();
			if ( line.contains(L" ") )
			{
				if ( malformedLines )
					malformedLines->pushBack(line, Utils::WString::Number(iLine));
				continue;
			}
		}
 
		// check for the type line
		if ( !package && line.token(L":", 1).Compare(L"FileType") )
		{
			Utils::WString sFileType = line.tokens(L":", 2).removeFirstSpace();
			if ( sFileType.Compare(L"Ship") )
				package = new CXspFile();
			else if ( sFileType.Compare(L"Script") )
				package = new CSpkFile();
			else if ( sFileType.Compare(L"Base") )
				package = new CBaseFile();
			continue;
		}
 
		fileData.pushBack(line, Utils::WString::Number(iLine));
	}
 
	// assume its a script if no type is set (all old versions are scripts)
	if ( !package )
		package = new CSpkFile();
 
	if ( compression != -1 )
		package->SetDataCompression(compression);
 
	Utils::WString ftpaddr;
	Utils::WString ftpuser;
	Utils::WString ftppass;
	Utils::WString ftpdir;
	Utils::WString sMainGame;
	Utils::WStringList otherGames;
	Utils::WStringList gameAddons;
	for (unsigned int i = 0; i < m_gameExe.gameCount(); ++i)
	{
		SGameExe *exe = m_gameExe.game(i);
		if (!exe->sAddon.empty())
			gameAddons.pushBack(Utils::WString::Number(i + 1), exe->sAddon);
	}
 
	// now lets read the rest of the day
	Utils::WStringList listVaribles;
	for (Utils::WStringNode *line = fileData.first(); line; line = fileData.next())
	{
		Utils::WString cmd = line->str.token(L":", 1);
		Utils::WString rest = line->str.tokens(L":", 2).removeFirstSpace();
 
		if (cmd.Compare(L"Varible") || cmd.Compare(L"Variable"))
		{
			Utils::WString s1 = rest.token(L" ", 1);
			Utils::WString s2 = rest.tokens(L" ", 2);
			if(!listVaribles.changeData(s1, s2))
				listVaribles.pushBack(s1, s2);
		}
		else
		{
			// replace variables
			if ( rest.contains(L"$") )
			{
				for (Utils::WStringNode *strVar = listVaribles.first(); strVar; strVar = listVaribles.next())
				{
					if ( rest.contains(strVar->str) )
						rest = rest.findReplace(strVar->str, strVar->data);
				}
 
				if ( variables )
				{
					for (Utils::WStringNode *strVar = variables->first(); strVar; strVar = variables->next())
					{
						if ( rest.contains(strVar->str) )
							rest = rest.findReplace(strVar->str, strVar->data);
					}
				}
			}
 
			//check for the built in varibles
			if ( rest.contains(L"$ASK") )
			{
				Utils::WString replace = L"$ASK";
				Utils::WString result;
 
				if ( askFunc )
					result = askFunc(cmd);
 
				if ( rest.contains(L"$ASK(") )
				{
					replace = rest.tokens(L"$ASK(", 2).token(L")", 1);
					if ( result.empty() )
						result = replace;
					replace = L"$ASK(" + replace + L")";
				}
 
				if ( !result.empty() )
					rest = rest.findReplace(replace, result);
			}
			// todays date
			if ( rest.contains(L"$DATE") )
			{
				time_t now;
				time(&now);
				struct tm *timeinfo = localtime(&now);
				Utils::WString result = Utils::WString::Number(timeinfo->tm_mday) + L"." + Utils::WString::Number(timeinfo->tm_mon + 1) + L"." + Utils::WString::Number(timeinfo->tm_year + 1900);
				if ( !result.empty() )
					rest = rest.findReplace(L"$DATE", result);
			}
			// mydocuments
			if ( rest.contains(L"$MYDOCUMENTS") )
			{
				if ( !m_sMyDoc.empty() )
					rest = rest.findReplace(L"$MYDOCUMENTS", m_sMyDoc);
			}
 
			// current path
			if ( rest.contains(L"$PATH") )
			{
				Utils::WString currentDir = CFileIO(filename).dir();
				if ( !currentDir.empty() )
					rest = rest.findReplace(L"$PATH", currentDir);
			}
 
			// now parse the rest of the values
			if ( cmd.Compare(L"FtpUpload") )
				ftpaddr = rest.token(L" ", 1) + L":" + rest.token(L" ", 2);
			else if ( cmd.Compare(L"FtpUser") )
				ftpuser = rest;
			else if ( cmd.Compare(L"FtpPass") )
				ftppass = rest;
			else if ( cmd.Compare(L"FtpDir") )
				ftpdir = rest;
			else if ( cmd.Compare(L"MultiGames") ) {
				sMainGame = rest.token(L" ", 1);
				otherGames.tokenise(rest.tokens(L" ", 2), L" ");
			}
			else if ( !package->loadPackageData(cmd, rest, sMainGame, otherGames, gameAddons, progress))
			{
				if ( unknownCommands )
					unknownCommands->pushBack(cmd, rest);
			}
		}
	}
 
	if ( package->filename().empty() )
		package->loadPackageData(L"AutoSave", L"$AUTOSAVE", sMainGame, otherGames, gameAddons, progress);
 
	if (package->autoExtraction())
	{
		for (auto itr = package->autoExtraction()->begin(); itr != package->autoExtraction()->end(); itr++)
		{

		}
 
		if ( !ftpdir.empty() )
			ftpaddr += ftpdir;
 
		package->setFtpAddr(ftpaddr.toString());
	}
 
	return package;
}
 
Utils::String CPackages::getLanguageName() const
{
	return CPackages::ConvertLanguage(m_iLanguage);
}
 
size_t CPackages::updateFoundPackages(const Utils::WString& dir)
{
	m_lFoundPackages.MemoryClear();
	if (!m_sCurrentDir.empty())
		return findAllPackages(m_lFoundPackages, dir);
 
	return 0;
}
 
size_t CPackages::addFoundPackages(const Utils::WString& dir)
{
	return findPackageDirectories(m_lFoundPackages, dir);
}
 
int CPackages::findAllPackages(CLinkList<CBaseFile> &packages, const Utils::WString &dir)
{
	int count = 0;
	if (!dir.empty())
	{
		count += findPackageDirectories(packages, dir + L"/Addons");
		count += findPackageDirectories(packages, dir + L"/Downloads");
	}
 
	count += findPackageDirectories(packages, L"./Addons");
	count += findPackageDirectories(packages, L"./Downloads");
	count += findPackageDirectories(packages, m_sMyDoc + L"/Egosoft/PluginManager/Addons");
	count += findPackageDirectories(packages, m_sMyDoc + L"/Egosoft/PluginManager/Downloads");
 
	if (_pCurrentDir)
	{
		count += findPackageDirectories(packages, _pCurrentDir->dir + L"/Addons");
		count += findPackageDirectories(packages, _pCurrentDir->dir + L"/Downloads");
		count += findPackageDirectories(packages, _pCurrentDir->dir + L"/ExtraContent");
	}
 
	return count;
}
int CPackages::findPackageDirectories(CLinkList<CBaseFile> &packages, const Utils::WString &dir)
{
	CDirIO Dir(dir);
	int count = 0;
	Utils::WStringList files;
	if (Dir.dirList(files))

	}
 
	count += findPackageFiles(packages, dir);
	return count;
}
int CPackages::findPackageFiles(CLinkList<CBaseFile> &packages, const Utils::WString &dir)
{
	CDirIO Dir(dir);
	int count = 0;
	for (int type = 0; type < 2; type++)
	{

		else
			break;
			
		for(auto itr = files.begin(); itr != files.end(); itr++)
		{
			Utils::WString f = Dir.file((*itr)->str);
			int error = 0;
			CBaseFile *p = this->openPackage(f, &error, 0, SPKREAD_NODATA, READFLAG_NOUNCOMPRESS);
			if (!p)
				continue;
			if (p->IsMod() || this->findSpkPackage(p->name(), p->author()))

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

	}
 
	return Utils::String::Number(lang);
}
 
bool CPackages::checkAccessRights(const Utils::WString &aDir) const
{
	Utils::WString dir = aDir;
	if (dir.empty())
		dir = m_sCurrentDir;
 
	// write a file, then read the contents
	CFileIO File(dir + L"/accessrightscheck.dat");
 
	// check if file exists and remove it
	if ( File.exists() )
	{
		// if we cant remove it, we dont have enough rights

	// now check it exists
	if ( !File.exists() )
		return false;
 
	// now read the file for the correct contents
	std::vector<Utils::WString> lines;
	if (!File.readLines(lines))
		return false;
 
	// check that one of the lines is correct
	for(auto itr = lines.begin(); itr != lines.end(); itr++)
	{
		if ( *itr == L"testing access rights" )
			return true;
	}
 
	return false;
}
 
size_t CPackages::loadShipData(const Utils::String &file, Utils::CStringList &list) const
{
	CFileIO File;
	bool deleteFile = false;
 
	// load from cat file
	if (CFileIO(file).isFileExtension(L"cat"))
	{
		CCatFile cat;
		if (cat.open(file, this->getAddonDir().toString(), CATREAD_CATDECRYPT, false) != CATERR_NONE)
			return false;
 
		if (!cat.extractFile("types\\TShips.pck", m_sTempDir + "/tships.txt"))
			return false;
 
		File.open(m_sTempDir + "/tships.txt");
		deleteFile = true;
	}
	// otherwise its a normal file

			return false;
		f.UnPCKFile();
 
		f.setFilename(m_sTempDir + "/tships.txt");
		if (!f.writeFilePointer())
			return false;
 
		File.open(m_sTempDir + "/tships.txt");
		deleteFile = true;
	}
	else
		File.open(file);
 
	if (!File.exists())
		return false;
 
	bool ret = false;
	std::vector<Utils::String> lines;
	if (File.readLines(lines))
	{
		bool readFirst = false;
		for (auto itr = lines.begin(); itr != lines.end(); itr++)
		{
			if (itr->empty())
				continue;
			Utils::String str = itr->remove('\r').remove(9);
			str = str.removeFirstSpace();
			if (str.empty())

	}
 
	return Utils::String::Null();
}
 
bool CPackages::readTextPage(const Utils::WString &file, Utils::WStringList &list, bool search, int page) const
{
	CFileIO File;
	bool deleteFile = false;
 
	// read all text files from mod
	if ( CFileIO(file).isFileExtension(L"cat") )
	{
		bool done = false;
 
		CCatFile cat;
		if ( cat.open(file, this->getAddonDir().toString(), CATREAD_CATDECRYPT, false) != CATERR_NONE)
			return false;
 
		// extract 1 at a time
		for (unsigned int i = 0; i < cat.GetNumFiles(); i++ )
		{
			SInCatFile *f = cat.GetFile(i);
			Utils::WString sF = f->sFile;
			// is a text file
			sF = sF.findReplace(L"\\", L"/");
			if ( !sF.token(L"/", 1).Compare(L"t") )
				continue;
 
			Utils::WString baseFile = CFileIO(sF).baseName();
			// check language
			int lang = 0;
			if ( baseFile.findPos(L"-L") != -1 ) // new language file
				lang = baseFile.right(3).toInt();
			else
			{
				baseFile.truncate((int)baseFile.length() - 4);
				lang = baseFile.toInt();
			}
 
			if ( lang != m_iLanguage )
				continue;
 
			// now extract and parse
			if ( cat.extractFile(f->sFile, m_sTempDir + L"/" + CFileIO(f->sFile).baseName() + L".xml"))
			{
				if ( this->readTextPage(m_sTempDir + L"/" + CFileIO(f->sFile).baseName() + L".xml", list, search, page))
					done = true;
			}
		}
 
		return done;
	}
	// otherwise its a normal file
	else if ( CFileIO(file).isFileExtension(L"pck") )
	{
		C_File f(file);
		if ( !f.ReadFromFile() )
			return false;
		f.UnPCKFile();
 
		f.setFilename(m_sTempDir + L"/textfile.xml");
		if ( !f.writeFilePointer() )
			return false;
 
		File.open(m_sTempDir + L"/textfile.xml");
		deleteFile = true;
	}
	else
		File.open(file);
 
	if ( !File.exists() )
		return false;
 
	// open and read file
	std::vector<Utils::WString> lines;
	if(!File.readLines(lines))
		return false;
 
	bool inPage = false;
	for(auto itr = lines.begin(); itr != lines.end(); itr++)
	{
		// search for page
		if ( !inPage )
		{
			if (itr->findPos(L"<page") > -1 )
			{
				// find the page id
				int pos = itr->findPos(L"\"");
				if ( pos > -1 )
				{
					int endpos = itr->findPos(L"\"", pos + 1);
					if ( endpos > -1 )
					{
						Utils::WString p = itr->mid(pos + 2, endpos - pos - 1);
						if ( p.length() > 4 )
							p = p.right(4);
						int checkPage = p.toInt();
						if ( checkPage == page )
							inPage = true;

 
		}
		// add each id
		else
		{
			if (itr->findPos(L"</page") > -1 )
				break;
 
			if (itr->findPos(L"<t id") > -1 )
			{
				int pos = itr->findPos(L"\"");
				if ( pos > -1 )
				{
					int endpos = itr->findPos(L"\"", pos + 1);
					if ( endpos > -1 )
					{
						int id = itr->mid(pos + 2, endpos - pos - 1).toInt();
						pos = itr->findPos(">", endpos);
						if ( pos > -1 )
						{
							++pos;
							endpos = itr->findPos(L"</", pos);
							if ( endpos > -1 )
							{
								Utils::WString text = itr->mid(pos + 1, endpos - pos);
								while ( text.findPos(L'(') != -1 && text.findPos(L')') != -1 )
								{
									int s = text.findPos(L'(');
									text = text.erase(s, text.findPos(L')') - s + 1);
								}
								if(!search || !list.contains(Utils::WString::Number(id)))
									list.pushBack(Utils::WString::Number(id), text);
							}
						}
					}
				}
			}

 
	return true;
}
 
 
FileType CPackages::adjustFileType(const Utils::WString &file, FileType filetype) const
{
	CFileIO File(file);
	Utils::WString dir = File.GetDirIO().topDir();
	Utils::WString basename = File.baseName();
 

	return filetype;
}
 
void CPackages::RemoveFailedFiles()
{
	Utils::WStringList removed;
	for (auto itr = _lNonRemovedFiles.begin(); itr != _lNonRemovedFiles.end(); itr++)
	{
		if (CFileIO::Remove((*itr)->str))
			removed.pushBack((*itr)->str);
	}
	for (auto itr = removed.begin(); itr != removed.end(); itr++)
		_lNonRemovedFiles.remove((*itr)->str);
}
 
CXspFile *CPackages::extractShip(const Utils::String &sCatFile, const Utils::String &sId, CProgressInfo *progress)
{
	CVirtualFileSystem *pVfs = new CVirtualFileSystem();

	delete pVfs;
 
	return newShip;
}
 
void CPackages::getMergedFiles(Utils::WStringList &list, CCatFile *cat1, CCatFile *cat2) const
{
	// first add all files from the "primary" mod
	for (auto itr = cat1->GetFiles()->cbegin(); itr != cat1->GetFiles()->cend(); itr++)
		list.pushBack((*itr)->sFile.findReplace(L"\\", L"/"), L"1");
 
	// now add the ones from the secondary
	for (auto itr = cat2->GetFiles()->cbegin(); itr != cat2->GetFiles()->cend(); itr++)
	{
		Utils::WString sFile = (*itr)->sFile.findReplace(L"\\", L"/");
		// if its found on the 2nd list, dont add, just adjust the type
		if(!list.changeData(sFile, L"-1"))
			list.pushBack(sFile, L"2");
	}
}
 
bool CPackages::canWeMerge(const Utils::WString &file) const
{
	return CModDiff::CanBeDiffed(file);
}
 
bool CPackages::needToMerge(const Utils::WString &file) const
{
	Utils::WString firstDir = file.token(L"/", 1);
	if ( firstDir.Compare(L"t") )
		return true;
	if ( firstDir.Compare(L"types") )
		return true;
	if ( firstDir.Compare(L"maps") )
		return true;
 
	return false;
}
 
bool CPackages::mergeMods(CCatFile *mod1, CCatFile *mod2, const Utils::WString &outFile, Utils::WStringList *cantMerge) const
{
	CCatFile newCat;
	if ( newCat.open(outFile, this->getAddonDir()) != CATERR_CREATED )
		return false;
 
	Utils::WStringList list;
	this->getMergedFiles(list, mod1, mod2);
	if (list.empty())
		return false;
 
	// add all the files to the new mod first
	Utils::WStringList conflicts;
	for(auto itr = list.begin(); itr != list.end(); itr++)
	{		
		int status = (*itr)->data.toInt();
		if ( status == 1 )
		{
			if ( !newCat.writeFromCat(mod1, (*itr)->str) )
			{
				if ( cantMerge )
					cantMerge->pushBack((*itr)->str, L"1");
			}
		}
		else if ( status == 2 )
		{
			if ( !newCat.writeFromCat(mod2, (*itr)->str) )
			{
				if ( cantMerge )
					cantMerge->pushBack((*itr)->str, L"2");
			}
		}
		else if ( status == -1 )
		{
			if ( this->needToMerge((*itr)->str) )
			{
				if ( this->canWeMerge((*itr)->str) )
					conflicts.pushBack((*itr)->str);
				else if ( cantMerge )
					cantMerge->pushBack((*itr)->str, L"-1");
			}
			else
			{
				if ( !newCat.writeFromCat(mod1, (*itr)->str) )
				{
					if ( cantMerge )
						cantMerge->pushBack((*itr)->str, L"1");
				}
			}
		}
	}
 
	/* 
		Merging Files
 
		* Text Files: Join all text entries into a single file (excluding page 17)
		* Weapons: TBullets and TLaser (grab matching entrys from text files and adjust ids)
	*/
	// new merge the conflicting files
	// first the text files

 *
 * This includes all types and text files
 *
 * Returns true if it finds any files
 */
bool CPackages::getModCompatabilityList(C_File *file, Utils::WStringList *list) const
{
	// not a valid file
	if ( !file ) return false;
	if ( file->GetFileType() != FILETYPE_MOD ) return false;
	if ( !file->fileExt().Compare(L"cat") ) return false;
 
	// we need to read the file list for the mod
	CCatFile cat;
	if ( cat.open(file->filePointer(), this->getAddonDir().toString(), CATREAD_JUSTCONTENTS, false) == CATERR_NONE)
	{
		for (unsigned int i = 0; i < cat.GetNumFiles(); i++ )
		{
			SInCatFile *f = cat.GetFile(i);
			Utils::WString filename = f->sFile;
			filename = filename.findReplace(L"\\", L"/");
			bool found = false;
			//TODO: rework this
			if ( filename.left(2).Compare(L"t/") || filename.left(6).Compare(L"types/") )
				found = true;
			else if (filename.left(8).Compare(L"addon/t/") || filename.left(12).Compare(L"addon/types/"))
				found = true;
			else if (filename.left(9).Compare(L"addon2/t/") || filename.left(13).Compare(L"addon2/types/"))
				found = true;
 
			if ( found ) {
				if ( list )
					list->pushBack(filename, Utils::WString::Number(f->lSize));
				else
					return true;
			}
		}
	}
 
	if ( list && !list->empty() )
		return true;
 
	return false;
}
 

 *
 * Returns true if theres any files that are not compatable
 *
 * If list is specified, fills up with all files that were found
 */
bool CPackages::checkCompatabilityBetweenModFiles(C_File *from, C_File *to, Utils::WStringList *list) const
{
	// not a valid file
	if ( !from || !to ) return false;
	if ( from->GetFileType() != FILETYPE_MOD ) return false;
	if ( to->GetFileType() != FILETYPE_MOD ) return false;
	if (!from->fileExt().Compare(L"cat")) return false;
	if (!to->fileExt().Compare(L"cat")) return false;
 
	// get file lists from each file
	Utils::WStringList fromList;
	if (getModCompatabilityList(from, &fromList))
	{
		Utils::WStringList toList;
		if (getModCompatabilityList(to, &toList))
		{
			// both have files we need to check, compare them
			for(auto itr = fromList.begin(); itr != fromList.end(); itr++)
			{
				Utils::WString fromFile = (*itr)->str;
				fromFile = fromFile.findReplace(L"\\", L"/");
				fromFile = fromFile.findReplace(L"//", L"/");
				for (auto toItr = toList.begin(); toItr != toList.end(); toItr++)
				{
					Utils::WString toFile = (*toItr)->str;
					toFile = toFile.findReplace(L"\\", L"/");
					toFile = toFile.findReplace(L"//", L"/");
					if ( fromFile.Compare(toFile) )
					{
						if ( list )
							list->pushBack(from->filename() + L"::" + fromFile, to->filename() + L"::" + toFile);
						else
							return true;
					}
				}
			}

		return true;
 
	return false;
}
 
bool CPackages::checkCompatabilityBetweenMods(CBaseFile *from, CBaseFile *to, Utils::WStringList *list) const
{
	if ( !from || !to ) return false;
	if ( !from->IsEnabled() || !to->IsEnabled() ) return false;
	if ( !from->AnyFileType(FILETYPE_MOD) ) return false;
	if ( !to->AnyFileType(FILETYPE_MOD) ) return false;

 
	int count = 0;
	for ( C_File *f = from->GetFirstFile(FILETYPE_MOD); f; f = from->GetNextFile(f) )
	{
		if ( !f->IsFakePatch() ) continue;
		if ( f->fileExt().Compare(L"dat") ) continue;
 
		for ( C_File *compareFile = to->GetFirstFile(FILETYPE_MOD); compareFile; compareFile = to->GetNextFile(compareFile) )
		{
			if ( compareFile == f ) continue; // same file we're checking against
			if ( !compareFile->IsFakePatch() ) continue;
			if ( compareFile->fileExt().Compare(L"dat") ) continue;
 
			// now we have to files to compare
			if (checkCompatabilityBetweenModFiles(f, compareFile, list))
				++count;
		}

		return true;
 
	return false;
}
 
int CPackages::checkCompatabilityAgainstPackages(CBaseFile *newFile, Utils::WStringList *list, CLinkList<CBaseFile> *packages) const
{
	if ( !newFile->IsEnabled() ) return 0;
	if ( !newFile->AnyFileType(FILETYPE_MOD) ) return 0;
 
	// we need to extract all mod files
	for ( CListNode<C_File> *fNode = newFile->GetFileList()->Front(); fNode; fNode = fNode->next() )
	{
		C_File *f = fNode->Data();
		if ( f->GetFileType() != FILETYPE_MOD ) continue;
		if ( !f->IsFakePatch() ) continue;
		if (!f->checkFileExt(L"cat")) continue;
 
		if (newFile->extractFile(f, m_sTempDir.toString()) )
			f->setFullDir(m_sTempDir);
	}
 
	// compare mod files against all installed packages
	int count = 0;

	
	for ( CListNode<C_File> *fNode = newFile->GetFileList()->Front(); fNode; fNode = fNode->next() )
	{
		C_File *f = fNode->Data();
		CFileIO::Remove(f->filePointer());
		f->setFullDir(L"");
	}
 
	return count;
}
 

}
 
void CPackages::ApplyFakePatchOrder(Utils::CStringList *list)
{
	if ( !list ) return;
	_lFakePatchOrder.clear();
	for(auto itr = list->begin(); itr != list->end(); itr++)
		_lFakePatchOrder.pushBack((*itr)->str, (*itr)->data);
}
 
SAvailablePackage *CPackages::CreateAvailablePackageData(CBaseFile *package)
{
	if ( !package ) return NULL;

	else 
	{
		p->iType = ((CSpkFile *)package)->GetPackageType();
		p->iScriptType = ((CSpkFile *)package)->GetScriptType();
	}
	p->sAuthor = package->author().toWString();
	p->sDesc = package->description().toWString().findReplace(L"\n", L"::newline::");
	p->sName = package->name().toWString();
	p->sUpdated = package->creationDate().toWString();
	p->sVersion = package->version().toWString();
	p->sFilename = CFileIO(package->filename()).filename();
 
	return p;
}
 
Utils::WString CPackages::FormatAvailablePackageData(CBaseFile *package)
{
	SAvailablePackage *p = CPackages::CreateAvailablePackageData(package);
	Utils::WString ret = CPackages::FormatAvailablePackageData(p);
	delete p;
	return ret;
}
 
Utils::WString CPackages::FormatAvailablePackageData(SAvailablePackage *package)
{
	Utils::WString ret = (long)package->iType;
 
	Utils::WString gameCompat;
	for ( CListNode<SGameCompat> *node = package->lGames.Front(); node; node = node->next() ) {
		if ( !gameCompat.empty() )
			gameCompat += L"!";
		gameCompat += Utils::WString::Number(node->Data()->iGame);
	}
 
	if ( gameCompat.empty() )
		gameCompat = L"0";
 
	ret = ret.addToken(L"::", gameCompat);
	ret = ret.addToken(L"::", package->sName);
	ret = ret.addToken(L"::", package->sAuthor);
	ret = ret.addToken(L"::", package->sVersion);
	ret = ret.addToken(L"::", package->sUpdated);
	ret = ret.addToken(L"::", package->sFilename);
	ret = ret.addToken(L"::", Utils::WString::Number(package->iEase));
	ret = ret.addToken(L"::", Utils::WString::Number(package->iChanging));
	ret = ret.addToken(L"::", Utils::WString::Number(package->iRec));
	ret = ret.addToken(L"::", Utils::WString::Number(package->iPluginType));
	ret = ret.addToken(L"::", Utils::WString::Number(package->iScriptType));
	ret = ret.addToken(L"::", (package->bSigned) ? L"1" : L"0");
	ret = ret.addToken(L"::", package->sDesc);
 
	return ret;
}
 
void CPackages::parseAvailablePackage(const Utils::WString &str, const Utils::WString &webaddress)
{
	// first check game
	int num = 0;
	std::vector<Utils::WString> tok;
	if (!str.tokenise(L"::", tok))
		return;
	// invalid number of entries?
	if ( num < 7 ) return;
 
	SAvailablePackage *p = new SAvailablePackage;
	p->iType = tok[0].toLong();
	p->bSigned = false;
 
	// theres multiple games, so we need to split it
	if ( m_iGame ) {
		Utils::WString sGame = tok[1];
		if ( sGame.contains(L"!") ) {
			for(int i = 1; i <= sGame.countToken(L"!"); i++) {
				SGameCompat *gc = new SGameCompat;
				gc->iVersion = 0;
				gc->iGame = sGame.token(L"!", i).toLong();
				p->lGames.push_back(gc);
			}
		}
		else {
			SGameCompat *gc = new SGameCompat;

	p->sName = tok[2];
	p->sAuthor = tok[3];
	p->sVersion = tok[4];
	p->sUpdated = tok[5];
	p->sFilename = tok[6];
 
	if ( !webaddress.empty() )
		p->sFilename = webaddress + L"/" + p->sFilename;
 
	p->iChanging = p->iEase = p->iPluginType = p->iRec = p->iScriptType = -1;
 
	// check if we have the extra values
	if ( num >= 12 )

		p->iScriptType = tok[11].toLong();
		if ( num > 12 ) {
			if ( num > 13 ) {
				p->sDesc = tok[13];
				p->bSigned = tok[12].toBool();
			}
			else
				p->sDesc = tok[12];
		}
	}
	else if ( num > 7 )
		p->sDesc = tok[8];
 
	if ( !p->sDesc.empty() )
		p->sDesc = p->sDesc.findReplace(L"::newline::", L"\\n");
 
	addAvailablePackage(p);
 
 
}
 
const SAvailablePackage* CPackages::findAvailablePackage(const Utils::WString& filename) const
{
	for (CListNode<SAvailablePackage>* node = m_lAvailablePackages.Front(); node; node = node->next())
	{
		if (node->Data()->sFilename.Compare(filename))
			return node->Data();
	}
	return NULL;
}
const SAvailablePackage* CPackages::findAvailablePackage(const Utils::WString& name, const Utils::WString& author) const
{
	for (CListNode<SAvailablePackage>* node = m_lAvailablePackages.Front(); node; node = node->next())
	{
		if (node->Data()->sName.Compare(name) && node->Data()->sAuthor.Compare(author))
			return node->Data();
	}
	return NULL;
}
 
CBaseFile* CPackages::findFoundPackage(const Utils::WString& name, const Utils::WString& author) const
{
	for (CListNode<CBaseFile>* node = m_lFoundPackages.Front(); node; node = node->next())
	{
		if (node->Data()->name().toWString().Compare(name) &&; node->;Data()->author().toWString().Compare(author))
			return node->Data();
	}
	return NULL;
}
 

	}
 
	// check if a matching package is already found
	const CBaseFile* bf = findFoundPackage(package->sName, package->sAuthor);
	if (bf)
	{
		if (bf->version().toWString().compareVersion(package->sVersion) <= 0)
			return true;		
	}
 
	const SAvailablePackage *p = findAvailablePackage(package->sFilename);
	if(p)
	{
		if (p->sVersion.compareVersion(package->sVersion) <= 0)
			return true;
		m_lAvailablePackages.remove(p);
	}
 
	p = findAvailablePackage(package->sName, package->sAuthor);
	if (p)
	{
		if (p->sVersion.compareVersion(package->sVersion) <= 0)
			return true;
		m_lAvailablePackages.remove(p);
	}
 
	m_lAvailablePackages.push_back(package); 
	saveAvailablePackages();
	return true;
}
 
void CPackages::saveAvailablePackages()
{
	std::vector<Utils::WString> lines;
 
	lines.push_back(L"Version;1;" + Utils::WString::Number(m_lAvailablePackages.size()));
 
	for (auto itr = m_lAvailablePackages.First(); itr; itr = m_lAvailablePackages.Next())
	{
		Utils::WString l = L"Package";
		l += L";" + itr->sName.findReplace(L";", L":&COL&:");
		l += L";" + itr->sAuthor.findReplace(L";", L":&COL&:");
		l += L";" + itr->sVersion.findReplace(L";", L":&COL&:");
		l += L";" + itr->sFilename;
		l += L";" + itr->sDesc.findReplace(L";", L":&COL&:");
		l += L";" + itr->sUpdated;
 
		l += L";" + Utils::WString::Number(itr->lGames.size());
 
		for (auto g = itr->lGames.First(); g; g = itr->lGames.Next())
			l += L";" + Utils::WString::Number(g->iGame) + L";" + Utils::WString::Number(g->iVersion) + L";" + g->sVersion;
 
 
 
 
 
 
		l += L";" + Utils::WString::Number(itr->iType);
		l += L";" + Utils::WString::Number(itr->iPluginType);
		l += L";" + Utils::WString::Number(itr->iScriptType);
		l += L";" + Utils::WString::Number(itr->iChanging);
		l += L";" + Utils::WString::Number(itr->iEase);
		l += L";" + Utils::WString::Number(itr->iRec);
		l += itr->bSigned ? L";1" : L";0";
 
		lines.push_back(l);
	}
 
	// write out the file
	CDirIO dir(m_sCurrentDir + L"/PluginManager");
	if (!dir.exists())
		dir.create();
	CFileIO file(dir.file(L"packagecache.new"));
	if (file.writeFile(lines))
	{
		if (CFileIO::Exists(dir.file(L"packagecache.new")))
		{
			if (CFileIO::Exists(dir.file(L"packagecache.dat")))
				CFileIO::Remove(dir.file(L"packagecache.dat"));
			file.Rename(dir.file(L"packagecache.dat"));
		}
	}
}
 
void CPackages::readAvailablePackages()
{
	m_lAvailablePackages.MemoryClear();
 
	CDirIO dir(m_sCurrentDir + L"/PluginManager");
	CFileIO file(dir.file(L"packagecache.dat"));
 
	if (file.exists())
	{
 
		size_t version = 0;
		size_t count = 0;
		std::vector<Utils::WString> lines;
		if (file.readLines(lines))
		{
			for (auto itr = lines.begin(); itr != lines.end(); itr++)
			{
				Utils::WString cmd = itr->token(L";", 1);
				if (cmd == L"Version")
				{
					version = itr->token(L";", 2).toInt();
					count = itr->token(L";", 3).toInt();
				}
				else if (cmd == L"Package")
				{
					int max = 0;
					std::vector<Utils::WString> str;
					itr-&gt;tokenise(L";", str);
 
					SAvailablePackage* package = new SAvailablePackage;
					int pos = 1;
					package->sName = str[pos++].findReplace(L":&COL&:", L";");
					package->sAuthor = str[pos++].findReplace(L":&COL&:", L";");
					package->sVersion = str[pos++].findReplace(L":&COL&:", L";");
					package->sFilename = str[pos++].findReplace(L":&COL&:", L";");
					package->sDesc = str[pos++].findReplace(L":&COL&:", L";");
					package->sUpdated = str[pos++].findReplace(L":&COL&:", L";");
 
					size_t games = str[pos++].toInt();
					for (size_t i = 0; i < games; i++)
					{
						SGameCompat* g = new SGameCompat;

					package->iPluginType = str[pos++].toInt();
					package->iScriptType = str[pos++].toInt();
					package->iChanging = str[pos++].toInt();
					package->iEase = str[pos++].toInt();
					package->iRec = str[pos++].toInt();
					package->bSigned = (str[pos] == L"1");
 
 
 
					addAvailablePackage(package);
				}
			}
		}

					list->pushBack((*itr)->str);
			}
		}
	}
 
	CFileIO File(L"data\\web");
 
	if ( File.startRead() ) {
		while(!File.atEnd()) {
			Utils::String line = File.readEndOfLineStr();
			line.removeChar("\n\r\t ");
			if (!line.empty())
			{
				if(!list->contains(line))
					list->pushBack(line);

	size_t size;
	char *data = CFileIO(filename).ReadToData(&size);
	if ( size && data )
		readArchiveData(data, size, archive);
}
 
void CPackages::readArchiveData(const char *buf, size_t len, CBaseFile *archive) const
{
	Utils::WStringList otherGames;
	Utils::WStringList gameAddons;
	for (unsigned int i = 0; i < m_gameExe.gameCount(); ++i)
	{
		SGameExe *exe = m_gameExe.game(i);
		if (!exe->sAddon.empty())
			gameAddons.pushBack(Utils::WString::Number(i + 1), exe->sAddon);
	}
 
	Utils::WString data(buf);
 
	std::vector<Utils::WString&gt; str;
	if(data.tokenise(L&quot;\n", str))
	{
		for(size_t i = 0; i < str.size(); i++ )
		{
			Utils::WString line = str[i];
			if ( line.empty() )
				continue;
 
			// filter out any spaces, tabs in front
			line.removeChar('\t');
			line.removeChar('\r');
			Utils::WString linenospace = line;
			linenospace.removeFirstSpace();
			if ( linenospace.empty() )
				continue;
 
			// check for any comments
			if ( linenospace.left(2) == L"//" )
				continue;
			if ( linenospace[0] == L'#' )
				continue;
 
			// all commands start with a keyword followed by a colon, if one doesn't exist, it cant be a valid line
			if ( !line.contains(':'))
				continue;
 
			Utils::WString first = line.token(L":", 1);
			Utils::WString rest = line.tokens(L":", 2).removeFirstSpace();
 
			Utils::WString checkType = first;
			bool shared = false;
			if ( checkType.left(6).Compare(L"Shared") )
			{
				checkType = first.right(-6);
				shared = true;
			}
			bool packed = false;
			if (checkType.right(3).compare(L"PCK"))
			{
				checkType = checkType.left(-3);
				packed = true;
			}
 
			// now check type name
			int filetype = GetFileTypeFromString(checkType);
			if (filetype == -1)
			{
				archive->loadPackageData(first, rest, Utils::WString::Null(), otherGames, gameAddons, NULL);
			}
		}
	}
 
 
}
 
CBaseFile *CPackages::_archive_fromRar(const Utils::String &filename, bool toInstall) const
{
	// make sure we can open the zip file

 
	bool error = false;
	Utils::WString extractedFile = CDirIO(m_sTempDir).file("extracted.tst").findReplace(L"/", L"\\").findReplace(L"\\\\", L"\\");
	while ((RHCode=RARReadHeaderEx(hArcData,&HeaderData))==0)
	{
		Utils::WString fileName = HeaderData.FileName;
 
		if ( HeaderData.FileAttr == 16 )
			continue;
		PFCode=RARProcessFileW(hArcData, RAR_EXTRACT, NULL, NULL);
		if (PFCode!=0)

		}
 
		CFileIO File(fileName);
		if ( File.exists() )
		{
			if ( fileName.Compare(L"pluginmanager.txt") )
				this->readArchiveData(File.fullFilenameStr(), archive);
			else
			{
				Utils::WString extradir;
				int type = SPK::GetAutomaticFiletype(fileName, &extradir, true);
				// check for special file types
				C_File *f = NULL;
 
				if ( type == FILETYPE_SCRIPT_UNINSTALL ) {
					f = archive->addFile(CFileIO(fileName).filename(), L"", FILETYPE_SCRIPT);
					if ( f ) {
						f->readFromFile(File.fullFilename());
					}
					type = FILETYPE_UNINSTALL;
				}
 
				if ( type == -1 )
					f = archive->addFile(CFileIO(fileName).filename(), CFileIO(fileName).dir(), FILETYPE_EXTRA);
				else
					f = archive->addFile(CFileIO(fileName).filename(), extradir, static_cast<FileType>(type));
				f->readFromFile(File.fullFilenameStr());
			}
 
			File.remove();
		}
	}
 
	RARCloseArchive(hArcData);
 
	if ( error )
	{
		delete archive;
		archive = NULL;

	CloseZip(hz);
 
	hz = OpenZip(buf, 0);
	if ( !hz ) 
		return NULL;
 
	// create the correct package
	if ( toInstall )
		archive = new CArchiveFile(); // just installing an archive file
	else
		archive = new CSpkFile(); // converting to a spk file
 
	GetZipItem(hz, -1, &ze);
	int numitems = ze.index;
 
	bool error = false;
	for ( int zi = 0; zi < numitems; zi++ )
	{
		ZIPENTRY ze;
		if ( GetZipItem(hz, zi, &ze) != Z_OK )
		{
			error = true;
			break;
		}
 
		if ( ze.attr & FILE_ATTRIBUTE_DIRECTORY )
			continue; // dont do directories
 
 
		char *iBuf = new char[ze.unc_size];
		UnzipItem(hz, zi, iBuf, ze.unc_size);
 
		Utils::String Name(ze.name);
 
		// if its the data file, dont add it, but extract to get settings from
		if ( Name.Compare("pluginmanager.txt") )
		{
			this->readArchiveData(iBuf, ze.unc_size, archive);
			delete[] iBuf;
		}
		else
		{
			Utils::WString extradir;
			int type = SPK::GetAutomaticFiletype(Name, &extradir, true);
 
			C_File *f = NULL;
 
			Utils::WString filename = CFileIO(Name).filename();
			Utils::WString dir = CFileIO(Name).dir();
 
			// check for special file types
			if ( type == FILETYPE_SCRIPT_UNINSTALL ) {
				f = archive->addFile(filename, dir, FILETYPE_SCRIPT);
				if ( f ) {

 
			int game = 0;
			// check for addons
			if (dir.contains('/', true)) 
			{
				Utils::WString first = dir.token(L"/", 1);
				int g = m_gameExe.findAddonType(first);
				if (g != -1)
					game = g + 1;
			}
 

 
	if ( error )
	{
		delete archive;
		archive = NULL;
	}
	return archive;
}
 
CBaseFile *CPackages::createFromArchive(const Utils::String &filename, bool toInstall) const
{
	// make sure we can open the zip file

	}
 
	return archive;
}
 
Utils::WString CPackages::CreateFromPackagerScript(CPackages *packages, const Utils::WString &filename)
{
	Utils::WString curDir = CFileIO(filename).dir();
	Utils::WStringList variables;
	variables.pushBack(L"$PATH", curDir);
	CBaseFile *package = packages->loadPackagerScript(filename, NULL, NULL, NULL, &variables);
 
	if ( !package )
		return Utils::String::Null();
 
	Utils::WString saveto = package->filename();
	saveto = saveto.findReplace(L"$DEFAULTDIR", curDir + L"/");
	saveto = saveto.findReplace(L"$PATH", curDir);
	saveto = saveto.findReplace(L"\\", L"/");
	saveto = saveto.findReplace(L"//", L"/");
	if ( !saveto.right(4).Compare(L".spk") && package->GetType() != TYPE_XSP )
		saveto += L".spk";
	else if ( !saveto.right(4).Compare(L".xsp") && package->GetType() == TYPE_XSP )
		saveto += L".xsp";
 
	// write script
	if ( package->writeFile(saveto.toString()) )
	{
		if ( package->AutoGenerateUpdateFile() )
			package->createUpdateFile(CFileIO(saveto).dir());
		return saveto;
	}
 
	return Utils::String::Null();
}
 
int CPackages::GeneratePackageUpdateData(const Utils::WString &dir, bool includeSingle)
{
	Utils::WStringList filedata;
 
	CPackages packages;
 
	CDirIO Dir(dir);
	for ( int i = 0; i < 2; i++ )
	{
		Utils::WString pattern;
		if ( i == 0 ) pattern = L"*.spk";
		else if ( i == 1 ) pattern = L".xsp";
		else break;
 
		Utils::WStringList files;
		if(Dir.dirList(files, L"", pattern))
		{
			for(auto itr = files.begin(); itr != files.end(); itr++)
			{
				int error = 0;
				CBaseFile *p = packages.openPackage(Dir.file((*itr)->str), &error, 0, SPKREAD_NODATA);
				if ( !p )
					continue;
 
				if ( includeSingle )
					p->createUpdateFile(dir);

		}
	}
 
	if ( !filedata.empty() )
	{
		CFileIO File(dir + L"/xpackagedata.dat");
		if ( File.writeFile(&filedata) )
			return filedata.size();
	}
 
	return 0;
}
 
size_t CPackages::verifyInstalledFiles(Utils::WStringList *missingFiles, bool getPackages) const
{
	int count = 0;
	for ( CListNode<C_File> *fn = m_lFiles.Front(); fn; fn = fn->next() )
	{
		C_File *f = fn->Data();
		bool exists = false;
		if ( f->filePointer().contains(L"::") ) {
			Utils::WString modFile = f->filePointer().token(L"::", 1);
			Utils::WString file = f->filePointer().token(L"::", 2);
 
			if ( CFileIO::Exists(modFile)) {
				CCatFile catFile;
				if ( catFile.open(modFile, L"", CATREAD_CATDECRYPT, false) == CATERR_NONE ) {
					if ( catFile.findData(file) )
						exists = true;
				}
			}
		}

		if ( !exists )
		{
			++count;
			if ( missingFiles )
			{
				Utils::WString packages;
				if ( getPackages )
				{
					for ( CListNode<CBaseFile> *p = m_lPackages.Front(); p; p = p->next() )
					{
						CBaseFile *package = p->Data();
						if ( package->IsFileAdded(f) )
						{
							if ( !packages.empty() )
								packages += L"\n";
							packages += package->getFullPackageName(m_iLanguage).toWString();
						}
					}
				}
				Utils::WString filename = f->filePointer();
				filename = filename.findRemove(m_sCurrentDir);
				missingFiles->pushBack(filename, packages);
			}
		}
	}

Rev 196	Rev 197
Line 28...	Line 28...
28	`typedef struct SComponantEntry {`	28	`typedef struct SComponantEntry {`
29	`Utils::String sSection;`	29	`Utils::String sSection;`
30	`CLinkList<SComponantEntry2> lEntries;`	30	`CLinkList<SComponantEntry2> lEntries;`
31	`} SComponantEntry;`	31	`} SComponantEntry;`
32		32
33	`Utils::String CPackages::m_sTempDir;`	33	`Utils::WString CPackages::m_sTempDir;`
34		34
35	`//////////////////////////////////////////////////////////////////////////////////////`	35	`//////////////////////////////////////////////////////////////////////////////////////`
36		36
37	`//////////////////////////////////////////////////////////////////////////////////////`	37	`//////////////////////////////////////////////////////////////////////////////////////`
38		38
Line 74...	Line 74...
74	`m_lDisableList.clear();`	74	`m_lDisableList.clear();`
75	`m_lEnableList.clear();`	75	`m_lEnableList.clear();`
76	`this->Reset();`	76	`this->Reset();`
77	`}`	77	`}`
78		78
79	`void CPackages::setCurrentDir(const Utils::String &dir)`	79	`void CPackages::setCurrentDir(const Utils::WString &dir)`
80	`{`	80	`{`
81	`m_sCurrentDir = dir;`	81	`m_sCurrentDir = dir;`
82	`if (_pCurrentDir) delete _pCurrentDir;`	82	`if (_pCurrentDir) delete _pCurrentDir;`
83	`_pCurrentDir = new GameDirectory();`	83	`_pCurrentDir = new GameDirectory();`
84	`_pCurrentDir->dir = dir;`	84	`_pCurrentDir->dir = dir;`
85	`_pCurrentDir->id = -1;`	85	`_pCurrentDir->id = -1;`
86		86
87	`m_gameExe.GetDirectoryData(_pCurrentDir);`	87	`m_gameExe.getDirectoryData(_pCurrentDir);`
88	`_pCurrentDir->langid = this->getGameLanguage(_pCurrentDir->dir);`	88	`_pCurrentDir->langid = this->getGameLanguage(_pCurrentDir->dir.toString());`
89	`if (_pCurrentDir->langid > 0)`	89	`if (_pCurrentDir->langid > 0)`
90	`_pCurrentDir->langname = this->ConvertLanguage(_pCurrentDir->langid);`	90	`_pCurrentDir->langname = this->ConvertLanguage(_pCurrentDir->langid).toWString();`
91		91
92	`updateFoundPackages("");`	92	`updateFoundPackages("");`
93	`}`	93	`}`
94		94
95		95
Line 101...	Line 101...
101	`}`	101	`}`
102	`}`	102	`}`
103	`m_bVanilla = b;`	103	`m_bVanilla = b;`
104	`}`	104	`}`
105		105
106	`void CPackages::setMod(const Utils::String &mod)`	106	`void CPackages::setMod(const Utils::WString &mod)`
107	`{`	107	`{`
108	`if (mod != "PluginManager")`	108	`if (mod != L"PluginManager")`
109	`m_sSetMod = mod;`	109	`m_sSetMod = mod;`
110	`}`	110	`}`
111		111
112	`void CPackages::setSaveGameManager(bool managed)`	112	`void CPackages::setSaveGameManager(bool managed)`
113	`{`	113	`{`
Line 118...	Line 118...
118	`// find new save directory`	118	`// find new save directory`
119	`CDirIO dir(this->saveDirectory());`	119	`CDirIO dir(this->saveDirectory());`
120	`if (dir.exists())`	120	`if (dir.exists())`
121	`{`	121	`{`
122	`int id = 1;`	122	`int id = 1;`
123	`while (dir.exists(Utils::String::PadNumber(id, 4)))`	123	`while (dir.exists(Utils::WString::PadNumber(id, 4)))`
124	`++id;`	124	`++id;`
125	`Utils::String d = Utils::String::PadNumber(id, 4);`	125	`Utils::WString d = Utils::WString::PadNumber(id, 4);`
126	`dir.create(d);`	126	`dir.create(d);`
127	`_sSaveDir = d;`	127	`_sSaveDir = d;`
128		128
129	`CDirIO destDir1(dir.dir(d));`	129	`CDirIO destDir1(dir.dir(d));`
130	`destDir1.create("Vanilla");`	130	`destDir1.create(L"Vanilla");`
131	`destDir1.cd("Vanilla");`	131	`destDir1.cd(L"Vanilla");`
132	`CDirIO destDir2(dir.dir(d));`	132	`CDirIO destDir2(dir.dir(d));`
133	`destDir2.create("Modified");`	133	`destDir2.create(L"Modified");`
134	`destDir2.cd("Modified");`	134	`destDir2.cd(L"Modified");`
135		135
136	`Utils::CStringList files;`	136	`Utils::WStringList files;`
137	`if (dir.dirList(files, Utils::String::Null(), "*.sav"))`	137	`if (dir.dirList(files, Utils::WString::Null(), L"*.sav"))`
138	`{`	138	`{`
139	`for (auto itr = files.begin(); itr != files.end(); ++itr)`	139	`for (auto itr = files.begin(); itr != files.end(); ++itr)`
140	`{`	140	`{`
141	`Utils::WString f = dir.file((*itr)->str);`	141	`Utils::WString f = dir.file((*itr)->str);`
142	`CFileIO(f).copy(destDir1.file((*itr)->str));`	142	`CFileIO(f).copy(destDir1.file((*itr)->str));`
Line 187...	Line 187...
187	`m_lFoundPackages.MemoryClear();`	187	`m_lFoundPackages.MemoryClear();`
188	`m_lInstallList.MemoryClear();`	188	`m_lInstallList.MemoryClear();`
189	`m_lEnableList.MemoryClear();`	189	`m_lEnableList.MemoryClear();`
190	`m_lDisableList.MemoryClear();`	190	`m_lDisableList.MemoryClear();`
191		191
192	`m_lCreatedFiles.clear();`	192	`_lCreatedFiles.clear();`
193	`m_lNonRemovedFiles.clear();`	193	`_lNonRemovedFiles.clear();`
194	`m_lGlobals.clear();`	194	`_lGlobals.clear();`
195	`m_lFakePatchOrder.clear();`	195	`_lFakePatchOrder.clear();`
196	`if (_pCurrentDir)`	196	`if (_pCurrentDir)`
197	`delete _pCurrentDir;`	197	`delete _pCurrentDir;`
198	`_pCurrentDir = NULL;`	198	`_pCurrentDir = NULL;`
199	`}`	199	`}`
200		200
Line 252...	Line 252...
252	`}`	252	`}`
253		253
254	`return oldPlugin;`	254	`return oldPlugin;`
255	`}`	255	`}`
256		256
257	`bool CPackages::read(const Utils::String& dir, CProgressInfo* progress)`	257	`bool CPackages::read(const Utils::WString& dir, CProgressInfo* progress)`
258	`{`	258	`{`
259	`m_sCurrentDir = dir;`	259	`m_sCurrentDir = dir;`
260	`m_sCurrentDir = m_sCurrentDir.findReplace("\\", "/");`	260	`m_sCurrentDir = m_sCurrentDir.findReplace("\\", "/");`
261	`this->setCurrentDir(dir);`	261	`this->setCurrentDir(dir);`
262	`m_bOldPlugin = false;`	262	`m_bOldPlugin = false;`
263	`m_lCreatedFiles.clear();`	263	`_lCreatedFiles.clear();`
264	`m_bRemoveDir = false;`	264	`m_bRemoveDir = false;`
265	`m_bSurpressProtectedWarning = false;`	265	`m_bSurpressProtectedWarning = false;`
266	`m_iSaveGame = -1;`	266	`m_iSaveGame = -1;`
267	`m_iSaveGameManager = -1;`	267	`m_iSaveGameManager = -1;`
268	`m_lNonRemovedFiles.clear();`	268	`_lNonRemovedFiles.clear();`
269	`m_lGlobals.clear();`	269	`_lGlobals.clear();`
270	`m_lFakePatchOrder.clear();`	270	`_lFakePatchOrder.clear();`
271		271
272	`if ( _pOriginalFiles ) delete _pOriginalFiles;`	272	`if ( _pOriginalFiles ) delete _pOriginalFiles;`
273	`_pOriginalFiles = new COriginalFiles(m_sCurrentDir);`	273	`_pOriginalFiles = new COriginalFiles(m_sCurrentDir);`
274		274
275	`m_bVanilla = true;`	275	`m_bVanilla = true;`
276		276
277	`// check the pluginmanager data file exists`	277	`// check the pluginmanager data file exists`
278	`CFileIO datFile(m_sCurrentDir + "/PluginManager/pluginmanager.dat");`	278	`CFileIO datFile(m_sCurrentDir + L"/PluginManager/pluginmanager.dat");`
279	`if ( datFile.exists() )`	279	`if ( datFile.exists() )`
280	`{`	280	`{`
281	`std::vector<Utils::String> *readFile = datFile.readLines();`	281	`std::vector<Utils::WString> readFile;`
282	`if ( readFile )`	282	`if(datFile.readLines(readFile))`
283	`{`	283	`{`
284	`float fVersion = 0;`	284	`float fVersion = 0;`
285	`bool spkinstaller = false;`	285	`bool spkinstaller = false;`
286	`float fBeta = 0;`	286	`float fBeta = 0;`
287		287
Line 289...	Line 289...
289	`int iCount = 0;`	289	`int iCount = 0;`
290	`int iWare = -1;`	290	`int iWare = -1;`
291	`int iShip = -1;`	291	`int iShip = -1;`
292		292
293	`CBaseFile *packageFile = 0;`	293	`CBaseFile *packageFile = 0;`
294		294
295	`for ( int i = 0; i < (int)readFile->size(); i++ )`	295	`for ( int i = 0; i < (int)readFile.size(); i++ )`
296	`{`	296	`{`
297	`Utils::String line(readFile->at(i));`	297	`Utils::WString line(readFile.at(i));`
298		298
299	`Utils::String cmd = line.token(":", 1).lower();`	299	`Utils::WString cmd = line.token(L":", 1).lower();`
300	`Utils::String rest = line.tokens(":", 2).removeFirstSpace();`	300	`Utils::WString rest = line.tokens(L":", 2).removeFirstSpace();`
301		301
302	`if ( iStatus == READ_GLOBAL )`	302	`if ( iStatus == READ_GLOBAL )`
303	`{`	303	`{`
304	`if ( cmd == "<script>" )`	304	`if ( cmd == L"<script>" )`
305	`{`	305	`{`
306	`packageFile = new CSpkFile();`	306	`packageFile = new CSpkFile();`
307	`iStatus = READ_SCRIPT;`	307	`iStatus = READ_SCRIPT;`
308	`}`	308	`}`
309	`else if ( cmd == "<ship>" )`	309	`else if ( cmd == L"<ship>" )`
310	`{`	310	`{`
311	`packageFile = new CXspFile();`	311	`packageFile = new CXspFile();`
312	`iStatus = READ_SCRIPT;`	312	`iStatus = READ_SCRIPT;`
313	`}`	313	`}`
314	`else if ( cmd == "<base>" )`	314	`else if ( cmd == L"<base>" )`
315	`{`	315	`{`
316	`packageFile = new CBaseFile();`	316	`packageFile = new CBaseFile();`
317	`iStatus = READ_SCRIPT;`	317	`iStatus = READ_SCRIPT;`
318	`}`	318	`}`
319	`else if ( cmd == "<archive>" )`	319	`else if ( cmd == L"<archive>" )`
320	`{`	320	`{`
321	`packageFile = new CArchiveFile();`	321	`packageFile = new CArchiveFile();`
322	`iStatus = READ_SCRIPT;`	322	`iStatus = READ_SCRIPT;`
323	`}`	323	`}`
324	`else if ( cmd != "</scripts>" )`	324	`else if ( cmd != L"</scripts>" )`
325	`{`	325	`{`
326	`int game = 0;`	326	`int game = 0;`
327	`bool disabled = false;`	327	`bool disabled = false;`
328	`Utils::String fileName = line.tokens(":", 5);`	328	`Utils::WString fileName = line.tokens(L":", 5);`
329	`Utils::String origName;`	329	`Utils::WString origName;`
330	`if ( fileName.left(2) == "D#" )`	330	`if ( fileName.left(2) == L"D#" )`
331	`{`	331	`{`
332	`fileName.erase(0, 2);`	332	`fileName.erase(0, 2);`
333	`disabled = true;`	333	`disabled = true;`
334	`}`	334	`}`
335	`if ( fileName.left(2) == "G#" ) {`	335	`if ( fileName.left(2) == L"G#" ) {`
336	`fileName.erase(0, 2);`	336	`fileName.erase(0, 2);`
337	`game = fileName.token("#", 1).toLong();`	337	`game = fileName.token(L"#", 1).toLong();`
338	`fileName = fileName.tokens("#", 2);`	338	`fileName = fileName.tokens(L"#", 2);`
339	`}`	339	`}`
340	`if ( fileName.isin("O#") )`	340	`if ( fileName.isin(L"O#") )`
341	`{`	341	`{`
342	`origName = fileName.token("O#", 2);`	342	`origName = fileName.token(L"O#", 2);`
343	`fileName = fileName.token("O#", 1);`	343	`fileName = fileName.token(L"O#", 1);`
344	`}`	344	`}`
345		345
346	`C_File *newFile = new C_File(m_sCurrentDir + fileName);`	346	`C_File *newFile = new C_File(m_sCurrentDir + fileName);`
347	`newFile->setGame(game);`	347	`newFile->setGame(game);`
348	`newFile->SetOriginalName(origName);`	348	`newFile->SetOriginalName(origName);`
349	`newFile->SetDisabled(disabled);`	349	`newFile->SetDisabled(disabled);`
350	`newFile->setFileType((FileType)line.token(":", 1).toLong());`	350	`newFile->setFileType(static_cast<FileType>(line.token(L":", 1).toLong()));`
351	`newFile->SetCreationTime((time_t)line.token(":", 2).toLong());`	351	`newFile->SetCreationTime(static_cast<time_t>(line.token(L":", 2).toLong()));`
352	`newFile->setDir(line.token(":", 3));`	352	`newFile->setDir(line.token(L":", 3));`
353	`if ( line.token(":", 4).toLong() )`	353	`if ( line.token(L":", 4).toLong() )`
354	`newFile->SetShared(true);`	354	`newFile->SetShared(true);`
355	`newFile->UpdateSigned();`	355	`newFile->UpdateSigned();`
356		356
357	`m_lFiles.push_back(newFile);`	357	`m_lFiles.push_back(newFile);`
358	`}`	358	`}`
359	`}`	359	`}`
360	`else if ( iStatus == READ_SCRIPT )`	360	`else if ( iStatus == READ_SCRIPT )`
361	`{`	361	`{`
362	`if ( cmd == "installspk" )`	362	`if ( cmd == L"installspk" )`
363	`packageFile->setFilename(rest);`	363	`packageFile->setFilename(rest);`
364	`else if ( cmd == "files" )`	364	`else if ( cmd == L"files" )`
365	`{`	365	`{`
366	`iStatus = READ_SCRIPTFILE;`	366	`iStatus = READ_SCRIPTFILE;`
367	`if ( spkinstaller )`	367	`if ( spkinstaller )`
368	`{`	368	`{`
369	`int max;`	369	`std::vector<Utils::WString> files;`
370	`Utils::String *files = rest.tokenise("; ", &max);`	370	`rest.tokenise(L"; ", files);`
371		-
372	`for ( int i = 0; i < max; i++ )`	371	`for (size_t i = 0; i < files.size(); i++ )`
373	`{`	372	`{`
374	`int fileNum = files[i].toLong();`	373	`int fileNum = files[i].toLong();`
375	`if ( fileNum >= 0 && fileNum < m_lFiles.size() )`	374	`if ( fileNum >= 0 && fileNum < m_lFiles.size() )`
376	`packageFile->AddFile(m_lFiles[fileNum]);`	375	`packageFile->AddFile(m_lFiles[fileNum]);`
377	`}`	376	`}`
378		-
379	`CLEANSPLIT(files, max);`	-
380	`}`	377	`}`
381	`}`	378	`}`
382	`else if ( cmd == "disabled" )`	379	`else if ( cmd == L"disabled" )`
383	`packageFile->SetEnabled(false);`	380	`packageFile->SetEnabled(false);`
384	`else if ( cmd == "modifieddisabled" )`	381	`else if ( cmd == L"modifieddisabled" )`
385	`packageFile->SetModifiedEnabled(false);`	382	`packageFile->SetModifiedEnabled(false);`
386	`else if ( cmd == "icon" )`	383	`else if ( cmd == L"icon" )`
387	`{`	384	`{`
388	`C_File *icon = new C_File(rest.tokens(" ", 2));`	385	`C_File *icon = new C_File(rest.tokens(L" ", 2));`
389	`packageFile->setIcon(icon, rest.token(" ", 1));`	386	`packageFile->setIcon(icon, rest.token(L" ", 1).toString());`
390	`}`	387	`}`
391	`else`	388	`else`
392	`packageFile->ParseValueLine(line);`	389	`packageFile->ParseValueLine(line.toString());`
393	`}`	390	`}`
394	`else if ( iStatus == READ_SCRIPTFILE )`	391	`else if ( iStatus == READ_SCRIPTFILE )`
395	`{`	392	`{`
396	`if ( cmd == "<script>" )`	393	`if ( cmd == L"<script>" )`
397	`{`	394	`{`
398	`if ( packageFile->IsMod() && packageFile->IsEnabled() )`	395	`if ( packageFile->IsMod() && packageFile->IsEnabled() )`
399	`m_pEnabledMod = packageFile;`	396	`m_pEnabledMod = packageFile;`
400		397
401	`m_lPackages.push_back(packageFile);`	398	`m_lPackages.push_back(packageFile);`
402	`this->ConvertOldPackage(packageFile);`	399	`this->ConvertOldPackage(packageFile);`
403	`packageFile = new CSpkFile();`	400	`packageFile = new CSpkFile();`
404	`iStatus = READ_SCRIPT;`	401	`iStatus = READ_SCRIPT;`
405		402
406	`}`	403	`}`
407	`else if ( cmd == "<ship>" )`	404	`else if ( cmd == L"<ship>" )`
-		405	`{`
-		406	`m_lPackages.push_back(packageFile);`
-		407	`this->ConvertOldPackage(packageFile);`
-		408	`packageFile = new CXspFile();`
-		409	`iStatus = READ_SCRIPT;`
-		410	`}`
-		411	`else if ( cmd == L"<base>" )`
408	`{`	412	`{`
409	`m_lPackages.push_back(packageFile);`	413	`m_lPackages.push_back(packageFile);`
410	`this->ConvertOldPackage(packageFile);`	414	`this->ConvertOldPackage(packageFile);`
411	`packageFile = new CXspFile();`	415	`packageFile = new CBaseFile();`
412	`iStatus = READ_SCRIPT;`	416	`iStatus = READ_SCRIPT;`
413	`}`	417	`}`
414	`else if ( cmd == "<base>" )`	-
415	`{`	-
416	`m_lPackages.push_back(packageFile);`	-
417	`this->ConvertOldPackage(packageFile);`	-
418	`packageFile = new CBaseFile();`	-
419	`iStatus = READ_SCRIPT;`	-
420	`}`	-
421	`else if ( cmd == "<archive>" )`	418	`else if ( cmd == L"<archive>" )`
422	`{`	419	`{`
423	`m_lPackages.push_back(packageFile);`	420	`m_lPackages.push_back(packageFile);`
424	`this->ConvertOldPackage(packageFile);`	421	`this->ConvertOldPackage(packageFile);`
425	`packageFile = new CArchiveFile();`	422	`packageFile = new CArchiveFile();`
426	`iStatus = READ_SCRIPT;`	423	`iStatus = READ_SCRIPT;`
427	`}`	424	`}`
428	`else if ( cmd == "</scripts>" )`	425	`else if ( cmd == L"</scripts>" )`
429	`{`	426	`{`
430	`if ( packageFile->IsMod() && packageFile->IsEnabled() )`	427	`if ( packageFile->IsMod() && packageFile->IsEnabled() )`
431	`m_pEnabledMod = packageFile;`	428	`m_pEnabledMod = packageFile;`
432		429
433	`m_lPackages.push_back(packageFile);`	430	`m_lPackages.push_back(packageFile);`
434	`this->ConvertOldPackage(packageFile);`	431	`this->ConvertOldPackage(packageFile);`
435	`}`	432	`}`
436	`else`	433	`else`
437	`{`	434	`{`
438	`int fileNum = line.token("::", 1).toLong();`	435	`int fileNum = line.token(L"::", 1).toLong();`
439	`if ( fileNum >= 0 && fileNum < m_lFiles.size() )`	436	`if ( fileNum >= 0 && fileNum < m_lFiles.size() )`
440	`packageFile->AddFile(m_lFiles[fileNum]);`	437	`packageFile->AddFile(m_lFiles[fileNum]);`
441	`}`	438	`}`
442	`}`	439	`}`
443	`else if ( iWare != -1 )`	440	`else if ( iWare != -1 )`
444	`{`	441	`{`
445	`--iCount;`	442	`--iCount;`
446		443
447	`SGameWare *gm = new SGameWare;`	444	`SGameWare *gm = new SGameWare;`
448	`gm->iPos = line.token(" ", 1).toLong();`	445	`gm->iPos = line.token(L" ", 1).toLong();`
449	`gm->iType = line.token(" ", 2).toLong();`	446	`gm->iType = line.token(L" ", 2).toLong();`
450	`gm->cType = line.token(" ", 3)[0];`	447	`gm->cType = line.token(L" ", 3)[0];`
451	`gm->pWare = NULL;`	448	`gm->pWare = NULL;`
452	`gm->sWareName = line.tokens(" ", 4);`	449	`gm->sWareName = line.tokens(L" ", 4);`
453	`m_lGameWares[iWare].push_back(gm);`	450	`m_lGameWares[iWare].push_back(gm);`
454	`if ( iCount <= 0 )`	451	`if ( iCount <= 0 )`
455	`iWare = -1;`	452	`iWare = -1;`
456	`}`	453	`}`
457	`else if ( iShip != -1 )`	454	`else if ( iShip != -1 )`
458	`{`	455	`{`
459	`--iCount;`	456	`--iCount;`
460		457
461	`SGameShip *gm = new SGameShip;`	458	`SGameShip *gm = new SGameShip;`
462	`gm->iType = line.token(" ", 1).toLong();`	459	`gm->iType = line.token(L" ", 1).toLong();`
463	`if ( line.token(" ", 2).left(4) == "$#C:" )`	460	`if ( line.token(L" ", 2).left(4) == L"$#C:" )`
464	`{`	461	`{`
465	`gm->sShipClass = line.token(" ", 2).right(-4);`	462	`gm->sShipClass = line.token(L" ", 2).right(-4);`
466	`gm->sShipID = line.tokens(" ", 3);`	463	`gm->sShipID = line.tokens(L" ", 3);`
467	`}`	464	`}`
468	`else`	465	`else`
469	`{`	466	`{`
470	`gm->sShipID = line.tokens(" ", 2);`	467	`gm->sShipID = line.tokens(L" ", 2);`
471	`gm->sShipClass = "OBJ_SHIP_M5";`	468	`gm->sShipClass = L"OBJ_SHIP_M5";`
472	`}`	469	`}`
473	`gm->pPackage = NULL;`	470	`gm->pPackage = NULL;`
474	`m_lGameShips.push_back(gm);`	471	`m_lGameShips.push_back(gm);`
475	`if ( iCount <= 0 )`	472	`if ( iCount <= 0 )`
476	`iShip = -1;`	473	`iShip = -1;`
477	`}`	474	`}`
478	`else if ( cmd.Compare("savegamemanager") )`	475	`else if ( cmd.Compare(L"savegamemanager") )`
479	`m_iSaveGameManager = rest.toLong();`	476	`m_iSaveGameManager = rest.toLong();`
480	`else if ( cmd.Compare("savegame") )`	477	`else if ( cmd.Compare(L"savegame") )`
481	`m_iSaveGame = rest.toLong();`	478	`m_iSaveGame = rest.toLong();`
482	`else if ( cmd == "fakepatch" )`	479	`else if ( cmd == L"fakepatch" )`
483	`m_iFakePatch = rest.toLong();`	480	`m_iFakePatch = rest.toLong();`
484	`else if ( cmd == "updatetime" )`	481	`else if ( cmd == L"updatetime" )`
485	`m_iLastUpdated = rest.toLong();`	482	`m_iLastUpdated = rest.toLong();`
486	`else if ( cmd == "surpressprotectedwarning" )`	483	`else if ( cmd == L"surpressprotectedwarning" )`
487	`m_bSurpressProtectedWarning = true;`	484	`m_bSurpressProtectedWarning = true;`
488	`else if ( cmd == "pluginmanager" )`	485	`else if ( cmd == L"pluginmanager" )`
489	`{`	486	`{`
490	`fVersion = rest.toFloat();`	487	`fVersion = rest.toFloat();`
491	`m_bOldPlugin = true;`	488	`m_bOldPlugin = true;`
492	`}`	489	`}`
493	`else if ( cmd == "setmod" )`	490	`else if ( cmd == L"setmod" )`
494	`m_sSetMod = rest;`	491	`m_sSetMod = rest;`
495	`else if ( cmd == "shipbuffer" )`	492	`else if ( cmd == L"shipbuffer" )`
496	`m_iShipBuffer = rest.toLong();`	493	`m_iShipBuffer = rest.toLong();`
497	`else if(cmd == "savedir")`	494	`else if(cmd == L"savedir")`
498	`_sSaveDir = rest;`	495	`_sSaveDir = rest;`
499	`else if ( cmd == "warebuffers" )`	496	`else if ( cmd == L"warebuffers" )`
500	`{`	497	`{`
501	`int max = rest.countToken(" ");`	498	`int max = rest.countToken(L" ");`
502	`for ( int i = 0; i < WAREBUFFERS; i++ )`	499	`for ( int i = 0; i < WAREBUFFERS; i++ )`
503	`{`	500	`{`
504	`if ( i > max )`	501	`if ( i > max )`
505	`m_iWareBuffer[i] = 0;`	502	`m_iWareBuffer[i] = 0;`
506	`else`	503	`else`
507	`m_iWareBuffer[i] = rest.token(" ", i + 1).toLong();`	504	`m_iWareBuffer[i] = rest.token(L" ", i + 1).toLong();`
508	`}`	505	`}`
509	`}`	506	`}`
510	`else if ( cmd == "createdfile" )`	507	`else if ( cmd == L"createdfile" )`
511	`m_lCreatedFiles.pushBack(rest);`	508	`_lCreatedFiles.pushBack(rest);`
512	`else if ( cmd == "wares" )`	509	`else if ( cmd == L"wares" )`
513	`{`	510	`{`
514	`iWare = rest.token(" ", 1).toLong();`	511	`iWare = rest.token(L" ", 1).toLong();`
515	`iCount = rest.token(" ", 2).toLong();`	512	`iCount = rest.token(L" ", 2).toLong();`
516	`}`	513	`}`
517	`else if ( cmd == "ships" )`	514	`else if ( cmd == L"ships" )`
518	`{`	515	`{`
519	`iShip = 1;`	516	`iShip = 1;`
520	`iCount = rest.token(" ", 1).toLong();`	517	`iCount = rest.token(L" ", 1).toLong();`
521	`}`	518	`}`
522	`else if ( cmd == "modified" )`	519	`else if ( cmd == L"modified" )`
523	`m_bVanilla = false;`	520	`m_bVanilla = false;`
524	`else if ( cmd == "spkinstaller" )`	521	`else if ( cmd == L"spkinstaller" )`
525	`{`	522	`{`
526	`fVersion = rest.toFloat();`	523	`fVersion = rest.toFloat();`
527	`spkinstaller = true;`	524	`spkinstaller = true;`
528	`}`	525	`}`
529	`else if ( cmd == "betaversion" )`	526	`else if ( cmd == L"betaversion" )`
530	`fBeta = rest.toFloat();`	527	`fBeta = rest.toFloat();`
531	`else if ( cmd == "uninstall" )`	528	`else if ( cmd == L"uninstall" )`
532	`{`	529	`{`
533	`C_File *uf = new C_File();`	530	`C_File *uf = new C_File();`
534	`uf->setFileType(FILETYPE_SCRIPT);`	531	`uf->setFileType(FILETYPE_SCRIPT);`
535	`uf->SetCreationTime(rest.token(" ", 1).toLong());`	532	`uf->SetCreationTime(rest.token(L" ", 1).toLong());`
536	`uf->setFilename(m_sCurrentDir + "/Scripts/" + rest.tokens(" ", 2));`	533	`uf->setFilename(m_sCurrentDir + L"/Scripts/" + rest.tokens(L" ", 2));`
537	`m_lUninstallFiles.push_back(uf);`	534	`m_lUninstallFiles.push_back(uf);`
538	`}`	535	`}`
539	`else if ( cmd == "nonremovedfile" )`	536	`else if ( cmd == L"nonremovedfile" )`
540	`{`	537	`{`
541	`if ( !CFileIO::Remove(rest) )`	538	`if ( !CFileIO::Remove(rest) )`
542	`m_lNonRemovedFiles.pushBack(rest);`	539	`_lNonRemovedFiles.pushBack(rest);`
543	`}`	540	`}`
544	`else if ( cmd == "original" )`	541	`else if ( cmd == L"original" )`
545	`_pOriginalFiles->parse(rest);`	542	`_pOriginalFiles->parse(rest);`
546	`else if ( cmd.Compare("GlobalSetting") )`	543	`else if ( cmd.Compare(L"GlobalSetting") )`
547	`m_lGlobals.pushBack(rest.token(":", 1), rest.tokens(":", 2));`	544	`_lGlobals.pushBack(rest.token(L":", 1), rest.tokens(L":", 2));`
548	`else if ( cmd.Compare("FakePatchOrder") )`	545	`else if ( cmd.Compare(L"FakePatchOrder") )`
549	`m_lFakePatchOrder.pushBack(rest.token(":", 1), rest.tokens(":", 2));`	546	`_lFakePatchOrder.pushBack(rest.token(L":", 1), rest.tokens(L":", 2));`
550	`else if ( cmd.Compare("EMPPriceOverride") )`	547	`else if ( cmd.Compare(L"EMPPriceOverride") )`
551	`this->addEMPPriceOverride(rest.token(" ", 1).toLong(), rest.token(" ", 2).toLong());`	548	`this->addEMPPriceOverride(rest.token(L" ", 1).toLong(), rest.token(L" ", 2).toLong());`
552	`else if ( cmd.Compare("EMPNotoOverride") )`	549	`else if ( cmd.Compare(L"EMPNotoOverride") )`
553	`this->addEMPNotoOverride(rest.token(" ", 1).toLong(), rest.token(" ", 2).toLong());`	550	`this->addEMPNotoOverride(rest.token(L" ", 1).toLong(), rest.token(L" ", 2).toLong());`
554	`else if ( cmd.Compare("BuiltInWarePriceOverride") )`	551	`else if ( cmd.Compare(L"BuiltInWarePriceOverride") )`
555	`this->addBuiltInWarePriceOverride(rest.token(" ", 1).toLong(), rest.token(" ", 2).toLong());`	552	`this->addBuiltInWarePriceOverride(rest.token(L" ", 1).toLong(), rest.token(L" ", 2).toLong());`
556	`else if ( cmd.Compare("BuiltInWareNotoOverride") )`	553	`else if ( cmd.Compare(L"BuiltInWareNotoOverride") )`
557	`this->addBuiltInWareNotoOverride(rest.token(" ", 1).toLong(), rest.token(" ", 2).toLong());`	554	`this->addBuiltInWareNotoOverride(rest.token(L" ", 1).toLong(), rest.token(L" ", 2).toLong());`
558	`else if ( cmd.Compare("CustomWarePriceOverride") )`	555	`else if ( cmd.Compare(L"CustomWarePriceOverride") )`
559	`this->addCustomWarePriceOverride(rest.token(";", 1), rest.token(";", 2).toLong());`	556	`this->addCustomWarePriceOverride(rest.token(L";", 1), rest.token(L";", 2).toLong());`
560	`else if ( cmd.Compare("CustomWareNotoOverride") )`	557	`else if ( cmd.Compare(L"CustomWareNotoOverride") )`
561	`this->addCustomWareNotoOverride(rest.token(";", 1), rest.token(";", 2).toLong());`	558	`this->addCustomWareNotoOverride(rest.token(L";", 1), rest.token(L";", 2).toLong());`
562	`else if ( cmd == "globalfiles" )`	559	`else if ( cmd == L"globalfiles" )`
563	`iStatus = READ_GLOBAL;`	560	`iStatus = READ_GLOBAL;`
564		561
565	`if ( progress )`	562	`if ( progress )`
566	`{`	563	`{`
567	`progress->UpdateProgress((long)i, (long)readFile->size());`	564	`progress->UpdateProgress((long)i, static_cast<long>(readFile.size()));`
568	`}`	565	`}`
569	`}`	566	`}`
570	`readFile->clear();`	567	`readFile.clear();`
571		568
572	`if ( !spkinstaller )`	569	`if ( !spkinstaller )`
573	`m_bRedo = true;`	570	`m_bRedo = true;`
574		-
575	`delete readFile;`	-
576	`}`	571	`}`
577	`}`	572	`}`
578		573
579	`if ( m_pEnabledMod && !m_pEnabledMod->IsEnabled() )`	574	`if ( m_pEnabledMod && !m_pEnabledMod->IsEnabled() )`
580	`m_pEnabledMod = NULL;`	575	`m_pEnabledMod = NULL;`
581		576
582	`m_iGame = m_gameExe.GetGameType(m_sCurrentDir) + 1;`	577	`m_iGame = m_gameExe.getGameType(m_sCurrentDir) + 1;`
583	`m_pCurrentGameExe = m_gameExe.GetGame(m_gameExe.GetGameType(m_sCurrentDir));`	578	`m_pCurrentGameExe = m_gameExe.game(m_gameExe.getGameType(m_sCurrentDir));`
584	`Utils::String sGameVersion;`	579	`Utils::WString sGameVersion;`
585	`m_iGameVersion = m_gameExe.GetGameVersion(m_sCurrentDir, &sGameVersion) + 1;`	580	`m_iGameVersion = m_gameExe.getGameVersion(m_sCurrentDir, &sGameVersion) + 1;`
586	`m_sGameVersion = sGameVersion;`	581	`_sGameVersion = sGameVersion;`
587	`m_iGameFlags = m_gameExe.GetGameFlags(m_iGame - 1);`	582	`m_iGameFlags = m_gameExe.gameFlags(m_iGame - 1);`
588	`m_iMaxPatch = m_gameExe.GetMaxPatch(m_iGame - 1);`	583	`m_iMaxPatch = m_gameExe.maxPatch(m_iGame - 1);`
589		584
590	`// find the fake patch`	585	`// find the fake patch`
591	`if ( !ReadyFakePatch() )`	586	`if ( !ReadyFakePatch() )`
592	`return false;`	587	`return false;`
593		588
Line 616...	Line 611...
616	`else if ( node->Data()->GetType() == TYPE_XSP )`	611	`else if ( node->Data()->GetType() == TYPE_XSP )`
617	`{`	612	`{`
618	`CXspFile p = (CXspFile )node->Data();`	613	`CXspFile p = (CXspFile )node->Data();`
619	`for ( CListNode<SGameShip> *gNode = m_lGameShips.Front(); gNode; gNode = gNode->next() )`	614	`for ( CListNode<SGameShip> *gNode = m_lGameShips.Front(); gNode; gNode = gNode->next() )`
620	`{`	615	`{`
621	`if ( p->GetShipID().Compare(gNode->Data()->sShipID) )`	616	`if ( p->GetShipID().Compare(gNode->Data()->sShipID.toString()) )`
622	`{`	617	`{`
623	`gNode->Data()->pPackage = p;`	618	`gNode->Data()->pPackage = p;`
624	`break;`	619	`break;`
625	`}`	620	`}`
626	`}`	621	`}`
Line 637...	Line 632...
637	`return true;`	632	`return true;`
638	`}`	633	`}`
639		634
640	`void CPackages::RemoveCreatedFiles()`	635	`void CPackages::RemoveCreatedFiles()`
641	`{`	636	`{`
642	`for(auto itr = m_lCreatedFiles.begin(); itr != m_lCreatedFiles.end(); itr++)`	637	`for(auto itr = _lCreatedFiles.begin(); itr != _lCreatedFiles.end(); itr++)`
643	`{`	638	`{`
644	`if ( CFileIO::Exists((*itr)->str) )`	639	`if ( CFileIO::Exists((*itr)->str) )`
645	`CFileIO::Remove((*itr)->str);`	640	`CFileIO::Remove((*itr)->str);`
646	`else if ( CFileIO::Exists(m_sCurrentDir + "/" + (*itr)->str) )`	641	`else if ( CFileIO::Exists(m_sCurrentDir + L"/" + (*itr)->str) )`
647	`CFileIO::Remove(m_sCurrentDir + "/" + (*itr)->str);`	642	`CFileIO::Remove(m_sCurrentDir + L"/" + (*itr)->str);`
648	`}`	643	`}`
649		644
650	`m_lCreatedFiles.clear();`	645	`_lCreatedFiles.clear();`
651	`}`	646	`}`
652		647
653	`void CPackages::PurgeGameObjects()`	648	`void CPackages::PurgeGameObjects()`
654	`{`	649	`{`
655	`// check for the log file`	650	`// check for the log file`
656	`Utils::String logDir = logDirectory();`	651	`Utils::WString logDir = logDirectory();`
657	`CFileIO LogFile(logDir + "/log0" + Utils::String::PadNumber(PMTEXTFILE, 4) + ".txt");`	652	`CFileIO LogFile(logDir + L"/log0" + Utils::WString::PadNumber(PMTEXTFILE, 4) + L".txt");`
658	`if ( LogFile.exists() )`	653	`if ( LogFile.exists() )`
659	`{`	654	`{`
660	`// read the log file to memory`	655	`// read the log file to memory`
661	`std::vector<Utils::String> *lines = LogFile.readLines();`	656	`std::vector<Utils::String> *lines = LogFile.readLines();`
662	`if ( lines )`	657	`if ( lines )`
Line 711...	Line 706...
711	`node->Data()->iType = WARETYPE_NONE;`	706	`node->Data()->iType = WARETYPE_NONE;`
712	`}`	707	`}`
713	`m_lGameShips.RemoveEmpty();`	708	`m_lGameShips.RemoveEmpty();`
714	`}`	709	`}`
715		710
716	`Utils::String CPackages::logDirectory()`	711	`Utils::WString CPackages::logDirectory()`
717	`{`	712	`{`
718	`Utils::String logDir = m_sCurrentDir;`	713	`Utils::WString logDir = m_sCurrentDir;`
719	`if ( m_iGameFlags & EXEFLAG_MYDOCLOG ) {`	714	`if ( m_iGameFlags & EXEFLAG_MYDOCLOG ) {`
720	`SGameExe *exe = m_gameExe.GetGame(m_iGame - 1);`	715	`SGameExe *exe = m_gameExe.game(m_iGame - 1);`
721	`if ( exe ) {`	716	`if ( exe ) {`
722	`if ( !exe->sMyDoc.empty() )`	717	`if ( !exe->sMyDoc.empty() )`
723	`logDir = m_sMyDoc + "/" + exe->sMyDoc;`	718	`logDir = m_sMyDoc + L"/" + exe->sMyDoc;`
724	`}`	719	`}`
725	`}`	720	`}`
726		721
727	`return logDir;`	722	`return logDir;`
728	`}`	723	`}`
729		724
730	`Utils::String CPackages::logDirectory(const Utils::String &gameExe)`	725	`Utils::WString CPackages::logDirectory(const Utils::WString &gameExe)`

Subversion Repositories spk

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