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(L"");
}

					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));
					}
					else
						packageFile->parseValueLine(line);
				}
				else if ( iStatus == READ_SCRIPTFILE )

 
	if ( !useFile.empty() )
	{
		// lets check whats in the file first
		CCatFile openCat;
		if ( openCat.open((m_sCurrentDir + L"/" + useFile + L".cat"), addonDir, CATREAD_CATDECRYPT, false) == CATERR_NONE)
		{
			std::vector<SInCatFile *> *files = openCat.GetFiles();
			bool found = false;
			if ( files )
			{

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

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

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

				{
					if ( f->Data()->baseName().left(5).Compare(L"fake_") )
					{
						shuffle = true;
						C_File *match = package->findMatchingMod(f->Data());
						Utils::WString next = Utils::WString::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)))

				if ( spk->IsAnotherMod() )
				{
					for ( CListNode<CBaseFile> *node = m_lInstallList.Front(); node; node = node->next() )
					{
						CBaseFile *p = node->Data();
						if ( spk->otherName().Compare(p->name()) &&amp; spk->;otherAuthor().Compare(p->author()) )
						{
							m_lInstallList.insert(m_lInstallList.FindPos(p) + 2, package);
							added = true;
							break;
						}

 
					CSpkFile *spk = (CSpkFile *)node->Data();
					if ( !spk->isAnotherMod() )
						continue;
 
					if ( spk->otherName().Compare(package->name()) &&amp; spk->;otherAuthor().Compare(package->author()) )
					{
						added = true;
						m_lInstallList.insert(node->Data(), package);
						break;
					}

	for(auto itr = _lNonRemovedFiles.begin(); itr != _lNonRemovedFiles.end(); itr++)
		lines.pushBack(L"NonRemovedFile: " + (*itr)->str);
 
	if ( m_lGameShips.size() )
	{
		lines.pushBack(Utils::WString(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);

		if ( !currentFile.exists() )
		{
			// missing file ??
			if ( !newFile.exists() )
			{
				this->addLogEntry(SPKINSTALL_MISSINGFILE, newFilename, errors);
				continue;
			}
		}
		// remove existing file
		// file exists, so lets try to move it

			if ( newFile.exists() )
				newFile.remove();
 
			if ( !currentFile.Rename(newFile.fullFilename()) )
			{
				this->addLogEntry(SPKINSTALL_ENABLEFILE_FAIL, newFilename, errors);
				continue;
			}
		}
 
		this->addLogEntry(SPKINSTALL_ENABLEFILE, newFilename, errors);
 
		// adjust the internal name to match the new filename
		f->setFilename(m_sCurrentDir + L"/" + newFilename);
		// no longer disabled, we need to remove the flag
		f->SetDisabled(false);
	}
 
	// recursive, auto enable all children

				continue;
		}
 
		if ( f->GetFileType() == FILETYPE_MOD && !f->IsFakePatch() && f->checkFileExt(L"cat") )
		{
			if ( f->baseName().Compare(m_sSetMod) )
				m_sSetMod = Utils::WString::Null();
		}
 
		// file is not being used by any enabled package
		// set disabled and move to disabled directory

			if(!removeDirs.contains(f->getDirectory(checkPackage)))
				removeDirs.pushBack(f->getDirectory(checkPackage));
		}
 
		// change the filename
		f->setFilename(newFilename);
 
		// finally mark the file as disabled so we know not to try to move it again
		f->SetDisabled(true);
	}
 

	
			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);
			}
			else
				this->addLogEntry(SPKINSTALL_AUTOTEXT_FAIL, f->name() + L"~" + newName, errors);
		}
	}

			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);
			}
			else
				this->addLogEntry(SPKINSTALL_FAKEPATCH_FAIL, f2->name() + L"~" + newName2, errors);
		}
 
		// finally make sure the internal name matches the new one
		file->setName(newName);
	}
	else
		this->addLogEntry(SPKINSTALL_FAKEPATCH_FAIL, file->name() + L"~" + newName, errors);
}
 

	CDirIO Dir((dir.empty()) ? m_sCurrentDir : dir);
 
	int check = start;
	while ( check > 0 )
	{
		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)

 *
 * 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::WString::Null(), start);
}
unsigned int CPackages::findNextTextFile(const Utils::WString &dir, unsigned int start) const
{
	int check = start;
	if ( check < 2 ) check = 2;

		size_t size;
		char *data = File.ReadToData(&size);
 
		if ( data )
		{
			Utils::WString str(data);
			m_iLanguage = str.token(L"\n", 1).token(L" ", 1).toInt();
		}
	}
}
 
