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



	_pCurrentDir = new GameDirectory();
	_pCurrentDir->dir = dir;
	_pCurrentDir->id = -1;
 
	m_gameExe.GetDirectoryData(_pCurrentDir);
	_pCurrentDir->langid = this->getGameLanguage(_pCurrentDir->dir);
	if (_pCurrentDir->langid > 0)
		_pCurrentDir->langname = this->ConvertLanguage(_pCurrentDir->langid);
 
	updateFoundPackages("");
}

			delete readFile;
		}
	}
 
	return oldPlugin;
 
 
 
 
 
}
 
bool CPackages::read(const Utils::String& dir, CProgressInfo* progress)
{
	m_sCurrentDir = dir;

	// now lets find the fake patch
	Utils::String useFile;
	if ( m_iFakePatch > 0 )
	{
		Utils::String file = Utils::String::PadNumber(m_iFakePatch, 2);
		if (checkValidPluginManagerFile(file))
			useFile = file;
		else if (checkIfPluginManagerFile(file))
			useFile = file;
	}
 
	if ( useFile.empty() )
	{
		int nextfree = this->findNextFakePatch();
		--nextfree; // gets the end fake patch
 
		// work backwards till we find a valid one
		while ( nextfree > m_iMaxPatch )
		{
			Utils::String file = Utils::String::PadNumber(nextfree, 2);
			if (checkValidPluginManagerFile(file))
			{
				useFile = file;
				break;
			}
			--nextfree;
		}
	}
 
	Utils::String addonDir = this->getAddonDir();
 
	// couldn't find the correct file, lets search for it
	if ( useFile.empty() ) {
		int nextfree = this->findNextFakePatch();
		--nextfree; // gets the end fake patch
 
		// work backwards till we find a valid one
		while ( nextfree > m_iMaxPatch )
		{
			Utils::String file = Utils::String::PadNumber(nextfree, 2);
			if (checkIfPluginManagerFile(file))
			{
				useFile = file;
				break;
			}
			--nextfree;

 
	if ( !useFile.empty() )
	{
		// lets check whats in the file first
		CCatFile openCat;
		if ( openCat.open(m_sCurrentDir + "/" + useFile + ".cat", addonDir, CATREAD_CATDECRYPT, false) == CATERR_NONE )
		{
			std::vector<SInCatFile *> *files = openCat.GetFiles();
			bool found = false;
			if ( files )
			{
				Utils::String useAddonDir = addonDir;
				if ( !useAddonDir.empty() ) useAddonDir += "\\";
				for (auto itr = files->cbegin(); itr != files->cend(); itr++)
				{
					if ((*itr)->sFile.Compare("PlugMan\\TFake.pck") )
						continue;

	// otherwise we didn't need to (hopefully)
	return true;
}
 
 
bool CPackages::checkIfPluginManagerFile(const Utils::String &filename) const
{
	bool found = false;
 
	CFileIO catFile(m_sCurrentDir + "/" + filename + ".cat");
	if ( catFile.exists() && CFileIO::Exists(m_sCurrentDir + "/" + filename + ".dat"))
	{
		CCatFile openFile;
		if ( openFile.open(catFile.fullFilename(), this->getAddonDir(), CATREAD_CATDECRYPT, false) == CATERR_NONE )
		{
//			if ( openFile.internaldatFilename().Compare("PlugMan_Fake.dat") ) return true;

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

 
	// check for another mod
	if ( !package->IsAnotherMod() )
		return;
 
	package->SetParent((CSpkFile *)findSpkPackage(package->GetOtherName(), package->GetOtherAuthor()));
}
 
/**
 * Updates the package list once data has been read
 *

 
	m_bRedo = false;
	return true;
}
 
int CPackages::checkOpenPackage(const Utils::String &file, int *error)
{
	// first check if it exists
	if (!CFileIO::Exists(file))
	{
		*error = INSTALLERR_NOEXIST;
		return -1;
	}
 
	// open the spk file
	float fVersion = 0.0f;
	int check = CBaseFile::CheckFile(file, &fVersion);
 
	// wrong version
	if ( fVersion > (float)FILEVERSION )
	{
		*error = INSTALLERR_VERSION;

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

	*error = INSTALLERR_NONE;
 
	CMultiSpkFile *package = new CMultiSpkFile;
 
	bool ret = false;
	if ( package->readFile(file, true))
	{
		if ( package->readAllPackages(SPKREAD_NODATA) )
		{
			for ( CListNode<SMultiSpkFile> *node = package->GetFileList()->Front(); node; node = node->next() )
				this->ConvertOldPackage(node->Data()->pFile);

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

	*error = INSTALLERR_NONE;
 
	CMultiSpkFile *package = new CMultiSpkFile;
 
	bool ret = false;
	if ( package->readFile(file, true))
	{
		if ( package->readAllPackages(SPKREAD_ALL, packageList) )
		{
			for ( CListNode<CBaseFile> *node = packageList->Front(); node; node = node->next() )
				this->ConvertOldPackage(node->Data());

	delete package;
 
	return ret;
}
 
int CPackages::prepareMultiPackage(const Utils::String &file, CLinkList<CBaseFile> *errorPackageList, int *error, CProgressInfo *progress)
{
	int check = checkOpenPackage(file, error);
	if ( *error == -1 )
		return 0;
 
	if ( check != SPKFILE_MULTI )
	{

	*error = INSTALLERR_NONE;
 
	CMultiSpkFile *package = new CMultiSpkFile;
 
	int count = 0;
	if ( package->readFile(file, true))
	{
		CLinkList<CBaseFile> packageList;
		if ( package->readAllPackages(SPKREAD_ALL, &packageList) )
		{
			for ( CListNode<CBaseFile> *node = packageList.Front(); node; node = node->next() )

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

		case SPKFILE_INVALID:
			// convert xsp
			if ( CFileIO(file).isFileExtension("xsp") )
			{
				installFile = new CXspFile();
				if ( !((CXspFile *)installFile)->ConvertOld(file) )
				{
					delete installFile;
					return NULL;
				}
				break;
			}
			*error = INSTALLERR_INVALID;
			return NULL;
		case SPKFILE_BASE:
			installFile = new CBaseFile();
			if ( !installFile->readFile(file, readtype, progress) )
			{
				delete installFile;
				return NULL;
			}
			break;
		case SPKFILE_SINGLE:
			installFile = new CSpkFile();
			if ( !((CSpkFile *)installFile)->readFile(file, 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, readtype, progress))
			{
				delete installFile;
				return NULL;
			}
			break;

{
	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());
	
	Utils::CStringList lErrors;
 
	CBaseFile *oldPackage = findPackage(package);
	disabled = _checkForDisable(package, disabled, oldPackage);
 
	// update packages must have an old package installed already (should have been checked for already)
	if ( package->GetType() == TYPE_SPK )
	{

				{
					if ( f->Data()->baseName().left(5).Compare("fake_") )
					{
						shuffle = true;
						C_File *match = package->findMatchingMod(f->Data());
						Utils::String next = Utils::String::PadNumber(this->findNextFakePatch(), 2);
						
						Utils::String oldFilePointer = f->Data()->filePointer();
						f->Data()->setDir("");
						f->Data()->changeBaseName(next);
						if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + "/" + f->Data()->getNameDirectory(package)) )

	// now we need to link any child/parent packages
	if ( package->GetType() == TYPE_SPK )
	{
		CSpkFile *spk = (CSpkFile *)package;
		if ( spk->IsAnotherMod() ) {
			spk->SetParent((CSpkFile *)findSpkPackage(spk->GetOtherName(), spk->GetOtherAuthor()));
			CLog::logf(CLog::Log_Install, 2, "Linking to parent package: %s by %s (Version: %s)", spk->name().c_str(), spk->author().c_str(), spk->version().c_str());
		}
	}
 
	// store enabled mod

			gw->sShipClass = p->GetShipClass();
			gw->pPackage = p;
			m_lGameShips.push_back(gw);
		}
		gw->iType = WARETYPE_ADDED;
	}
}
 
void CPackages::SetupWares()
{
	for ( int i = 0; i < WAREBUFFERS; i++ )
	{
		for ( CListNode<SGameWare> *wNode = m_lGameWares[i].Front(); wNode; wNode = wNode->next() )

		if ( !CDirIO(m_sCurrentDir).exists("mods") )
			CDirIO(m_sCurrentDir).create("mods");
 
		SetupWares();
		SetupShips();
		createEMPFile();
		CreateWareFiles();
		CreateDummies();
		CreateComponants();
		CreateTShips();
		CreateCutData();

 
	m_bLoaded = false;
	return true;
}
 
Utils::String CPackages::getModKey() const
{
	return m_gameExe.getModKey(m_iGame - 1);
}
Utils::String CPackages::selectedModName() const
{
	if ( !m_pEnabledMod )
	{

			datFile.copy(datFile.dir() + "/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::String filename = Utils::String::PadNumber(m_iFakePatch, 2);
		CLog::log(CLog::Log_Directory, 2, "Renaming cat file to: " + filename + ".cat");
		if ( catFile.Rename(m_sCurrentDir + "/" + filename + ".cat") )

 * 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 )

{
	if (!errors)
		return;
 
	errors->PushBack(args, ERRORLOG_OLD(type));
}
void CPackages::addLogEntry(int type, const Utils::String &args, Utils::CStringList *errors)
{
	if (!errors)
		return;
 
	errors->pushBack(args, ERRORLOG(type));
}
 
/**
 * Enable a package
 *
 * Enables all files in the package, unless they are already enabled, ie, used by other packages
 * Backs up any original files before attempting to enable the file
 *
 * Fake patches are renamed to the next available slot
 *
 * Clears up the "PluginManager/Disabled" directory
 *
 * param: package		- The package class to be removed
 * 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 false;
	}
 
	if ( this->PrepareEnablePackage(package) )
		return this->EnablePreparedPackages(errors, progress);
 
	return false;
}
bool CPackages::EnablePreparedPackages ( CyStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *enabledPackages )
{
	ClearError();

		}
 
		if ( progress )
		{
			progress->UpdateProgress(fileCount++, maxFiles);
			progress->UpdateFile(f);
		}
 
		// only move fiels that are disabled
		if ( !f->IsDisabled() )
			continue;
 
		// make the directory if it dont exist

			if (fakePatches.contains(f->baseName()))
				newFilename = fakePatches.findString(f->baseName()) + "." + f->fileExt();
			// we need to find the next available number instead
			else
			{
				Utils::String newPos = Utils::String::PadNumber(findNextFakePatch(), 2);
				newFilename = newPos + "." + f->fileExt();
				// and wee need to push this onto the string list so we can adjust the matchign pair
				fakePatches.pushBack(f->baseName(), newPos);
			}
		}

		CFileIO newFile(m_sCurrentDir + "/" + newFilename);
		if ( !currentFile.exists() )
		{
			// missing file ??
			if ( !newFile.exists() )
			{
				this->AddLogEntry(SPKINSTALL_MISSINGFILE, newFilename, errors);
				continue;
			}
		}
		// remove existing file

	CyStringList removeDirs;
 
	// get all files, including children
	CLinkList<C_File> fileList;
	int maxFiles = this->GetAllPackageFiles(&m_lDisableList, &fileList, true);
 
	// interate through all the files in the package
	int fileCount = 0;
	for ( CListNode<C_File> *node = fileList.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();

 *
 * Finds a matching package so we can find if one is already installed
 *
 * Uses seperate functions for each package type, ie for SPK and XSP packages
 */
CBaseFile* CPackages::findPackage(CBaseFile* package) const
{
	// no point checking if we've been sent a null pointer
	if ( !package )
		return 0;
 
	// we are checking against a SPK package, so we match the name and author
	if ( package->GetType() == TYPE_SPK )
		return findSpkPackage(package->name(), package->author());
	else if ( package->GetType() == TYPE_XSP )
		return findXspPackage(((CXspFile *)package)->GetShipID());
	else if ( package->GetType() == TYPE_ARCHIVE )
		return findArchivePackage(package->name());
 
	// nothing found obviously
	return 0;
}
 
CBaseFile *CPackages::findFirstPackageWithFile(C_File *f) const
{
	return findNextPackageWithFile(NULL, f);
}
 
CBaseFile *CPackages::findNextPackageWithFile(CBaseFile *p, C_File *f) const
{
	bool startCheck = (p) ? false : true;
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
	{
		if ( startCheck )

/**
 * 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::String &filename, const Utils::String &dir) const
{
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		if ( f->GetFileType() != filetype )
			continue;
 
		if ( !f->filename().Compare(filename) )
			continue;
 
		if ( !dir.empty() && f->dir().Compare(dir) )
			continue;
 
		return f;
	}
 
	return NULL;
}
 
CArchiveFile *CPackages::findArchivePackage(const Utils::String &name) const
{
	// interate through all packages
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
	{
		CBaseFile *file = node->Data();
 
		// only look for archive packages
		if ( file->GetType() != TYPE_ARCHIVE )
			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;
}
 
/**
 * Find a SPK Package
 *
 * This searching all installed packages for a SPK Package matching the name and author
 */
 
 
 
 
CBaseFile *CPackages::findSpkPackage(const Utils::String &name, const Utils::String &author) const
{
	// interate through all packages
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
	{
		CBaseFile *file = node->Data();
 
		// only look for spk packages
		if ( file->GetType() != TYPE_SPK )
			continue;
 
		// now compare the name and author, "Compare" is a non case senseative check, opposed to ==.
		if ( file->name().Compare(name) && file->author().Compare(author) )
			return file;
	}
 
	// nothing found
	return 0;
}
 
CBaseFile* CPackages::findPackage(const Utils::String &name, const Utils::String &author) const
{

	{
		CBaseFile* file = node->Data();
 
		// now compare the name and author, "Compare" is a non case senseative check, opposed to ==.
		if (file->name().Compare(name) && file->author().Compare(author))
			return file;
	}
 
	// nothing found
	return 0;
 
 
 
 
}
 
/**
 * Find a XSP Package
 *
 * This searching all installed packages for a XSP Package matching the object id
 */
CBaseFile *CPackages::findXspPackage(const Utils::String &id) const
{
	// interate through all packages
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
	{
		CBaseFile *file = node->Data();
 
		// only look for spk packages
		if ( file->GetType() != TYPE_XSP )
			continue;
 
		// now compare the id, "Compare" is a non case senseative check, opposed to ==.
		if ( ((CXspFile *)file)->GetShipID().Compare(id) )
			return file;
	}
 
	// nothing found
	return 0;

	CListNode<C_File> *fnode = m_lFiles.Front();
	while ( fnode )
	{
		fnode->Data()->clearUsed();
		fnode = fnode->next();
	}
 
	// update for all packages
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node= node->next() )
	{
		CBaseFile *file = node->Data();
		if ( (ignoreList) && (ignoreList->FindData(file)) )

{
	if ( package->GetType() == TYPE_XSP && m_iGame == GAME_X2 )
		return INSTALLCHECK_NOSHIP;
 
	// search for an old version
	CBaseFile *oldPackage = findPackage(package);
 
	// check versions are newer
	if (oldPackage && (check & IC_OLDVERSION))
	{
		if ( oldPackage->version().compareVersion(package->version()) == COMPARE_OLDER )

	if ( package->GetType() == TYPE_SPK )
	{
		CSpkFile *spk = (CSpkFile *)package;
		if ( spk->IsAnotherMod() )
		{
			if ( !findSpkPackage(spk->GetOtherName(), spk->GetOtherAuthor()) )
			{
				// check the install list
				if ( m_lInstallList.empty() )
					return false;
 

						break;
					}
				}
 
				if ( !found )
					return false;
			}
		}
	}
 
	return true;
}
 
bool CPackages::CheckEnabledDependacy(CBaseFile *p)
{
	// check the for another mod
	if ( p->GetType() == TYPE_SPK )
	{
		if ( ((CSpkFile *)p)->IsAnotherMod() )
		{
			CBaseFile *parent = this->findSpkPackage(((CSpkFile *)p)->GetOtherName(), ((CSpkFile *)p)->GetOtherAuthor());
			if ( parent )
			{
				if ( !parent->IsEnabled() )
					return false;
			}
			else
				return false;
		}
	}
 
	// check any dependacies
	if ( p->AnyDependacies() )

	}
 
	return true;
}
 
 
 
 
 
 
 
bool CPackages::checkInstalledDependacy(const Utils::String &name, const Utils::String &author, const Utils::String &version, bool onlyEnabled, bool includePrepared) const
{
	CBaseFile *p = this->findSpkPackage(name, author);
	if ( p )
	{

 *
 * IE, when one is removed, the rest need to be shuffled down so theres no gaps
 */
void CPackages::ShuffleFakePatches(CyStringList *errors)
{
	int check = findNextFakePatch();
 
	// lets make sure our order is correct
	// find Lowest Fake Patch Installed
	CLinkList<C_File> doneList;
	int lowest = FindLowestFakePatchInstalled();

 
		if (p->AnyDependacies())
		{
			for (SNeededLibrary* nl = p->GetNeededLibraries()->First(); nl; nl = p->GetNeededLibraries()->Next())
			{
				auto package = findPackage(nl->sName, nl->sAuthor);
				if (package)
				{
					packagesBefore.insert(package);
					packagesAfter[p].insert(package);
				}

		CSpkFile* spk = dynamic_cast<CSpkFile*>(p);
		if (spk)
		{
			if (spk->IsAnotherMod())
			{
				auto package = findPackage(spk->otherName(), spk->otherAuthor());
				if (package)
				{
					packagesBefore.insert(package);
					packagesAfter[p].insert(package);
				}

		{
			packagesBefore.insert(p);
			auto& list = p->getFakePatchBeforeOrder();
			for (auto itr = list.begin(); itr != list.end(); itr++)
			{
				auto package = findPackage((*itr)->str, (*itr)->data);
				if (package)				
					packagesAfter[package].insert(p);
			}
		}
		if (!p->getFakePatchAfterOrder().empty())
		{
			auto& list = p->getFakePatchAfterOrder();
			for (auto itr = list.begin(); itr != list.end(); itr++)
			{
				auto package = findPackage((*itr)->str, (*itr)->data);
				if (package)
				{
					packagesBefore.insert(package);
					packagesAfter[p].insert(package);
				}

					// if the file already exists, we need to move it elsewhere
					Utils::String nextName = Utils::String::PadNumber(lowest, 2);
					if ( CFileIO::Exists(m_sCurrentDir + "/" + nextName + ".cat") )
					{
						// find the file in our internal file list
						C_File *moveFile = findFile(FILETYPE_MOD, nextName + ".cat");
						if ( !moveFile ) // must not have it in our list ? lets move to the next
						{
							lowest++;
							continue;
						}
 
						// now we can move the the cat/dat file elsewhere, lets shuffle it to the highest free number
						ShufflePatchTo(moveFile, findLastFakePatch(), errors);
					}
 
					// space should be free, now lets shuffle it
					ShufflePatchTo(lowestFile, lowest, errors);
				}

		// we only want cat and dat files, all fake patchs should be, but incase theres an error in the package somewhere we can check
		if (!f->checkFileExt("cat"))
			continue;
 
		// now lets check if its greater than our gap
		int check = findNextFakePatch();
		int patchNum = f->filename().token(".", 1).toInt();
		if ( patchNum <= check )
			continue;
 
		ShufflePatchTo(f, check, errors);

	}
 
	return lowest;
}
 
int CPackages::findLastFakePatch(int start, const Utils::String &dir) const
{
	CDirIO Dir((dir.empty()) ? m_sCurrentDir : dir);
 
	int check = start;
	while ( check > 0 )
	{
		Utils::String checkStr = Utils::String::PadNumber(check, 2);

/**
 * 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::String &dir) const
{
	CDirIO Dir((dir.empty()) ? m_sCurrentDir : dir);
 
	int check = start;
	while ( check < 99 )
	{
		++check;

	}
 
	return check;
}
 
int CPackages::findLastTextFile(int start, const Utils::String& dir) const
{
	CDirIO Dir((dir.empty()) ? m_sCurrentDir : dir);
	Dir.cd("t");
 
	int check = start;
	while ( check < 9999 )
	{

 */
bool CPackages::RenameTextFile(const Utils::String &textid, int languageid, Utils::CStringList *errors)
{
	// lets check if the file already exists
	Utils::String newFilename = SPK::FormatTextName(textid.toInt(), m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT));
	C_File *addFile = findFile(FILETYPE_TEXT, newFilename + ".xml");
	if ( !addFile )
		addFile = findFile(FILETYPE_TEXT, newFilename + ".pck");
 
	// we have found the file, lets just add it to our scripts
	if ( addFile )
	{
		addTextFileToScripts(addFile, textid);
		return true;
	}
 
	// first we need to find our text file
	Utils::String filename;
	if ( languageid != -1 )
		filename = SPK::FormatTextName(textid.toInt(), languageid, (m_iGameFlags & EXEFLAG_TCTEXT));
	else
		filename = textid;
 
	C_File *textFile = findFile(FILETYPE_TEXT, filename + ".xml");
	if ( !textFile )
	{
		textFile = findFile(FILETYPE_TEXT, filename + ".pck");
		if ( !textFile )
			return false;
	}
 
	// now lets create out new text file

		// now we have the file wrriten, we need to add it to all scripts that need it
		// first we add it to the global list
		m_lFiles.push_back(addFile);
 
		// now add it to the scripts
		addTextFileToScripts(addFile, textid);
	}
	else
	{
		this->addLogEntry(SPKINSTALL_WRITEFILE_FAIL, addFile->getNameDirectory(NULL), errors);
		if ( lines )

/**
 * Add file to scripts
 *
 * Adds a file to all scripts that need it
 */
void CPackages::addTextFileToScripts(C_File *file, const Utils::String &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::String id = tFile->baseName().token("-", 1);
			if ( id == textid )
			{
				found = true;
				break;
			}
		}

/**
 * Get Install Before Text
 *
 * Returns the install before text for the package in the correct language
 */
Utils::String CPackages::getInstallBeforeText(CBaseFile *package) const
{
	return package->installText(m_iLanguage, true);
}
Utils::String CPackages::getInstallAfterText(CBaseFile *package) const
{
	return package->installText(m_iLanguage, false);
}
Utils::String CPackages::getUninstallBeforeText(CBaseFile *package) const
{
	return package->uninstallText(m_iLanguage, true);
}
Utils::String CPackages::getUninstallAfterText(CBaseFile *package) const
{
	return package->uninstallText(m_iLanguage, false);
}
 
int CPackages::GetChildPackages(CBaseFile *package, CLinkList<CBaseFile> *children, bool recursive)

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

		}
	}
 
	return 0;
}
Utils::String CPackages::getGameRunExe(const Utils::String &dir) const
{
	return m_gameExe.GetGameRunExe(dir);
}
Utils::String CPackages::getGameRunExe() const
{
	return m_gameExe.GetGameRunExe(m_sCurrentDir);
}
 
Utils::String CPackages::getGameNameFromType(int game) const
{
	return m_gameExe.GetGameNameFromType(game - 1);
}
Utils::String CPackages::getGameName() const
{

Utils::String CPackages::getGameName(const Utils::String &dir) const
{
	return m_gameExe.GetGameName(dir.empty() ? m_sCurrentDir : dir);
}
 
 
 
 
 
 
 
 
 
 
 
 
 
Utils::String CPackages::getProperDir() const
{
	return getProperDir(m_sCurrentDir);
}
Utils::String CPackages::getProperDir(const Utils::String &dir) const

}
Utils::String CPackages::getAddonDir(const Utils::String &dir) const
{
	return m_gameExe.GetAddonDir((dir.empty()) ? m_sCurrentDir : dir);
}
int CPackages::getGameAddons(Utils::CStringList &exes, const Utils::String &dir) const
{
	return m_gameExe.getGameAddons((dir.empty()) ? m_sCurrentDir : dir, exes);
}
int CPackages::getGameAddons(Utils::CStringList &exes) const
{
	return m_gameExe.getGameAddons(m_sCurrentDir, exes);
}
 
Utils::String CPackages::getGameTypesString(CBaseFile *package, bool includeVersion) const
{
	if ( !package->AnyGameCompatability() )
		return "";
 
	Utils::String sGames;

		}
	}
	return sGames;
}
 
Utils::String 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.GetGameVersionFromType(m_iGame - 1, gNode->Data()->iVersion - 1, gNode->Data()->sVersion);
		}
	}
 
	return Utils::String::Null();
}
 
Utils::String CPackages::getGameVersionFromType(int game, int version, const Utils::String &sVersion) const
{
	return m_gameExe.GetGameVersionFromType(game - 1, version - 1, sVersion);
}
 
int CPackages::CountBuiltInPackages(bool onlyEnabled)
{
	int count = 0;
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
	{
		if ( !node->Data()->CheckGameCompatability(m_iGame) )
			continue;
		if ( onlyEnabled && !node->Data()->IsEnabled() )
			continue;
		if ( node->Data()->author().Compare("PluginManager") )
			++count;
	}
 
	return count;
}
 
int CPackages::countPackages(int type, bool onlyEnabled) const
{
	int count = 0;
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )

 
		int e;
		if ( i == WARES_TECH && CFileIO::Exists(m_sTempDir + "/TWareT.txt") )
			openFile = m_sTempDir + "/TWareT.txt";
		else {
			e = extractGameFile("types/" + wareFile + ".pck", m_sTempDir + "/" + wareFile + ".txt");
			if ( e == 1 )
				openFile = m_sTempDir + "/" + wareFile + ".txt";
			else if ( e == -2 )
				openFile = wareFile + ".txt";
		}

						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::String("28;0;0;0;0;") + (long)wareLines.size() + ";" + (long)(w->iText + 3) + ";" + (long)w->pWare->iVolumn + ";" + price + ";1;1;" + (long)w->pWare->iSize + ";" + price + ";" + (long)notority + ";0;0;" + w->sWareName.upper() + ";");
					}
				}
 
				if ( create )
				{
					wareLines.pushFront(Utils::String::Number(version) + ";" + Utils::String::Number(wareLines.size()) + ";", Utils::String::Null());
					Utils::String strV;
					strV.FromFloat(GetLibraryVersion(), 2);
					wareLines.pushFront("// Created by SPKInstaller Libraries V" + strV, Utils::String::Null());
					if ( readFile.writeFile(&wareLines) )
						this->packFile(&readFile, "types\\" + wareFile + ".pck");
				}
			}
			readFile.remove();
		}
	}
}
 
Utils::String 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 )
	{

}
 
void CPackages::addEMPNotoOverride(int empId, int noto)
{
	_addWareOverride(Ware_EMP, empId, Utils::String::Null(), noto, true);
}
 
void CPackages::addBuiltInWarePriceOverride(int empId, int price)
{
	_addWareOverride(Ware_BuiltIn, empId, Utils::String::Null(), price, false);
}
 
void CPackages::addBuiltInWareNotoOverride(int empId, int noto)
{
	_addWareOverride(Ware_BuiltIn, empId, Utils::String::Null(), noto, false);
}
 
void CPackages::addCustomWarePriceOverride(const Utils::String &id, int price)
{
	_addWareOverride(Ware_Custom, 0, id, price, false);
}
 
void CPackages::addCustomWareNotoOverride(const Utils::String &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::String empWares = empWaresForGame(&maxsize);
 
	if ( maxsize )
	{
		int e = extractGameFile("types/TWareT.pck", m_sTempDir + "/TWareT.txt");
		if (e)
		{
			// read the file into memory
			Utils::CStringList wareLines;
			size_t oldSize = -1;
			int version = -1;
 
			// read first number
			CFileIO readFile((e == -1) ? "TWareT.txt" : m_sTempDir + "/TWareT.txt");
			std::vector<Utils::String> lines;
			if(readFile.readLines(lines))
			{
				for ( int i = 0; i < (int)lines.size(); i++ )
				{
					Utils::String line(lines.at(i));
					line.removeFirstSpace();
					line.removeChar('\r');
					line.removeChar(9);
					if ( line[0] == '/' )
						continue;
 
					if ( oldSize == -1 )
					{
						version = line.token(";", 1).toLong();
						oldSize = line.token(";", 2).toLong();
					}
					else
					{
						line.removeEndSpace();
						if ( line.right(1) != ";" )
							line += ";";
 
						// check for any override values for built in wares

								line = line.replaceToken(";", 13, Utils::String::Number(price));
							}
 
							int noto = 0;
							if ( this->builtInWareOverideNoto(pos, &noto) ) {
								line = line.replaceToken(";", 14, Utils::String::Number(noto));
							}
						}
 
						// check for any override values for EMP
						if ( i >= 116 ) {
							int price = this->empOveridePrice(i - 116);
							if ( price ) {
								line = line.replaceToken(";", 9, Utils::String::Number(price));
								line = line.replaceToken(";", 13, Utils::String::Number(price));
							}
 
							int noto = 0;
							if ( this->empOverideNoto(i - 116, &noto) ) {
								line = line.replaceToken(";", 14, Utils::String::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 )

						{
							for (size_t i = (maxsize + empEntries); i < wareLines.size(); i++)
							{
								auto node = wareLines.get(i);
								addAfter.pushBack(node->str);
							}
						}
 
						// no remove them all
						while (wareLines.size() > maxsize)
							wareLines.removeAt(wareLines.size() - 1);
					}

 
				// finally we write the whole file
				wareLines.pushFront(Utils::String::Number(version) + ";" + Utils::String::Number(wareLines.size()) + ";", Utils::String::Null());
				wareLines.pushFront("// Created by SPKInstaller Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2), Utils::String::Null());
				if ( readFile.writeFile(&wareLines) )
					this->packFile(&readFile, "types\\TWareT.pck");
			}
			CLEANSPLIT(empStr, empEntries);
		}
	}
}
 

		pos = sStr.find_first_of("&", pos + 1);
	}
 
	// replace the & now
	newStr = newStr.findReplace("&", "&amp;");
 
	// restore the commands
	for ( SStringList *strNode = changes.Head(); strNode; strNode = strNode->next ) {
		newStr = newStr.findReplace(strNode->data.ToString(), strNode->str.ToString());
	}
 

		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::String filename = SPK::FormatTextName(PMTEXTFILE, lang, (m_iGameFlags & EXEFLAG_TCTEXT));
	CFileIO textFile(m_sCurrentDir + "/t/" + filename + ".xml");
 
	std::vector<Utils::String> writeData;

		unsigned char *pckData = PCKData((unsigned char *)fileData, fileSize, &newFileSize, true);
		if ( pckData )
		{
			CFileIO pckFile(m_sCurrentDir + "/t/" + filename + ".pck");
			pckFile.WriteData((char *)pckData, newFileSize);
			this->addCreatedFile(pckFile.fullFilename());
		}
	}
	textFile.remove();
}
 

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

		unsigned char *pckData = PCKData((unsigned char *)fileData, fileSize, &newFileSize, true);
		if ( pckData )
		{
			CFileIO pckFile(m_sCurrentDir + "/t/" + filename + ".pck");
			pckFile.WriteData((char *)pckData, newFileSize);
			this->addCreatedFile(pckFile.fullFilename());
		}
	}
	textFile.remove();
}
 

	if ( dir.Compare(cur) )
		return true;
 
	Utils::String checkDir = cur;
	checkDir = checkDir.findReplace("/", "\\");
	if ( checkDir.Compare(dir) )
		return true;
 
	checkDir = checkDir.findReplace("\\", "/");
	if ( checkDir.Compare(dir) )
		return true;

		return;
 
	CLinkList<SDummyEntry> dummyList;
 
	// now extract the existing dummies
	int e = extractGameFile("types/Dummies.pck", m_sTempDir + "/Dummies.txt");
	if ( e )
	{
		// read the dummies
		CFileIO File;
		if ( File.open((e == -1) ? "Dummies.txt" : m_sTempDir + "/Dummies.txt") )

							break;
						}
					}
 
					if ( f )
						continue;
				}
 
				found->lEntries.PushBack(CyString(dummy->sData));
			}
		}

 
		// write the file to disk
		CFileIO WriteFile(m_sTempDir + "/dummies.txt");
		if ( WriteFile.writeFile(&lines) )
		{
			this->packFile(&WriteFile, "types\\dummies.pck");
			WriteFile.remove();
		}
	}
}
 

	// first check we have any ships
	if ( m_lGameShips.empty() || !this->countPackages(TYPE_XSP, true) )
		return;
 
	bool found = false;
	for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
	{
		SGameShip *s = node->Data();
		if ( s->iType != WARETYPE_ADDED || !s->pPackage )
			continue;
 
		// no dummies to add?

 
	if ( !found )
		return;
 
	std::vector<Utils::String> cutList;
	int e = extractGameFile("types/CutData.pck", m_sTempDir + "/CutData.txt");
	if ( e )
	{
		CFileIO File;
		if ( File.open((e == -1) ? "CutData.txt" : m_sTempDir + "/CutData.txt") )
		{

					}
				}
			}
 
			File.remove();
		}
	}
 
	for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
	{
		SGameShip *s = node->Data();

	cutList.insert(cutList.begin(), "// Cut Data file, created by SPK Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2));
 
	// write the file to disk
	CFileIO WriteFile(m_sTempDir + "/CutData.txt");
	if ( WriteFile.writeFile(&cutList) )
	{
		this->packFile(&WriteFile, "types\\CutData.pck");
		WriteFile.remove();
	}
}
 
void CPackages::CreateAnimations()
{
	// first check we have any ships

 
	if ( !found )
		return;
 
	Utils::CStringList aniList;
	int e = extractGameFile("types/Animations.pck", m_sTempDir + "/Animations.txt");
	if ( e )
	{
		CFileIO File;
		if ( File.open((e == -1) ? "Animations.txt" : m_sTempDir + "/Animations.txt") )
		{

 
	// write the file to disk
	CFileIO WriteFile(m_sTempDir + "/Animations.txt");
	if ( WriteFile.writeFile(&formatedAniList) )
	{
		this->packFile(&WriteFile, "types\\Animations.pck");
		WriteFile.remove();
	}
}
 
void CPackages::CreateBodies()

		return;
 
	// lets read our current bodies file
	CLinkList<SBodies> bodiesList;
	SBodies *currentSection = NULL;
	int e = extractGameFile("types/Bodies.pck", m_sTempDir + "/Bodies.txt");
	if ( e )
	{
		CFileIO File;
		if ( File.open((e == -1) ? "Bodies.txt" : m_sTempDir + "/Bodies.txt") )
		{

 
	// write the file to disk
	CFileIO WriteFile(m_sTempDir + "/Bodies.txt");
	if ( WriteFile.writeFile(&writeList) )
	{
		this->packFile(&WriteFile, "types\\Bodies.pck");
		WriteFile.remove();
	}
}
 
void CPackages::CreateCustomStarts()

		// only use custom starts
		if ( !p->IsCustomStart() )
			continue;
 
		// get the name of the start to use
		Utils::String name = p->GetCustomStartName();
		if ( name.empty() )
			continue;
 
		// find if maps file exists
		Utils::CStringList createFiles;
		createFiles.pushBack(name, "maps/x3_universe");
		createFiles.pushBack(name, "types/Jobs");
		createFiles.pushBack(name, "types/JobWings");
 
		for(auto itr = createFiles.begin(); itr != createFiles.end(); itr++)
		{
			Utils::String dir = CFileIO((*itr)->data).dir();
			FileType type = FileType::FILETYPE_EXTRA;
			if ( dir.Compare("maps") )
				type = FileType::FILETYPE_MAP;
 
			if ( !p->findFile((*itr)->str + &quot;.xml", type) &amp;&amp; !p->;findFile((*itr)->str + ".pck", type))
			{
				// create a maps files
				int e = this->extractGameFile((*itr)->data + ".pck", m_sTempDir + "/" + (*itr)->data + ".pck");
				if ( e )
				{
					CFileIO File((e == -1) ? ((*itr)->data + ".pck") : (m_sTempDir + "/" + (*itr)->data + ".pck"));
					if ( File.exists() )
					{
						File.Rename(m_sCurrentDir + "/" + dir + "/" + (*itr)->str + ".pck");
						this->addCreatedFile(dir + "/" + (*itr)->str + ".pck");
					}
				}
			}
		}
	}
}
 
void CPackages::addCreatedFile(const Utils::String &sFile)
{
 
	Utils::String file = sFile.findRemove(m_sCurrentDir);
	while ( file[0] == '/' )
		file.erase(0, 1);
	while ( file[0] == '\\' )
		file.erase(0, 1);
 

		return;
 
	CLinkList<SComponantEntry> dummyList;
 
	// now extract the existing dummies
	int e = extractGameFile("types/Components.pck", m_sTempDir + "/Components.txt");
	if ( e )
	{
		// read the dummies
		CFileIO File;
		if ( File.open((e == -1) ? "Components.txt" : m_sTempDir + "/Components.txt") )

			{
				int insection = 0;
				int insubsection = 0;
				SComponantEntry *currentSection = NULL;
				SComponantEntry2 *currentSubSection = NULL;
				for ( int j = 0; j < (int)lines->size(); j++ )
				{
					Utils::String line(lines->at(j));
					if ( line[0] == '/' )
						continue;
					line.removeChar('\r');
					line = line.removeFirstSpace();
					line = line.removeEndSpace();
					if ( line.empty() )
						continue;
 
 
					// read the section, first entry is section, second is size
					while ( !line.empty() )
					{
						line = line.removeFirstSpace();
						if ( line.empty() )
							break;
 
						if ( !insection && !insubsection )
						{
							Utils::String section = line.token(";", 1);
							insection = line.token(";", 2).toInt();

						else
						{
							--insubsection;
							currentSubSection->lEntries.PushBack(CyString(line.remove(' ')), true);
							line = "";
						}
					}
				}
 
				delete lines;
			}
 
			File.remove();
		}

		// add the new entries for the ships
		for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
		{
			SGameShip *s = node->Data();
			if ( s->iType != WARETYPE_ADDED || !s->pPackage )
				continue;
 
			// no dummies to add?
			if ( !s->pPackage->AnyComponents() )
				continue;
 

					if ( !found2 )
					{
						found2 = new SComponantEntry2;
						found2->sSection = dummy->sSection2;
						found->lEntries.push_back(found2);
					}
					else
					{
						bool f = false;
						for ( SStringList *strNode = found2->lEntries.Head(); strNode; strNode = strNode->next )
						{

 
		// write the file to disk
		CFileIO WriteFile(m_sTempDir + "/Components.txt");
		if ( WriteFile.writeFile(&lines) )
		{
			this->packFile(&WriteFile, "types\\Components.pck");
			WriteFile.remove();
		}
	}
}
 

		writeList.pushFront("// Globals file, created by SPK Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2), "");
 
		CFileIO WriteFile(m_sTempDir + "/Globals.txt");
		if ( WriteFile.writeFile(&writeList) )
		{
			this->packFile(&WriteFile, "types/Globals.pck");
			WriteFile.remove();
		}
	}
}
 
void CPackages::CreateTShips()
{
	// no ships ?
	if ( m_lGameShips.empty() )
		return;
 
	// get the cockpit list to match with ships turrets

			continue;
		shipOverrides.push_back(node->Data());
	}
 
	// read the existing tships file
	int e = extractGameFile("types/TShips.pck", m_sTempDir + "/TShips.txt");
	if ( e )
	{
		int fileType = 51;
		std::vector<Utils::String> tshipsList;
 

			tshipsList.insert(tshipsList.begin(), "// TShips file, created by SPK Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2));
 
			CFileIO WriteFile(m_sTempDir + "/TShips.txt");
			if ( WriteFile.writeFile(&tshipsList) )
			{
				this->packFile(&WriteFile, "types/TShips.pck");
				WriteFile.remove();
			}
		}
	}
 
}
 
bool CPackages::packFile(const Utils::String &filename) const
{
	// compress the file
	CFileIO File(filename);
	size_t fileSize;
	char *fileData = File.ReadToData(&fileSize);

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

			if ( checkxml )
			{
				int readmaxlines = 20;
				bool isxml = false;
				do {
					Utils::String line = pckFile.readEndOfLine();
					if ( line.contains("<language id=") )
					{
						isxml = true;
						break;
					}
					else if ( line.contains("<page id=") )
					{
						isxml = true;
						break;
					}
					else if ( line.contains("<?xml") || line.contains("<script>") )
					{
						isxml = true;
						break;
					}
					--readmaxlines;

	}
 
	return false;
}
 
 
 
 
 
bool CPackages::packFile(CFileIO* File, const Utils::String &sFilename) const
{
	Utils::String filename = sFilename.findReplace("\\", "/");
	if ( m_iGame == GAME_X3 )
	{
		CCatFile catFile;

//					filename = this->GetAddonDir() + "/" + filename;
				CFileIO pckFile(m_sCurrentDir + "/" + 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 list.size();
}
 
CBaseFile *CPackages::findScriptByAuthor(const Utils::String &author, CBaseFile *prev)
{
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
	{
		CBaseFile *p = node->Data();
		if ( prev )
		{
			if ( p == prev )
				prev = NULL;
			continue;
		}
		if ( p->author().Compare(author) )
			return p;
	}
 
	return NULL;
}

	}
 
	return package;
}
 
Utils::String CPackages::getLanguageName() const
{
	return CPackages::ConvertLanguage(m_iLanguage);
}
 
size_t CPackages::updateFoundPackages(const Utils::String& dir)

			
		for(auto itr = files.begin(); itr != files.end(); itr++)
		{
			Utils::String 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()))
			{
				delete p;
				continue;
			}
 

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

			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("cat"))
	{
		CCatFile cat;
		if (cat.open(file, this->getAddonDir(), 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
	else if (CFileIO(file).isFileExtension("pck"))
	{
		C_File f(file);
		if (!f.ReadFromFile())
			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())
				continue;
			if (str[0] == '/' || str[0] == '#')
				continue;
 
			if (!readFirst)
				readFirst = true;
			else
			{
				Utils::String t = str.tokens(";", -2);
				while (t.right(1) == ";")
					t.truncate((int)t.length() - 1);
				list.pushBack(t, str);
			}
		}
 
		ret = true;
	}
 
	if (deleteFile)
		File.remove();
 
	return ret;
}
 
Utils::String CPackages::readShipData(const Utils::String &file, const Utils::String &id) const
{
	Utils::CStringList list;
	if(!this->loadShipData(file, list))
		return Utils::String::Null();
 
	CShipData data;
	for(auto itr = list.begin(); itr != list.end(); itr++)
	{
		if ((*itr)->str.Compare(id))
 
 
			return (*itr)->data;
 
	}
 
 
	return Utils::String::Null();
 
 
 
 
 
 
 
 
 
 
}
 
bool CPackages::readTextPage(const Utils::String &file, Utils::CStringList &list, bool search, int page) const
{
	CFileIO File;
	bool deleteFile = false;
 
	// read all text files from mod
	if ( CFileIO(file).isFileExtension("cat") )
	{
		bool done = false;
 
		CCatFile cat;
		if ( cat.open(file, this->getAddonDir(), 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);

			// is a text file
			sF = sF.FindReplace("\\", "/");
			if ( !sF.GetToken("/", 1, 1).Compare("t") )
				continue;
 
			Utils::String baseFile = CFileIO(sF).baseName();
			// check language
			int lang = 0;
			if ( baseFile.findPos("-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 + "/" + CFileIO(f->sFile).baseName() + ".xml") )
			{
				if ( this->readTextPage(m_sTempDir + "/" + CFileIO(f->sFile).baseName() + ".xml", list, search, page))
					done = true;
			}
		}
 
		return done;
	}
	// otherwise its a normal file
	else if ( CFileIO(file).isFileExtension("pck") )
	{
		C_File f(file);
		if ( !f.ReadFromFile() )
			return false;
		f.UnPCKFile();
 
		f.setFilename(m_sTempDir + "/textfile.xml");

 
		File.open(m_sTempDir + "/textfile.xml");
		deleteFile = true;
	}
	else
		File.open(file);
 
	if ( !File.exists() )
		return false;
 
	// open and read file

								while ( text.findPos('(') != -1 && text.findPos(')') != -1 )
								{
									int s = text.findPos('(');
									text = text.erase(s, text.findPos(')') - s + 1);
								}
								if(!search || !list.contains(Utils::String::Number(id)))
									list.pushBack(Utils::String::Number(id), text);
							}
						}
					}
				}
			}

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

	delete pVfs;
 
	return newShip;
}
 
void CPackages::getMergedFiles(Utils::CStringList &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("\\", "/"), "1");
 

		if(!list.changeData(sFile, "-1"))
			list.pushBack(sFile, "2");
	}
}
 
bool CPackages::canWeMerge(const Utils::String &file) const
{
	return CModDiff::CanBeDiffed(file);
}
 
bool CPackages::needToMerge(const Utils::String &file) const
{
	Utils::String firstDir = file.token("/", 1);
	if ( firstDir.Compare("t") )
		return true;
	if ( firstDir.Compare("types") )
		return true;
	if ( firstDir.Compare("maps") )
		return true;
 
	return false;
}
 
bool CPackages::mergeMods(CCatFile *mod1, CCatFile *mod2, const Utils::String &outFile, Utils::CStringList *cantMerge) const
{
	CCatFile newCat;
	if ( newCat.open(outFile, this->getAddonDir()) != CATERR_CREATED )
		return false;
 
	Utils::CStringList list;
	this->getMergedFiles(list, mod1, mod2);
	if (list.empty())

		if ( status == 1 )
		{
			if ( !newCat.writeFromCat(mod1, (*itr)->str) )
			{
				if ( cantMerge )
					cantMerge->pushBack((*itr)->str, "1");
			}
		}
		else if ( status == 2 )
		{
			if ( !newCat.writeFromCat(mod2, (*itr)->str) )
			{
				if ( cantMerge )
					cantMerge->pushBack((*itr)->str, "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, "-1");
			}
			else
			{
				if ( !newCat.writeFromCat(mod1, (*itr)->str) )
				{
					if ( cantMerge )
						cantMerge->pushBack((*itr)->str, "1");
				}
			}
		}
	}
 

 *
 * This includes all types and text files
 *
 * Returns true if it finds any files
 */
bool CPackages::getModCompatabilityList(C_File *file, Utils::CStringList *list) const
{
	// not a valid file
	if ( !file ) return false;
	if ( file->GetFileType() != FILETYPE_MOD ) return false;
	if ( !file->fileExt().Compare("cat") ) return false;

				found = true;
			else if (filename.left(8).Compare("addon/t/") || filename.left(12).Compare("addon/types/"))
				found = true;
			else if (filename.left(9).Compare("addon2/t/") || filename.left(13).Compare("addon2/types/"))
				found = true;
 
			if ( found ) {
				if ( list )
					list->pushBack(filename, Utils::String::Number(f->lSize));
				else
					return true;
			}
		}
	}
 
	if ( list && !list->empty() )
		return true;
 

 *
 * 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::CStringList *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;

					toFile = toFile.findReplace("\\", "/");
					toFile = toFile.findReplace("//", "/");
					if ( fromFile.Compare(toFile) )
					{
						if ( list )
							list->pushBack(from->filename() + "::" + (*itr)->str, to->filename() + "::" + (*itr)->str);
						else
							return true;
					}
				}
			}
		}
	}
 
	if ( list && !list->empty() )
		return true;
 
	return false;
}
 