/**

	return package->uninstallText(m_iLanguage, true);
}
Utils::WString CPackages::getUninstallAfterText(CBaseFile *package) const
{
	return package->uninstallText(m_iLanguage, false);
}
 
int CPackages::GetChildPackages(CBaseFile *package, CLinkList<CBaseFile> *children, bool recursive)
{
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
	{
		CBaseFile *p = node->Data();
		if ( p->GetParent() == package )
		{
			children->push_back(p);
 
			if ( recursive )
				this->GetChildPackages(p, children, recursive);
		}
	}
 

}
 
Utils::WString CPackages::findDataDir(const Utils::WString &dir, const Utils::WString &file)
{
	CDirIO Dir(dir);
 
	// data files could be in 4 places depending on what program is used, check for all of these
	if (Dir.exists(file))
		return Dir.file(file);
	else if (Dir.exists(L"Data/" + file))
		return Dir.file(L"Data/" + file);

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

		size_t size;
		char *data = File.ReadToData(&size);
 
		if ( data )
		{
			Utils::WString str(data);
			return str.token(L"\n", 1).token(L" ", 1).toLong();
		}
	}
 
	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::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 ( !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;
	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
	{
		if ( !node->Data()->CheckGameCompatability(m_iGame) )
			continue;
		if ( onlyEnabled && !node->Data()->IsEnabled() )
			continue;

	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, CATREAD_CATDECRYPT, false) == CATERR_NONE)
			{
				if (catFile.extractFile(aFilename, aTo))
					return 1;
				if (catFile.error() == CATERR_INVALIDDEST || catFile.error() == CATERR_CANTCREATEDIR)
				{

 
	// 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, 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)

					}
				}
 
				if ( create )
				{
					wareLines.pushFront(Utils::WString::Number(version) + L";" + Utils::WString::Number(wareLines.size()) + L";", Utils::WString::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");
				}

	{
		if ( maxsize ) (*maxsize) = EMP_X3;
		return GetX3Emp();
	}
 
	return Utils::WString::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()) {

{
	_addWareOverride(Ware_Custom, 0, id, noto, true);
}
 
 
void CPackages::createEMPFile(const Utils::WString &progDir)
{
	// do emp wares
	size_t maxsize = 0;
	Utils::WString empWares = empWaresForGame(&maxsize);
 

void CPackages::backupSaves(bool vanilla)
{
	if (!_sSaveDir.empty())
	{
		// copy any saves into the vanilla directory
		Utils::WString dir = (vanilla) ? L"Vanilla" : L"Modified";
 
		// make sure the directory exists
		CDirIO saveDir(this->saveDirectory());
		CDirIO gameSaveDir(saveDir.dir(_sSaveDir));
 

void CPackages::restoreSaves(bool vanilla)
{
	// get dir to restore from
	if (!_sSaveDir.empty())
	{
		Utils::WString dir = (vanilla) ? L"Vanilla" : L"Modified";
		CDirIO toDir(this->saveDirectory());
		CDirIO restoreDir(toDir.dir(_sSaveDir));
		restoreDir.cd(dir);
 
		if (restoreDir.exists())

		}
	}
}
 
void CPackages::CreateCutData()
{
	// 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 ( !s->pPackage->anyCutData() )
			continue;

			if(File.readLines(lines))
			{
				for ( int j = 0; j < (int)lines.size(); j++ )
				{
					Utils::WString line(lines.at(j));
					aniList.pushBack(line);
				}
			}
 
			File.remove();
		}

		if ( !s->pPackage->anyAnimations() )
			continue;
 
		// add each dummy to list
		for(auto itr = s->pPackage->getAnimations().begin(); itr != s->pPackage->getAnimations().end(); itr++)
			parsedAniList.pushBack((*itr)->str);
	}
 
	// format the list with added spaces
	Utils::WStringList formatedAniList;
	int lineCount = -1;

	// write the file to disk
	CFileIO WriteFile(m_sTempDir + L"/Animations.txt");
	if ( WriteFile.writeFile(&formatedAniList) )
	{
		this->packFile(&WriteFile, L"types\\Animations.pck");
		WriteFile.remove();
	}
}
 
void CPackages::CreateBodies()
{
	// first check we have any ships
	if ( m_lGameShips.empty() || !this->countPackages(TYPE_XSP, true) )
		return;

	if ( e )
	{
		CFileIO File;
		if ( File.open((e == -1) ? L"Bodies.txt" : m_sTempDir + L"/Bodies.txt") )
		{
			std::vector<Utils::WString> lines;
			if(File.readLines(lines))
			{
				int entries = 0;
				for (size_t j = 0; j < lines.size(); j++ )
				{
					Utils::WString line(lines.at(j));
					line.removeChar(' ');
					line.removeChar(9);
					if ( line.empty() || line[0] == '/' )
						continue;
					if ( entries <= 0 )
					{
						entries = line.token(L";", 2).toInt();
						currentSection = new SBodies;
						currentSection->sSection = line.token(L";", 1);
						bodiesList.push_back(currentSection);
					}
					else if ( currentSection )
					{
 
						std::vector<Utils::WString&gt; strs;
						if(line.tokenise(L";&quot;, strs))
						{
							for (size_t i = 0; i <; strs.size(); i++)
							{
								if ( strs[i].empty() )
									continue;
								if(!currentSection->lEntries.contains(strs[i] + L";"))
									currentSection->lEntries.pushBack(strs[i] + L";");
								--entries;
							}
						}
 
					}
				}
 
 
			}
			File.remove();
		}
	}
 

				foundSection->lEntries.pushBack(body);
		}
	}
 
	// now write the file
	std::vector<Utils::WString> writeList;
	// the header first
	writeList.push_back(L"// Bodies file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2));
	writeList.push_back(L"//body type;num bodies;");
	writeList.push_back(L"//[body id/name]");
 
	// now our sections
	for ( SBodies *bSection = bodiesList.First(); bSection; bSection = bodiesList.Next() )
	{
		writeList.push_back(L"");
		writeList.push_back(L"// Section: " + bSection->sSection);
		writeList.push_back(bSection->sSection + L";" + Utils::WString::Number(bSection->lEntries.size()) + L";");
		for(auto itr = bSection->lEntries.begin(); itr != bSection->lEntries.end(); itr++)
		{
			Utils::WString str = (*itr)->str;
			str.removeChar(9);
			str.removeChar(' ');
			if ( str.right(1) != L";" )
				str += L";";
			writeList.push_back(str);
		}
	}
 
	// write the file to disk
	CFileIO WriteFile(m_sTempDir + L"/Bodies.txt");
	if ( WriteFile.writeFile(writeList) )
	{
		this->packFile(&WriteFile, L"types\\Bodies.pck");
		WriteFile.remove();
	}
}

		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;
 

					// read the section, first entry is section, second is size
					while ( !line.empty() )
					{
						line = line.removeFirstSpace();
						if ( line.empty() )
							break;
 
						if ( !insection && !insubsection )
						{
							Utils::WString section = line.token(L";", 1);
							insection = line.token(L";", 2).toInt();
 
							// search for the sections
							currentSection = NULL;
							for ( CListNode<SComponantEntry> *node = dummyList.Front(); node; node = node->next() )
							{
								SComponantEntry *d = node->Data();
								if ( d->sSection.Compare(section) )
								{
									currentSection = node->Data();
									break;

							insubsection = line.token(L";", 2).toInt();
 
							currentSubSection = new SComponantEntry2;
							currentSubSection->sSection = section;
							currentSection->lEntries.push_back(currentSubSection);
 
							line = line.remTokens(L";", 1, 2);
						}
						else
						{
							--insubsection;

				SComponantEntry *found = NULL;
				SComponantEntry2 *found2 = NULL;
				for ( CListNode<SComponantEntry> *eNode = dummyList.Front(); eNode; eNode = eNode->next() )
				{
					if ( eNode->Data()->sSection.Compare(dummy->sSection) )
					{
						found = eNode->Data();
						break;
					}
				}
				if ( !found )

				}
				// else check for the 2nd section
				else
				{
					for ( CListNode<SComponantEntry2> *cNode = found->lEntries.Front(); cNode; cNode = cNode->next() )
					{
						if ( cNode->Data()->sSection.Compare(dummy->sSection2) )
						{
							found2 = cNode->Data();
							break;
						}
					}
 
					if ( !found2 )
					{
						found2 = new SComponantEntry2;
						found2->sSection = dummy->sSection2;
						found->lEntries.push_back(found2);
					}
					else

					cStr.removeChar(9);
					cStr.removeChar('\r');
					if ( cStr.right(1) != L";" )
						cStr += L";";
					lines.push_back(cStr);
				}
			}
		}
 
		// write the file to disk
		CFileIO WriteFile(m_sTempDir + L"/Components.txt");
		if ( WriteFile.writeFile(lines) )
		{
			this->packFile(&WriteFile, L"types\\Components.pck");
			WriteFile.remove();
		}
	}
}
 
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;
}
 
bool CPackages::readCommands(int iLang, CLinkList<SCommandSlot> &list)
{
	if ( iLang == 0 ) iLang = m_iLanguage;
 
	for(CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next()) {
		if ( !node->Data()->IsEnabled() ) continue;
		node->Data()->readCommands(iLang, list);
	}
 
	return true;
}
 
bool CPackages::readWingCommands(int iLang, CLinkList<SCommandSlot> &list)
{
	if ( iLang == 0 ) iLang = m_iLanguage;

 
	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;
		
			(*noto) = node->Data()->notority;
			return true;
		}
	}
	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;

						if ( !added )
							tshipsList.push_back(line);
						--count;
						if ( count < 0 )
							break;
					}
				}
			}
 
			File.remove();
 
			// assign the ship buffer
			if ( !m_iShipBuffer )
				m_iShipBuffer = tshipsList.size() + 15;

			}
 
			// finally, write the file
			tshipsList.insert(tshipsList.begin(), Utils::WString::Number(fileType) + L";" + Utils::WString::Number(tshipsList.size()) + L";");
			tshipsList.insert(tshipsList.begin(), L"// TShips file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2));
 
			CFileIO WriteFile(m_sTempDir + L"/TShips.txt");
			if ( WriteFile.writeFile(tshipsList) )
			{
				this->packFile(&WriteFile, L"types/TShips.pck");
				WriteFile.remove();

			Utils::WString ext = L"pck";
			if ( File.isFileExtension(L"bob") )
				ext = L"pbb";
			else if ( File.isFileExtension(L"bod") )
				ext = L"pbd";
			CFileIO pckFile(File.changeFileExtension(ext));
			if ( !CDirIO(pckFile.dir()).exists() )
				CDirIO(pckFile.dir()).create();
			pckFile.WriteData((char *)pckData, newFileSize);
			return true;
		}
	}
 
	return false;

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

		list.popFront();
		list.popFront();
	}
 
	return list.size();
}
 
CBaseFile *CPackages::findScriptByAuthor(const Utils::WString &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;
}
 
bool CPackages::extractAll(CBaseFile *baseFile, const Utils::WString &dir, int game, bool includedir, CProgressInfo *progress) const
{
	if (!baseFile)
		return false;
 
	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);
	}
 
	return baseFile->extractAll(dir, game, gameAddons, includedir, progress);
}
 
bool CPackages::generatePackagerScript(CBaseFile *baseFile, bool wildcard, Utils::WStringList *list, int game, bool datafile) const
{	
	if (!baseFile)
		return false;
 

	CFileIO File(filename);
	if ( !File.startRead() ) 
		return NULL;
 
	Utils::WStringList fileData;
 
	int iLine = 0;
 
	CBaseFile *package = NULL;
 
	while(!File.atEnd()) {

 
		// 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 ( 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++)
		{

			for (auto node = package->fileList().Front(); node; node = node->next())
			{
				C_File *f = node->Data();
				if (f->game() && f->game() != GAME_ALLNEW && !(f->game() & (1 << game)))
					continue;
				package->extractFile(f, itr->second, game, gameAddons);
			}
		}
	}
 
	if (package->autoExporter())
	{
		for (auto itr = package->autoExporter()->begin(); itr != package->autoExporter()->end(); itr++)
			package->saveToArchive(itr->second, itr->first, &m_gameExe);
	}
 
	if ( !ftpaddr.empty() )
	{
		if ( !ftpuser.empty() )
		{
			if ( !ftppass.empty() )
				ftpaddr = ftpuser + L":" + ftppass + L"@" + ftpaddr;
			else
				ftpaddr = ftpuser + L"@" + ftpaddr;
		}
 
		if ( !ftpdir.empty() )
			ftpaddr += ftpdir;
 
		package->setFtpAddr(ftpaddr);
	}
 
	return package;
}
 

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

	{
		for (auto itr = files.begin(); itr != files.end(); itr++)
		{
			Utils::WString d = Dir.file((*itr)->str);
			if (CDirIO(d).isDir())
				count += findPackageDirectories(packages, d);
		}
	}
 
	count += findPackageFiles(packages, dir);
	return count;

	if ( CFileIO(file).isFileExtension(L"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);

	}
	for (auto itr = removed.begin(); itr != removed.end(); itr++)
		_lNonRemovedFiles.remove((*itr)->str);
}
 
CXspFile *CPackages::extractShip(const Utils::WString &sCatFile, const Utils::WString &sId, CProgressInfo *progress)
{
	CVirtualFileSystem *pVfs = new CVirtualFileSystem();
	if ( !pVfs->addMod(sCatFile) ) {
		delete pVfs;
		return NULL;

	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(), CATREAD_JUSTCONTENTS, false) == CATERR_NONE)
	{
		for (unsigned int i = 0; i < cat.GetNumFiles(); i++ )
		{
			SInCatFile *f = cat.GetFile(i);
			Utils::WString filename = f->sFile;

		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) )
			f->setFullDir(m_sTempDir);
	}
 
	// compare mod files against all installed packages
	int count = 0;

		list->pushBack(L"http://xpluginmanager.co.uk/flscripts");
 
	return list->size();
}
 
void CPackages::readArchiveData(const Utils::WString &filename, CBaseFile *archive) const
{
	size_t size;
	char *data = CFileIO(filename).ReadToData(&size);
	if ( size && data )
		readArchiveData(data, size, archive);

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

 
		HeaderData.CmtBuf=NULL;
		memset(&OpenArchiveData.Reserved,0,sizeof(OpenArchiveData.Reserved));
 
		while ((RHCode=RARReadHeaderEx(hArcData,&HeaderData))==0) {
			if ( Utils::WString(HeaderData.FileName).Compare(L"pluginmanager.txt") ) {
				toInstall = false;
				break;
			}
		}
		RARCloseArchive(hArcData);

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

 
 
		char *iBuf = new char[ze.unc_size];
		UnzipItem(hz, zi, iBuf, ze.unc_size);
 
		Utils::WString 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);

		archive = NULL;
	}
	return archive;
}
 
CBaseFile *CPackages::createFromArchive(const Utils::WString &filename, bool toInstall) const
{
	// make sure we can open the zip file
	CBaseFile *archive = NULL;
	if ( CFileIO(filename).isFileExtension(L"rar") )
		archive = this->_archive_fromRar(filename, toInstall);
	else if ( CFileIO(filename).isFileExtension(L"zip") )
		archive = this->_archive_fromZip(filename, toInstall);
 
	if ( archive ) {
		archive->setFilename(CFileIO(filename).changeFileExtension(L"spk"));
		if ( toInstall )
			archive->setName(CFileIO(filename).filenameStr());
		else
			archive->setName(CFileIO(filename).baseName());
	}
 
	return archive;
}
 

	Utils::WStringList variables;
	variables.pushBack(L"$PATH", curDir);
	CBaseFile *package = packages->loadPackagerScript(filename, NULL, NULL, NULL, &variables);
 
	if ( !package )
		return Utils::WString::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 += L".spk";
	else if ( !saveto.right(4).Compare(L".xsp") && package->GetType() == TYPE_XSP )
		saveto += L".xsp";
 
	// write script
	if ( package->writeFile(saveto) )
	{
		if ( package->AutoGenerateUpdateFile() )
			package->createUpdateFile(CFileIO(saveto).dir());
		return saveto;
	}
 
	return Utils::WString::Null();
}
 
int CPackages::GeneratePackageUpdateData(const Utils::WString &dir, bool includeSingle)
{
	Utils::WStringList filedata;

Rev 220	Rev 221
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.toString());`	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(L"");`	92	`updateFoundPackages(L"");`
93	`}`	93	`}`
Line 379...	Line 379...
379	`else if ( cmd == L"modifieddisabled" )`	379	`else if ( cmd == L"modifieddisabled" )`
380	`packageFile->SetModifiedEnabled(false);`	380	`packageFile->SetModifiedEnabled(false);`
381	`else if ( cmd == L"icon" )`	381	`else if ( cmd == L"icon" )`
382	`{`	382	`{`
383	`C_File *icon = new C_File(rest.tokens(L" ", 2));`	383	`C_File *icon = new C_File(rest.tokens(L" ", 2));`
384	`packageFile->setIcon(icon, rest.token(L" ", 1).toString());`	384	`packageFile->setIcon(icon, rest.token(L" ", 1));`
385	`}`	385	`}`
386	`else`	386	`else`
387	`packageFile->parseValueLine(line);`	387	`packageFile->parseValueLine(line);`
388	`}`	388	`}`
389	`else if ( iStatus == READ_SCRIPTFILE )`	389	`else if ( iStatus == READ_SCRIPTFILE )`
Line 808...	Line 808...
808		808
809	`if ( !useFile.empty() )`	809	`if ( !useFile.empty() )`
810	`{`	810	`{`
811	`// lets check whats in the file first`	811	`// lets check whats in the file first`
812	`CCatFile openCat;`	812	`CCatFile openCat;`
813	`if ( openCat.open((m_sCurrentDir + L"/" + useFile + L".cat").toString(), addonDir.toString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)`	813	`if ( openCat.open((m_sCurrentDir + L"/" + useFile + L".cat"), addonDir, CATREAD_CATDECRYPT, false) == CATERR_NONE)`
814	`{`	814	`{`
815	`std::vector<SInCatFile > files = openCat.GetFiles();`	815	`std::vector<SInCatFile > files = openCat.GetFiles();`
816	`bool found = false;`	816	`bool found = false;`
817	`if ( files )`	817	`if ( files )`
818	`{`	818	`{`
Line 1198...	Line 1198...
1198	`delete package;`	1198	`delete package;`
1199		1199
1200	`return ret;`	1200	`return ret;`
1201	`}`	1201	`}`
1202		1202
1203	`int CPackages::prepareMultiPackage(const Utils::String &file, CLinkList<CBaseFile> errorPackageList, int error, CProgressInfo *progress)`	1203	`int CPackages::prepareMultiPackage(const Utils::WString &file, CLinkList<CBaseFile> errorPackageList, int error, CProgressInfo *progress)`
1204	`{`	1204	`{`
1205	`int check = checkOpenPackage(file, error);`	1205	`int check = checkOpenPackage(file, error);`
1206	`if ( *error == -1 )`	1206	`if ( *error == -1 )`
1207	`return 0;`	1207	`return 0;`
1208		1208
Line 1377...	Line 1377...
1377	`}`	1377	`}`
1378		1378
1379	`void CPackages::_addToFakePatch(CBaseFile *pPackage)`	1379	`void CPackages::_addToFakePatch(CBaseFile *pPackage)`
1380	`{`	1380	`{`
1381	`CCatFile cat;`	1381	`CCatFile cat;`
1382	`if ( CCatFile::Opened(cat.open((m_sCurrentDir + L"/PluginManager/PlugMan_Fake.cat").toString(), this->getAddonDir(), CATREAD_DAT))) {`	1382	`if ( CCatFile::Opened(cat.open((m_sCurrentDir + L"/PluginManager/PlugMan_Fake.cat"), this->getAddonDir(), CATREAD_DAT))) {`
1383	`for ( CListNode<C_File> *f = pPackage->GetFileList()->Front(); f; f = f->next() ) {`	1383	`for ( CListNode<C_File> *f = pPackage->GetFileList()->Front(); f; f = f->next() ) {`
1384	`if ( f->Data()->GetFileType() != FILETYPE_SHIPSCENE && f->Data()->GetFileType() != FILETYPE_COCKPITSCENE && f->Data()->GetFileType() != FILETYPE_SHIPMODEL && f->Data()->GetFileType() != FILETYPE_SHIPOTHER ) {`	1384	`if ( f->Data()->GetFileType() != FILETYPE_SHIPSCENE && f->Data()->GetFileType() != FILETYPE_COCKPITSCENE && f->Data()->GetFileType() != FILETYPE_SHIPMODEL && f->Data()->GetFileType() != FILETYPE_SHIPOTHER ) {`
1385	`continue;`	1385	`continue;`
1386	`}`	1386	`}`
1387	`if ( CCatFile::IsAddonDir(f->Data()->getNameDirectory(pPackage)) ) {`	1387	`if ( CCatFile::IsAddonDir(f->Data()->getNameDirectory(pPackage)) ) {`
Line 1492...	Line 1492...
1492		1492
1493	`CLog::log(CLog::Log_Install, 3, L"Reading all files into memory");`	1493	`CLog::log(CLog::Log_Install, 3, L"Reading all files into memory");`
1494	`package->ReadAllFilesToMemory();`	1494	`package->ReadAllFilesToMemory();`
1495		1495
1496	`CLog::log(CLog::Log_Install, 3, L"Starting to install files");`	1496	`CLog::log(CLog::Log_Install, 3, L"Starting to install files");`
1497	`if ( !package->installFiles (m_sCurrentDir.toString(), progress, &m_lFiles, errors, !disabled, this))`	1497	`if ( !package->installFiles (m_sCurrentDir, progress, &m_lFiles, errors, !disabled, this))`
1498	`{`	1498	`{`
1499	`CLog::log(CLog::Log_Install, 2, L"There was an error installing files!!");`	1499	`CLog::log(CLog::Log_Install, 2, L"There was an error installing files!!");`
1500		1500
1501	`// TODO: clear up installed files`	1501	`// TODO: clear up installed files`
1502	`return false;`	1502	`return false;`
Line 1602...	Line 1602...
1602	`{`	1602	`{`
1603	`if ( f->Data()->baseName().left(5).Compare(L"fake_") )`	1603	`if ( f->Data()->baseName().left(5).Compare(L"fake_") )`
1604	`{`	1604	`{`
1605	`shuffle = true;`	1605	`shuffle = true;`
1606	`C_File *match = package->findMatchingMod(f->Data());`	1606	`C_File *match = package->findMatchingMod(f->Data());`
1607	`Utils::String next = Utils::String::PadNumber(this->findNextFakePatch(), 2);`	1607	`Utils::WString next = Utils::WString::PadNumber(this->findNextFakePatch(), 2);`
1608		1608
1609	`Utils::WString oldFilePointer = f->Data()->filePointer();`	1609	`Utils::WString oldFilePointer = f->Data()->filePointer();`
1610	`f->Data()->setDir(L"");`	1610	`f->Data()->setDir(L"");`
1611	`f->Data()->changeBaseName(next);`	1611	`f->Data()->changeBaseName(next);`
1612	`if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + L"/" + f->Data()->getNameDirectory(package)))`	1612	`if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + L"/" + f->Data()->getNameDirectory(package)))`
Line 2211...	Line 2211...
2211	`if ( spk->IsAnotherMod() )`	2211	`if ( spk->IsAnotherMod() )`
2212	`{`	2212	`{`
2213	`for ( CListNode<CBaseFile> *node = m_lInstallList.Front(); node; node = node->next() )`	2213	`for ( CListNode<CBaseFile> *node = m_lInstallList.Front(); node; node = node->next() )`
2214	`{`	2214	`{`
2215	`CBaseFile *p = node->Data();`	2215	`CBaseFile *p = node->Data();`
2216	`if ( spk->otherName().Compare(p->name().toString()) && spk->;otherAuthor().Compare(p->author().toString()) )`	2216	`if ( spk->otherName().Compare(p->name()) && spk->;otherAuthor().Compare(p->author()) )`
2217	`{`	2217	`{`
2218	`m_lInstallList.insert(m_lInstallList.FindPos(p) + 2, package);`	2218	`m_lInstallList.insert(m_lInstallList.FindPos(p) + 2, package);`
2219	`added = true;`	2219	`added = true;`
2220	`break;`	2220	`break;`
2221	`}`	2221	`}`
Line 2233...	Line 2233...
2233		2233
2234	`CSpkFile spk = (CSpkFile )node->Data();`	2234	`CSpkFile spk = (CSpkFile )node->Data();`
2235	`if ( !spk->isAnotherMod() )`	2235	`if ( !spk->isAnotherMod() )`
2236	`continue;`	2236	`continue;`
2237		2237
2238	`if ( spk->otherName().Compare(package->name().toString()) && spk->;otherAuthor().Compare(package->author().toString()) )`	2238	`if ( spk->otherName().Compare(package->name()) && spk->;otherAuthor().Compare(package->author()) )`
2239	`{`	2239	`{`
2240	`added = true;`	2240	`added = true;`
2241	`m_lInstallList.insert(node->Data(), package);`	2241	`m_lInstallList.insert(node->Data(), package);`
2242	`break;`	2242	`break;`
2243	`}`	2243	`}`
Line 2707...	Line 2707...
2707	`for(auto itr = _lNonRemovedFiles.begin(); itr != _lNonRemovedFiles.end(); itr++)`	2707	`for(auto itr = _lNonRemovedFiles.begin(); itr != _lNonRemovedFiles.end(); itr++)`
2708	`lines.pushBack(L"NonRemovedFile: " + (*itr)->str);`	2708	`lines.pushBack(L"NonRemovedFile: " + (*itr)->str);`
2709		2709
2710	`if ( m_lGameShips.size() )`	2710	`if ( m_lGameShips.size() )`
2711	`{`	2711	`{`
2712	`lines.pushBack(Utils::String(L"Ships: ") + (long)m_lGameShips.size());`	2712	`lines.pushBack(Utils::WString(L"Ships: ") + (long)m_lGameShips.size());`
2713		2713
2714	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`	2714	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`
2715	`{`	2715	`{`
2716	`SGameShip *gm = node->Data();`	2716	`SGameShip *gm = node->Data();`
2717	`lines.pushBack(Utils::WString((long)gm->iType) + L" $#C:" + gm->sShipClass + L" " + gm->sShipID);`	2717	`lines.pushBack(Utils::WString((long)gm->iType) + L" $#C:" + gm->sShipClass + L" " + gm->sShipID);`
Line 3059...	Line 3059...
3059	`if ( !currentFile.exists() )`	3059	`if ( !currentFile.exists() )`
3060	`{`	3060	`{`
3061	`// missing file ??`	3061	`// missing file ??`
3062	`if ( !newFile.exists() )`	3062	`if ( !newFile.exists() )`
3063	`{`	3063	`{`
3064	`this->addLogEntry(SPKINSTALL_MISSINGFILE, newFilename.toString(), errors);`	3064	`this->addLogEntry(SPKINSTALL_MISSINGFILE, newFilename, errors);`
3065	`continue;`	3065	`continue;`
3066	`}`	3066	`}`
3067	`}`	3067	`}`
3068	`// remove existing file`	3068	`// remove existing file`
3069	`// file exists, so lets try to move it`	3069	`// file exists, so lets try to move it`
Line 3072...	Line 3072...
3072	`if ( newFile.exists() )`	3072	`if ( newFile.exists() )`
3073	`newFile.remove();`	3073	`newFile.remove();`
3074		3074
3075	`if ( !currentFile.Rename(newFile.fullFilename()) )`	3075	`if ( !currentFile.Rename(newFile.fullFilename()) )`
3076	`{`	3076	`{`
3077	`this->addLogEntry(SPKINSTALL_ENABLEFILE_FAIL, newFilename.toString(), errors);`	3077	`this->addLogEntry(SPKINSTALL_ENABLEFILE_FAIL, newFilename, errors);`
3078	`continue;`	3078	`continue;`
3079	`}`	3079	`}`
3080	`}`	3080	`}`
3081		3081
3082	`this->addLogEntry(SPKINSTALL_ENABLEFILE, newFilename.toString(), errors);`	3082	`this->addLogEntry(SPKINSTALL_ENABLEFILE, newFilename, errors);`
3083		3083
3084	`// adjust the internal name to match the new filename`	3084	`// adjust the internal name to match the new filename`
3085	`f->setFilename((m_sCurrentDir + L"/" + newFilename).toString());`	3085	`f->setFilename(m_sCurrentDir + L"/" + newFilename);`
3086	`// no longer disabled, we need to remove the flag`	3086	`// no longer disabled, we need to remove the flag`
3087	`f->SetDisabled(false);`	3087	`f->SetDisabled(false);`
3088	`}`	3088	`}`
3089		3089
3090	`// recursive, auto enable all children`	3090	`// recursive, auto enable all children`
Line 3196...	Line 3196...
3196	`continue;`	3196	`continue;`
3197	`}`	3197	`}`
3198		3198
3199	`if ( f->GetFileType() == FILETYPE_MOD && !f->IsFakePatch() && f->checkFileExt(L"cat") )`	3199	`if ( f->GetFileType() == FILETYPE_MOD && !f->IsFakePatch() && f->checkFileExt(L"cat") )`
3200	`{`	3200	`{`
3201	`if ( f->baseName().Compare(m_sSetMod.toString()) )`	3201	`if ( f->baseName().Compare(m_sSetMod) )`
3202	`m_sSetMod = Utils::WString::Null();`	3202	`m_sSetMod = Utils::WString::Null();`
3203	`}`	3203	`}`
3204		3204
3205	`// file is not being used by any enabled package`	3205	`// file is not being used by any enabled package`
3206	`// set disabled and move to disabled directory`	3206	`// set disabled and move to disabled directory`
Line 3280...	Line 3280...
3280	`if(!removeDirs.contains(f->getDirectory(checkPackage)))`	3280	`if(!removeDirs.contains(f->getDirectory(checkPackage)))`
3281	`removeDirs.pushBack(f->getDirectory(checkPackage));`	3281	`removeDirs.pushBack(f->getDirectory(checkPackage));`
3282	`}`	3282	`}`
3283		3283
3284	`// change the filename`	3284	`// change the filename`
3285	`f->setFilename(newFilename.toString());`	3285	`f->setFilename(newFilename);`
3286		3286
3287	`// finally mark the file as disabled so we know not to try to move it again`	3287	`// finally mark the file as disabled so we know not to try to move it again`
3288	`f->SetDisabled(true);`	3288	`f->SetDisabled(true);`
3289	`}`	3289	`}`
3290		3290
Line 4179...	Line 4179...
4179		4179
4180	`Utils::WString newName = SPK::FormatTextName(current, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT)) + L"." + moveFile.extension();`	4180	`Utils::WString newName = SPK::FormatTextName(current, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT)) + L"." + moveFile.extension();`
4181	`if ( moveFile.Rename(m_sCurrentDir + L"/t/" + newName) )`	4181	`if ( moveFile.Rename(m_sCurrentDir + L"/t/" + newName) )`
4182	`{`	4182	`{`
4183	`this->addLogEntry(SPKINSTALL_AUTOTEXT, f->name() + L"~" + newName, errors);`	4183	`this->addLogEntry(SPKINSTALL_AUTOTEXT, f->name() + L"~" + newName, errors);`
4184	`f->setName(newName.toString());`	4184	`f->setName(newName);`
4185	`}`	4185	`}`
4186	`else`	4186	`else`
4187	`this->addLogEntry(SPKINSTALL_AUTOTEXT_FAIL, f->name() + L"~" + newName, errors);`	4187	`this->addLogEntry(SPKINSTALL_AUTOTEXT_FAIL, f->name() + L"~" + newName, errors);`
4188	`}`	4188	`}`
4189	`}`	4189	`}`
Line 4474...	Line 4474...
4474	`Utils::WString newName2 = Utils::WString::PadNumber(to, 2) + L"." + f2->fileExt();`	4474	`Utils::WString newName2 = Utils::WString::PadNumber(to, 2) + L"." + f2->fileExt();`
4475	`CFileIO moveFile(f2->filePointer());`	4475	`CFileIO moveFile(f2->filePointer());`
4476	`if ( moveFile.Rename(m_sCurrentDir + L"/" + newName2) )`	4476	`if ( moveFile.Rename(m_sCurrentDir + L"/" + newName2) )`
4477	`{`	4477	`{`
4478	`this->addLogEntry(SPKINSTALL_FAKEPATCH, f2->name() + L"~" + newName2, errors);`	4478	`this->addLogEntry(SPKINSTALL_FAKEPATCH, f2->name() + L"~" + newName2, errors);`
4479	`f2->setName(newName2.toString());`	4479	`f2->setName(newName2);`
4480	`}`	4480	`}`
4481	`else`	4481	`else`
4482	`this->addLogEntry(SPKINSTALL_FAKEPATCH_FAIL, f2->name() + L"~" + newName2, errors);`	4482	`this->addLogEntry(SPKINSTALL_FAKEPATCH_FAIL, f2->name() + L"~" + newName2, errors);`
4483	`}`	4483	`}`
4484		4484
4485	`// finally make sure the internal name matches the new one`	4485	`// finally make sure the internal name matches the new one`
4486	`file->setName(newName.toString());`	4486	`file->setName(newName);`
4487	`}`	4487	`}`
4488	`else`	4488	`else`
4489	`this->addLogEntry(SPKINSTALL_FAKEPATCH_FAIL, file->name() + L"~" + newName, errors);`	4489	`this->addLogEntry(SPKINSTALL_FAKEPATCH_FAIL, file->name() + L"~" + newName, errors);`
4490	`}`	4490	`}`
4491		4491
Line 4517...	Line 4517...
4517	`CDirIO Dir((dir.empty()) ? m_sCurrentDir : dir);`	4517	`CDirIO Dir((dir.empty()) ? m_sCurrentDir : dir);`
4518		4518
4519	`int check = start;`	4519	`int check = start;`
4520	`while ( check > 0 )`	4520	`while ( check > 0 )`
4521	`{`	4521	`{`
4522	`Utils::WString checkStr = Utils::String::PadNumber(check, 2);`	4522	`Utils::WString checkStr = Utils::WString::PadNumber(check, 2);`
4523		4523
4524	`// check if a cat file exists`	4524	`// check if a cat file exists`
4525	`if ( !Dir.exists(checkStr + L".cat") )`	4525	`if ( !Dir.exists(checkStr + L".cat") )`
4526	`{`	4526	`{`
4527	`// it doen't, check if theres a dat file (incase of package error)`	4527	`// it doen't, check if theres a dat file (incase of package error)`
Line 4566...	Line 4566...
4566	`*`	4566	`*`
4567	`* Searching for the next gap in automatic text files, start with 0004-LXXX or XX0004`	4567	`* Searching for the next gap in automatic text files, start with 0004-LXXX or XX0004`
4568	`*/`	4568	`*/`
4569	`unsigned int CPackages::findNextTextFile(unsigned int start) const`	4569	`unsigned int CPackages::findNextTextFile(unsigned int start) const`
4570	`{`	4570	`{`
4571	`return findNextTextFile(Utils::String::Null(), start);`	4571	`return findNextTextFile(Utils::WString::Null(), start);`
4572	`}`	4572	`}`
4573	`unsigned int CPackages::findNextTextFile(const Utils::WString &dir, unsigned int start) const`	4573	`unsigned int CPackages::findNextTextFile(const Utils::WString &dir, unsigned int start) const`
4574	`{`	4574	`{`
4575	`int check = start;`	4575	`int check = start;`
4576	`if ( check < 2 ) check = 2;`	4576	`if ( check < 2 ) check = 2;`
Line 4633...	Line 4633...
4633	`size_t size;`	4633	`size_t size;`
4634	`char *data = File.ReadToData(&size);`	4634	`char *data = File.ReadToData(&size);`
4635		4635
4636	`if ( data )`	4636	`if ( data )`
4637	`{`	4637	`{`
4638	`Utils::String str(data);`	4638	`Utils::WString str(data);`
4639	`m_iLanguage = str.token("\n", 1).token(" ", 1).toInt();`	4639	`m_iLanguage = str.token(L"\n", 1).token(L" ", 1).toInt();`
4640	`}`	4640	`}`
4641	`}`	4641	`}`
4642	`}`	4642	`}`
4643		4643
4644	`/**`	4644	`/**`
Line 4979...	Line 4979...
4979	`return package->uninstallText(m_iLanguage, true);`	4979	`return package->uninstallText(m_iLanguage, true);`
4980	`}`	4980	`}`
4981	`Utils::WString CPackages::getUninstallAfterText(CBaseFile *package) const`	4981	`Utils::WString CPackages::getUninstallAfterText(CBaseFile *package) const`
4982	`{`	4982	`{`
4983	`return package->uninstallText(m_iLanguage, false);`	4983	`return package->uninstallText(m_iLanguage, false);`
4984	`}`	4984	`}`
4985		4985
4986	`int CPackages::GetChildPackages(CBaseFile package, CLinkList<CBaseFile> children, bool recursive)`	4986	`int CPackages::GetChildPackages(CBaseFile package, CLinkList<CBaseFile> children, bool recursive)`
4987	`{`	4987	`{`
4988	`for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )`	4988	`for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )`
4989	`{`	4989	`{`
4990	`CBaseFile *p = node->Data();`	4990	`CBaseFile *p = node->Data();`
4991	`if ( p->GetParent() == package )`	4991	`if ( p->GetParent() == package )`
4992	`{`	4992	`{`
4993	`children->push_back(p);`	4993	`children->push_back(p);`
4994		4994
4995	`if ( recursive )`	4995	`if ( recursive )`
4996	`this->GetChildPackages(p, children, recursive);`	4996	`this->GetChildPackages(p, children, recursive);`
4997	`}`	4997	`}`
4998	`}`	4998	`}`
4999		4999
Line 5008...	Line 5008...
5008	`}`	5008	`}`
5009		5009
5010	`Utils::WString CPackages::findDataDir(const Utils::WString &dir, const Utils::WString &file)`	5010	`Utils::WString CPackages::findDataDir(const Utils::WString &dir, const Utils::WString &file)`
5011	`{`	5011	`{`
5012	`CDirIO Dir(dir);`	5012	`CDirIO Dir(dir);`
5013		5013
5014	`// data files could be in 4 places depending on what program is used, check for all of these`	5014	`// data files could be in 4 places depending on what program is used, check for all of these`
5015	`if (Dir.exists(file))`	5015	`if (Dir.exists(file))`
5016	`return Dir.file(file);`	5016	`return Dir.file(file);`
5017	`else if (Dir.exists(L"Data/" + file))`	5017	`else if (Dir.exists(L"Data/" + file))`
5018	`return Dir.file(L"Data/" + file);`	5018	`return Dir.file(L"Data/" + file);`
Line 5055...	Line 5055...
5055	`int CPackages::getGameLanguage() const`	5055	`int CPackages::getGameLanguage() const`
5056	`{`	5056	`{`
5057	`return this->getGameLanguage(m_sCurrentDir);`	5057	`return this->getGameLanguage(m_sCurrentDir);`
5058	`}`	5058	`}`
5059	`int CPackages::getGameLanguage(const Utils::WString &sDir) const`	5059	`int CPackages::getGameLanguage(const Utils::WString &sDir) const`
5060	`{`	5060	`{`
5061	`Utils::WString dir = sDir;`	5061	`Utils::WString dir = sDir;`
5062	`if (dir.empty())`	5062	`if (dir.empty())`
5063	`dir = m_sCurrentDir;`	5063	`dir = m_sCurrentDir;`
5064	`else`	5064	`else`
5065	`dir = this->getProperDir(dir);`	5065	`dir = this->getProperDir(dir);`
Line 5074...	Line 5074...
5074	`size_t size;`	5074	`size_t size;`
5075	`char *data = File.ReadToData(&size);`	5075	`char *data = File.ReadToData(&size);`
5076		5076
5077	`if ( data )`	5077	`if ( data )`
5078	`{`	5078	`{`
5079	`Utils::String str(data);`	5079	`Utils::WString str(data);`
5080	`return str.token("\n", 1).token(" ", 1).toLong();`	5080	`return str.token(L"\n", 1).token(L" ", 1).toLong();`
5081	`}`	5081	`}`
5082	`}`	5082	`}`
5083		5083
5084	`return 0;`	5084	`return 0;`
5085	`}`	5085	`}`
5086	`Utils::WString CPackages::getGameRunExe(const Utils::WString &dir) const`	5086	`Utils::WString CPackages::getGameRunExe(const Utils::WString &dir) const`
5087	`{`	5087	`{`
5088	`return m_gameExe.gameRunExe(dir);`	5088	`return m_gameExe.gameRunExe(dir);`
5089	`}`	5089	`}`
5090	`Utils::WString CPackages::getGameRunExe() const`	5090	`Utils::WString CPackages::getGameRunExe() const`
5091	`{`	5091	`{`
5092	`return m_gameExe.gameRunExe(m_sCurrentDir);`	5092	`return m_gameExe.gameRunExe(m_sCurrentDir);`
5093	`}`	5093	`}`
5094		5094
5095	`Utils::WString CPackages::getGameNameFromType(int game) const`	5095	`Utils::WString CPackages::getGameNameFromType(int game) const`
5096	`{`	5096	`{`
5097	`return m_gameExe.gameNameFromType(game - 1);`	5097	`return m_gameExe.gameNameFromType(game - 1);`
5098	`}`	5098	`}`
5099	`Utils::WString CPackages::getGameName() const`	5099	`Utils::WString CPackages::getGameName() const`
5100	`{`	5100	`{`
5101	`return getGameName(m_sCurrentDir);`	5101	`return getGameName(m_sCurrentDir);`
5102	`}`	5102	`}`
5103		5103
5104	`Utils::WString CPackages::getGameName(const Utils::WString &dir) const`	5104	`Utils::WString CPackages::getGameName(const Utils::WString &dir) const`
5105	`{`	5105	`{`
5106	`return m_gameExe.gameName(dir.empty() ? m_sCurrentDir : dir);`	5106	`return m_gameExe.gameName(dir.empty() ? m_sCurrentDir : dir);`
5107	`}`	5107	`}`
5108		5108
5109	`Utils::WString CPackages::getProperDir() const`	5109	`Utils::WString CPackages::getProperDir() const`
5110	`{`	5110	`{`
5111	`return getProperDir(m_sCurrentDir);`	5111	`return getProperDir(m_sCurrentDir);`
5112	`}`	5112	`}`
5113	`Utils::WString CPackages::getProperDir(const Utils::WString &dir) const`	5113	`Utils::WString CPackages::getProperDir(const Utils::WString &dir) const`
5114	`{`	5114	`{`
5115	`return m_gameExe.properDir((dir.empty()) ? m_sCurrentDir : dir);`	5115	`return m_gameExe.properDir((dir.empty()) ? m_sCurrentDir : dir);`
Line 5133...	Line 5133...
5133		5133
5134	`Utils::WString CPackages::getGameTypesString(CBaseFile *package, bool includeVersion) const`	5134	`Utils::WString CPackages::getGameTypesString(CBaseFile *package, bool includeVersion) const`
5135	`{`	5135	`{`
5136	`if ( !package->AnyGameCompatability() )`	5136	`if ( !package->AnyGameCompatability() )`
5137	`return L"";`	5137	`return L"";`
5138		5138
5139	`Utils::WString sGames;`	5139	`Utils::WString sGames;`
5140	`for ( CListNode<SGameCompat> *gNode = package->GetGameCompatabilityList()->Front(); gNode; gNode = gNode->next() ) {`	5140	`for ( CListNode<SGameCompat> *gNode = package->GetGameCompatabilityList()->Front(); gNode; gNode = gNode->next() ) {`
5141	`if ( !sGames.empty() )`	5141	`if ( !sGames.empty() )`
5142	`sGames += L", ";`	5142	`sGames += L", ";`
5143	`sGames += m_gameExe.gameNameFromType(gNode->Data()->iGame - 1);`	5143	`sGames += m_gameExe.gameNameFromType(gNode->Data()->iGame - 1);`
Line 5146...	Line 5146...
5146	`if ( !version.empty() ) {`	5146	`if ( !version.empty() ) {`
5147	`sGames += L" (";`	5147	`sGames += L" (";`
5148	`sGames += version;`	5148	`sGames += version;`
5149	`sGames += L")";`	5149	`sGames += L")";`
5150	`}`	5150	`}`
5151	`}`	5151	`}`
5152	`}`	5152	`}`
5153	`return sGames;`	5153	`return sGames;`
5154	`}`	5154	`}`
5155		5155
5156	`Utils::WString CPackages::getGameVersionString(CBaseFile *package) const`	5156	`Utils::WString CPackages::getGameVersionString(CBaseFile *package) const`
5157	`{`	5157	`{`
5158	`for ( CListNode<SGameCompat> *gNode = package->GetGameCompatabilityList()->Front(); gNode; gNode = gNode->next() ) {`	5158	`for ( CListNode<SGameCompat> *gNode = package->GetGameCompatabilityList()->Front(); gNode; gNode = gNode->next() ) {`
5159	`if ( gNode->Data()->iGame == m_iGame ) {`	5159	`if ( gNode->Data()->iGame == m_iGame ) {`
5160	`return m_gameExe.gameVersionFromType(m_iGame - 1, gNode->Data()->iVersion - 1, gNode->Data()->sVersion);`	5160	`return m_gameExe.gameVersionFromType(m_iGame - 1, gNode->Data()->iVersion - 1, gNode->Data()->sVersion);`
Line 5163...	Line 5163...
5163		5163
5164	`return Utils::WString::Null();`	5164	`return Utils::WString::Null();`
5165	`}`	5165	`}`
5166		5166
5167	`Utils::WString CPackages::getGameVersionFromType(int game, int version, const Utils::WString &sVersion) const`	5167	`Utils::WString CPackages::getGameVersionFromType(int game, int version, const Utils::WString &sVersion) const`
5168	`{`	5168	`{`
5169	`return m_gameExe.gameVersionFromType(game - 1, version - 1, sVersion);`	5169	`return m_gameExe.gameVersionFromType(game - 1, version - 1, sVersion);`
5170	`}`	5170	`}`
5171		5171
5172	`int CPackages::CountBuiltInPackages(bool onlyEnabled)`	5172	`int CPackages::CountBuiltInPackages(bool onlyEnabled)`
5173	`{`	5173	`{`
5174	`int count = 0;`	5174	`int count = 0;`
5175	`for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )`	5175	`for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )`
5176	`{`	5176	`{`
5177	`if ( !node->Data()->CheckGameCompatability(m_iGame) )`	5177	`if ( !node->Data()->CheckGameCompatability(m_iGame) )`
5178	`continue;`	5178	`continue;`
5179	`if ( onlyEnabled && !node->Data()->IsEnabled() )`	5179	`if ( onlyEnabled && !node->Data()->IsEnabled() )`
5180	`continue;`	5180	`continue;`
Line 5238...	Line 5238...
5238	`else if (!m_sSetMod.empty())`	5238	`else if (!m_sSetMod.empty())`
5239	`{`	5239	`{`
5240	`if (CFileIO::Exists(m_sCurrentDir + L"/mods/" + m_sSetMod + L".cat"))`	5240	`if (CFileIO::Exists(m_sCurrentDir + L"/mods/" + m_sSetMod + L".cat"))`
5241	`{`	5241	`{`
5242	`CCatFile catFile;`	5242	`CCatFile catFile;`
5243	`if (catFile.open(m_sCurrentDir + L"/mods/" + m_sSetMod + L".cat", addonDir.toString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)`	5243	`if (catFile.open(m_sCurrentDir + L"/mods/" + m_sSetMod + L".cat", addonDir, CATREAD_CATDECRYPT, false) == CATERR_NONE)`
5244	`{`	5244	`{`
5245	`if (catFile.extractFile(aFilename, aTo))`	5245	`if (catFile.extractFile(aFilename, aTo))`
5246	`return 1;`	5246	`return 1;`
5247	`if (catFile.error() == CATERR_INVALIDDEST \|\| catFile.error() == CATERR_CANTCREATEDIR)`	5247	`if (catFile.error() == CATERR_INVALIDDEST \|\| catFile.error() == CATERR_CANTCREATEDIR)`
5248	`{`	5248	`{`
Line 5263...	Line 5263...
5263		5263
5264	`// work backwards until we find the file`	5264	`// work backwards until we find the file`
5265	`for (; catNumber; catNumber--)`	5265	`for (; catNumber; catNumber--)`
5266	`{`	5266	`{`
5267	`CCatFile catFile;`	5267	`CCatFile catFile;`
5268	`if (catFile.open((dir + L"/" + Utils::WString::PadNumber(catNumber, 2) + L".cat"), addonDir.toString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)`	5268	`if (catFile.open((dir + L"/" + Utils::WString::PadNumber(catNumber, 2) + L".cat"), addonDir, CATREAD_CATDECRYPT, false) == CATERR_NONE)`
5269	`{`	5269	`{`
5270	`// check for the file`	5270	`// check for the file`
5271	`if (catFile.extractFile(aFilename, aTo))`	5271	`if (catFile.extractFile(aFilename, aTo))`
5272	`return 1;`	5272	`return 1;`
5273	`if (catFile.error() == CATERR_INVALIDDEST \|\| catFile.error() == CATERR_CANTCREATEDIR)`	5273	`if (catFile.error() == CATERR_INVALIDDEST \|\| catFile.error() == CATERR_CANTCREATEDIR)`
Line 5393...	Line 5393...
5393	`}`	5393	`}`
5394	`}`	5394	`}`
5395		5395
5396	`if ( create )`	5396	`if ( create )`
5397	`{`	5397	`{`
5398	`wareLines.pushFront(Utils::String::Number(version) + ";" + Utils::String::Number(wareLines.size()) + ";", Utils::String::Null());`	5398	`wareLines.pushFront(Utils::WString::Number(version) + L";" + Utils::WString::Number(wareLines.size()) + L";", Utils::WString::Null());`
5399	`Utils::WString strV = Utils::WString::FromFloat(GetLibraryVersion(), 2);`	5399	`Utils::WString strV = Utils::WString::FromFloat(GetLibraryVersion(), 2);`
5400	`wareLines.pushFront("// Created by SPKInstaller Libraries V" + strV, Utils::WString::Null());`	5400	`wareLines.pushFront("// Created by SPKInstaller Libraries V" + strV, Utils::WString::Null());`
5401	`if ( readFile.writeFile(&wareLines) )`	5401	`if ( readFile.writeFile(&wareLines) )`
5402	`this->packFile(&readFile, L"types\\" + wareFile + L".pck");`	5402	`this->packFile(&readFile, L"types\\" + wareFile + L".pck");`
5403	`}`	5403	`}`
Line 5430...	Line 5430...
5430	`{`	5430	`{`
5431	`if ( maxsize ) (*maxsize) = EMP_X3;`	5431	`if ( maxsize ) (*maxsize) = EMP_X3;`
5432	`return GetX3Emp();`	5432	`return GetX3Emp();`
5433	`}`	5433	`}`
5434		5434
5435	`return Utils::String::Null();`	5435	`return Utils::WString::Null();`
5436	`}`	5436	`}`
5437		5437
5438	`void CPackages::_addWareOverride(enum WareTypes type, int pos, const Utils::WString &id, int value, bool noto)`	5438	`void CPackages::_addWareOverride(enum WareTypes type, int pos, const Utils::WString &id, int value, bool noto)`
5439	`{`	5439	`{`
5440	`for(CListNode<SWarePriceOverride> *node = m_lWarePrices.Front(); node; node = node->next()) {`	5440	`for(CListNode<SWarePriceOverride> *node = m_lWarePrices.Front(); node; node = node->next()) {`
Line 5491...	Line 5491...
5491	`{`	5491	`{`
5492	`_addWareOverride(Ware_Custom, 0, id, noto, true);`	5492	`_addWareOverride(Ware_Custom, 0, id, noto, true);`
5493	`}`	5493	`}`
5494		5494
5495		5495
5496	`void CPackages::createEMPFile(const Utils::String &progDir)`	5496	`void CPackages::createEMPFile(const Utils::WString &progDir)`
5497	`{`	5497	`{`
5498	`// do emp wares`	5498	`// do emp wares`
5499	`size_t maxsize = 0;`	5499	`size_t maxsize = 0;`
5500	`Utils::WString empWares = empWaresForGame(&maxsize);`	5500	`Utils::WString empWares = empWaresForGame(&maxsize);`
5501		5501
Line 6066...	Line 6066...
6066	`void CPackages::backupSaves(bool vanilla)`	6066	`void CPackages::backupSaves(bool vanilla)`
6067	`{`	6067	`{`
6068	`if (!_sSaveDir.empty())`	6068	`if (!_sSaveDir.empty())`
6069	`{`	6069	`{`
6070	`// copy any saves into the vanilla directory`	6070	`// copy any saves into the vanilla directory`
6071	`Utils::String dir = (vanilla) ? "Vanilla" : "Modified";`	6071	`Utils::WString dir = (vanilla) ? L"Vanilla" : L"Modified";`
6072		6072
6073	`// make sure the directory exists`	6073	`// make sure the directory exists`
6074	`CDirIO saveDir(this->saveDirectory());`	6074	`CDirIO saveDir(this->saveDirectory());`
6075	`CDirIO gameSaveDir(saveDir.dir(_sSaveDir));`	6075	`CDirIO gameSaveDir(saveDir.dir(_sSaveDir));`
6076		6076
Line 6103...	Line 6103...
6103	`void CPackages::restoreSaves(bool vanilla)`	6103	`void CPackages::restoreSaves(bool vanilla)`
6104	`{`	6104	`{`
6105	`// get dir to restore from`	6105	`// get dir to restore from`
6106	`if (!_sSaveDir.empty())`	6106	`if (!_sSaveDir.empty())`
6107	`{`	6107	`{`
6108	`Utils::String dir = (vanilla) ? "Vanilla" : "Modified";`	6108	`Utils::WString dir = (vanilla) ? L"Vanilla" : L"Modified";`
6109	`CDirIO toDir(this->saveDirectory());`	6109	`CDirIO toDir(this->saveDirectory());`
6110	`CDirIO restoreDir(toDir.dir(_sSaveDir));`	6110	`CDirIO restoreDir(toDir.dir(_sSaveDir));`
6111	`restoreDir.cd(dir);`	6111	`restoreDir.cd(dir);`
6112		6112
6113	`if (restoreDir.exists())`	6113	`if (restoreDir.exists())`
Line 6353...	Line 6353...
6353	`}`	6353	`}`
6354	`}`	6354	`}`
6355	`}`	6355	`}`
6356		6356
6357	`void CPackages::CreateCutData()`	6357	`void CPackages::CreateCutData()`
6358	`{`	6358	`{`
6359	`// first check we have any ships`	6359	`// first check we have any ships`
6360	`if ( m_lGameShips.empty() \|\| !this->countPackages(TYPE_XSP, true) )`	6360	`if ( m_lGameShips.empty() \|\| !this->countPackages(TYPE_XSP, true) )`
6361	`return;`	6361	`return;`
6362		6362
6363	`bool found = false;`	6363	`bool found = false;`
6364	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`	6364	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`
6365	`{`	6365	`{`
6366	`SGameShip *s = node->Data();`	6366	`SGameShip *s = node->Data();`
6367	`if ( s->iType != WARETYPE_ADDED \|\| !s->pPackage )`	6367	`if ( s->iType != WARETYPE_ADDED \|\| !s->pPackage )`
6368	`continue;`	6368	`continue;`
6369		6369
6370	`// no dummies to add?`	6370	`// no dummies to add?`
6371	`if ( !s->pPackage->anyCutData() )`	6371	`if ( !s->pPackage->anyCutData() )`
6372	`continue;`	6372	`continue;`
Line 6483...	Line 6483...
6483	`if(File.readLines(lines))`	6483	`if(File.readLines(lines))`
6484	`{`	6484	`{`
6485	`for ( int j = 0; j < (int)lines.size(); j++ )`	6485	`for ( int j = 0; j < (int)lines.size(); j++ )`
6486	`{`	6486	`{`
6487	`Utils::WString line(lines.at(j));`	6487	`Utils::WString line(lines.at(j));`
6488	`aniList.pushBack(line.toString());`	6488	`aniList.pushBack(line);`
6489	`}`	6489	`}`
6490	`}`	6490	`}`
6491		6491
6492	`File.remove();`	6492	`File.remove();`
6493	`}`	6493	`}`
Line 6506...	Line 6506...
6506	`if ( !s->pPackage->anyAnimations() )`	6506	`if ( !s->pPackage->anyAnimations() )`
6507	`continue;`	6507	`continue;`

Subversion Repositories spk

(root)//libspk/src/Packages.cpp – Rev 220 → 221