bool CPackages::checkCompatabilityBetweenMods(CBaseFile *from, CBaseFile *to, Utils::CStringList *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;

			if ( compareFile == f ) continue; // same file we're checking against
			if ( !compareFile->IsFakePatch() ) continue;
			if ( compareFile->fileExt().Compare("dat") ) continue;
 
			// now we have to files to compare
			if (checkCompatabilityBetweenModFiles(f, compareFile, list))
				++count;
		}
	}
 
	if ( count )
		return true;
 
	return false;
}
 
int CPackages::checkCompatabilityAgainstPackages(CBaseFile *newFile, Utils::CStringList *list, CLinkList<CBaseFile> *packages) const
{
	if ( !newFile->IsEnabled() ) return 0;
	if ( !newFile->AnyFileType(FILETYPE_MOD) ) return 0;
 
	// we need to extract all mod files

		if ( !node->Data() ) continue;
		CBaseFile *p = node->Data();
		if ( !p->IsEnabled() ) continue;
		if ( !p->AnyFileType(FILETYPE_MOD) ) continue;
 
		if ( this->isSamePackage(p, newFile) ) continue; // dont include self
 
		if (checkCompatabilityBetweenMods(newFile, p, list))
		{
			++count;
			if ( packages && !packages->FindData(p) )
				packages->push_back(p);
		}

	}
 
	return count;
}
 
bool CPackages::isSamePackage(CBaseFile *p1, CBaseFile *p2) const
{
	if ( !p1 || !p2 ) return false;
	if ( p1 == p2 ) return true;
 
	if ( p1->name().Compare(p2->name()) && p1->author().Compare(p2->author()) )

		list->pushBack("http://xpluginmanager.co.uk/flscripts");
 
	return list->size();
}
 
void CPackages::readArchiveData(const Utils::String &filename, CBaseFile *archive) const
{
	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::CStringList otherGames;
	Utils::CStringList gameAddons;
	for (unsigned int i = 0; i < m_gameExe.gameCount(); ++i)
	{

	}
 
	CLEANSPLIT(str, max)
}
 
CBaseFile *CPackages::_archive_fromRar(const Utils::String &filename, bool toInstall) const
{
	// make sure we can open the zip file
	CBaseFile *archive = NULL;
#ifdef _RAR
	HANDLE hArcData;

 
		CFileIO File(fileName);
		if ( File.exists() )
		{
			if ( fileName.Compare("pluginmanager.txt") )
				this->readArchiveData(File.fullFilename(), archive);
			else
			{
				Utils::String extradir;
				int type = SPK::GetAutomaticFiletype(fileName, &extradir, true);
				// check for special file types

#endif
 
	return archive;
}
 
CBaseFile *CPackages::_archive_fromZip(const Utils::String &filename, bool toInstall) const
{
	CBaseFile *archive = NULL;
 
	TCHAR buf[5000];
	wsprintf(buf, L"%hs", filename.c_str());

		Utils::String Name(CyString(ze.name).ToString());
 
		// 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::String extradir;

		archive = NULL;
	}
	return archive;
}
 
CBaseFile *CPackages::createFromArchive(const Utils::String &filename, bool toInstall) const
{
	// make sure we can open the zip file
	CBaseFile *archive = NULL;
	if ( CFileIO(filename).isFileExtension("rar") )
		archive = this->_archive_fromRar(filename, toInstall);

		if(Dir.dirList(files, "", 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);

	}
 
	return 0;
}
 
size_t CPackages::verifyInstalledFiles(Utils::CStringList *missingFiles, bool getPackages) const
{
	int count = 0;
	for ( CListNode<C_File> *fn = m_lFiles.Front(); fn; fn = fn->next() )
	{
		C_File *f = fn->Data();

						}
					}
				}
				Utils::String filename = f->filePointer();
				filename = filename.findRemove(m_sCurrentDir);
				missingFiles->pushBack(filename, packages);
			}
		}
	}
	return count;
}

Rev 181	Rev 182
Line 83...	Line 83...
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);`
89	`if (_pCurrentDir->langid > 0)`	89	`if (_pCurrentDir->langid > 0)`
90	`_pCurrentDir->langname = this->ConvertLanguage(_pCurrentDir->langid);`	90	`_pCurrentDir->langname = this->ConvertLanguage(_pCurrentDir->langid);`
91		91
92	`updateFoundPackages("");`	92	`updateFoundPackages("");`
93	`}`	93	`}`
Line 250...	Line 250...
250	`delete readFile;`	250	`delete readFile;`
251	`}`	251	`}`
252	`}`	252	`}`
253		253
254	`return oldPlugin;`	254	`return oldPlugin;`
255	`}`	-
256		-
257	`bool CPackages::Read(CyString dir, CProgressInfo* progress)`	-
258	`{`	-
259	`return read(dir.ToString(), progress);`	-
260	`}`	255	`}`
261		256
262	`bool CPackages::read(const Utils::String& dir, CProgressInfo* progress)`	257	`bool CPackages::read(const Utils::String& dir, CProgressInfo* progress)`
263	`{`	258	`{`
264	`m_sCurrentDir = dir;`	259	`m_sCurrentDir = dir;`
Line 774...	Line 769...
774	`// now lets find the fake patch`	769	`// now lets find the fake patch`
775	`Utils::String useFile;`	770	`Utils::String useFile;`
776	`if ( m_iFakePatch > 0 )`	771	`if ( m_iFakePatch > 0 )`
777	`{`	772	`{`
778	`Utils::String file = Utils::String::PadNumber(m_iFakePatch, 2);`	773	`Utils::String file = Utils::String::PadNumber(m_iFakePatch, 2);`
779	`if ( CheckValidPluginManagerFile(file) )`	774	`if (checkValidPluginManagerFile(file))`
780	`useFile = file;`	775	`useFile = file;`
781	`else if ( CheckIfPluginManagerFile(file) )`	776	`else if (checkIfPluginManagerFile(file))`
782	`useFile = file;`	777	`useFile = file;`
783	`}`	778	`}`
784		779
785	`if ( useFile.empty() )`	780	`if ( useFile.empty() )`
786	`{`	781	`{`
787	`int nextfree = this->FindNextFakePatch();`	782	`int nextfree = this->findNextFakePatch();`
788	`--nextfree; // gets the end fake patch`	783	`--nextfree; // gets the end fake patch`
789		784
790	`// work backwards till we find a valid one`	785	`// work backwards till we find a valid one`
791	`while ( nextfree > m_iMaxPatch )`	786	`while ( nextfree > m_iMaxPatch )`
792	`{`	787	`{`
793	`Utils::String file = Utils::String::PadNumber(nextfree, 2);`	788	`Utils::String file = Utils::String::PadNumber(nextfree, 2);`
794	`if ( CheckValidPluginManagerFile(file) )`	789	`if (checkValidPluginManagerFile(file))`
795	`{`	790	`{`
796	`useFile = file;`	791	`useFile = file;`
797	`break;`	792	`break;`
798	`}`	793	`}`
799	`--nextfree;`	794	`--nextfree;`
800	`}`	795	`}`
801	`}`	796	`}`
802		797
803	`CyString addonDir = this->GetAddonDir();`	798	`Utils::String addonDir = this->getAddonDir();`
804		799
805	`// couldn't find the correct file, lets search for it`	800	`// couldn't find the correct file, lets search for it`
806	`if ( useFile.empty() ) {`	801	`if ( useFile.empty() ) {`
807	`int nextfree = this->FindNextFakePatch();`	802	`int nextfree = this->findNextFakePatch();`
808	`--nextfree; // gets the end fake patch`	803	`--nextfree; // gets the end fake patch`
809		804
810	`// work backwards till we find a valid one`	805	`// work backwards till we find a valid one`
811	`while ( nextfree > m_iMaxPatch )`	806	`while ( nextfree > m_iMaxPatch )`
812	`{`	807	`{`
813	`Utils::String file = Utils::String::PadNumber(nextfree, 2);`	808	`Utils::String file = Utils::String::PadNumber(nextfree, 2);`
814	`if ( CheckIfPluginManagerFile(file) )`	809	`if (checkIfPluginManagerFile(file))`
815	`{`	810	`{`
816	`useFile = file;`	811	`useFile = file;`
817	`break;`	812	`break;`
818	`}`	813	`}`
819	`--nextfree;`	814	`--nextfree;`
Line 822...	Line 817...
822		817
823	`if ( !useFile.empty() )`	818	`if ( !useFile.empty() )`
824	`{`	819	`{`
825	`// lets check whats in the file first`	820	`// lets check whats in the file first`
826	`CCatFile openCat;`	821	`CCatFile openCat;`
827	`if ( openCat.open(m_sCurrentDir + "/" + useFile + ".cat", addonDir.ToString(), CATREAD_CATDECRYPT, false) == CATERR_NONE )`	822	`if ( openCat.open(m_sCurrentDir + "/" + useFile + ".cat", addonDir, CATREAD_CATDECRYPT, false) == CATERR_NONE )`
828	`{`	823	`{`
829	`std::vector<SInCatFile > files = openCat.GetFiles();`	824	`std::vector<SInCatFile > files = openCat.GetFiles();`
830	`bool found = false;`	825	`bool found = false;`
831	`if ( files )`	826	`if ( files )`
832	`{`	827	`{`
833	`Utils::String useAddonDir = addonDir.ToString();`	828	`Utils::String useAddonDir = addonDir;`
834	`if ( !useAddonDir.empty() ) useAddonDir += "\\";`	829	`if ( !useAddonDir.empty() ) useAddonDir += "\\";`
835	`for (auto itr = files->cbegin(); itr != files->cend(); itr++)`	830	`for (auto itr = files->cbegin(); itr != files->cend(); itr++)`
836	`{`	831	`{`
837	`if ((*itr)->sFile.Compare("PlugMan\\TFake.pck") )`	832	`if ((*itr)->sFile.Compare("PlugMan\\TFake.pck") )`
838	`continue;`	833	`continue;`
Line 888...	Line 883...
888	`// otherwise we didn't need to (hopefully)`	883	`// otherwise we didn't need to (hopefully)`
889	`return true;`	884	`return true;`
890	`}`	885	`}`
891		886
892		887
893	`bool CPackages::CheckIfPluginManagerFile(CyString filename)`	888	`bool CPackages::checkIfPluginManagerFile(const Utils::String &filename) const`
894	`{`	889	`{`
895	`bool found = false;`	890	`bool found = false;`
896		891
897	`CFileIO catFile(m_sCurrentDir + "/" + filename.ToString() + ".cat");`	892	`CFileIO catFile(m_sCurrentDir + "/" + filename + ".cat");`
898	`if ( catFile.exists() && CFileIO::Exists(m_sCurrentDir + "/" + filename.ToString() + ".dat"))`	893	`if ( catFile.exists() && CFileIO::Exists(m_sCurrentDir + "/" + filename + ".dat"))`
899	`{`	894	`{`
900	`CCatFile openFile;`	895	`CCatFile openFile;`
901	`if ( openFile.open(catFile.fullFilename(), this->getAddonDir(), CATREAD_CATDECRYPT, false) == CATERR_NONE )`	896	`if ( openFile.open(catFile.fullFilename(), this->getAddonDir(), CATREAD_CATDECRYPT, false) == CATERR_NONE )`
902	`{`	897	`{`
903	`// if ( openFile.internaldatFilename().Compare("PlugMan_Fake.dat") ) return true;`	898	`// if ( openFile.internaldatFilename().Compare("PlugMan_Fake.dat") ) return true;`
Line 924...	Line 919...
924	`}`	919	`}`
925		920
926	`return found;`	921	`return found;`
927	`}`	922	`}`
928		923
929	`bool CPackages::CheckValidPluginManagerFile(CyString filename)`	924	`bool CPackages::checkValidPluginManagerFile(const Utils::String &filename) const`
930	`{`	925	`{`
931	`// both the cat file and dat file exists, lets open it`	926	`// both the cat file and dat file exists, lets open it`
932	`CFileIO catFile(m_sCurrentDir + "/" + filename.ToString() + ".cat");`	927	`CFileIO catFile(m_sCurrentDir + "/" + filename + ".cat");`
933	`if ( catFile.exists() && CFileIO::Exists(m_sCurrentDir + "/" + filename.ToString() + ".dat"))`	928	`if ( catFile.exists() && CFileIO::Exists(m_sCurrentDir + "/" + filename + ".dat"))`
934	`{`	929	`{`
935	`CCatFile openFile;`	930	`CCatFile openFile;`
936	`if ( openFile.open(catFile.fullFilename(), this->getAddonDir(), CATREAD_CATDECRYPT, false) == CATERR_NONE )`	931	`if ( openFile.open(catFile.fullFilename(), this->getAddonDir(), CATREAD_CATDECRYPT, false) == CATERR_NONE )`
937	`{`	932	`{`
938	`if ( openFile.findData("PlugMan\\TFake.pck") )`	933	`if ( openFile.findData("PlugMan\\TFake.pck") )`
Line 1067...	Line 1062...
1067		1062
1068	`// check for another mod`	1063	`// check for another mod`
1069	`if ( !package->IsAnotherMod() )`	1064	`if ( !package->IsAnotherMod() )`
1070	`return;`	1065	`return;`
1071		1066
1072	`package->SetParent((CSpkFile *)FindSpkPackage(package->GetOtherName(), package->GetOtherAuthor()));`	1067	`package->SetParent((CSpkFile *)findSpkPackage(package->GetOtherName(), package->GetOtherAuthor()));`
1073	`}`	1068	`}`
1074		1069
1075	`/**`	1070	`/**`
1076	`* Updates the package list once data has been read`	1071	`* Updates the package list once data has been read`
1077	`*`	1072	`*`
Line 1120...	Line 1115...
1120		1115
1121	`m_bRedo = false;`	1116	`m_bRedo = false;`
1122	`return true;`	1117	`return true;`
1123	`}`	1118	`}`
1124		1119
1125	`int CPackages::CheckOpenPackage(CyString file, int *error)`	1120	`int CPackages::checkOpenPackage(const Utils::String &file, int *error)`
1126	`{`	1121	`{`
1127	`// first check if it exists`	1122	`// first check if it exists`
1128	`if ( !CFileIO(file).ExistsOld() )`	1123	`if (!CFileIO::Exists(file))`
1129	`{`	1124	`{`
1130	`*error = INSTALLERR_NOEXIST;`	1125	`*error = INSTALLERR_NOEXIST;`
1131	`return -1;`	1126	`return -1;`
1132	`}`	1127	`}`
1133		1128
1134	`// open the spk file`	1129	`// open the spk file`
1135	`float fVersion = 0.0f;`	1130	`float fVersion = 0.0f;`
1136	`int check = CBaseFile::CheckFile(file.ToString(), &fVersion);`	1131	`int check = CBaseFile::CheckFile(file, &fVersion);`
1137		1132
1138	`// wrong version`	1133	`// wrong version`
1139	`if ( fVersion > (float)FILEVERSION )`	1134	`if ( fVersion > (float)FILEVERSION )`
1140	`{`	1135	`{`
1141	`*error = INSTALLERR_VERSION;`	1136	`*error = INSTALLERR_VERSION;`
Line 1143...	Line 1138...
1143	`}`	1138	`}`
1144		1139
1145	`return check;`	1140	`return check;`
1146	`}`	1141	`}`
1147		1142
1148	`CMultiSpkFile CPackages::OpenMultiPackage(CyString file, int error, CProgressInfo *progress)`	1143	`CMultiSpkFile CPackages::openMultiPackage(const Utils::String &file, int error, CProgressInfo *progress)`
1149	`{`	1144	`{`
1150	`int check = CheckOpenPackage(file, error);`	1145	`int check = checkOpenPackage(file, error);`
1151	`if ( *error == -1 )`	1146	`if ( *error == -1 )`
1152	`return false;`	1147	`return false;`
1153		1148
1154	`if ( check != SPKFILE_MULTI )`	1149	`if ( check != SPKFILE_MULTI )`
1155	`{`	1150	`{`
Line 1160...	Line 1155...
1160	`*error = INSTALLERR_NONE;`	1155	`*error = INSTALLERR_NONE;`
1161		1156
1162	`CMultiSpkFile *package = new CMultiSpkFile;`	1157	`CMultiSpkFile *package = new CMultiSpkFile;`
1163		1158
1164	`bool ret = false;`	1159	`bool ret = false;`
1165	`if ( package->readFile(file.ToString(), true))`	1160	`if ( package->readFile(file, true))`
1166	`{`	1161	`{`
1167	`if ( package->readAllPackages(SPKREAD_NODATA) )`	1162	`if ( package->readAllPackages(SPKREAD_NODATA) )`
1168	`{`	1163	`{`
1169	`for ( CListNode<SMultiSpkFile> *node = package->GetFileList()->Front(); node; node = node->next() )`	1164	`for ( CListNode<SMultiSpkFile> *node = package->GetFileList()->Front(); node; node = node->next() )`
1170	`this->ConvertOldPackage(node->Data()->pFile);`	1165	`this->ConvertOldPackage(node->Data()->pFile);`
Line 1178...	Line 1173...
1178		1173
1179	`delete package;`	1174	`delete package;`
1180	`return NULL;`	1175	`return NULL;`
1181	`}`	1176	`}`
1182		1177
1183	`bool CPackages::OpenMultiPackage ( CyString file, CLinkList<CBaseFile> packageList, int error, CProgressInfo *progress )`	1178	`bool CPackages::openMultiPackage(const Utils::String &file, CLinkList<CBaseFile> packageList, int error, CProgressInfo *progress )`
1184	`{`	1179	`{`
1185	`int check = CheckOpenPackage(file, error);`	1180	`int check = checkOpenPackage(file, error);`
1186	`if ( *error == -1 )`	1181	`if ( *error == -1 )`
1187	`return false;`	1182	`return false;`
1188		1183
1189	`if ( check != SPKFILE_MULTI )`	1184	`if ( check != SPKFILE_MULTI )`
1190	`{`	1185	`{`
Line 1195...	Line 1190...
1195	`*error = INSTALLERR_NONE;`	1190	`*error = INSTALLERR_NONE;`
1196		1191
1197	`CMultiSpkFile *package = new CMultiSpkFile;`	1192	`CMultiSpkFile *package = new CMultiSpkFile;`
1198		1193
1199	`bool ret = false;`	1194	`bool ret = false;`
1200	`if ( package->readFile(file.ToString(), true))`	1195	`if ( package->readFile(file, true))`
1201	`{`	1196	`{`
1202	`if ( package->readAllPackages(SPKREAD_ALL, packageList) )`	1197	`if ( package->readAllPackages(SPKREAD_ALL, packageList) )`
1203	`{`	1198	`{`
1204	`for ( CListNode<CBaseFile> *node = packageList->Front(); node; node = node->next() )`	1199	`for ( CListNode<CBaseFile> *node = packageList->Front(); node; node = node->next() )`
1205	`this->ConvertOldPackage(node->Data());`	1200	`this->ConvertOldPackage(node->Data());`
Line 1212...	Line 1207...
1212	`delete package;`	1207	`delete package;`
1213		1208
1214	`return ret;`	1209	`return ret;`
1215	`}`	1210	`}`
1216		1211
1217	`int CPackages::PrepareMultiPackage ( CyString file, CLinkList<CBaseFile> errorPackageList, int error, CProgressInfo *progress )`	1212	`int CPackages::prepareMultiPackage(const Utils::String &file, CLinkList<CBaseFile> errorPackageList, int error, CProgressInfo *progress)`
1218	`{`	1213	`{`
1219	`int check = CheckOpenPackage(file, error);`	1214	`int check = checkOpenPackage(file, error);`
1220	`if ( *error == -1 )`	1215	`if ( *error == -1 )`
1221	`return 0;`	1216	`return 0;`
1222		1217
1223	`if ( check != SPKFILE_MULTI )`	1218	`if ( check != SPKFILE_MULTI )`
1224	`{`	1219	`{`
Line 1229...	Line 1224...
1229	`*error = INSTALLERR_NONE;`	1224	`*error = INSTALLERR_NONE;`
1230		1225
1231	`CMultiSpkFile *package = new CMultiSpkFile;`	1226	`CMultiSpkFile *package = new CMultiSpkFile;`
1232		1227
1233	`int count = 0;`	1228	`int count = 0;`
1234	`if ( package->readFile(file.ToString(), true))`	1229	`if ( package->readFile(file, true))`
1235	`{`	1230	`{`
1236	`CLinkList<CBaseFile> packageList;`	1231	`CLinkList<CBaseFile> packageList;`
1237	`if ( package->readAllPackages(SPKREAD_ALL, &packageList) )`	1232	`if ( package->readAllPackages(SPKREAD_ALL, &packageList) )`
1238	`{`	1233	`{`
1239	`for ( CListNode<CBaseFile> *node = packageList.Front(); node; node = node->next() )`	1234	`for ( CListNode<CBaseFile> *node = packageList.Front(); node; node = node->next() )`
Line 1258...	Line 1253...
1258	`delete package;`	1253	`delete package;`
1259		1254
1260	`return count;`	1255	`return count;`
1261	`}`	1256	`}`
1262		1257
1263	`CBaseFile CPackages::OpenPackage(CyString file, int error, CProgressInfo *progress, int readtype, int flags)`	1258	`CBaseFile CPackages::openPackage(const Utils::String &file, int error, CProgressInfo *progress, int readtype, int flags)`
1264	`{`	1259	`{`
1265	`int check = CheckOpenPackage(file, error);`	1260	`int check = checkOpenPackage(file, error);`
1266	`if ( *error == -1 )`	1261	`if ( *error == -1 )`
1267	`return NULL;`	1262	`return NULL;`
1268		1263
1269	`CBaseFile *installFile = 0;`	1264	`CBaseFile *installFile = 0;`
1270		1265
Line 1279...	Line 1274...
1279	`case SPKFILE_INVALID:`	1274	`case SPKFILE_INVALID:`
1280	`// convert xsp`	1275	`// convert xsp`
1281	`if ( CFileIO(file).isFileExtension("xsp") )`	1276	`if ( CFileIO(file).isFileExtension("xsp") )`
1282	`{`	1277	`{`
1283	`installFile = new CXspFile();`	1278	`installFile = new CXspFile();`
1284	`if ( !((CXspFile *)installFile)->ConvertOld(file.ToString()) )`	1279	`if ( !((CXspFile *)installFile)->ConvertOld(file) )`
1285	`{`	1280	`{`
1286	`delete installFile;`	1281	`delete installFile;`
1287	`return NULL;`	1282	`return NULL;`
1288	`}`	1283	`}`
1289	`break;`	1284	`break;`
1290	`}`	1285	`}`
1291	`*error = INSTALLERR_INVALID;`	1286	`*error = INSTALLERR_INVALID;`
1292	`return NULL;`	1287	`return NULL;`
1293	`case SPKFILE_BASE:`	1288	`case SPKFILE_BASE:`
1294	`installFile = new CBaseFile();`	1289	`installFile = new CBaseFile();`
1295	`if ( !installFile->readFile(file.ToString(), readtype, progress) )`	1290	`if ( !installFile->readFile(file, readtype, progress) )`
1296	`{`	1291	`{`
1297	`delete installFile;`	1292	`delete installFile;`
1298	`return NULL;`	1293	`return NULL;`
1299	`}`	1294	`}`
1300	`break;`	1295	`break;`
1301	`case SPKFILE_SINGLE:`	1296	`case SPKFILE_SINGLE:`
1302	`installFile = new CSpkFile();`	1297	`installFile = new CSpkFile();`
1303	`if ( !((CSpkFile *)installFile)->readFile(file.ToString(), readtype, progress) )`	1298	`if ( !((CSpkFile *)installFile)->readFile(file, readtype, progress) )`
1304	`{`	1299	`{`
1305	`delete installFile;`	1300	`delete installFile;`
1306	`return NULL;`	1301	`return NULL;`
1307	`}`	1302	`}`
1308	`break;`	1303	`break;`
1309	`case SPKFILE_MULTI:`	1304	`case SPKFILE_MULTI:`
1310	`*error = INSTALLERR_NOMULTI;`	1305	`*error = INSTALLERR_NOMULTI;`
1311	`return NULL;`	1306	`return NULL;`
1312	`case SPKFILE_SINGLESHIP:`	1307	`case SPKFILE_SINGLESHIP:`
1313	`installFile = new CXspFile();`	1308	`installFile = new CXspFile();`
1314	`if ( !((CXspFile *)installFile)->readFile(file.ToString(), readtype, progress))`	1309	`if ( !((CXspFile *)installFile)->readFile(file, readtype, progress))`
1315	`{`	1310	`{`
1316	`delete installFile;`	1311	`delete installFile;`
1317	`return NULL;`	1312	`return NULL;`
1318	`}`	1313	`}`
1319	`break;`	1314	`break;`
Line 1454...	Line 1449...
1454	`{`	1449	`{`
1455	`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());`	1450	`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());`
1456		1451
1457	`Utils::CStringList lErrors;`	1452	`Utils::CStringList lErrors;`
1458		1453
1459	`CBaseFile *oldPackage = FindPackage(package);`	1454	`CBaseFile *oldPackage = findPackage(package);`
1460	`disabled = _checkForDisable(package, disabled, oldPackage);`	1455	`disabled = _checkForDisable(package, disabled, oldPackage);`
1461		1456
1462	`// update packages must have an old package installed already (should have been checked for already)`	1457	`// update packages must have an old package installed already (should have been checked for already)`
1463	`if ( package->GetType() == TYPE_SPK )`	1458	`if ( package->GetType() == TYPE_SPK )`
1464	`{`	1459	`{`
Line 1619...	Line 1614...
1619	`{`	1614	`{`
1620	`if ( f->Data()->baseName().left(5).Compare("fake_") )`	1615	`if ( f->Data()->baseName().left(5).Compare("fake_") )`
1621	`{`	1616	`{`
1622	`shuffle = true;`	1617	`shuffle = true;`
1623	`C_File *match = package->findMatchingMod(f->Data());`	1618	`C_File *match = package->findMatchingMod(f->Data());`
1624	`Utils::String next = Utils::String::PadNumber(this->FindNextFakePatch(), 2);`	1619	`Utils::String next = Utils::String::PadNumber(this->findNextFakePatch(), 2);`
1625		1620
1626	`Utils::String oldFilePointer = f->Data()->filePointer();`	1621	`Utils::String oldFilePointer = f->Data()->filePointer();`
1627	`f->Data()->setDir("");`	1622	`f->Data()->setDir("");`
1628	`f->Data()->changeBaseName(next);`	1623	`f->Data()->changeBaseName(next);`
1629	`if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + "/" + f->Data()->getNameDirectory(package)) )`	1624	`if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + "/" + f->Data()->getNameDirectory(package)) )`
Line 1794...	Line 1789...
1794	`// now we need to link any child/parent packages`	1789	`// now we need to link any child/parent packages`
1795	`if ( package->GetType() == TYPE_SPK )`	1790	`if ( package->GetType() == TYPE_SPK )`
1796	`{`	1791	`{`
1797	`CSpkFile spk = (CSpkFile )package;`	1792	`CSpkFile spk = (CSpkFile )package;`
1798	`if ( spk->IsAnotherMod() ) {`	1793	`if ( spk->IsAnotherMod() ) {`
1799	`spk->SetParent((CSpkFile *)FindSpkPackage(spk->GetOtherName(), spk->GetOtherAuthor()));`	1794	`spk->SetParent((CSpkFile *)findSpkPackage(spk->GetOtherName(), spk->GetOtherAuthor()));`
1800	`CLog::logf(CLog::Log_Install, 2, "Linking to parent package: %s by %s (Version: %s)", spk->name().c_str(), spk->author().c_str(), spk->version().c_str());`	1795	`CLog::logf(CLog::Log_Install, 2, "Linking to parent package: %s by %s (Version: %s)", spk->name().c_str(), spk->author().c_str(), spk->version().c_str());`
1801	`}`	1796	`}`
1802	`}`	1797	`}`
1803		1798
1804	`// store enabled mod`	1799	`// store enabled mod`
Line 2386...	Line 2381...
2386	`gw->sShipClass = p->GetShipClass();`	2381	`gw->sShipClass = p->GetShipClass();`
2387	`gw->pPackage = p;`	2382	`gw->pPackage = p;`
2388	`m_lGameShips.push_back(gw);`	2383	`m_lGameShips.push_back(gw);`
2389	`}`	2384	`}`
2390	`gw->iType = WARETYPE_ADDED;`	2385	`gw->iType = WARETYPE_ADDED;`
2391	`}`	2386	`}`
2392	`}`	2387	`}`
2393		2388
2394	`void CPackages::SetupWares()`	2389	`void CPackages::SetupWares()`
2395	`{`	2390	`{`
2396	`for ( int i = 0; i < WAREBUFFERS; i++ )`	2391	`for ( int i = 0; i < WAREBUFFERS; i++ )`
2397	`{`	2392	`{`
2398	`for ( CListNode<SGameWare> *wNode = m_lGameWares[i].Front(); wNode; wNode = wNode->next() )`	2393	`for ( CListNode<SGameWare> *wNode = m_lGameWares[i].Front(); wNode; wNode = wNode->next() )`
Line 2526...	Line 2521...
2526	`if ( !CDirIO(m_sCurrentDir).exists("mods") )`	2521	`if ( !CDirIO(m_sCurrentDir).exists("mods") )`
2527	`CDirIO(m_sCurrentDir).create("mods");`	2522	`CDirIO(m_sCurrentDir).create("mods");`
2528		2523
2529	`SetupWares();`	2524	`SetupWares();`
2530	`SetupShips();`	2525	`SetupShips();`
2531	`CreateEMPFile();`	2526	`createEMPFile();`
2532	`CreateWareFiles();`	2527	`CreateWareFiles();`
2533	`CreateDummies();`	2528	`CreateDummies();`
2534	`CreateComponants();`	2529	`CreateComponants();`
2535	`CreateTShips();`	2530	`CreateTShips();`
2536	`CreateCutData();`	2531	`CreateCutData();`
Line 2564...	Line 2559...
2564		2559
2565	`m_bLoaded = false;`	2560	`m_bLoaded = false;`
2566	`return true;`	2561	`return true;`
2567	`}`	2562	`}`
2568		2563
2569	`CyString CPackages::GetModKey()`	2564	`Utils::String CPackages::getModKey() const`
2570	`{`	2565	`{`
2571	`return m_gameExe.GetModKey(m_iGame - 1);`	2566	`return m_gameExe.getModKey(m_iGame - 1);`
2572	`}`	2567	`}`
2573	`Utils::String CPackages::selectedModName() const`	2568	`Utils::String CPackages::selectedModName() const`
2574	`{`	2569	`{`
2575	`if ( !m_pEnabledMod )`	2570	`if ( !m_pEnabledMod )`
2576	`{`	2571	`{`
Line 2648...	Line 2643...
2648	`datFile.copy(datFile.dir() + "/Backup/" + datFile.filename());`	2643	`datFile.copy(datFile.dir() + "/Backup/" + datFile.filename());`
2649	`}`	2644	`}`
2650		2645
2651		2646
2652	`// find next available fake patch`	2647	`// find next available fake patch`
2653	`m_iFakePatch = this->FindNextFakePatch();`	2648	`m_iFakePatch = this->findNextFakePatch();`
2654	`CLog::log(CLog::Log_Directory, 2, "Finding next available fake patch number: " + (long)m_iFakePatch);`	2649	`CLog::log(CLog::Log_Directory, 2, "Finding next available fake patch number: " + (long)m_iFakePatch);`
2655		2650
2656	`Utils::String filename = Utils::String::PadNumber(m_iFakePatch, 2);`	2651	`Utils::String filename = Utils::String::PadNumber(m_iFakePatch, 2);`
2657	`CLog::log(CLog::Log_Directory, 2, "Renaming cat file to: " + filename + ".cat");`	2652	`CLog::log(CLog::Log_Directory, 2, "Renaming cat file to: " + filename + ".cat");`
2658	`if ( catFile.Rename(m_sCurrentDir + "/" + filename + ".cat") )`	2653	`if ( catFile.Rename(m_sCurrentDir + "/" + filename + ".cat") )`
Line 2911...	Line 2906...
2911	`* Gets a list of all files, includes any child package files`	2906	`* Gets a list of all files, includes any child package files`
2912	`*/`	2907	`*/`
2913	`int CPackages::GetAllPackageFiles(CBaseFile package, CLinkList<C_File> fileList, bool includeChild)`	2908	`int CPackages::GetAllPackageFiles(CBaseFile package, CLinkList<C_File> fileList, bool includeChild)`
2914	`{`	2909	`{`
2915	`for ( CListNode<C_File> *node = package->GetFileList()->Front(); node; node = node->next() )`	2910	`for ( CListNode<C_File> *node = package->GetFileList()->Front(); node; node = node->next() )`
2916	`{`	2911	`{`
2917	`C_File *f = node->Data();`	2912	`C_File *f = node->Data();`
2918	`if ( !fileList->FindData(f) )`	2913	`if ( !fileList->FindData(f) )`
2919	`fileList->push_back(f);`	2914	`fileList->push_back(f);`
2920	`}`	2915	`}`
2921		2916
2922	`if ( includeChild )`	2917	`if ( includeChild )`
Line 2959...	Line 2954...
2959	`{`	2954	`{`
2960	`if (!errors)`	2955	`if (!errors)`
2961	`return;`	2956	`return;`
2962		2957
2963	`errors->PushBack(args, ERRORLOG_OLD(type));`	2958	`errors->PushBack(args, ERRORLOG_OLD(type));`
2964	`}`	2959	`}`
2965	`void CPackages::addLogEntry(int type, const Utils::String &args, Utils::CStringList *errors)`	2960	`void CPackages::addLogEntry(int type, const Utils::String &args, Utils::CStringList *errors)`
2966	`{`	2961	`{`
2967	`if (!errors)`	2962	`if (!errors)`
2968	`return;`	2963	`return;`
2969		2964
2970	`errors->pushBack(args, ERRORLOG(type));`	2965	`errors->pushBack(args, ERRORLOG(type));`
2971	`}`	2966	`}`
2972		2967
2973	`/**`	2968	`/**`
2974	`* Enable a package`	2969	`* Enable a package`
2975	`*`	2970	`*`
2976	`* Enables all files in the package, unless they are already enabled, ie, used by other packages`	2971	`* Enables all files in the package, unless they are already enabled, ie, used by other packages`
2977	`* Backs up any original files before attempting to enable the file`	2972	`* Backs up any original files before attempting to enable the file`
2978	`*`	2973	`*`
2979	`* Fake patches are renamed to the next available slot`	2974	`* Fake patches are renamed to the next available slot`
2980	`*`	2975	`*`
2981	`* Clears up the "PluginManager/Disabled" directory`	2976	`* Clears up the "PluginManager/Disabled" directory`
2982	`*`	2977	`*`
2983	`* param: package - The package class to be removed`	2978	`* param: package - The package class to be removed`
2984	`* param: errors - The string list for all the status for debugging, ie has an entry for whats happened to every file`	2979	`* param: errors - The string list for all the status for debugging, ie has an entry for whats happened to every file`
2985	`* param: progress - The progress class, updates a progress screen of the derived class`	2980	`* param: progress - The progress class, updates a progress screen of the derived class`
Line 3008...	Line 3003...
3008	`return false;`	3003	`return false;`
3009	`}`	3004	`}`
3010		3005
3011	`if ( this->PrepareEnablePackage(package) )`	3006	`if ( this->PrepareEnablePackage(package) )`
3012	`return this->EnablePreparedPackages(errors, progress);`	3007	`return this->EnablePreparedPackages(errors, progress);`
3013		3008
3014	`return false;`	3009	`return false;`
3015	`}`	3010	`}`
3016	`bool CPackages::EnablePreparedPackages ( CyStringList errors, CProgressInfo progress, CLinkList<CBaseFile> *enabledPackages )`	3011	`bool CPackages::EnablePreparedPackages ( CyStringList errors, CProgressInfo progress, CLinkList<CBaseFile> *enabledPackages )`
3017	`{`	3012	`{`
3018	`ClearError();`	3013	`ClearError();`
Line 3041...	Line 3036...
3041	`}`	3036	`}`
3042		3037
3043	`if ( progress )`	3038	`if ( progress )`
3044	`{`	3039	`{`
3045	`progress->UpdateProgress(fileCount++, maxFiles);`	3040	`progress->UpdateProgress(fileCount++, maxFiles);`
3046	`progress->UpdateFile(f);`	3041	`progress->UpdateFile(f);`
3047	`}`	3042	`}`
3048		3043
3049	`// only move fiels that are disabled`	3044	`// only move fiels that are disabled`
3050	`if ( !f->IsDisabled() )`	3045	`if ( !f->IsDisabled() )`
3051	`continue;`	3046	`continue;`
3052		3047
3053	`// make the directory if it dont exist`	3048	`// make the directory if it dont exist`
Line 3079...	Line 3074...
3079	`if (fakePatches.contains(f->baseName()))`	3074	`if (fakePatches.contains(f->baseName()))`
3080	`newFilename = fakePatches.findString(f->baseName()) + "." + f->fileExt();`	3075	`newFilename = fakePatches.findString(f->baseName()) + "." + f->fileExt();`
3081	`// we need to find the next available number instead`	3076	`// we need to find the next available number instead`
3082	`else`	3077	`else`
3083	`{`	3078	`{`
3084	`Utils::String newPos = Utils::String::PadNumber(FindNextFakePatch(), 2);`	3079	`Utils::String newPos = Utils::String::PadNumber(findNextFakePatch(), 2);`
3085	`newFilename = newPos + "." + f->fileExt();`	3080	`newFilename = newPos + "." + f->fileExt();`
3086	`// and wee need to push this onto the string list so we can adjust the matchign pair`	3081	`// and wee need to push this onto the string list so we can adjust the matchign pair`
3087	`fakePatches.pushBack(f->baseName(), newPos);`	3082	`fakePatches.pushBack(f->baseName(), newPos);`
3088	`}`	3083	`}`
3089	`}`	3084	`}`
Line 3094...	Line 3089...
3094	`CFileIO newFile(m_sCurrentDir + "/" + newFilename);`	3089	`CFileIO newFile(m_sCurrentDir + "/" + newFilename);`
3095	`if ( !currentFile.exists() )`	3090	`if ( !currentFile.exists() )`
3096	`{`	3091	`{`
3097	`// missing file ??`	3092	`// missing file ??`
3098	`if ( !newFile.exists() )`	3093	`if ( !newFile.exists() )`
3099	`{`	3094	`{`
3100	`this->AddLogEntry(SPKINSTALL_MISSINGFILE, newFilename, errors);`	3095	`this->AddLogEntry(SPKINSTALL_MISSINGFILE, newFilename, errors);`
3101	`continue;`	3096	`continue;`
3102	`}`	3097	`}`
3103	`}`	3098	`}`
3104	`// remove existing file`	3099	`// remove existing file`
Line 3175...	Line 3170...
3175	`CyStringList removeDirs;`	3170	`CyStringList removeDirs;`
3176		3171
3177	`// get all files, including children`	3172	`// get all files, including children`
3178	`CLinkList<C_File> fileList;`	3173	`CLinkList<C_File> fileList;`
3179	`int maxFiles = this->GetAllPackageFiles(&m_lDisableList, &fileList, true);`	3174	`int maxFiles = this->GetAllPackageFiles(&m_lDisableList, &fileList, true);`
3180		3175
3181	`// interate through all the files in the package`	3176	`// interate through all the files in the package`
3182	`int fileCount = 0;`	3177	`int fileCount = 0;`
3183	`for ( CListNode<C_File> *node = fileList.Front(); node; node = node->next() )`	3178	`for ( CListNode<C_File> *node = fileList.Front(); node; node = node->next() )`
3184	`{`	3179	`{`
3185	`C_File *f = node->Data();`	3180	`C_File *f = node->Data();`
Line 3398...	Line 3393...
3398	`*`	3393	`*`
3399	`* Finds a matching package so we can find if one is already installed`	3394	`* Finds a matching package so we can find if one is already installed`
3400	`*`	3395	`*`
3401	`* Uses seperate functions for each package type, ie for SPK and XSP packages`	3396	`* Uses seperate functions for each package type, ie for SPK and XSP packages`
3402	`*/`	3397	`*/`
3403	`CBaseFile* CPackages::FindPackage(CBaseFile* package)`	3398	`CBaseFile* CPackages::findPackage(CBaseFile* package) const`
3404	`{`	3399	`{`
3405	`// no point checking if we've been sent a null pointer`	3400	`// no point checking if we've been sent a null pointer`
3406	`if ( !package )`	3401	`if ( !package )`
3407	`return 0;`	3402	`return 0;`
3408		3403
3409	`// we are checking against a SPK package, so we match the name and author`	3404	`// we are checking against a SPK package, so we match the name and author`
3410	`if ( package->GetType() == TYPE_SPK )`	3405	`if ( package->GetType() == TYPE_SPK )`

Subversion Repositories spk

(root)//libspk/src/Packages.cpp – Rev 181 → 182